maxritter
diff --git a/‎.gitignore‎
Lines changed: 1 addition & 0 deletions b/‎.gitignore‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎README.md‎
Lines changed: 34 additions & 35 deletions b/‎README.md‎
Lines changed: 34 additions & 35 deletions
diff --git a/‎console/src/services/worker-service.ts‎
Lines changed: 2 additions & 0 deletions b/‎console/src/services/worker-service.ts‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎console/src/services/worker/http/routes/VaultRoutes.ts‎
Lines changed: 188 additions & 0 deletions b/‎console/src/services/worker/http/routes/VaultRoutes.ts‎
Lines changed: 188 additions & 0 deletions
@@ -239,6 +239,7 @@ playwright/
 docs/plans
 docs/license
 docs/video
+docs/slides
 .install-version
 bun.lock
 
 
@@ -50,7 +50,7 @@ So I built Pilot. Instead of adding process on top, it bakes quality into every
 | Every session starts fresh | Persistent memory across sessions via Pilot Console             |
 | Hope it works              | Verifier sub-agents perform code review before marking complete |
 | No codebase knowledge      | Production-tested rules loaded into every session               |
-| Generic suggestions        | Coding skills activated dynamically when relevant               |
+| Generic suggestions        | Coding standards activated conditionally by file type           |
 | Changes mixed into branch  | Isolated worktrees — review and squash merge when verified      |
 | Manual tool setup          | MCP servers + language servers pre-configured and ready         |
 
@@ -97,7 +97,7 @@ After installation, run `pilot` or `ccp` in your project folder to start Claude
 1. **Prerequisites** — Checks Homebrew, Node.js, Python 3.12+, uv, git
 2. **Dependencies** — Installs Vexor, playwright-cli, mcp-cli, Claude Code
 3. **Shell integration** — Auto-configures bash, fish, and zsh with `pilot` alias
-4. **Config & Claude files** — Sets up `.claude/` plugin, rules, skills, hooks, MCP servers
+4. **Config & Claude files** — Sets up `.claude/` plugin, rules, commands, hooks, MCP servers
 5. **VS Code extensions** — Installs recommended extensions for your stack
 6. **Dev Container** — Auto-setup with all tools pre-configured
 7. **Automated updater** — Checks for updates on launch with release notes and one-key upgrade
@@ -118,9 +118,9 @@ curl -fsSL https://raw.githubusercontent.com/maxritter/claude-pilot/main/install
 
 ## How It Works
 
-### /sync — Sync Rules & Skills
+### /sync — Sync Rules & Standards
 
-Run `/sync` to sync custom rules and skills with your codebase. Explores your codebase, builds a semantic search index, discovers undocumented patterns, updates project documentation, and creates new skills. Run it once initially, then anytime again:
+Run `/sync` to sync rules and standards with your codebase. Explores your codebase, builds a semantic search index, discovers undocumented patterns, updates project documentation, and creates new custom skills. Run it once initially, then anytime again:
 
 ```bash
 pilot
@@ -133,13 +133,13 @@ pilot
 | Phase | Action                                                          |
 | ----- | --------------------------------------------------------------- |
 | 0     | Load reference guidelines, output locations, error handling     |
-| 1     | Read existing rules and skills from `.claude/`                  |
+| 1     | Read existing rules and standards from `.claude/`               |
 | 2     | Build Vexor semantic search index (first run may take 5-15 min) |
 | 3     | Explore codebase with Vexor/Grep to find patterns               |
 | 4     | Compare discovered vs documented patterns                       |
 | 5     | Sync/update `project.md` with tech stack and commands           |
 | 6     | Sync MCP server documentation                                   |
-| 7     | Update existing skills that have changed                        |
+| 7     | Update existing custom skills that have changed                 |
 | 8     | Discover and document new undocumented patterns as rules        |
 | 9     | Create new skills via `/learn` command                          |
 | 10    | Report summary of all changes                                   |
@@ -300,13 +300,13 @@ All commands support `--json` for structured output. Multiple Pilot sessions can
 
 Create your own in your project's `.claude/` folder:
 
-| Type         | Loaded                            | Best for                                 |
-| ------------ | --------------------------------- | ---------------------------------------- |
-| **Rules**    | Every session (always in context) | Guidelines Claude should always follow   |
-| **Commands** | On demand via `/command`          | Specific workflows or multi-step tasks   |
-| **Skills**   | Dynamically when relevant         | Specialized knowledge for specific tasks |
+| Type         | Loaded                                          | Best for                                 |
+| ------------ | ----------------------------------------------- | ---------------------------------------- |
+| **Rules**    | Every session, or conditionally by file type    | Guidelines Claude should always follow   |
+| **Commands** | On demand via `/command`                        | Specific workflows or multi-step tasks   |
+| **Skills**   | On demand, created via `/learn`                 | Reusable knowledge from past sessions    |
 
-Claude Pilot automatically installs best-practice rules, commands, and coding standard skills.
+Claude Pilot automatically installs best-practice rules, commands, and coding standards. Standards rules use `paths` frontmatter to activate only when you're working with matching file types (e.g., Python standards load only when editing `.py` files). Custom skills are created by `/learn` when it detects non-obvious discoveries, workarounds, or reusable workflows — and can be shared across your team via `/vault`.
 
 ### Custom MCP Servers
 
@@ -424,26 +424,25 @@ Production-tested best practices loaded into **every session**. These aren't sug
 
 </details>
 
-### Built-in Coding Skills
-
-Dynamically activated when relevant — specialized knowledge loaded on demand:
-
-| Skill                | Coverage                                                         |
-| -------------------- | ---------------------------------------------------------------- |
-| Python Standards     | uv, pytest, ruff, basedpyright, type hints, docstrings           |
-| TypeScript Standards | npm/pnpm, Jest, ESLint, Prettier, React patterns                 |
-| Go Standards         | Modules, testing, formatting, error handling                     |
-| Testing Patterns     | Unit testing, integration testing, mocking, coverage goals       |
-| Test Organization    | File structure, naming conventions, fixtures, setup              |
-| API Design           | RESTful patterns, response envelopes, error handling, versioning |
-| Data Models          | Database schemas, type safety, migrations, relationships         |
-| Components           | Reusable patterns, props design, documentation, testing          |
-| CSS / Styling        | Naming conventions, organization, responsive design, performance |
-| Responsive Design    | Mobile-first, breakpoints, Flexbox/Grid, touch interactions      |
-| Design System        | Color palette, typography, spacing, component consistency        |
-| Accessibility        | WCAG compliance, ARIA attributes, keyboard nav, screen readers   |
-| DB Migrations        | Schema changes, data transformation, rollback strategy           |
-| Query Optimization   | Indexing, N+1 problems, query patterns, performance              |
+### Built-in Coding Standards
+
+Conditional rules activated by file type — loaded only when working with matching files:
+
+| Standard             | Activates On                    | Coverage                                                         |
+| -------------------- | ------------------------------- | ---------------------------------------------------------------- |
+| Python               | `*.py`                          | uv, pytest, ruff, basedpyright, type hints, docstrings           |
+| TypeScript           | `*.ts`, `*.tsx`, `*.js`, `*.jsx`| npm/pnpm, Jest, ESLint, Prettier, React patterns                 |
+| Go                   | `*.go`                          | Modules, testing, formatting, error handling                     |
+| Testing Strategies   | `*test*`, `*spec*`              | Unit vs integration vs E2E, mocking, coverage goals              |
+| API Design           | `*route*`, `*endpoint*`, `*api*`| RESTful patterns, response envelopes, error handling, versioning |
+| Data Models          | `*model*`, `*schema*`, `*entity*`| Database schemas, type safety, migrations, relationships        |
+| Components           | `*component*`, `*.tsx`, `*.vue` | Reusable patterns, props design, documentation, testing          |
+| CSS / Styling        | `*.css`, `*.scss`, `*.tailwind*`| Naming conventions, organization, responsive design, performance |
+| Responsive Design    | `*.css`, `*.scss`, `*.tsx`      | Mobile-first, breakpoints, Flexbox/Grid, touch interactions      |
+| Design System        | `*.css`, `*.tsx`, `*.vue`       | Color palette, typography, spacing, component consistency        |
+| Accessibility        | `*.tsx`, `*.jsx`, `*.vue`, `*.html`| WCAG compliance, ARIA attributes, keyboard nav, screen readers |
+| DB Migrations        | `*migration*`, `*alembic*`      | Schema changes, data transformation, rollback strategy           |
+| Query Optimization   | `*query*`, `*repository*`, `*dao*`| Indexing, N+1 problems, query patterns, performance            |
 
 ### MCP Servers
 
@@ -537,21 +536,21 @@ Yes. Pilot enhances Claude Code — it doesn't replace it. You need an active Cl
 <details>
 <summary><b>Does Pilot work with any programming language?</b></summary>
 
-Pilot's quality hooks (auto-formatting, linting, type checking) currently support Python, TypeScript/JavaScript, and Go out of the box. TDD enforcement, spec-driven development, Endless Mode, persistent memory, and all rules and skills work with any language that Claude Code supports. You can add custom hooks for additional languages.
+Pilot's quality hooks (auto-formatting, linting, type checking) currently support Python, TypeScript/JavaScript, and Go out of the box. TDD enforcement, spec-driven development, Endless Mode, persistent memory, and all rules and standards work with any language that Claude Code supports. You can add custom hooks for additional languages.
 
 </details>
 
 <details>
 <summary><b>Can I use Pilot on multiple projects?</b></summary>
 
-Yes. Pilot installs once and works across all your projects. Each project can have its own `.claude/` rules, skills, and MCP servers. Run `/sync` in each project to generate project-specific documentation and skills.
+Yes. Pilot installs once and works across all your projects. Each project can have its own `.claude/` rules, custom skills, and MCP servers. Run `/sync` in each project to generate project-specific documentation and standards.
 
 </details>
 
 <details>
 <summary><b>Can I customize the rules and hooks?</b></summary>
 
-Yes. All rules in `.claude/rules/` are markdown files you can edit, extend, or replace. Hooks are Python scripts you can modify. Skills are dynamically loaded and can be customized or created via `/learn`. Project-specific rules override global defaults. Use `/vault` to share customizations across your team.
+Yes. All rules in `.claude/rules/` are markdown files you can edit, extend, or replace. Hooks are Python scripts you can modify. Built-in coding standards are conditional rules that activate by file type and can be customized. You can also create custom skills via `/learn`. Project-specific rules override global defaults. Use `/vault` to share customizations across your team.
 
 </details>
 
 
@@ -66,6 +66,7 @@ import { PlanRoutes } from "./worker/http/routes/PlanRoutes.js";
 import { WorktreeRoutes } from "./worker/http/routes/WorktreeRoutes.js";
 import { VexorRoutes } from "./worker/http/routes/VexorRoutes.js";
 import { LicenseRoutes } from "./worker/http/routes/LicenseRoutes.js";
+import { VaultRoutes } from "./worker/http/routes/VaultRoutes.js";
 import { MetricsService } from "./worker/MetricsService.js";
 import { startRetentionScheduler, stopRetentionScheduler } from "./worker/RetentionScheduler.js";
 
@@ -251,6 +252,7 @@ export class WorkerService {
     this.server.registerRoutes(this.vexorRoutes);
 
     this.server.registerRoutes(new LicenseRoutes());
+    this.server.registerRoutes(new VaultRoutes());
 
     startRetentionScheduler(this.dbManager);
   }
 
@@ -0,0 +1,188 @@
+/**
+ * VaultRoutes
+ *
+ * API endpoints for sx Team Vault status and management.
+ * Invokes the sx CLI via Bun.spawn with timeout and caching.
+ */
+
+import express, { type Request, type Response } from "express";
+import { BaseRouteHandler } from "../BaseRouteHandler.js";
+import { logger } from "../../../../utils/logger.js";
+
+export interface VaultAsset {
+  name: string;
+  version: string;
+  type: string;
+  clients: string[];
+  status: string;
+  scope: string;
+}
+
+export interface VaultCatalogItem {
+  name: string;
+  type: string;
+  latestVersion: string;
+  versionsCount: number;
+  updatedAt: string;
+}
+
+export interface VaultStatus {
+  installed: boolean;
+  version: string | null;
+  configured: boolean;
+  vaultUrl: string | null;
+  profile: string | null;
+  assets: VaultAsset[];
+  catalog: VaultCatalogItem[];
+  isInstalling: boolean;
+}
+
+const STATUS_TIMEOUT_MS = 15_000;
+const INSTALL_TIMEOUT_MS = 60_000;
+const STATUS_CACHE_TTL_MS = 30_000;
+
+export class VaultRoutes extends BaseRouteHandler {
+  private statusCache: { data: VaultStatus; timestamp: number } | null = null;
+  private _isInstalling = false;
+
+  setupRoutes(app: express.Application): void {
+    app.get("/api/vault/status", this.handleStatus.bind(this));
+    app.post("/api/vault/install", this.handleInstall.bind(this));
+  }
+
+  private handleStatus = this.wrapHandler(async (_req: Request, res: Response): Promise<void> => {
+    if (this.statusCache && Date.now() - this.statusCache.timestamp < STATUS_CACHE_TTL_MS) {
+      res.json({ ...this.statusCache.data, isInstalling: this._isInstalling });
+      return;
+    }
+
+    const sxPath = this.resolveSxBinary();
+    if (!sxPath) {
+      res.json(this.emptyStatus());
+      return;
+    }
+
+    try {
+      const [configOutput, catalogOutput] = await Promise.all([
+        this.runSxCommand([sxPath, "config", "--json"], STATUS_TIMEOUT_MS),
+        this.runSxCommand([sxPath, "vault", "list", "--json"], STATUS_TIMEOUT_MS).catch(() => "[]"),
+      ]);
+
+      const config = JSON.parse(configOutput);
+      const catalog: VaultCatalogItem[] = JSON.parse(catalogOutput).map((item: any) => ({
+        name: item.name,
+        type: item.type,
+        latestVersion: item.latestVersion,
+        versionsCount: item.versionsCount,
+        updatedAt: item.updatedAt,
+      }));
+
+      const assets: VaultAsset[] = [];
+      for (const scopeGroup of config.assets || []) {
+        const scope = scopeGroup.scope || "Global";
+        for (const asset of scopeGroup.assets || []) {
+          assets.push({
+            name: asset.name,
+            version: asset.version,
+            type: asset.type,
+            clients: asset.clients || [],
+            status: asset.status || "unknown",
+            scope,
+          });
+        }
+      }
+
+      const status: VaultStatus = {
+        installed: true,
+        version: config.version?.version || null,
+        configured: !!config.config?.repositoryUrl,
+        vaultUrl: config.config?.repositoryUrl || null,
+        profile: config.config?.profile || null,
+        assets,
+        catalog,
+        isInstalling: this._isInstalling,
+      };
+
+      this.statusCache = { data: status, timestamp: Date.now() };
+      res.json(status);
+    } catch (error) {
+      logger.error("HTTP", "Vault status failed", {}, error as Error);
+      res.json(this.emptyStatus());
+    }
+  });
+
+  private handleInstall = this.wrapHandler(async (_req: Request, res: Response): Promise<void> => {
+    if (this._isInstalling) {
+      res.status(409).json({ error: "Installation already in progress" });
+      return;
+    }
+
+    const sxPath = this.resolveSxBinary();
+    if (!sxPath) {
+      res.status(500).json({ error: "sx CLI not found" });
+      return;
+    }
+
+    this._isInstalling = true;
+    this.statusCache = null;
+    res.json({ started: true });
+
+    try {
+      await this.runSxCommand([sxPath, "install", "--repair"], INSTALL_TIMEOUT_MS);
+      logger.info("HTTP", "Vault install --repair completed");
+    } catch (error) {
+      logger.error("HTTP", "Vault install failed", {}, error as Error);
+    } finally {
+      this._isInstalling = false;
+      this.statusCache = null;
+    }
+  });
+
+  private emptyStatus(): VaultStatus {
+    return {
+      installed: false,
+      version: null,
+      configured: false,
+      vaultUrl: null,
+      profile: null,
+      assets: [],
+      catalog: [],
+      isInstalling: this._isInstalling,
+    };
+  }
+
+  private resolveSxBinary(): string | null {
+    const found = Bun.which("sx");
+    return found || null;
+  }
+
+  private async runSxCommand(args: string[], timeoutMs: number): Promise<string> {
+    const proc = Bun.spawn(args, {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const timeoutId = setTimeout(() => {
+      try {
+        proc.kill("SIGTERM");
+        setTimeout(() => { try { proc.kill("SIGKILL"); } catch {} }, 1000);
+      } catch {}
+    }, timeoutMs);
+
+    try {
+      const [stdout, stderr] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+      ]);
+      const exitCode = await proc.exited;
+
+      if (exitCode !== 0) {
+        throw new Error(`sx exited with code ${exitCode}: ${stderr.slice(0, 200)}`);
+      }
+
+      return stdout;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+}