@brainst0rm/cli 0.13.0

package/dist/index.js

@@ -0,0 +1,4635 @@
+import {
+  renderMarkdownToString
+} from "./chunk-GJXEX2A3.js";
+import {
+  ROLES
+} from "./chunk-YWXOPUDW.js";
+import "./chunk-7D4SUZUM.js";
+
+// src/bin/brainstorm.ts
+import { Command } from "commander";
+import { loadConfig } from "@brainst0rm/config";
+import { getDb, closeDb, CostRepository } from "@brainst0rm/db";
+import {
+  createProviderRegistry,
+  getBrainstormApiKey,
+  isCommunityKey
+} from "@brainst0rm/providers";
+import { BrainstormRouter, CostTracker } from "@brainst0rm/router";
+import {
+  createDefaultToolRegistry,
+  configureSandbox,
+  stopDockerSandbox
+} from "@brainst0rm/tools";
+import {
+  runAgentLoop,
+  buildSystemPrompt,
+  buildToolAwarenessSection,
+  SessionManager,
+  PermissionManager,
+  createSubagentTool,
+  spawnSubagent,
+  spawnParallel,
+  createDefaultMiddlewarePipeline
+} from "@brainst0rm/core";
+import { AgentManager, parseAgentNL } from "@brainst0rm/agents";
+import {
+  runWorkflow,
+  getPresetWorkflow,
+  autoSelectPreset,
+  PRESET_WORKFLOWS
+} from "@brainst0rm/workflow";
+
+// src/init/detect.ts
+import { existsSync, readFileSync } from "fs";
+import { join, basename } from "path";
+import { createConnection } from "net";
+async function detectProject(projectDir) {
+  const detection = {
+    name: basename(projectDir),
+    type: null,
+    language: null,
+    framework: null,
+    runtime: null,
+    hasGit: existsSync(join(projectDir, ".git")),
+    hasStormMd: existsSync(join(projectDir, "STORM.md")),
+    hasBrainstormMd: existsSync(join(projectDir, "BRAINSTORM.md")),
+    hasClaudeMd: existsSync(join(projectDir, "CLAUDE.md")),
+    hasGitignore: existsSync(join(projectDir, ".gitignore")),
+    hasGithubWorkflows: existsSync(join(projectDir, ".github", "workflows")),
+    hasEnvExample: existsSync(join(projectDir, ".env.example")),
+    hasPrettierrc: existsSync(join(projectDir, ".prettierrc")),
+    hasBrainstormToml: existsSync(join(projectDir, "brainstorm.toml")),
+    packageName: null,
+    scripts: {},
+    localModels: []
+  };
+  const pkgPath = join(projectDir, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      detection.packageName = pkg.name ?? null;
+      if (detection.packageName) detection.name = detection.packageName;
+      detection.scripts = pkg.scripts ?? {};
+      detection.language = "typescript";
+      detection.runtime = "node";
+      if (pkg.workspaces || existsSync(join(projectDir, "turbo.json")) || existsSync(join(projectDir, "pnpm-workspace.yaml"))) {
+        detection.type = "monorepo";
+      }
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (allDeps?.next) detection.framework = "nextjs";
+      else if (allDeps?.hono) detection.framework = "hono";
+      else if (allDeps?.express) detection.framework = "express";
+      if (pkg.bin) detection.type = detection.type ?? "cli";
+      if (pkg.exports || pkg.main) detection.type = detection.type ?? "library";
+    } catch {
+    }
+  }
+  if (!detection.framework) {
+    if (existsSync(join(projectDir, "next.config.ts")) || existsSync(join(projectDir, "next.config.js")) || existsSync(join(projectDir, "next.config.mjs"))) {
+      detection.framework = "nextjs";
+    } else if (existsSync(join(projectDir, "vite.config.ts")) || existsSync(join(projectDir, "vite.config.js"))) {
+      detection.framework = "none";
+    }
+  }
+  if (existsSync(join(projectDir, "pyproject.toml")) || existsSync(join(projectDir, "requirements.txt"))) {
+    detection.language = "python";
+    detection.runtime = "python";
+    try {
+      const content = readFileSync(join(projectDir, "requirements.txt"), "utf-8");
+      if (content.includes("fastapi")) detection.framework = "fastapi";
+    } catch {
+    }
+    detection.type = detection.type ?? "api";
+  }
+  if (existsSync(join(projectDir, "Cargo.toml"))) {
+    detection.language = "rust";
+    detection.type = detection.type ?? "cli";
+  }
+  if (existsSync(join(projectDir, "go.mod"))) {
+    detection.language = "go";
+    detection.runtime = "go";
+    detection.type = detection.type ?? "api";
+  }
+  detection.type = detection.type ?? "app";
+  const probes = await Promise.allSettled([
+    probePort(11434).then((ok) => ok ? "ollama" : null),
+    probePort(1234).then((ok) => ok ? "lmstudio" : null),
+    probePort(8080).then((ok) => ok ? "llamacpp" : null)
+  ]);
+  for (const result of probes) {
+    if (result.status === "fulfilled" && result.value) {
+      detection.localModels.push(result.value);
+    }
+  }
+  return detection;
+}
+function probePort(port) {
+  return new Promise((resolve) => {
+    const socket = createConnection({ host: "127.0.0.1", port, timeout: 500 });
+    socket.on("connect", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => resolve(false));
+    socket.on("timeout", () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
+}
+
+// src/init/prompts.ts
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+async function runPrompts(detection) {
+  const rl = createInterface({ input, output });
+  try {
+    console.log("\n  brainstorm init\n");
+    const detected = [];
+    if (detection.type) detected.push(`${detection.language ?? "unknown"} ${detection.type}`);
+    if (detection.framework && detection.framework !== "none") detected.push(`framework: ${detection.framework}`);
+    if (detection.localModels.length > 0) detected.push(`local models: ${detection.localModels.join(", ")}`);
+    if (detected.length > 0) {
+      console.log(`  Detected: ${detected.join(" | ")}
+`);
+    }
+    const name = await ask(rl, "Project name", detection.name);
+    const type = await askChoice(rl, "Project type", ["monorepo", "app", "cli", "library", "api"], detection.type ?? "app");
+    const language = await askChoice(rl, "Language", ["typescript", "python", "rust", "go", "multi"], detection.language ?? "typescript");
+    const framework = await askChoice(rl, "Framework", ["nextjs", "hono", "fastapi", "express", "none"], detection.framework ?? "none");
+    const runtime = language === "python" ? "python" : language === "go" ? "go" : detection.runtime ?? "node";
+    const deploy = await askChoice(rl, "Deploy target", ["vercel", "do-app-platform", "docker", "aws", "none"], "none");
+    console.log();
+    const cloudProvider = await askChoice(rl, "Cloud LLM routing", ["brainstormrouter", "direct", "none"], "brainstormrouter");
+    const budgetTier = await askChoice(rl, "Budget tier", ["low", "standard", "premium"], "standard");
+    console.log();
+    const secretsStrategy = await askChoice(rl, "Secrets strategy", ["env-file", "op-cli", "sops", "doppler", "infisical", "manual"], "env-file");
+    const ciTier = await askChoice(rl, "CI/CD setup", ["standard", "full", "monorepo", "none"], type === "monorepo" ? "monorepo" : "standard");
+    console.log();
+    const architecture = await ask(rl, "Architecture (one line)", "");
+    const choices = {
+      name,
+      type,
+      language,
+      framework,
+      runtime,
+      deploy,
+      cloudProvider,
+      localModels: detection.localModels,
+      budgetTier,
+      secretsStrategy,
+      ciTier,
+      architecture
+    };
+    console.log("\n  Will create:");
+    console.log("    STORM.md              \u2014 project context for AI routing");
+    console.log("    brainstorm.toml       \u2014 routing + provider config");
+    console.log("    .brainstormignore     \u2014 AI file exclusions");
+    if (!detection.hasGitignore) console.log("    .gitignore            \u2014 comprehensive ignore patterns");
+    if (!detection.hasPrettierrc) console.log("    .prettierrc           \u2014 code formatting");
+    console.log("    .env.example          \u2014 documented environment variables");
+    if (ciTier !== "none") {
+      console.log("    .github/workflows/    \u2014 CI/CD pipeline");
+      console.log("    .github/ISSUE_TEMPLATE/ \u2014 bug + feature templates");
+      console.log("    .github/pull_request_template.md");
+    }
+    console.log();
+    const confirm = await ask(rl, "Proceed? [Y/n]", "Y");
+    if (confirm.toLowerCase() === "n") {
+      console.log("  Aborted.\n");
+      return null;
+    }
+    return choices;
+  } finally {
+    rl.close();
+  }
+}
+function buildDefaultChoices(detection) {
+  return {
+    name: detection.name,
+    type: detection.type ?? "app",
+    language: detection.language ?? "typescript",
+    framework: detection.framework ?? "none",
+    runtime: detection.runtime ?? "node",
+    deploy: "none",
+    cloudProvider: "brainstormrouter",
+    localModels: detection.localModels,
+    budgetTier: "standard",
+    secretsStrategy: "env-file",
+    ciTier: detection.type === "monorepo" ? "monorepo" : "standard",
+    architecture: ""
+  };
+}
+async function ask(rl, prompt, defaultVal) {
+  const suffix = defaultVal ? ` [${defaultVal}]` : "";
+  const answer = await rl.question(`  ${prompt}${suffix}: `);
+  return answer.trim() || defaultVal;
+}
+async function askChoice(rl, prompt, options, defaultVal) {
+  const optStr = options.map((o) => o === defaultVal ? `[${o}]` : o).join(" / ");
+  const answer = await rl.question(`  ${prompt}: ${optStr}: `);
+  const trimmed = answer.trim().toLowerCase();
+  if (!trimmed) return defaultVal;
+  const match = options.find((o) => o.startsWith(trimmed));
+  return match ?? defaultVal;
+}
+
+// src/init/generate.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join2, dirname } from "path";
+function generateFile(projectDir, relativePath, content, options = {}) {
+  const fullPath = join2(projectDir, relativePath);
+  const dir = dirname(fullPath);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  if (existsSync2(fullPath) && !options.force) {
+    return { action: "skipped", path: relativePath };
+  }
+  writeFileSync(fullPath, content, "utf-8");
+  return { action: "created", path: relativePath };
+}
+function mergeGitignore(projectDir, newContent) {
+  const fullPath = join2(projectDir, ".gitignore");
+  if (!existsSync2(fullPath)) {
+    writeFileSync(fullPath, newContent, "utf-8");
+    return { action: "created", path: ".gitignore" };
+  }
+  const existing = readFileSync2(fullPath, "utf-8");
+  const existingPatterns = new Set(
+    existing.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"))
+  );
+  const newPatterns = newContent.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#")).filter((l) => !existingPatterns.has(l));
+  if (newPatterns.length === 0) {
+    return { action: "skipped", path: ".gitignore" };
+  }
+  const appendBlock = "\n# Added by brainstorm init\n" + newPatterns.join("\n") + "\n";
+  writeFileSync(fullPath, existing.trimEnd() + "\n" + appendBlock, "utf-8");
+  return { action: "merged", path: ".gitignore" };
+}
+
+// src/init/templates.ts
+function generateStormMd(choices) {
+  const lines = [
+    "---",
+    "version: 1",
+    `name: ${choices.name}`,
+    `type: ${choices.type}`,
+    `language: ${choices.language}`,
+    `framework: ${choices.framework}`,
+    `runtime: ${choices.runtime}`,
+    `deploy: ${choices.deploy}`,
+    "routing:",
+    "  primary_tasks: [code-generation, debugging]",
+    `  typical_complexity: moderate`,
+    `  prefer_local: ${choices.budgetTier === "low"}`,
+    `  budget_tier: ${choices.budgetTier}`,
+    "providers:",
+    `  cloud: ${choices.cloudProvider}`,
+    `  local: [${choices.localModels.join(", ")}]`,
+    "secrets:",
+    `  strategy: ${choices.secretsStrategy}`,
+    `entry_points: []`,
+    choices.language === "typescript" ? "test_command: npm test" : choices.language === "python" ? "test_command: pytest" : void 0,
+    choices.language === "typescript" ? "build_command: npm run build" : void 0,
+    choices.language === "typescript" ? "dev_command: npm run dev" : choices.language === "python" ? "dev_command: python -m uvicorn app:app --reload" : void 0,
+    "---",
+    "",
+    "## What is this?",
+    `<!-- One sentence. What does this project do? -->`,
+    choices.architecture || "[Describe your project here.]",
+    "",
+    "## Start here",
+    "<!-- The 5 files to read first to understand the architecture. -->",
+    "- [Add your key entry point]",
+    "- [Add your main abstraction]",
+    "- [Add your data schema]",
+    "- [Add your route definitions]",
+    "- [Add your config file]",
+    "",
+    "## Commands that work",
+    "<!-- Copy-pasteable. Must work on a fresh clone. -->",
+    "```bash",
+    choices.language === "typescript" ? "npm install" : choices.language === "python" ? "pip install -r requirements.txt" : "# install dependencies",
+    choices.language === "typescript" ? "npm run dev" : choices.language === "python" ? "python -m uvicorn app:app --reload" : "# start dev server",
+    choices.language === "typescript" ? "npm test" : choices.language === "python" ? "pytest" : "# run tests",
+    choices.language === "typescript" ? "npm run build" : "# build",
+    "```",
+    "",
+    "## Conventions",
+    "<!-- Show patterns by example. I learn by reading code, not rules. -->",
+    "```" + (choices.language === "typescript" ? "typescript" : choices.language),
+    "// Add code examples of your project's patterns here",
+    "```",
+    "",
+    "## Environment",
+    "<!-- Required vars marked [REQUIRED]. -->",
+    choices.cloudProvider === "brainstormrouter" ? "- `BRAINSTORM_API_KEY` [REQUIRED] \u2014 BrainstormRouter SaaS key" : "- [Add required environment variables]",
+    "",
+    "## Don't touch",
+    "<!-- Files I should never modify without asking. -->",
+    "- [Add protected files/directories here]",
+    ""
+  ];
+  return lines.filter((l) => l !== void 0).join("\n");
+}
+function generateBrainstormToml(choices) {
+  const strategy = choices.budgetTier === "low" ? "cost-first" : choices.budgetTier === "premium" ? "quality-first" : "combined";
+  const lines = [
+    "[general]",
+    `defaultStrategy = "${strategy}"`,
+    "",
+    "[providers.gateway]",
+    `enabled = ${choices.cloudProvider === "brainstormrouter"}`,
+    "",
+    "[providers.ollama]",
+    `enabled = ${choices.localModels.includes("ollama")}`,
+    "",
+    "[providers.lmstudio]",
+    `enabled = ${choices.localModels.includes("lmstudio")}`,
+    "",
+    "[budget]",
+    choices.budgetTier === "low" ? "daily = 2.00" : choices.budgetTier === "premium" ? "daily = 20.00" : "daily = 5.00",
+    "hardLimit = false",
+    ""
+  ];
+  return lines.join("\n");
+}
+function generateGitignore(choices) {
+  return `# Dependencies
+node_modules/
+.pnp.*
+venv/
+__pycache__/
+
+# Build
+dist/
+build/
+.next/
+.turbo/
+*.tsbuildinfo
+
+# Environment & secrets
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+secrets.dec.yaml
+
+# Data
+*.db
+*.db-wal
+*.db-shm
+
+# IDE & OS
+.idea/
+.vscode/settings.json
+*.swp
+.DS_Store
+
+# Test
+coverage/
+
+# Brainstorm
+.brainstorm/cache/
+`;
+}
+function generateBrainstormignore() {
+  return `# Build artifacts \u2014 never useful, always stale
+dist/
+build/
+.next/
+.turbo/
+__pycache__/
+*.pyc
+
+# Dependencies \u2014 I don't need to read library source
+node_modules/
+.pnp.*
+venv/
+
+# Lock files \u2014 huge, never informative
+package-lock.json
+yarn.lock
+pnpm-lock.yaml
+Cargo.lock
+
+# Binary/media \u2014 I can't read these meaningfully
+*.jpg
+*.png
+*.gif
+*.svg
+*.ico
+*.woff
+*.woff2
+*.ttf
+*.eot
+*.mp4
+*.mp3
+*.pdf
+
+# Generated/cached
+*.tsbuildinfo
+coverage/
+.cache/
+.eslintcache
+
+# Secrets \u2014 I should never see these
+.env
+.env.*
+!.env.example
+*.pem
+*.key
+*.p12
+credentials.json
+`;
+}
+function generatePrettierrc() {
+  return JSON.stringify({
+    semi: true,
+    singleQuote: true,
+    tabWidth: 2,
+    printWidth: 100,
+    trailingComma: "all"
+  }, null, 2) + "\n";
+}
+function generateEnvExample(choices) {
+  const lines = [
+    "# === LLM Providers ==="
+  ];
+  if (choices.cloudProvider === "brainstormrouter") {
+    lines.push(
+      "# BrainstormRouter SaaS (recommended \u2014 routes to optimal model)",
+      "# Sign up: https://brainstormrouter.com",
+      "BRAINSTORM_API_KEY="
+    );
+  } else if (choices.cloudProvider === "direct") {
+    lines.push(
+      "# Direct provider keys (set the ones you use)",
+      "# ANTHROPIC_API_KEY=",
+      "# OPENAI_API_KEY=",
+      "# GOOGLE_GENERATIVE_AI_API_KEY=",
+      "# DEEPSEEK_API_KEY="
+    );
+  }
+  lines.push(
+    "",
+    "# === Local Models ===",
+    "# Ollama runs on localhost:11434 by default (auto-detected)",
+    "# LM Studio runs on localhost:1234 by default (auto-detected)",
+    "",
+    "# === Application ===",
+    "# DATABASE_URL=",
+    "# Add project-specific env vars below",
+    ""
+  );
+  return lines.join("\n");
+}
+function generateCiWorkflow(choices) {
+  if (choices.ciTier === "monorepo") {
+    return `name: CI
+on:
+  push: { branches: [main] }
+  pull_request: { branches: [main] }
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with: { fetch-depth: 2 }
+      - uses: actions/setup-node@v4
+        with: { node-version: 22, cache: npm }
+      - run: npm ci
+      - run: npx turbo run typecheck test build --affected
+`;
+  }
+  if (choices.language === "python") {
+    return `name: CI
+on:
+  push: { branches: [main] }
+  pull_request: { branches: [main] }
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with: { python-version: "3.13" }
+      - run: pip install -r requirements.txt
+      - run: pytest
+`;
+  }
+  return `name: CI
+on:
+  push: { branches: [main] }
+  pull_request: { branches: [main] }
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with: { node-version: 22, cache: npm }
+      - run: npm ci
+      - run: npx tsc --noEmit
+      - run: npm test
+      - run: npm run build
+`;
+}
+function generateDeployWorkflow(choices) {
+  return `name: Deploy
+on:
+  push: { branches: [main] }
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with: { node-version: 22, cache: npm }
+      - run: npm ci && npm run build
+      # Add deployment command for your target:
+      # Vercel: npx vercel --prod --token=\${{ secrets.VERCEL_TOKEN }}
+      # DO App Platform: doctl apps create-deployment $APP_ID
+      # Docker: docker build -t app . && docker push
+      - run: echo "Configure deployment for ${choices.deploy}"
+`;
+}
+function generateReleaseWorkflow() {
+  return `name: Release
+on:
+  push: { tags: ['v*'] }
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with: { node-version: 22, cache: npm }
+      - run: npm ci && npm run build
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: \${{ secrets.NPM_TOKEN }}
+      - uses: softprops/action-gh-release@v2
+        with:
+          generate_release_notes: true
+`;
+}
+function generateDependabot() {
+  return `version: 2
+updates:
+  - package-ecosystem: npm
+    directory: /
+    schedule: { interval: weekly }
+    open-pull-requests-limit: 5
+    groups:
+      dev-deps:
+        dependency-type: development
+      prod-deps:
+        dependency-type: production
+`;
+}
+function generatePrTemplate() {
+  return `## Summary
+<!-- What does this PR do? -->
+
+## Test plan
+- [ ] Tests pass locally
+- [ ] Manually verified
+
+## Notes
+<!-- Anything reviewers should know? -->
+`;
+}
+function generateBugTemplate() {
+  return `---
+name: Bug Report
+about: Report a bug
+labels: bug
+---
+
+## Expected behavior
+
+## Actual behavior
+
+## Steps to reproduce
+
+## Environment
+- OS:
+- Node:
+- Version:
+`;
+}
+function generateFeatureTemplate() {
+  return `---
+name: Feature Request
+about: Suggest a feature
+labels: enhancement
+---
+
+## Problem
+<!-- What problem does this solve? -->
+
+## Proposed solution
+
+## Alternatives considered
+`;
+}
+
+// src/init/index.ts
+import { createGatewayClient } from "@brainst0rm/gateway";
+async function runInit(projectDir, options) {
+  const detection = await detectProject(projectDir);
+  let gatewayInfo = null;
+  const gw = createGatewayClient();
+  if (gw) {
+    try {
+      const [self, health, discovery] = await Promise.all([
+        gw.getSelf().catch(() => null),
+        gw.getHealth().catch(() => ({ status: "unknown" })),
+        gw.getDiscovery().catch(() => null)
+      ]);
+      if (self) {
+        gatewayInfo = {
+          connected: true,
+          modelCount: discovery?.models?.available ?? 0,
+          budget: discovery?.budget ? `$${discovery.budget.remaining_usd?.toFixed(2)}/${discovery.budget.period}` : void 0,
+          health: health.status
+        };
+      }
+    } catch {
+    }
+  }
+  let choices;
+  if (options.yes) {
+    choices = buildDefaultChoices(detection);
+    if (gatewayInfo) choices.cloudProvider = "brainstormrouter";
+    console.log("\n  brainstorm init --yes\n");
+    console.log(`  Auto-detected: ${choices.language} ${choices.type}`);
+    if (detection.localModels.length > 0) {
+      console.log(`  Local models: ${detection.localModels.join(", ")}`);
+    }
+    if (gatewayInfo) {
+      console.log(
+        `  Gateway: connected (${gatewayInfo.modelCount} models, ${gatewayInfo.health})`
+      );
+      if (gatewayInfo.budget) console.log(`  Budget: ${gatewayInfo.budget}`);
+    }
+    console.log();
+  } else {
+    if (gatewayInfo) {
+      console.log(
+        `
+  BrainstormRouter detected: ${gatewayInfo.modelCount} models, ${gatewayInfo.health}`
+      );
+    }
+    choices = await runPrompts(detection);
+    if (!choices) return;
+    if (gatewayInfo) choices.cloudProvider = "brainstormrouter";
+  }
+  const results = [];
+  const opts = { force: options.force };
+  results.push(
+    generateFile(projectDir, "STORM.md", generateStormMd(choices), opts)
+  );
+  results.push(
+    generateFile(
+      projectDir,
+      "brainstorm.toml",
+      generateBrainstormToml(choices),
+      opts
+    )
+  );
+  results.push(
+    generateFile(
+      projectDir,
+      ".brainstormignore",
+      generateBrainstormignore(),
+      opts
+    )
+  );
+  results.push(
+    generateFile(projectDir, ".env.example", generateEnvExample(choices), opts)
+  );
+  results.push(mergeGitignore(projectDir, generateGitignore(choices)));
+  results.push(
+    generateFile(projectDir, ".prettierrc", generatePrettierrc(), opts)
+  );
+  if (choices.ciTier !== "none") {
+    results.push(
+      generateFile(
+        projectDir,
+        ".github/workflows/ci.yml",
+        generateCiWorkflow(choices),
+        opts
+      )
+    );
+    results.push(
+      generateFile(
+        projectDir,
+        ".github/pull_request_template.md",
+        generatePrTemplate(),
+        opts
+      )
+    );
+    results.push(
+      generateFile(
+        projectDir,
+        ".github/ISSUE_TEMPLATE/bug_report.md",
+        generateBugTemplate(),
+        opts
+      )
+    );
+    results.push(
+      generateFile(
+        projectDir,
+        ".github/ISSUE_TEMPLATE/feature_request.md",
+        generateFeatureTemplate(),
+        opts
+      )
+    );
+    if (choices.ciTier === "full") {
+      results.push(
+        generateFile(
+          projectDir,
+          ".github/workflows/deploy.yml",
+          generateDeployWorkflow(choices),
+          opts
+        )
+      );
+      results.push(
+        generateFile(
+          projectDir,
+          ".github/workflows/release.yml",
+          generateReleaseWorkflow(),
+          opts
+        )
+      );
+      results.push(
+        generateFile(
+          projectDir,
+          ".github/dependabot.yml",
+          generateDependabot(),
+          opts
+        )
+      );
+    }
+  }
+  console.log("  Results:\n");
+  for (const r of results) {
+    const icon = r.action === "created" ? "+" : r.action === "merged" ? "~" : "-";
+    const label = r.action === "created" ? "created" : r.action === "merged" ? "merged" : "exists (skipped)";
+    console.log(`    ${icon} ${r.path}  (${label})`);
+  }
+  const created = results.filter((r) => r.action === "created").length;
+  const merged = results.filter((r) => r.action === "merged").length;
+  const skipped = results.filter((r) => r.action === "skipped").length;
+  console.log(
+    `
+  Done. ${created} created, ${merged} merged, ${skipped} skipped.`
+  );
+  console.log(
+    "  Edit STORM.md to add your architecture, entry points, and conventions.\n"
+  );
+}
+
+// src/bin/brainstorm.ts
+import { runEvalCli, runProbe } from "@brainst0rm/eval";
+import {
+  createGatewayClient as createGatewayClient2,
+  createIntelligenceClient,
+  formatGatewayFeedback
+} from "@brainst0rm/gateway";
+import { MCPClientManager } from "@brainst0rm/mcp";
+import { BrainstormVault, KeyResolver } from "@brainst0rm/vault";
+import { homedir } from "os";
+import { join as join3 } from "path";
+import { readFileSync as readFileSyncVersion } from "fs";
+import { dirname as dirnameVersion } from "path";
+import { fileURLToPath as fileURLToPathVersion } from "url";
+var PROVIDER_KEY_NAMES = [
+  "BRAINSTORM_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "GOOGLE_GENERATIVE_AI_API_KEY",
+  "DEEPSEEK_API_KEY",
+  "MOONSHOT_API_KEY",
+  "BRAINSTORM_ADMIN_KEY"
+];
+async function resolveProviderKeys() {
+  const vault = new BrainstormVault(VAULT_PATH);
+  const resolver = new KeyResolver(
+    vault.exists() ? vault : null,
+    () => promptPassword("  Vault password: ")
+  );
+  const resolved = /* @__PURE__ */ new Map();
+  for (const name of PROVIDER_KEY_NAMES) {
+    const value = await resolver.get(name);
+    if (value) resolved.set(name, value);
+  }
+  return { get: (name) => resolved.get(name) ?? null };
+}
+function buildCompactionCallbacks(sessionManager) {
+  return {
+    getTokenEstimate: () => sessionManager.getTokenEstimate(),
+    compact: (opts) => sessionManager.compact(opts)
+  };
+}
+async function connectMCPServers(tools, config, resolvedBRKey) {
+  const mcp = new MCPClientManager();
+  if (config.mcp.servers.length > 0) {
+    mcp.addServers(
+      config.mcp.servers.map((s) => ({
+        name: s.name,
+        transport: s.transport,
+        url: s.url ?? "",
+        command: s.command,
+        args: s.args,
+        env: s.env,
+        enabled: s.enabled,
+        toolFilter: s.toolFilter
+      }))
+    );
+  }
+  const { connected, errors } = await mcp.connectAll(tools);
+  if (connected.length > 0) {
+    process.stderr.write(`[mcp] Connected: ${connected.join(", ")}
+`);
+  }
+  for (const err of errors) {
+    process.stderr.write(`[mcp] ${err.name}: ${err.error}
+`);
+  }
+}
+var program = new Command();
+var __pkg_dir = join3(
+  dirnameVersion(fileURLToPathVersion(import.meta.url)),
+  ".."
+);
+var CLI_VERSION = "0.12.1";
+try {
+  CLI_VERSION = JSON.parse(
+    readFileSyncVersion(join3(__pkg_dir, "package.json"), "utf-8")
+  ).version;
+} catch {
+}
+program.name("brainstorm").description("AI coding assistant with intelligent model routing").version(CLI_VERSION);
+program.command("init").description("Initialize project for AI-assisted development").option("--yes", "Use defaults, skip prompts").option("--force", "Overwrite existing files").action(async (opts) => {
+  await runInit(process.cwd(), opts);
+});
+program.command("eval").description("Run capability evaluation probes against a model").option(
+  "--model <id>",
+  "Model to evaluate (e.g., anthropic/claude-sonnet-4-6)"
+).option("--capability <dim>", "Run only probes for this dimension").option("--compare", "Compare results across all previously evaluated models").option(
+  "--scorecard",
+  "Show current capability scores without re-running probes"
+).option("--all-models", "Run probes against every available model").option("--timeout <ms>", "Timeout per probe in milliseconds", "30000").action(
+  async (opts) => {
+    await runEvalCli({
+      model: opts.model,
+      capability: opts.capability,
+      compare: opts.compare,
+      scorecard: opts.scorecard,
+      allModels: opts.allModels,
+      timeout: parseInt(opts.timeout ?? "30000")
+    });
+  }
+);
+program.command("eval-swe-bench").description(
+  "Run SWE-bench evaluation: apply agent to instances, score with Docker"
+).requiredOption(
+  "--instances <path>",
+  "Path to SWE-bench instances.jsonl file"
+).option("--model <id>", "Target model (default: let router decide)").option("--limit <n>", "Max instances to evaluate", "10").option("--concurrency <n>", "Parallel evaluations", "2").option("--json", "Output results as JSON").action(
+  async (opts) => {
+    const { loadInstances, runSWEBench, scorePatch, generateScorecard } = await import("@brainst0rm/eval");
+    const limit = parseInt(opts.limit);
+    const concurrency = parseInt(opts.concurrency);
+    console.log(`
+  SWE-bench Evaluation`);
+    console.log(`  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+`);
+    console.log(`  Instances: ${opts.instances}`);
+    console.log(`  Limit: ${limit}`);
+    console.log(`  Model: ${opts.model ?? "auto (router decides)"}`);
+    console.log(`  Concurrency: ${concurrency}
+`);
+    const instances = loadInstances(opts.instances, limit);
+    console.log(`  Loaded ${instances.length} instances.
+`);
+    if (instances.length === 0) {
+      console.error("  No instances found in file.");
+      process.exit(1);
+    }
+    const config = loadConfig();
+    config.general.defaultPermissionMode = "auto";
+    const db = getDb();
+    const resolvedKeys = await resolveProviderKeys();
+    const registry = await createProviderRegistry(config, resolvedKeys);
+    const costTracker = new CostTracker(db, config.budget);
+    const tools = createDefaultToolRegistry();
+    const { frontmatter } = buildSystemPrompt(process.cwd());
+    const router = new BrainstormRouter(
+      config,
+      registry,
+      costTracker,
+      frontmatter
+    );
+    if (opts.model) {
+    } else {
+      router.setStrategy("quality-first");
+    }
+    const { execFileSync: execGit } = await import("child_process");
+    const {
+      mkdtempSync,
+      writeFileSync: writePatch,
+      rmSync
+    } = await import("fs");
+    const { tmpdir } = await import("os");
+    let completed = 0;
+    console.log(`  Running agent on ${instances.length} instances...
+`);
+    const patches = await runSWEBench(
+      instances,
+      async (instance) => {
+        const startTime = Date.now();
+        const instanceNum = ++completed;
+        const shortId = instance.instanceId.slice(0, 40);
+        try {
+          const workDir = mkdtempSync(join3(tmpdir(), "swe-bench-"));
+          const repoDir = join3(workDir, "repo");
+          try {
+            process.stderr.write(
+              `  [${instanceNum}/${instances.length}] ${shortId} \u2014 cloning...`
+            );
+            execGit(
+              "git",
+              [
+                "clone",
+                "--depth",
+                "100",
+                `https://github.com/${instance.repo}.git`,
+                "repo"
+              ],
+              {
+                cwd: workDir,
+                timeout: 12e4,
+                stdio: ["ignore", "pipe", "pipe"]
+              }
+            );
+            execGit("git", ["checkout", instance.baseCommit], {
+              cwd: repoDir,
+              timeout: 3e4,
+              stdio: ["ignore", "pipe", "pipe"]
+            });
+            process.stderr.write(` solving...`);
+            const issuePrompt = [
+              `You are solving a GitHub issue in this repository.`,
+              ``,
+              `## Problem`,
+              instance.issue,
+              instance.hints ? `
+## Hints
+${instance.hints}` : "",
+              ``,
+              `## Instructions`,
+              `1. Read the relevant source files to understand the codebase`,
+              `2. Identify the root cause of the issue`,
+              `3. Make the minimal code changes needed to fix it`,
+              `4. Do NOT modify test files`,
+              `5. Verify your changes make sense by re-reading the modified files`
+            ].join("\n");
+            const result = await spawnSubagent(issuePrompt, {
+              config,
+              registry,
+              router,
+              costTracker,
+              tools,
+              projectPath: repoDir,
+              type: "code",
+              maxSteps: 15,
+              budgetLimit: 3,
+              permissionCheck: () => "allow"
+              // unattended — auto-approve everything
+            });
+            let patch = "";
+            try {
+              patch = execGit("git", ["diff"], {
+                cwd: repoDir,
+                encoding: "utf-8",
+                timeout: 1e4,
+                stdio: ["ignore", "pipe", "pipe"]
+              });
+              const untrackedDiff = execGit("git", ["diff", "--cached"], {
+                cwd: repoDir,
+                encoding: "utf-8",
+                timeout: 1e4,
+                stdio: ["ignore", "pipe", "pipe"]
+              });
+              if (untrackedDiff) patch += "\n" + untrackedDiff;
+            } catch {
+            }
+            const success = patch.length > 0 && !result.budgetExceeded;
+            const status = success ? "\u2713" : patch.length === 0 ? "no changes" : "budget exceeded";
+            process.stderr.write(
+              ` ${status} ($${result.cost.toFixed(3)}, ${result.modelUsed})
+`
+            );
+            return {
+              instanceId: instance.instanceId,
+              patch,
+              model: result.modelUsed,
+              strategy: opts.model ? "forced" : "quality-first",
+              cost: result.cost,
+              latencyMs: Date.now() - startTime,
+              success
+            };
+          } finally {
+            try {
+              rmSync(workDir, { recursive: true, force: true });
+            } catch {
+            }
+          }
+        } catch (err) {
+          process.stderr.write(
+            ` ERROR: ${(err.message ?? "").slice(0, 80)}
+`
+          );
+          return {
+            instanceId: instance.instanceId,
+            patch: "",
+            model: "error",
+            strategy: "quality-first",
+            cost: 0,
+            latencyMs: Date.now() - startTime,
+            success: false
+          };
+        }
+      },
+      concurrency
+    );
+    console.log(`  Scoring ${patches.length} patches...`);
+    const scores = patches.map(
+      (patch, i) => scorePatch(instances[i], patch)
+    );
+    const scorecard = generateScorecard(patches, scores);
+    if (opts.json) {
+      console.log(JSON.stringify(scorecard, null, 2));
+      return;
+    }
+    console.log(`
+  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
+    console.log(`   SWE-bench Results`);
+    console.log(`  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+`);
+    console.log(`  Total:     ${scorecard.total}`);
+    console.log(
+      `  Passed:    ${scorecard.passed} (${(scorecard.passRate * 100).toFixed(1)}%)`
+    );
+    console.log(`  Failed:    ${scorecard.failed}`);
+    console.log(`  Errored:   ${scorecard.errored}`);
+    console.log(`  Cost:      $${scorecard.totalCost.toFixed(4)}`);
+    console.log(`  Avg Lat:   ${scorecard.avgLatencyMs}ms`);
+    console.log();
+  }
+);
+var routerCmd = program.command("router").description("Manage BrainstormRouter gateway");
+routerCmd.command("status").description("Show gateway health, budget, and rate limits").action(async () => {
+  const gw = createGatewayClient2();
+  if (!gw) {
+    console.error(
+      "  BRAINSTORM_API_KEY not set. Configure with: export BRAINSTORM_API_KEY=br_live_xxx"
+    );
+    return;
+  }
+  try {
+    const [self, health] = await Promise.all([gw.getSelf(), gw.getHealth()]);
+    console.log("\n  BrainstormRouter Gateway\n");
+    console.log(`  Health:  ${health.status}`);
+    console.log(`  Role:    ${self.identity.roles.join(", ")}`);
+    console.log(`  Caps:    ${self.capabilities.granted.length} permissions`);
+    try {
+      const discovery = await gw.getDiscovery();
+      if (discovery.budget) {
+        console.log(
+          `  Budget:  $${discovery.budget.remaining_usd?.toFixed(2)} / $${discovery.budget.limit_usd?.toFixed(2)} (${discovery.budget.period})`
+        );
+      }
+      if (discovery.models) {
+        console.log(
+          `  Models:  ${discovery.models.available} available, ${discovery.models.runnable} runnable`
+        );
+      }
+    } catch {
+      console.log("  Budget:  (discovery unavailable)");
+      console.log("  Models:  (discovery unavailable)");
+    }
+    console.log();
+  } catch (e) {
+    console.error(`  Error: ${e.message}`);
+  }
+});
+routerCmd.command("models").description("List models available through the gateway").option("--json", "Output as JSON").action(async (opts) => {
+  const gw = createGatewayClient2();
+  if (!gw) {
+    console.error("  BRAINSTORM_API_KEY not set.");
+    return;
+  }
+  try {
+    const models = await gw.listModels();
+    if (opts.json) {
+      console.log(JSON.stringify(models, null, 2));
+      return;
+    }
+    console.log(`
+  Gateway Models (${models.length})
+`);
+    for (const m of models.slice(0, 30)) {
+      const name = (m.name ?? m.id).padEnd(40);
+      const provider = (m.provider ?? "").padEnd(12);
+      console.log(`    ${provider} ${name}`);
+    }
+    if (models.length > 30)
+      console.log(`    ... and ${models.length - 30} more`);
+    console.log();
+  } catch (e) {
+    console.error(`  Error: ${e.message}`);
+  }
+});
+routerCmd.command("budget").description("Show gateway-side cost tracking and forecast").action(async () => {
+  const gw = createGatewayClient2();
+  if (!gw) {
+    console.error("  BRAINSTORM_API_KEY not set.");
+    return;
+  }
+  try {
+    const usage = await gw.getUsageSummary();
+    console.log("\n  Gateway Budget\n");
+    console.log(`  Requests: ${usage.total_requests ?? "N/A"}`);
+    console.log(`  Cost:     $${(usage.total_cost_usd ?? 0).toFixed(4)}`);
+    console.log(
+      `  Tokens:   ${(usage.total_input_tokens ?? 0).toLocaleString()} in / ${(usage.total_output_tokens ?? 0).toLocaleString()} out`
+    );
+    if (usage.by_model?.length > 0) {
+      console.log("\n  By model:");
+      for (const m of usage.by_model) {
+        console.log(
+          `    ${m.model}: $${m.cost_usd.toFixed(4)} (${m.requests} reqs)`
+        );
+      }
+    }
+    console.log();
+  } catch (e) {
+    console.error(`  Error: ${e.message}`);
+  }
+});
+routerCmd.command("keys").description("List API keys").option("--json", "Output as JSON").action(async (opts) => {
+  const gw = createGatewayClient2();
+  if (!gw) {
+    console.error("  BRAINSTORM_API_KEY not set.");
+    return;
+  }
+  try {
+    const keys = await gw.listKeys();
+    if (opts.json) {
+      console.log(JSON.stringify(keys, null, 2));
+      return;
+    }
+    console.log(`
+  API Keys (${keys.length})
+`);
+    for (const k of keys) {
+      const budget = k.budgetLimitUsd ? `$${k.budgetLimitUsd}/${k.budgetPeriod}` : "unlimited";
+      console.log(
+        `    ${k.id.slice(0, 8)}  ${(k.name ?? "").padEnd(30)} scopes=${JSON.stringify(k.scopes)}  budget=${budget}`
+      );
+    }
+    console.log();
+  } catch (e) {
+    console.error(`  Error: ${e.message}`);
+  }
+});
+routerCmd.command("config").description("Get or set gateway configuration").argument("<key>", "Config key (e.g., guardrails, tools)").argument("[value]", "JSON value to set (omit to read)").action(async (key, value) => {
+  const gw = createGatewayClient2();
+  if (!gw) {
+    console.error("  BRAINSTORM_API_KEY not set.");
+    return;
+  }
+  try {
+    if (value) {
+      await gw.setConfig(key, JSON.parse(value));
+      console.log(`  Set config/${key}`);
+    } else {
+      const data = await gw.getConfig(key);
+      console.log(JSON.stringify(data, null, 2));
+    }
+  } catch (e) {
+    console.error(`  Error: ${e.message}`);
+  }
+});
+routerCmd.command("audit").description("Show recent request audit trail").option("--since <duration>", "Time range (e.g., 1h, 24h, 7d)", "24h").action(async (opts) => {
+  const gw = createGatewayClient2();
+  if (!gw) {
+    console.error("  BRAINSTORM_API_KEY not set.");
+    return;
+  }
+  try {
+    const entries = await gw.getCompletionAudit(opts.since);
+    console.log(`
+  Audit Trail (last ${opts.since})
+`);
+    if (entries.length === 0) {
+      console.log("    No entries found.");
+    }
+    for (const e of entries.slice(0, 20)) {
+      console.log(
+        `    ${e.timestamp}  ${(e.model ?? "").padEnd(35)}  $${(e.cost_usd ?? 0).toFixed(4)}  ${e.latency_ms ?? "?"}ms  guardian=${e.guardian_status ?? "?"}`
+      );
+    }
+    if (entries.length > 20)
+      console.log(`    ... ${entries.length - 20} more`);
+    console.log();
+  } catch (e) {
+    console.error(`  Error: ${e.message}`);
+  }
+});
+routerCmd.command("memory").description("List gateway memory entries").action(async () => {
+  const gw = createGatewayClient2();
+  if (!gw) {
+    console.error("  BRAINSTORM_API_KEY not set.");
+    return;
+  }
+  try {
+    const entries = await gw.listMemory();
+    console.log(`
+  Gateway Memory (${entries.length} entries)
+`);
+    for (const e of entries) {
+      const block = e.block ?? "unknown";
+      const content = e.content ?? JSON.stringify(e).slice(0, 80);
+      console.log(
+        `    [${block}] ${content.slice(0, 80)}${content.length > 80 ? "..." : ""}`
+      );
+    }
+    console.log();
+  } catch (e) {
+    console.error(`  Error: ${e.message}`);
+  }
+});
+program.command("models").description("List available models and their status").action(async () => {
+  const config = loadConfig();
+  const registry = await createProviderRegistry(
+    config,
+    await resolveProviderKeys()
+  );
+  console.log("\n\u{1F9E0} Brainstorm \u2014 Available Models\n");
+  const local = registry.models.filter((m) => m.isLocal);
+  const cloud = registry.models.filter((m) => !m.isLocal);
+  if (local.length > 0) {
+    console.log("  Local Models:");
+    for (const m of local) {
+      const status = m.status === "available" ? "\u25CF" : "\u25CB";
+      console.log(
+        `    ${status} ${m.id}  (quality: ${m.capabilities.qualityTier}, speed: ${m.capabilities.speedTier})`
+      );
+    }
+    console.log();
+  } else {
+    console.log(
+      "  Local Models: none detected (start Ollama, LM Studio, or llama.cpp)\n"
+    );
+  }
+  console.log("  Cloud Models (via AI Gateway):");
+  for (const m of cloud) {
+    const cost = `$${m.pricing.inputPer1MTokens}/${m.pricing.outputPer1MTokens} per 1M tokens`;
+    console.log(
+      `    \u25CF ${m.id}  (quality: ${m.capabilities.qualityTier}, ${cost})`
+    );
+  }
+  console.log();
+});
+program.command("budget").description("Show cost tracking and budget status").action(async () => {
+  const config = loadConfig();
+  const db = getDb();
+  const costTracker = new CostTracker(db, config.budget);
+  const summary = costTracker.getSummary();
+  console.log("\n\u{1F9E0} Brainstorm \u2014 Budget Status\n");
+  console.log(`  Session:    $${summary.session.toFixed(4)}`);
+  console.log(
+    `  Today:      $${summary.today.toFixed(4)}${config.budget.daily ? ` / $${config.budget.daily.toFixed(2)}` : ""}`
+  );
+  console.log(
+    `  This month: $${summary.thisMonth.toFixed(4)}${config.budget.monthly ? ` / $${config.budget.monthly.toFixed(2)}` : ""}`
+  );
+  if (summary.byModel.length > 0) {
+    console.log("\n  Cost by model:");
+    for (const entry of summary.byModel) {
+      console.log(
+        `    ${entry.modelId}: $${entry.totalCost.toFixed(4)} (${entry.requestCount} requests)`
+      );
+    }
+  }
+  console.log();
+});
+program.command("config").description("Show current configuration").action(async () => {
+  const config = loadConfig();
+  console.log("\n\u{1F9E0} Brainstorm \u2014 Configuration\n");
+  console.log(`  Strategy:     ${config.general.defaultStrategy}`);
+  console.log(`  Max steps:    ${config.general.maxSteps}`);
+  console.log(`  Confirm tools: ${config.general.confirmTools}`);
+  console.log(
+    `  Budget daily: ${config.budget.daily ? `$${config.budget.daily}` : "unlimited"}`
+  );
+  console.log(
+    `  Budget monthly: ${config.budget.monthly ? `$${config.budget.monthly}` : "unlimited"}`
+  );
+  console.log(`  Hard limit:   ${config.budget.hardLimit}`);
+  console.log(
+    `  Ollama:       ${config.providers.ollama.enabled ? config.providers.ollama.baseUrl : "disabled"}`
+  );
+  console.log(
+    `  LM Studio:    ${config.providers.lmstudio.enabled ? config.providers.lmstudio.baseUrl : "disabled"}`
+  );
+  console.log(
+    `  llama.cpp:    ${config.providers.llamacpp.enabled ? config.providers.llamacpp.baseUrl : "disabled"}`
+  );
+  console.log(
+    `  AI Gateway:   ${config.providers.gateway.enabled ? "enabled" : "disabled"}`
+  );
+  if (config.routing.rules.length > 0) {
+    console.log(`  Routing rules: ${config.routing.rules.length}`);
+  }
+  console.log();
+});
+var agentCmd = program.command("agent").description("Manage named agents");
+agentCmd.command("create").description("Create an agent (structured flags or natural language)").argument(
+  "[description...]",
+  'Natural language description (e.g., "architect using opus with $30 budget")'
+).option("--id <id>", "Agent ID").option("--model <model>", "Model ID or alias").option(
+  "--role <role>",
+  "Agent role (architect|coder|reviewer|debugger|analyst|custom)"
+).option("--budget <usd>", "Per-workflow budget in USD", parseFloat).option("--budget-daily <usd>", "Daily budget in USD", parseFloat).option("--description <desc>", "What this agent does").option("--confidence <threshold>", "Confidence threshold 0-1", parseFloat).action(async (descWords, opts) => {
+  const config = loadConfig();
+  const db = getDb();
+  const manager = new AgentManager(db, config);
+  const nlInput = descWords.join(" ");
+  const parseResult = nlInput ? parseAgentNL(nlInput) : null;
+  const parsed = parseResult?.intent;
+  if (nlInput && !parsed && parseResult?.suggestion) {
+    console.log(
+      `  Could not parse agent definition.
+  ${parseResult.suggestion}`
+    );
+    process.exit(1);
+  }
+  const id = opts.id ?? parsed?.id ?? "agent-" + Date.now().toString(36);
+  const role = opts.role ?? parsed?.role ?? "custom";
+  const modelId = opts.model ?? parsed?.modelId ?? "auto";
+  const budget = opts.budget ?? parsed?.budget;
+  const budgetDaily = opts.budgetDaily ?? parsed?.budgetDaily;
+  const description = opts.description ?? parsed?.description ?? "";
+  const confidence = opts.confidence ?? 0.7;
+  const agent = manager.create({
+    id,
+    displayName: id.charAt(0).toUpperCase() + id.slice(1),
+    role,
+    description,
+    modelId,
+    allowedTools: role === "coder" ? "all" : ["file_read", "glob", "grep"],
+    budget: {
+      perWorkflow: budget,
+      daily: budgetDaily,
+      exhaustionAction: "downgrade"
+    },
+    confidenceThreshold: confidence,
+    maxSteps: 10,
+    fallbackChain: [],
+    guardrails: { pii: parsed?.guardrailsPii },
+    lifecycle: "active"
+  });
+  console.log(`
+  Created agent '${agent.id}'`);
+  console.log(`    Role: ${agent.role}`);
+  console.log(`    Model: ${agent.modelId}`);
+  if (agent.budget.perWorkflow)
+    console.log(`    Budget: $${agent.budget.perWorkflow}/workflow`);
+  if (agent.budget.daily)
+    console.log(`    Daily: $${agent.budget.daily}/day`);
+  if (agent.guardrails.pii) console.log(`    Guardrails: PII enabled`);
+  console.log();
+});
+agentCmd.command("list").description("List all agents").action(async () => {
+  const config = loadConfig();
+  const db = getDb();
+  const manager = new AgentManager(db, config);
+  const agents = manager.list();
+  console.log("\n  Agents:\n");
+  if (agents.length === 0) {
+    console.log(
+      "    No agents defined. Create one with: storm agent create <description>"
+    );
+  }
+  for (const a of agents) {
+    const budget = a.budget.perWorkflow ? `$${a.budget.perWorkflow}/wf` : a.budget.daily ? `$${a.budget.daily}/day` : "unlimited";
+    console.log(
+      `    ${a.id}  (${a.role})  model: ${a.modelId}  budget: ${budget}`
+    );
+  }
+  console.log();
+});
+agentCmd.command("show").description("Show agent details").argument("<id>", "Agent ID").action(async (id) => {
+  const config = loadConfig();
+  const db = getDb();
+  const manager = new AgentManager(db, config);
+  const agent = manager.get(id);
+  if (!agent) {
+    console.error(`  Agent '${id}' not found.`);
+    process.exit(1);
+  }
+  console.log(`
+  Agent: ${agent.id}`);
+  console.log(`    Display Name: ${agent.displayName}`);
+  console.log(`    Role: ${agent.role}`);
+  console.log(`    Model: ${agent.modelId}`);
+  console.log(`    Description: ${agent.description || "(none)"}`);
+  console.log(`    Allowed Tools: ${JSON.stringify(agent.allowedTools)}`);
+  console.log(
+    `    Budget/Workflow: ${agent.budget.perWorkflow ? `$${agent.budget.perWorkflow}` : "unlimited"}`
+  );
+  console.log(
+    `    Budget/Daily: ${agent.budget.daily ? `$${agent.budget.daily}` : "unlimited"}`
+  );
+  console.log(`    Confidence: ${agent.confidenceThreshold}`);
+  console.log(
+    `    Fallback Chain: ${agent.fallbackChain.length > 0 ? agent.fallbackChain.join(" \u2192 ") : "(none)"}`
+  );
+  console.log(`    Guardrails: PII=${agent.guardrails.pii ?? false}`);
+  console.log(`    Status: ${agent.lifecycle}`);
+  console.log();
+});
+agentCmd.command("delete").description("Delete an agent").argument("<id>", "Agent ID").action(async (id) => {
+  const config = loadConfig();
+  const db = getDb();
+  const manager = new AgentManager(db, config);
+  try {
+    const deleted = manager.delete(id);
+    if (deleted) console.log(`  Deleted agent '${id}'.`);
+    else console.error(`  Agent '${id}' not found.`);
+  } catch (e) {
+    console.error(`  ${e.message}`);
+  }
+});
+var workflowCmd = program.command("workflow").description("Run multi-agent workflows");
+workflowCmd.command("list").description("List available workflows").action(async () => {
+  console.log("\n  Workflows:\n");
+  for (const w of PRESET_WORKFLOWS) {
+    const steps = w.steps.map((s) => s.agentRole).join(" \u2192 ");
+    console.log(`    ${w.id}  \u2014 ${w.description}`);
+    console.log(
+      `      Steps: ${steps}  (mode: ${w.communicationMode}, max loops: ${w.maxIterations})`
+    );
+  }
+  console.log();
+});
+workflowCmd.command("run").description("Run a workflow").argument("<preset>", "Workflow preset ID or natural language description").argument("[description...]", "What to build/fix/review").option(
+  "--agents <mapping>",
+  'Agent role overrides (e.g., "architect=my-arch,coder=my-coder")'
+).option("--mode <mode>", "Communication mode (handoff|shared)", "handoff").option(
+  "--step-model <overrides...>",
+  'Per-step model overrides (e.g., "plan=claude-opus-4.6 code=claude-sonnet-4.6")'
+).option("--dry-run", "Show cost forecast only").action(async (preset, descWords, opts) => {
+  const description = descWords.join(" ") || preset;
+  let workflow = getPresetWorkflow(preset);
+  if (!workflow) {
+    const autoPreset = autoSelectPreset(preset + " " + description);
+    if (autoPreset) workflow = getPresetWorkflow(autoPreset);
+  }
+  if (!workflow) {
+    console.error(
+      `  Unknown workflow: '${preset}'. Run 'storm workflow list' to see available workflows.`
+    );
+    process.exit(1);
+  }
+  const config = loadConfig();
+  const db = getDb();
+  const registry = await createProviderRegistry(
+    config,
+    await resolveProviderKeys()
+  );
+  const costTracker = new CostTracker(db, config.budget);
+  const projectPath = process.cwd();
+  const { frontmatter } = buildSystemPrompt(projectPath);
+  const router = new BrainstormRouter(
+    config,
+    registry,
+    costTracker,
+    frontmatter
+  );
+  const agentManager = new AgentManager(db, config);
+  const agentOverrides = {};
+  if (opts.agents) {
+    for (const pair of opts.agents.split(",")) {
+      const [role, agentId] = pair.split("=");
+      if (role && agentId) agentOverrides[role.trim()] = agentId.trim();
+    }
+  }
+  const stepModelOverrides = {};
+  if (opts.stepModel) {
+    const items = Array.isArray(opts.stepModel) ? opts.stepModel : [opts.stepModel];
+    for (const item of items) {
+      for (const pair of item.split(/\s+/)) {
+        const [step, model] = pair.split("=");
+        if (step && model) stepModelOverrides[step.trim()] = model.trim();
+      }
+    }
+  }
+  console.log(`
+  Workflow: ${workflow.name}`);
+  console.log(`  Request: "${description}"`);
+  console.log(
+    `  Steps: ${workflow.steps.map((s) => s.agentRole).join(" \u2192 ")}`
+  );
+  if (Object.keys(stepModelOverrides).length > 0) {
+    console.log(
+      `  Model overrides: ${Object.entries(stepModelOverrides).map(([s, m]) => `${s}=${m}`).join(", ")}`
+    );
+  }
+  console.log();
+  for await (const event of runWorkflow(
+    workflow,
+    description,
+    agentOverrides,
+    {
+      config,
+      db,
+      registry,
+      router,
+      costTracker,
+      agentManager,
+      projectPath,
+      stepModelOverrides
+    }
+  )) {
+    switch (event.type) {
+      case "cost-forecast":
+        console.log(`  Estimated cost: $${event.estimated.toFixed(4)}`);
+        for (const b of event.breakdown) {
+          console.log(`    ${b.step}: $${b.cost.toFixed(4)}`);
+        }
+        if (opts.dryRun) {
+          console.log("\n  (dry run \u2014 not executing)\n");
+          return;
+        }
+        console.log();
+        break;
+      case "step-started":
+        process.stdout.write(
+          `  [${event.agent.role}] ${event.agent.displayName} (${event.agent.modelId})...`
+        );
+        break;
+      case "step-progress":
+        if (event.event.type === "text-delta") {
+        }
+        if (event.event.type === "routing") {
+          process.stdout.write(` \u2192 ${event.event.decision.model.name}`);
+        }
+        break;
+      case "step-completed":
+        console.log(
+          ` done ($${event.step.cost.toFixed(4)}, confidence: ${event.artifact.confidence.toFixed(2)})`
+        );
+        break;
+      case "step-failed":
+        console.log(` FAILED: ${event.error.message}`);
+        break;
+      case "review-rejected":
+        console.log(
+          `  [review] Rejected \u2014 looping back to ${event.loopingBackTo} (iteration ${event.step.iteration + 1})`
+        );
+        break;
+      case "confidence-escalation":
+        console.log(
+          `  [confidence] ${event.action} (${event.confidence.toFixed(2)})`
+        );
+        break;
+      case "model-fallback":
+        console.log(
+          `  [fallback] ${event.originalModel} \u2192 ${event.fallbackModel}: ${event.reason}`
+        );
+        break;
+      case "workflow-completed":
+        console.log(
+          `
+  Workflow complete. Total cost: $${event.run.totalCost.toFixed(4)}`
+        );
+        console.log(
+          `  Artifacts: ${event.run.artifacts.map((a) => a.id).join(", ")}
+`
+        );
+        break;
+      case "workflow-failed":
+        console.log(`
+  Workflow failed: ${event.error.message}
+`);
+        break;
+    }
+  }
+});
+program.command("run").description("Run a single prompt non-interactively").argument("[prompt]", "The prompt to send").option("--json", "Output structured JSON (for CI/CD pipelines)").option("--pipe", "Read from stdin if no prompt given").option("--model <id>", "Target a specific model (bypass routing)").option("--tools", "Enable tool use (default: disabled)").option("--max-steps <n>", "Maximum agentic steps (default: 1)", "1").option(
+  "--strategy <name>",
+  "Routing strategy: cost-first, quality-first, combined, capability"
+).option("--lfg", "Full auto mode \u2014 skip all permission confirmations").option(
+  "--unattended",
+  "Unattended mode \u2014 enable tools, auto-approve, auto-commit on success"
+).action(
+  async (prompt, opts) => {
+    let finalPrompt = prompt;
+    if (opts.pipe) {
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+      }
+      const stdinText = Buffer.concat(chunks).toString("utf-8").trim();
+      if (finalPrompt) {
+        finalPrompt = `${finalPrompt}
+
+${stdinText}`;
+      } else {
+        finalPrompt = stdinText;
+      }
+    }
+    if (!finalPrompt) {
+      process.stderr.write(
+        "Error: No prompt provided. Pass a prompt argument or use --pipe to read from stdin.\n"
+      );
+      process.exit(1);
+    }
+    const config = loadConfig();
+    if (opts.lfg || opts.unattended) {
+      config.general.defaultPermissionMode = "auto";
+    }
+    if (opts.unattended) {
+      opts.tools = true;
+      if (!opts.maxSteps || opts.maxSteps === "1") opts.maxSteps = "15";
+    }
+    const db = getDb();
+    const resolvedKeys = await resolveProviderKeys();
+    const resolvedBRKey = resolvedKeys.get("BRAINSTORM_API_KEY") ?? getBrainstormApiKey();
+    const isCommunityTier = isCommunityKey(resolvedBRKey);
+    if (resolvedBRKey) process.env._BR_RESOLVED_KEY = resolvedBRKey;
+    const registry = await createProviderRegistry(config, resolvedKeys);
+    const costTracker = new CostTracker(db, config.budget);
+    const tools = createDefaultToolRegistry();
+    await connectMCPServers(
+      tools,
+      config,
+      resolvedKeys.get("BRAINSTORM_API_KEY")
+    );
+    const sessionManager = new SessionManager(db);
+    const projectPath = process.cwd();
+    configureSandbox(
+      config.shell.sandbox,
+      projectPath,
+      config.shell.maxOutputBytes,
+      config.shell.containerImage,
+      config.shell.containerTimeout
+    );
+    const { prompt: rawPrompt, frontmatter } = buildSystemPrompt(projectPath);
+    const systemPrompt = rawPrompt + buildToolAwarenessSection(tools.listTools());
+    const router = new BrainstormRouter(
+      config,
+      registry,
+      costTracker,
+      frontmatter
+    );
+    const permissionManager = new PermissionManager(
+      config.general.defaultPermissionMode,
+      config.permissions
+    );
+    const hasDirectKeys = !!resolvedKeys.get("DEEPSEEK_API_KEY") || !!resolvedKeys.get("ANTHROPIC_API_KEY") || !!resolvedKeys.get("OPENAI_API_KEY") || !!resolvedKeys.get("GOOGLE_GENERATIVE_AI_API_KEY") || !!resolvedKeys.get("MOONSHOT_API_KEY");
+    if (opts.strategy) {
+      router.setStrategy(opts.strategy);
+    } else if (!isCommunityTier || hasDirectKeys) {
+      router.setStrategy("quality-first");
+    }
+    const session = sessionManager.start(projectPath);
+    sessionManager.addUserMessage(finalPrompt);
+    let fullResponse = "";
+    let modelName = "unknown";
+    let toolCallCount = 0;
+    if (!opts.json) {
+      process.stdout.write("\n");
+    }
+    const middleware = createDefaultMiddlewarePipeline(projectPath);
+    for await (const event of runAgentLoop(sessionManager.getHistory(), {
+      config,
+      registry,
+      router,
+      costTracker,
+      tools,
+      sessionId: session.id,
+      projectPath,
+      systemPrompt,
+      disableTools: !opts.tools,
+      preferredModelId: opts.model ?? (resolvedKeys.get("MOONSHOT_API_KEY") ? "moonshot/kimi-k2.5" : isCommunityTier && !resolvedKeys.get("DEEPSEEK_API_KEY") && !resolvedKeys.get("ANTHROPIC_API_KEY") && !resolvedKeys.get("OPENAI_API_KEY") && !resolvedKeys.get("GOOGLE_GENERATIVE_AI_API_KEY") ? "brainstormrouter/auto" : void 0),
+      maxSteps: parseInt(opts.maxSteps ?? "1"),
+      compaction: buildCompactionCallbacks(sessionManager),
+      permissionCheck: (tool, args) => permissionManager.check(tool, args),
+      middleware
+    })) {
+      switch (event.type) {
+        case "thinking":
+          if (!opts.json) {
+            const spinnerFrames = [
+              "\u280B",
+              "\u2819",
+              "\u2839",
+              "\u2838",
+              "\u283C",
+              "\u2834",
+              "\u2826",
+              "\u2827",
+              "\u2807",
+              "\u280F"
+            ];
+            const frame = spinnerFrames[Math.floor(Date.now() / 100) % spinnerFrames.length];
+            const phases = {
+              classifying: "Classifying task...",
+              routing: "Selecting model...",
+              connecting: `Connecting...`,
+              streaming: "Streaming..."
+            };
+            process.stderr.write(
+              `\r${frame} ${phases[event.phase] ?? event.phase}`
+            );
+          }
+          break;
+        case "routing":
+          modelName = event.decision.model.name;
+          process.stderr.write(
+            `\r[${event.decision.strategy}] \u2192 ${modelName}
+`
+          );
+          break;
+        case "text-delta":
+          fullResponse += event.delta;
+          break;
+        case "tool-call-start":
+          toolCallCount++;
+          process.stderr.write(`
+[tool: ${event.toolName}]
+`);
+          break;
+        case "gateway-feedback": {
+          const gwLine = formatGatewayFeedback(event.feedback);
+          if (gwLine) process.stderr.write(`${gwLine}
+`);
+          break;
+        }
+        case "model-retry":
+          process.stderr.write(
+            `
+[retry] ${event.fromModel} \u2192 ${event.toModel} (${event.reason})
+`
+          );
+          modelName = event.toModel;
+          fullResponse = "";
+          break;
+        case "done":
+          if (opts.json) {
+            process.stdout.write(
+              JSON.stringify({
+                text: fullResponse,
+                model: modelName,
+                cost: event.totalCost,
+                toolCalls: toolCallCount,
+                success: true
+              }) + "\n"
+            );
+          } else {
+            process.stdout.write(renderMarkdownToString(fullResponse));
+            process.stdout.write(
+              `
+
+[cost: $${event.totalCost.toFixed(4)}]
+`
+            );
+          }
+          break;
+        case "error":
+          if (opts.json) {
+            process.stdout.write(
+              JSON.stringify({
+                text: "",
+                model: modelName,
+                cost: 0,
+                toolCalls: toolCallCount,
+                error: event.error.message,
+                success: false
+              }) + "\n"
+            );
+            process.exit(1);
+          } else {
+            process.stderr.write(`
+Error: ${event.error.message}
+`);
+          }
+          break;
+      }
+    }
+    if (fullResponse) {
+      sessionManager.addAssistantMessage(fullResponse);
+    }
+  }
+);
+program.command("probe").description(
+  "Run an ad-hoc eval probe with verification (for autonomous testing)"
+).argument("<prompt>", "The prompt to test").option("--model <id>", "Target a specific model").option(
+  "--expect-tools <tools>",
+  "Comma-separated tool names that must be called"
+).option(
+  "--expect-contains <strings>",
+  "Comma-separated strings that must appear in output"
+).option(
+  "--expect-excludes <strings>",
+  "Comma-separated strings that must NOT appear"
+).option("--min-steps <n>", "Minimum number of agentic steps").option("--max-steps <n>", "Maximum number of agentic steps", "10").option("--timeout <ms>", "Timeout in milliseconds", "30000").option("--json", "Output full ProbeResult as JSON").option("--setup-file <pairs...>", "Setup files as path=content pairs").action(async (prompt, opts) => {
+  const probe = {
+    id: `adhoc-${Date.now().toString(36)}`,
+    capability: "multi-step",
+    prompt,
+    verify: {},
+    timeout_ms: parseInt(opts.timeout)
+  };
+  if (opts.expectTools) {
+    probe.verify.tool_calls_include = opts.expectTools.split(",").map((s) => s.trim());
+  }
+  if (opts.expectContains) {
+    probe.verify.answer_contains = opts.expectContains.split(",").map((s) => s.trim());
+  }
+  if (opts.expectExcludes) {
+    probe.verify.answer_excludes = opts.expectExcludes.split(",").map((s) => s.trim());
+  }
+  if (opts.minSteps) {
+    probe.verify.min_steps = parseInt(opts.minSteps);
+  }
+  if (opts.maxSteps) {
+    probe.verify.max_steps = parseInt(opts.maxSteps);
+  }
+  if (opts.setupFile) {
+    probe.setup = { files: {} };
+    for (const pair of opts.setupFile) {
+      const eqIdx = pair.indexOf("=");
+      if (eqIdx > 0) {
+        probe.setup.files[pair.slice(0, eqIdx)] = pair.slice(eqIdx + 1);
+      }
+    }
+  }
+  const result = await runProbe(probe, {
+    modelId: opts.model,
+    maxSteps: parseInt(opts.maxSteps),
+    defaultTimeout: parseInt(opts.timeout)
+  });
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+  } else {
+    const status = result.passed ? "PASSED" : "FAILED";
+    console.log(`
+  Probe: ${status}`);
+    console.log(`  Model: ${result.modelId}`);
+    console.log(`  Steps: ${result.steps}`);
+    console.log(`  Cost:  $${result.cost.toFixed(4)}`);
+    console.log(`  Time:  ${result.durationMs}ms`);
+    if (result.toolCalls.length > 0) {
+      console.log(
+        `  Tools: ${result.toolCalls.map((t) => t.name).join(", ")}`
+      );
+    }
+    if (!result.passed) {
+      const failures = result.checks.filter((c) => !c.passed);
+      console.log(`  Failures:`);
+      for (const f of failures) {
+        console.log(`    - ${f.check}: ${f.detail ?? "failed"}`);
+      }
+    }
+    if (result.error) console.log(`  Error: ${result.error}`);
+    console.log(
+      `  Output: ${result.output.slice(0, 200)}${result.output.length > 200 ? "..." : ""}`
+    );
+    console.log();
+  }
+  process.exit(result.passed ? 0 : 1);
+});
+var VAULT_PATH = join3(homedir(), ".brainstorm", "vault.enc");
+function printResumeSummary(session, sessionManager) {
+  const age = Math.floor((Date.now() / 1e3 - session.createdAt) / 60);
+  const ageStr = age < 60 ? `${age}m ago` : age < 1440 ? `${Math.floor(age / 60)}h ago` : `${Math.floor(age / 1440)}d ago`;
+  const history = sessionManager.getHistory();
+  const lastMsg = history.length > 0 ? history[history.length - 1] : null;
+  const lastPreview = lastMsg ? `"${lastMsg.content.slice(0, 60)}${lastMsg.content.length > 60 ? "..." : ""}"` : "none";
+  console.log(
+    `  Resumed session ${session.id.slice(0, 8)} | ${session.messageCount} msgs | $${(session.totalCost ?? 0).toFixed(4)} | ${ageStr}`
+  );
+  if (lastMsg) console.log(`  Last ${lastMsg.role}: ${lastPreview}`);
+}
+function promptPassword(prompt) {
+  const envPassword = process.env.BRAINSTORM_VAULT_PASSWORD;
+  if (envPassword) {
+    console.error(
+      "  [vault] Using BRAINSTORM_VAULT_PASSWORD from environment (no prompt)"
+    );
+    return Promise.resolve(envPassword);
+  }
+  return new Promise((resolve, reject) => {
+    process.stderr.write(prompt);
+    let rawModeWasSet = false;
+    try {
+      if (process.stdin.setRawMode) {
+        process.stdin.setRawMode(true);
+        rawModeWasSet = true;
+      }
+    } catch {
+    }
+    if (process.stdin.isPaused?.()) process.stdin.resume();
+    let password = "";
+    const cleanup = () => {
+      process.stdin.removeListener("data", onData);
+      if (rawModeWasSet) {
+        try {
+          process.stdin.setRawMode?.(false);
+        } catch {
+        }
+      }
+      process.stderr.write("\n");
+    };
+    const onData = (ch) => {
+      const c = ch.toString();
+      if (c === "\n" || c === "\r" || c === "") {
+        cleanup();
+        resolve(password);
+      } else if (c === "") {
+        cleanup();
+        reject(new Error("Cancelled"));
+      } else if (c === "\x7F" || c === "\b") {
+        if (password.length > 0) {
+          password = password.slice(0, -1);
+          process.stderr.write("\b \b");
+        }
+      } else if (c.charCodeAt(0) >= 32) {
+        password += c;
+        process.stderr.write("*");
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+var vaultCmd = program.command("vault").description("Manage encrypted key vault");
+vaultCmd.command("init").description("Create a new encrypted vault").action(async () => {
+  const vault = new BrainstormVault(VAULT_PATH);
+  if (vault.exists()) {
+    console.error(
+      "  Vault already exists. Use `brainstorm vault rotate` to change password."
+    );
+    process.exit(1);
+  }
+  const password = await promptPassword("  Master password: ");
+  const confirm = await promptPassword("  Confirm password: ");
+  if (password !== confirm) {
+    console.error("  Passwords do not match.");
+    process.exit(1);
+  }
+  if (password.length < 8) {
+    console.error("  Password must be at least 8 characters.");
+    process.exit(1);
+  }
+  await vault.init(password);
+  console.log(`  Vault created at ${VAULT_PATH}`);
+});
+vaultCmd.command("add <name>").description("Add a key to the vault").argument("[value]", "Key value (prompted if omitted)").action(async (name, value) => {
+  const vault = new BrainstormVault(VAULT_PATH);
+  const password = await promptPassword("  Master password: ");
+  vault.open(password);
+  const keyValue = value ?? await promptPassword(`  Value for ${name}: `);
+  vault.set(name, keyValue);
+  vault.seal();
+  console.log(`  Added ${name} to vault.`);
+});
+vaultCmd.command("list").description("List stored key names").action(async () => {
+  const vault = new BrainstormVault(VAULT_PATH);
+  if (!vault.exists()) {
+    console.log("  No vault found. Run `brainstorm vault init` first.");
+    return;
+  }
+  const password = await promptPassword("  Master password: ");
+  vault.open(password);
+  const keys = vault.list();
+  if (keys.length === 0) {
+    console.log("  Vault is empty.");
+  } else {
+    console.log(`
+  Keys (${keys.length}):
+`);
+    for (const k of keys) console.log(`    ${k}`);
+    console.log();
+  }
+});
+vaultCmd.command("get <name>").description("Show a key value (masked by default)").option("--reveal", "Show the full unmasked value").action(async (name, opts) => {
+  const vault = new BrainstormVault(VAULT_PATH);
+  const password = await promptPassword("  Master password: ");
+  vault.open(password);
+  const value = vault.get(name);
+  if (value) {
+    if (opts.reveal) {
+      console.log(value);
+    } else {
+      const masked = value.slice(0, 8) + "*".repeat(Math.max(0, value.length - 8));
+      console.log(masked);
+    }
+  } else {
+    console.error(`  Key "${name}" not found in vault.`);
+    process.exit(1);
+  }
+});
+vaultCmd.command("remove <name>").description("Remove a key from the vault").action(async (name) => {
+  const vault = new BrainstormVault(VAULT_PATH);
+  const password = await promptPassword("  Master password: ");
+  vault.open(password);
+  if (vault.delete(name)) {
+    vault.seal();
+    console.log(`  Removed ${name} from vault.`);
+  } else {
+    console.error(`  Key "${name}" not found in vault.`);
+    process.exit(1);
+  }
+});
+vaultCmd.command("rotate").description("Change vault master password").action(async () => {
+  const vault = new BrainstormVault(VAULT_PATH);
+  const current = await promptPassword("  Current password: ");
+  vault.open(current);
+  const newPass = await promptPassword("  New password: ");
+  const confirm = await promptPassword("  Confirm new password: ");
+  if (newPass !== confirm) {
+    console.error("  Passwords do not match.");
+    process.exit(1);
+  }
+  if (newPass.length < 8) {
+    console.error("  Password must be at least 8 characters.");
+    process.exit(1);
+  }
+  vault.rotate(newPass);
+  console.log("  Vault password rotated.");
+});
+vaultCmd.command("lock").description("Clear vault keys from memory").action(() => {
+  console.log("  Vault locked (keys cleared from memory).");
+});
+vaultCmd.command("status").description("Show vault and backend status").action(async () => {
+  const vault = new BrainstormVault(VAULT_PATH);
+  const resolver = new KeyResolver(vault.exists() ? vault : null);
+  const s = resolver.status();
+  console.log("\n  Vault Status:\n");
+  console.log(`    Vault:      ${s.vault}`);
+  console.log(`    1Password:  ${s.op}`);
+  console.log(`    Env vars:   ${s.env}`);
+  console.log(`    Priority:   vault \u2192 1Password \u2192 env vars
+`);
+});
+var projectsCmd = program.command("projects").description("Manage registered projects");
+projectsCmd.command("list").description("List all registered projects").option("--all", "Include inactive projects").action(async (opts) => {
+  const { ProjectManager } = await import("./dist-WLTQTLFO.js");
+  const db = getDb();
+  const pm = new ProjectManager(db);
+  const projects = pm.projects.list(opts.all);
+  console.log("\n  Registered Projects:\n");
+  if (projects.length === 0) {
+    console.log(
+      "    No projects registered. Run: storm projects register <path>"
+    );
+    console.log("    Or scan all: storm projects import ~/Projects\n");
+    return;
+  }
+  for (const p of projects) {
+    const dash = pm.dashboard(p.id);
+    const cost = dash ? `$${dash.costToday.toFixed(4)}/day` : "";
+    const sessions = dash ? `${dash.sessionCount} sessions` : "";
+    const active = p.isActive ? "" : " [inactive]";
+    console.log(
+      `    ${p.name.padEnd(25)} ${sessions.padEnd(15)} ${cost.padEnd(15)} ${p.path}${active}`
+    );
+  }
+  console.log();
+});
+projectsCmd.command("register").argument("<path>", "Path to project directory").option("-n, --name <name>", "Project name (default: directory name)").option("--budget-daily <amount>", "Daily budget limit in dollars").option("--budget-monthly <amount>", "Monthly budget limit in dollars").description("Register a project").action(
+  async (path, opts) => {
+    const { ProjectManager } = await import("./dist-WLTQTLFO.js");
+    const db = getDb();
+    const pm = new ProjectManager(db);
+    try {
+      const project = pm.register(path, opts.name, {
+        budgetDaily: opts.budgetDaily ? parseFloat(opts.budgetDaily) : void 0,
+        budgetMonthly: opts.budgetMonthly ? parseFloat(opts.budgetMonthly) : void 0
+      });
+      console.log(`
+  \u2713 Registered "${project.name}" \u2192 ${project.path}
+`);
+    } catch (err) {
+      console.error(
+        `
+  \u2717 ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+);
+projectsCmd.command("switch").argument("<name>", "Project name to switch to").description("Set the active project for this session").action(async (name) => {
+  const { ProjectManager } = await import("./dist-WLTQTLFO.js");
+  const db = getDb();
+  const pm = new ProjectManager(db);
+  try {
+    const project = pm.switch(name);
+    console.log(`
+  \u2713 Switched to "${project.name}" (${project.path})
+`);
+  } catch (err) {
+    console.error(
+      `
+  \u2717 ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+});
+projectsCmd.command("show").argument("<name>", "Project name").description("Show project dashboard").action(async (name) => {
+  const { ProjectManager } = await import("./dist-WLTQTLFO.js");
+  const db = getDb();
+  const pm = new ProjectManager(db);
+  const project = pm.projects.getByName(name);
+  if (!project) {
+    console.error(`
+  \u2717 Project "${name}" not found.
+`);
+    return;
+  }
+  const dash = pm.dashboard(project.id);
+  if (!dash) return;
+  console.log(`
+  \u2500\u2500 ${project.name} \u2500\u2500`);
+  console.log(`  Path:         ${project.path}`);
+  if (project.description)
+    console.log(`  Description:  ${project.description}`);
+  console.log(`  Sessions:     ${dash.sessionCount}`);
+  console.log(`  Cost today:   $${dash.costToday.toFixed(4)}`);
+  console.log(`  Cost month:   $${dash.costThisMonth.toFixed(4)}`);
+  if (project.budgetDaily) {
+    console.log(
+      `  Budget daily: $${project.budgetDaily.toFixed(2)} (${dash.budgetDailyUsed.toFixed(0)}% used)`
+    );
+  }
+  if (project.budgetMonthly) {
+    console.log(
+      `  Budget month: $${project.budgetMonthly.toFixed(2)} (${dash.budgetMonthlyUsed.toFixed(0)}% used)`
+    );
+  }
+  const memory = pm.memory.list(project.id);
+  if (memory.length > 0) {
+    console.log(`  Memory:       ${memory.length} entries`);
+  }
+  console.log();
+});
+projectsCmd.command("import").argument("[dir]", "Parent directory to scan", join3(homedir(), "Projects")).description("Scan a directory and register all project subdirectories").action(async (dir) => {
+  const { ProjectManager } = await import("./dist-WLTQTLFO.js");
+  const db = getDb();
+  const pm = new ProjectManager(db);
+  const registered = pm.import(dir);
+  if (registered.length === 0) {
+    console.log(`
+  No new projects found in ${dir}
+`);
+  } else {
+    console.log(`
+  Registered ${registered.length} projects:`);
+    for (const p of registered) {
+      console.log(`    \u2713 ${p.name} \u2192 ${p.path}`);
+    }
+    console.log();
+  }
+});
+var scheduleCmd = program.command("schedule").description("Manage scheduled tasks");
+scheduleCmd.command("list").option("-p, --project <name>", "Filter by project").description("List scheduled tasks").action(async (opts) => {
+  const { ScheduledTaskRepository } = await import("./dist-V5DTSTKJ.js");
+  const { ProjectManager } = await import("./dist-WLTQTLFO.js");
+  const db = getDb();
+  const taskRepo = new ScheduledTaskRepository(db);
+  let projectId;
+  if (opts.project) {
+    const pm = new ProjectManager(db);
+    const p = pm.projects.getByName(opts.project);
+    if (!p) {
+      console.error(`  Project "${opts.project}" not found.`);
+      return;
+    }
+    projectId = p.id;
+  }
+  const tasks = taskRepo.list(projectId, "active");
+  console.log("\n  Scheduled Tasks:\n");
+  if (tasks.length === 0) {
+    console.log(
+      '    No tasks. Add one: storm schedule add "<prompt>" --project <name>\n'
+    );
+    return;
+  }
+  for (const t of tasks) {
+    const cron = t.cronExpression || "one-shot";
+    const mutations = t.allowMutations ? "read+write" : "read-only";
+    const budget = t.budgetLimit ? `$${t.budgetLimit.toFixed(2)}` : "no limit";
+    console.log(
+      `    ${t.name.padEnd(25)} ${cron.padEnd(18)} ${mutations.padEnd(12)} ${budget}`
+    );
+  }
+  console.log();
+});
+scheduleCmd.command("add").argument("<prompt>", "Task instruction").requiredOption("-p, --project <name>", "Project name").option("-n, --name <name>", "Task name (default: first 30 chars of prompt)").option("--cron <expression>", "Cron schedule (e.g. '0 9 * * *')").option("--budget <amount>", "Budget limit per run in dollars", "0.50").option("--max-turns <n>", "Maximum turns per run", "20").option("--allow-mutations", "Allow file writes and shell commands").option("--model <id>", "Model override for this task").description("Add a scheduled task").action(async (prompt, opts) => {
+  const { ScheduledTaskRepository, validateCron, validateTaskSafety } = await import("./dist-V5DTSTKJ.js");
+  const { ProjectManager } = await import("./dist-WLTQTLFO.js");
+  const db = getDb();
+  const pm = new ProjectManager(db);
+  const project = pm.projects.getByName(opts.project);
+  if (!project) {
+    console.error(`  Project "${opts.project}" not found.`);
+    return;
+  }
+  if (opts.cron) {
+    const err = validateCron(opts.cron);
+    if (err) {
+      console.error(`  Invalid cron: ${err}`);
+      return;
+    }
+  }
+  const taskRepo = new ScheduledTaskRepository(db);
+  const task = taskRepo.create({
+    projectId: project.id,
+    name: opts.name || prompt.slice(0, 30),
+    prompt,
+    cronExpression: opts.cron,
+    budgetLimit: parseFloat(opts.budget),
+    maxTurns: parseInt(opts.maxTurns),
+    allowMutations: opts.allowMutations ?? false,
+    modelId: opts.model
+  });
+  const warnings = validateTaskSafety(task);
+  console.log(`
+  \u2713 Created task "${task.name}" (${task.id.slice(0, 8)})`);
+  if (task.cronExpression) {
+    const { describeCron } = await import("./dist-V5DTSTKJ.js");
+    console.log(`    Schedule: ${describeCron(task.cronExpression)}`);
+  }
+  if (warnings.length > 0) {
+    console.log("    Warnings:");
+    for (const w of warnings) console.log(`      \u26A0 ${w}`);
+  }
+  console.log();
+});
+scheduleCmd.command("run").option("--task-id <id>", "Run a specific task").option("--dry-run", "Show what would run without executing").description("Trigger due tasks").action(async (opts) => {
+  const { TriggerRunner } = await import("./dist-V5DTSTKJ.js");
+  const db = getDb();
+  const runner = new TriggerRunner(db);
+  const result = await runner.runDueTasks(opts);
+  console.log(`
+  Checked: ${result.tasksChecked} tasks`);
+  console.log(`  Run:     ${result.tasksRun}`);
+  if (result.tasksFailed > 0) console.log(`  Failed:  ${result.tasksFailed}`);
+  if (result.tasksSkipped > 0)
+    console.log(`  Skipped: ${result.tasksSkipped} (concurrency limit)`);
+  for (const r of result.runs) {
+    const icon = r.status === "completed" ? "\u2713" : r.status === "failed" ? "\u2717" : "\u25CB";
+    console.log(
+      `    ${icon} ${r.taskName} \u2192 ${r.status}${r.error ? ` (${r.error})` : ""}`
+    );
+  }
+  console.log();
+});
+scheduleCmd.command("history").option("--task-id <id>", "Filter by task").option("-n, --limit <count>", "Number of runs to show", "10").description("Show task run history").action(async (opts) => {
+  const { TaskRunRepository, ScheduledTaskRepository } = await import("./dist-V5DTSTKJ.js");
+  const db = getDb();
+  const runRepo = new TaskRunRepository(db);
+  const taskRepo = new ScheduledTaskRepository(db);
+  const runs = opts.taskId ? runRepo.listByTask(opts.taskId, parseInt(opts.limit)) : runRepo.listRecent(parseInt(opts.limit));
+  console.log("\n  Task Run History:\n");
+  if (runs.length === 0) {
+    console.log("    No runs yet.\n");
+    return;
+  }
+  for (const r of runs) {
+    const task = taskRepo.getById(r.taskId);
+    const icon = r.status === "completed" ? "\u2713" : r.status === "failed" ? "\u2717" : "\u25CF";
+    const date = new Date(r.createdAt * 1e3).toLocaleString();
+    console.log(
+      `    ${icon} ${(task?.name ?? r.taskId.slice(0, 8)).padEnd(22)} $${r.cost.toFixed(4).padEnd(10)} ${r.status.padEnd(16)} ${date}`
+    );
+  }
+  console.log();
+});
+scheduleCmd.command("pause").argument("<task-id>", "Task ID to pause").description("Pause a scheduled task").action(async (taskId) => {
+  const { ScheduledTaskRepository } = await import("./dist-V5DTSTKJ.js");
+  const db = getDb();
+  const repo = new ScheduledTaskRepository(db);
+  repo.updateStatus(taskId, "paused");
+  console.log(`  \u2713 Paused task ${taskId.slice(0, 8)}
+`);
+});
+scheduleCmd.command("resume").argument("<task-id>", "Task ID to resume").description("Resume a paused task").action(async (taskId) => {
+  const { ScheduledTaskRepository } = await import("./dist-V5DTSTKJ.js");
+  const db = getDb();
+  const repo = new ScheduledTaskRepository(db);
+  repo.updateStatus(taskId, "active");
+  console.log(`  \u2713 Resumed task ${taskId.slice(0, 8)}
+`);
+});
+scheduleCmd.command("delete").argument("<task-id>", "Task ID to delete").description("Delete a scheduled task").action(async (taskId) => {
+  const { ScheduledTaskRepository } = await import("./dist-V5DTSTKJ.js");
+  const db = getDb();
+  const repo = new ScheduledTaskRepository(db);
+  repo.delete(taskId);
+  console.log(`  \u2713 Deleted task ${taskId.slice(0, 8)}
+`);
+});
+var planCmd = program.command("plan").description("Execute and manage structured plans");
+planCmd.command("execute").argument("<path>", "Path to .plan.md file").option("--auto", "Run autonomously (no pauses)").option("--dry-run", "Show dispatch plan without executing").option("--budget <amount>", "Total budget limit in dollars").option("--task-budget <amount>", "Per-task budget limit", "0.50").option("--retries <n>", "Max retries per task", "2").description("Execute a plan file task-by-task using subagents").action(async (path, opts) => {
+  const { executePlan } = await import("@brainst0rm/core");
+  const { resolve } = await import("path");
+  const { execFileSync } = await import("child_process");
+  const planPath = resolve(path);
+  const mode = opts.dryRun ? "dry-run" : opts.auto ? "autonomous" : "interactive";
+  console.log(`
+  Plan Executor (${mode} mode)
+`);
+  const dispatcher = {
+    async execute(prompt, execOpts) {
+      console.log(
+        `    Dispatching: ${execOpts.subagentType}/${execOpts.modelHint}`
+      );
+      return {
+        text: `[Placeholder] Completed via ${execOpts.subagentType} subagent`,
+        cost: 0,
+        modelUsed: execOpts.modelHint,
+        toolCalls: [],
+        budgetExceeded: false
+      };
+    },
+    async checkBuild(command, cwd) {
+      const parts = command.split(/\s+/);
+      try {
+        execFileSync(parts[0], parts.slice(1), {
+          cwd,
+          timeout: 6e4,
+          stdio: "pipe"
+        });
+        return { passed: true, output: "" };
+      } catch (err) {
+        return {
+          passed: false,
+          output: err.stderr?.toString()?.slice(0, 500) ?? ""
+        };
+      }
+    }
+  };
+  try {
+    for await (const event of executePlan(planPath, dispatcher, {
+      projectPath: process.cwd(),
+      buildCommand: "npx turbo run build --force",
+      defaultBudgetPerTask: parseFloat(opts.taskBudget),
+      planBudgetLimit: opts.budget ? parseFloat(opts.budget) : void 0,
+      mode,
+      maxRetries: parseInt(opts.retries),
+      compactBetweenPhases: true
+    })) {
+      switch (event.type) {
+        case "plan-started":
+          console.log(`  Plan: ${event.plan.name}`);
+          console.log(`  Tasks: ${event.totalTasks} pending
+`);
+          break;
+        case "phase-started":
+          console.log(`  \u2500\u2500 ${event.phase.name} \u2500\u2500`);
+          break;
+        case "sprint-started":
+          console.log(`    ${event.sprint.name}`);
+          break;
+        case "task-started":
+          console.log(
+            `    \u25CF ${event.task.description.slice(0, 60)} [${event.subagentType}/${event.model}]`
+          );
+          break;
+        case "task-completed":
+          console.log(
+            `    \u2713 ${event.task.description.slice(0, 60)}  $${event.cost.toFixed(4)}`
+          );
+          break;
+        case "task-failed":
+          console.log(
+            `    \u2717 ${event.task.description.slice(0, 60)}  ${event.reason}`
+          );
+          break;
+        case "task-retrying":
+          console.log(`    \u21BB Retry #${event.attempt} with ${event.model}`);
+          break;
+        case "task-budget-exceeded":
+          console.log(`    $ Budget exceeded: $${event.cost.toFixed(4)}`);
+          break;
+        case "build-check":
+          console.log(
+            `    ${event.passed ? "\u2713" : "\u2717"} Build ${event.passed ? "passed" : "FAILED"}`
+          );
+          break;
+        case "phase-completed":
+          console.log(
+            `  \u2713 ${event.phase.name} complete  $${event.cost.toFixed(4)}
+`
+          );
+          break;
+        case "plan-completed":
+          console.log(`  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
+          console.log(
+            `  Plan complete: $${event.totalCost.toFixed(4)} total
+`
+          );
+          break;
+        case "plan-paused":
+          console.log(`
+  \u26A0 Paused: ${event.reason}
+`);
+          break;
+        case "skill-activated":
+          console.log(`    \u2726 Skill: ${event.skillName}`);
+          break;
+        case "dry-run-task": {
+          const d = event.dispatch;
+          console.log(
+            `    \u25CB ${event.task.description.slice(0, 45).padEnd(47)} ${d.subagentType.padEnd(10)} ${d.modelHint.padEnd(10)} ~$${event.estimatedCost.toFixed(2)}`
+          );
+          break;
+        }
+        case "dry-run-summary":
+          console.log(
+            `
+  Summary: ${event.totalTasks} tasks, ~$${event.estimatedCost.toFixed(2)} estimated`
+          );
+          console.log(
+            `  By type: ${Object.entries(event.tasksByType).map(([k, v]) => `${k}:${v}`).join(", ")}
+`
+          );
+          break;
+      }
+    }
+  } catch (err) {
+    console.error(
+      `
+  \u2717 ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+});
+planCmd.command("parse").argument("<path>", "Path to .plan.md file").description("Parse and display a plan file structure").action(async (path) => {
+  const { parsePlanFile } = await import("@brainst0rm/core");
+  const { resolve } = await import("path");
+  let plan;
+  try {
+    plan = parsePlanFile(resolve(path));
+  } catch (err) {
+    console.error(
+      `
+  \u2717 ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return;
+  }
+  console.log(`
+  ${plan.name} (${plan.status})`);
+  console.log(`  ${plan.completedTasks}/${plan.totalTasks} tasks complete
+`);
+  for (const phase of plan.phases) {
+    const icon = phase.status === "completed" ? "\u2713" : phase.status === "in_progress" ? "\u25D0" : "\u25CB";
+    console.log(
+      `  ${icon} ${phase.name}  ${phase.completedCount}/${phase.taskCount}`
+    );
+    for (const sprint of phase.sprints) {
+      console.log(`    ${sprint.name}`);
+      for (const task of sprint.tasks) {
+        const tIcon = task.status === "completed" ? "\u2713" : "\u25CB";
+        const cost = task.cost ? `$${task.cost.toFixed(2)}` : "";
+        const skill = task.assignedSkill ? `[${task.assignedSkill}]` : "";
+        console.log(`      ${tIcon} ${task.description} ${skill} ${cost}`);
+      }
+    }
+  }
+  console.log();
+});
+var orchestrateCmd = program.command("orchestrate").description("Coordinate work across multiple projects");
+orchestrateCmd.command("pipeline").argument("<request>", "What to build (natural language)").option("--build <cmd>", "Build command", "npx turbo run build --force").option("--test <cmd>", "Test command", "npx turbo run test").option("--deploy", "Include deployment phase").option("--budget <amount>", "Total budget limit in dollars").option(
+  "--phases <list>",
+  "Comma-separated phases to run (spec,architecture,implementation,review,verify,refactor,deploy,document,report)"
+).option("--resume-from <phase>", "Resume from a specific phase").option("--dry-run", "Show what agents would be dispatched").description("Run the full 9-phase development pipeline").action(async (request, opts) => {
+  const { runOrchestrationPipeline, createPipelineDispatcher } = await import("@brainst0rm/core");
+  console.log(`
+  Orchestration Pipeline
+`);
+  console.log(`  Request: "${request}"`);
+  console.log(`  Mode: ${opts.dryRun ? "dry-run" : "execute"}
+`);
+  const config = loadConfig();
+  const db = getDb();
+  const envKeys = /* @__PURE__ */ new Map();
+  for (const name of PROVIDER_KEY_NAMES) {
+    const val = process.env[name];
+    if (val) envKeys.set(name, val);
+  }
+  const resolvedKeys = {
+    get: (name) => envKeys.get(name) ?? null
+  };
+  const registry = await createProviderRegistry(config, resolvedKeys);
+  const costTracker = new CostTracker(db, config.budget);
+  const projectPath = process.cwd();
+  const tools = createDefaultToolRegistry();
+  const { frontmatter } = buildSystemPrompt(projectPath);
+  const router = new BrainstormRouter(
+    config,
+    registry,
+    costTracker,
+    frontmatter
+  );
+  const dispatcher = createPipelineDispatcher({
+    config,
+    registry,
+    router,
+    costTracker,
+    tools,
+    projectPath
+  });
+  const hasProviders = PROVIDER_KEY_NAMES.some(
+    (k) => resolvedKeys.get(k) !== null
+  );
+  if (!hasProviders && !opts.dryRun) {
+    console.log(
+      "  \u26A0 No model providers configured. Using placeholder dispatcher."
+    );
+    console.log("  Set API keys via: storm vault add ANTHROPIC_API_KEY\n");
+  }
+  const activeDispatcher = hasProviders || opts.dryRun ? dispatcher : {
+    async runPhase(agentId, subagentType, prompt, phaseOpts) {
+      console.log(`    Agent: ${agentId} (${subagentType})`);
+      return {
+        text: `[No providers] ${agentId} would execute`,
+        cost: 0,
+        toolCalls: []
+      };
+    },
+    async runParallel(specs, phaseOpts) {
+      return specs.map((s) => {
+        console.log(`    Agent: ${s.agentId} (${s.subagentType})`);
+        return {
+          agentId: s.agentId,
+          text: `[No providers] ${s.agentId} would execute`,
+          cost: 0,
+          toolCalls: []
+        };
+      });
+    },
+    async runCommand(command, cwd) {
+      const { execFileSync } = await import("child_process");
+      const parts = command.split(/\s+/);
+      try {
+        execFileSync(parts[0], parts.slice(1), {
+          cwd,
+          timeout: 12e4,
+          stdio: "pipe"
+        });
+        return { passed: true, output: "" };
+      } catch (err) {
+        return {
+          passed: false,
+          output: err.stderr?.toString()?.slice(0, 500) ?? ""
+        };
+      }
+    }
+  };
+  const phases = opts.phases?.split(",") ?? void 0;
+  for await (const event of runOrchestrationPipeline(
+    request,
+    activeDispatcher,
+    {
+      projectPath,
+      buildCommand: opts.build,
+      testCommand: opts.test,
+      deploy: opts.deploy,
+      budget: opts.budget ? parseFloat(opts.budget) : void 0,
+      phases,
+      resumeFrom: opts.resumeFrom,
+      dryRun: opts.dryRun
+    }
+  )) {
+    switch (event.type) {
+      case "pipeline-started":
+        console.log(`  Phases: ${event.phases.join(" \u2192 ")}
+`);
+        break;
+      case "phase-started":
+        console.log(
+          `  \u2500\u2500 ${event.phase.toUpperCase()} \u2500\u2500  (${event.agentId})`
+        );
+        break;
+      case "phase-completed":
+        const icon = event.result.success ? "\u2713" : "\u2717";
+        console.log(
+          `  ${icon} ${event.result.phase}  $${event.result.cost.toFixed(4)}  ${event.result.duration}ms`
+        );
+        if (event.result.output && !event.result.output.startsWith("[")) {
+          console.log(
+            `    ${event.result.output.split("\n")[0].slice(0, 100)}`
+          );
+        }
+        console.log();
+        break;
+      case "phase-failed":
+        console.log(`  \u2717 ${event.phase}: ${event.error}
+`);
+        break;
+      case "review-findings":
+        console.log(
+          `  Reviews: ${event.findings.length} finding(s)${event.hasCritical ? " (CRITICAL)" : ""}`
+        );
+        for (const f of event.findings.slice(0, 5)) {
+          console.log(`    [${f.severity}] ${f.description.slice(0, 80)}`);
+        }
+        console.log();
+        break;
+      case "feedback-loop":
+        console.log(
+          `  \u21BB Feedback: ${event.from} \u2192 ${event.to} (${event.reason})
+`
+        );
+        break;
+      case "pipeline-completed":
+        console.log(`  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
+        console.log(
+          `  Pipeline complete: $${event.totalCost.toFixed(4)} total`
+        );
+        console.log(
+          `  ${event.results.filter((r) => r.success).length}/${event.results.length} phases succeeded
+`
+        );
+        break;
+      case "pipeline-paused":
+        console.log(`  \u26A0 Paused at ${event.phase}: ${event.reason}
+`);
+        break;
+    }
+  }
+});
+orchestrateCmd.command("run").argument("<description>", "What to do across projects").requiredOption("-p, --projects <names>", "Comma-separated project names").option("--budget <amount>", "Total budget limit in dollars").option("--type <type>", "Subagent type (explore, code, review)", "code").description("Run a cross-project orchestration").action(
+  async (description, opts) => {
+    const { OrchestrationEngine, formatAggregatedResults, aggregateResults } = await import("./dist-GNHTH2DH.js");
+    const { ProjectManager } = await import("./dist-WLTQTLFO.js");
+    const db = getDb();
+    const engine = new OrchestrationEngine(db);
+    const pm = new ProjectManager(db);
+    const projectNames = opts.projects.split(",").map((s) => s.trim());
+    console.log(
+      `
+  Orchestrating across ${projectNames.length} projects...`
+    );
+    console.log(`  "${description}"
+`);
+    try {
+      for await (const event of engine.run({
+        description,
+        projectNames,
+        budgetLimit: opts.budget ? parseFloat(opts.budget) : void 0,
+        subagentType: opts.type
+      })) {
+        switch (event.type) {
+          case "plan-ready":
+            console.log(`  Plan: ${event.tasks.length} tasks created`);
+            break;
+          case "task-started":
+            console.log(`  \u25CF ${event.project.name} \u2014 starting...`);
+            break;
+          case "task-completed":
+            console.log(
+              `  \u2713 ${event.project.name} \u2014 $${event.cost.toFixed(4)}`
+            );
+            if (event.summary)
+              console.log(`    ${event.summary.slice(0, 120)}`);
+            break;
+          case "task-failed":
+            console.log(`  \u2717 ${event.project.name} \u2014 ${event.error}`);
+            break;
+          case "orchestration-completed": {
+            const projectMap = /* @__PURE__ */ new Map();
+            for (const name of projectNames) {
+              const p = pm.projects.getByName(name);
+              if (p) projectMap.set(p.id, p.name);
+            }
+            const tasks = event.results.map((r, i) => ({
+              ...event.run,
+              projectId: projectMap.get(r.projectName) ?? r.projectName
+            }));
+            console.log(`
+  \u2500\u2500 Complete \u2500\u2500`);
+            console.log(`  Total cost: $${event.run.totalCost.toFixed(4)}`);
+            console.log(
+              `  ${event.results.filter((r) => !r.summary.startsWith("FAILED")).length}/${event.results.length} succeeded
+`
+            );
+            break;
+          }
+        }
+      }
+    } catch (err) {
+      console.error(
+        `
+  \u2717 ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+);
+orchestrateCmd.command("history").option("-n, --limit <count>", "Number of runs to show", "10").description("Show recent orchestration runs").action(async (opts) => {
+  const { OrchestrationEngine } = await import("./dist-GNHTH2DH.js");
+  const db = getDb();
+  const engine = new OrchestrationEngine(db);
+  const runs = engine.listRecent(parseInt(opts.limit));
+  console.log("\n  Orchestration History:\n");
+  if (runs.length === 0) {
+    console.log("    No orchestration runs yet.\n");
+    return;
+  }
+  for (const r of runs) {
+    const icon = r.status === "completed" ? "\u2713" : r.status === "failed" ? "\u2717" : r.status === "cancelled" ? "\u25CB" : "\u25CF";
+    const date = new Date(r.createdAt * 1e3).toLocaleString();
+    console.log(
+      `    ${icon} ${r.name.slice(0, 40).padEnd(42)} $${r.totalCost.toFixed(4).padEnd(10)} ${r.status.padEnd(12)} ${date}`
+    );
+  }
+  console.log();
+});
+orchestrateCmd.command("status").argument("<run-id>", "Orchestration run ID").description("Show status of an orchestration run").action(async (runId) => {
+  const { OrchestrationEngine } = await import("./dist-GNHTH2DH.js");
+  const { ProjectManager } = await import("./dist-WLTQTLFO.js");
+  const db = getDb();
+  const engine = new OrchestrationEngine(db);
+  const pm = new ProjectManager(db);
+  const detail = engine.getRunWithTasks(runId);
+  if (!detail) {
+    console.error(`  Run "${runId}" not found.
+`);
+    return;
+  }
+  console.log(`
+  \u2500\u2500 ${detail.run.name} \u2500\u2500`);
+  console.log(`  Status: ${detail.run.status}`);
+  console.log(`  Cost:   $${detail.run.totalCost.toFixed(4)}`);
+  console.log(`  Tasks:  ${detail.tasks.length}
+`);
+  for (const t of detail.tasks) {
+    const project = pm.projects.getById(t.projectId);
+    const icon = t.status === "completed" ? "\u2713" : t.status === "failed" ? "\u2717" : t.status === "skipped" ? "\u25CB" : "\u25CF";
+    console.log(
+      `    ${icon} ${(project?.name ?? t.projectId.slice(0, 8)).padEnd(25)} ${t.status.padEnd(12)} $${t.cost.toFixed(4)}`
+    );
+    if (t.resultSummary)
+      console.log(`      ${t.resultSummary.slice(0, 100)}`);
+  }
+  console.log();
+});
+program.command("intelligence").alias("intel").description("Show what BrainstormRouter has learned about your usage").option("--json", "Output as JSON").option(
+  "--period <period>",
+  "Usage period (daily, weekly, monthly)",
+  "weekly"
+).action(async (opts) => {
+  const gw = createGatewayClient2();
+  const intel = createIntelligenceClient();
+  if (!gw) {
+    console.log(
+      "\n  No BRAINSTORM_API_KEY set. Cannot connect to BrainstormRouter.\n"
+    );
+    process.exit(1);
+  }
+  console.log("\n  Fetching intelligence from BrainstormRouter...\n");
+  const [
+    leaderboard,
+    usage,
+    waste,
+    forecast,
+    daily,
+    governance,
+    recommendations,
+    patterns
+  ] = await Promise.all([
+    gw.getLeaderboard().catch(() => []),
+    gw.getUsageSummary(opts.period).catch(() => null),
+    gw.getWasteInsights().catch(() => null),
+    gw.getForecast().catch(() => null),
+    gw.getDailyInsights().catch(() => []),
+    gw.getGovernanceSummary().catch(() => null),
+    intel?.getRecommendations("code", "typescript").catch(() => []) ?? [],
+    intel?.getPatterns("typescript").catch(() => []) ?? []
+  ]);
+  if (opts.json) {
+    console.log(
+      JSON.stringify(
+        {
+          leaderboard,
+          usage,
+          waste,
+          forecast,
+          daily,
+          governance,
+          recommendations,
+          patterns
+        },
+        null,
+        2
+      )
+    );
+    return;
+  }
+  console.log("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  console.log("   BrainstormRouter Intelligence Report");
+  console.log("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+  const usageData = usage?.data?.[0];
+  const totalRequests = usageData?.requestCount ?? 0;
+  const confidence = totalRequests >= 200 ? "HIGH" : totalRequests >= 50 ? "MEDIUM" : "LOW";
+  const confidenceNote = confidence === "LOW" ? ` (need ${200 - totalRequests} more for high confidence)` : "";
+  console.log(
+    `  Learning Status: ${totalRequests.toLocaleString()} requests analyzed`
+  );
+  console.log(`  Routing Confidence: ${confidence}${confidenceNote}
+`);
+  const realLeaderboard = leaderboard.filter(
+    (m) => m.id && !m.id.startsWith("cache/")
+  );
+  if (realLeaderboard.length > 0) {
+    console.log("  Model Performance:\n");
+    for (const entry of realLeaderboard.slice(0, 8)) {
+      const m = entry;
+      const modelName = m.model_id ?? m.id ?? m.model ?? "unknown";
+      const name = modelName.length > 35 ? modelName.slice(0, 35) + "\u2026" : modelName;
+      const latency = m.latency_ms != null ? m.latency_ms < 1e3 ? `${Math.round(m.latency_ms)}ms` : `${(m.latency_ms / 1e3).toFixed(1)}s` : "  n/a";
+      const reward = m.reward_score != null ? (m.reward_score * 100).toFixed(0) + "%" : "n/a";
+      const value = m.value_score != null ? m.value_score.toFixed(0) : "n/a";
+      const samples = m.sample_count ?? m.request_count ?? 0;
+      const isBest = entry === realLeaderboard[0] ? " \u2190 BEST" : "";
+      console.log(
+        `    ${name.padEnd(37)} reward:${reward.padStart(4)} value:${value.padStart(5)} ${latency.padStart(6)} (${samples} samples)${isBest}`
+      );
+    }
+    console.log();
+  }
+  if (recommendations.length > 0) {
+    console.log("  What the system learned:\n");
+    for (const rec of recommendations.slice(0, 5)) {
+      const r = rec;
+      const conf = r.confidence != null ? `${Math.round(r.confidence * 100)}%` : "";
+      console.log(
+        `    \u2022 ${r.taskType} \u2192 ${r.recommendedModel} (${conf} confidence)`
+      );
+      if (r.reasoning) {
+        console.log(`      ${r.reasoning}`);
+      }
+    }
+    console.log();
+  }
+  if (usageData) {
+    const totalTokens = (usageData.totalInputTokens ?? 0) + (usageData.totalOutputTokens ?? 0);
+    console.log("  Cost Summary:\n");
+    console.log(`    Period:       ${usage?.period ?? opts.period}`);
+    console.log(
+      `    Total:        $${(usageData.totalCostUsd ?? 0).toFixed(4)}`
+    );
+    console.log(
+      `    Requests:     ${(usageData.requestCount ?? 0).toLocaleString()}`
+    );
+    console.log(`    Tokens:       ${totalTokens.toLocaleString()}`);
+    console.log(
+      `    Avg latency:  ${(usageData.avgLatencyMs ?? 0).toFixed(0)}ms`
+    );
+    console.log();
+  }
+  const fc = forecast?.forecast;
+  if (fc) {
+    const trend = fc.trend ?? "stable";
+    const trendIcon = trend === "increasing" ? "\u2191" : trend === "decreasing" ? "\u2193" : "\u2192";
+    console.log("  Budget Forecast:\n");
+    console.log(
+      `    Avg daily:   $${(fc.avgDailySpendUsd ?? 0).toFixed(2)} (${trendIcon} ${trend})`
+    );
+    console.log(
+      `    Projected:   $${(fc.projectedPeriodSpendUsd ?? 0).toFixed(2)}`
+    );
+    console.log(
+      `    Today:       $${(forecast?.todaySpendUsd ?? 0).toFixed(4)}`
+    );
+    console.log(
+      `    Data points: ${forecast?.daysOfData ?? 0} days`
+    );
+    console.log();
+  }
+  const wasteAny = waste;
+  if (wasteAny && (wasteAny.overQualifiedModels?.length > 0 || wasteAny.duplicateRequests?.length > 0)) {
+    console.log("  Optimization Opportunities:\n");
+    console.log(
+      `    Total recoverable: $${(wasteAny.estimatedWasteUsd ?? 0).toFixed(4)}
+`
+    );
+    for (const m of (wasteAny.overQualifiedModels ?? []).slice(0, 3)) {
+      console.log(
+        `    \u2022 ${m.model}: $${m.totalCostUsd.toFixed(4)} on ${m.requestCount} reqs`
+      );
+      console.log(`      \u2192 ${m.suggestion}`);
+    }
+    const dupeCount = (wasteAny.duplicateRequests ?? []).length;
+    if (dupeCount > 0) {
+      const totalDupeWaste = (wasteAny.duplicateRequests ?? []).reduce(
+        (sum, d) => sum + (d.wastedCostUsd ?? 0),
+        0
+      );
+      console.log(
+        `    \u2022 ${dupeCount} duplicate request patterns ($${totalDupeWaste.toFixed(4)} wasted)`
+      );
+      console.log(`      \u2192 Enable prompt caching to reduce duplicates`);
+    }
+    console.log();
+  }
+  if (patterns.length > 0) {
+    console.log("  Community Patterns (TypeScript):\n");
+    for (const p of patterns.slice(0, 3)) {
+      const pat = p;
+      console.log(
+        `    \u2022 ${pat.taskType}: prefer ${(pat.preferredTools ?? []).join(", ")} (${pat.confirmations ?? 0} confirmations)`
+      );
+      if (pat.avoidTools?.length > 0) {
+        console.log(`      avoid: ${pat.avoidTools.join(", ")}`);
+      }
+    }
+    console.log();
+  }
+  if (governance) {
+    const gov = governance;
+    console.log("  Governance:\n");
+    if (gov.memory_health) {
+      console.log(
+        `    Memory:   ${gov.memory_health.total_entries} entries (${gov.memory_health.compliance_status})`
+      );
+    }
+    if (gov.audit_stats) {
+      console.log(
+        `    Audit:    ${gov.audit_stats.total_requests} requests, ${gov.audit_stats.flagged} flagged`
+      );
+    }
+    if (gov.anomaly_score != null) {
+      console.log(
+        `    Anomaly:  ${gov.anomaly_score.toFixed(2)} (0=clean, 1=suspicious)`
+      );
+    }
+    console.log();
+  }
+  console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log(
+    `  Tip: Run \`storm intel --json\` for machine-readable output.`
+  );
+  console.log();
+});
+program.command("analyze").description(
+  "Analyze a codebase \u2014 languages, frameworks, dependencies, complexity"
+).argument("[path]", "Project path to analyze", ".").option("--json", "Output as JSON").action(async (projectPath, opts) => {
+  const { resolve } = await import("path");
+  const absPath = resolve(projectPath);
+  console.log(`
+  Analyzing ${absPath}...
+`);
+  const startTime = Date.now();
+  const { analyzeProject } = await import("@brainst0rm/ingest");
+  const analysis = analyzeProject(absPath);
+  const elapsed = Date.now() - startTime;
+  if (opts.json) {
+    console.log(JSON.stringify(analysis, null, 2));
+    return;
+  }
+  console.log("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  console.log("   Codebase Analysis");
+  console.log("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+  console.log(
+    `  ${analysis.summary.totalFiles} files | ${analysis.summary.totalLines.toLocaleString()} lines | ${analysis.summary.primaryLanguage}`
+  );
+  console.log(
+    `  ${analysis.summary.moduleCount} modules | avg complexity: ${analysis.summary.avgComplexity}/100 | ${elapsed}ms
+`
+  );
+  console.log("  Languages:");
+  for (const l of analysis.languages.languages.slice(0, 8)) {
+    const bar = "\u2588".repeat(Math.max(1, Math.round(l.percentage / 5)));
+    console.log(
+      `    ${l.language.padEnd(15)} ${bar} ${l.percentage}% (${l.files} files, ${l.lines.toLocaleString()} lines)`
+    );
+  }
+  const hasStack = analysis.frameworks.frameworks.length > 0 || analysis.frameworks.buildTools.length > 0;
+  if (hasStack) {
+    console.log("\n  Stack:");
+    if (analysis.frameworks.frameworks.length > 0)
+      console.log(
+        `    Frameworks:  ${analysis.frameworks.frameworks.join(", ")}`
+      );
+    if (analysis.frameworks.buildTools.length > 0)
+      console.log(
+        `    Build:       ${analysis.frameworks.buildTools.join(", ")}`
+      );
+    if (analysis.frameworks.databases.length > 0)
+      console.log(
+        `    Databases:   ${analysis.frameworks.databases.join(", ")}`
+      );
+    if (analysis.frameworks.testing.length > 0)
+      console.log(
+        `    Testing:     ${analysis.frameworks.testing.join(", ")}`
+      );
+    if (analysis.frameworks.deployment.length > 0)
+      console.log(
+        `    Deploy:      ${analysis.frameworks.deployment.join(", ")}`
+      );
+    if (analysis.frameworks.ci.length > 0)
+      console.log(`    CI/CD:       ${analysis.frameworks.ci.join(", ")}`);
+  }
+  if (analysis.complexity.summary.hotspots.length > 0) {
+    console.log("\n  Complexity Hotspots (score > 70):");
+    for (const f of analysis.complexity.files.filter((cf) => cf.score >= 70).slice(0, 8)) {
+      console.log(
+        `    ${f.path.padEnd(50)} score:${f.score} branches:${f.branchCount} nesting:${f.maxNesting}`
+      );
+    }
+  }
+  if (analysis.dependencies.clusters.length > 0) {
+    console.log("\n  Module Clusters (by size):");
+    for (const c of analysis.dependencies.clusters.slice(0, 8)) {
+      const cohesionLabel = c.cohesion > 0.5 ? "high" : c.cohesion > 0.2 ? "med" : "low";
+      console.log(
+        `    ${c.directory.padEnd(40)} ${c.files.length} files  cohesion:${cohesionLabel}`
+      );
+    }
+  }
+  console.log("\n  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log(`  Run \`storm analyze --json\` for machine-readable output.`);
+  console.log();
+});
+program.command("docgen").description(
+  "Generate documentation \u2014 architecture docs, module docs, API reference"
+).argument("[path]", "Project path to document", ".").option("--output <dir>", "Output directory (default: docs/generated)").option("--json", "Output file list as JSON").action(
+  async (projectPath, opts) => {
+    const { resolve } = await import("path");
+    const absPath = resolve(projectPath);
+    console.log(`
+  Analyzing ${absPath}...`);
+    const { analyzeProject } = await import("@brainst0rm/ingest");
+    const analysis = analyzeProject(absPath);
+    console.log(`  Generating documentation...
+`);
+    const { generateAllDocs } = await import("@brainst0rm/docgen");
+    const result = generateAllDocs(analysis, opts.output);
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+    console.log("   Documentation Generated");
+    console.log("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+    console.log(`  Output: ${result.outputDir}`);
+    console.log(`  Files written: ${result.filesWritten.length}`);
+    console.log("");
+    console.log(`  Architecture:  ${result.architectureDoc}`);
+    console.log(`  Modules:       ${result.moduleDocs} module docs`);
+    if (result.apiDoc) {
+      console.log(`  API Reference: ${result.apiDoc}`);
+    } else {
+      console.log(`  API Reference: (no endpoints detected)`);
+    }
+    console.log("\n  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log(
+      `  Tip: Use these docs as context for AI agents with @docs/generated/ARCHITECTURE.md`
+    );
+    console.log();
+  }
+);
+program.command("spawn").description("Spawn a background agent in an isolated git worktree").argument("<task>", "Task description for the background agent").option(
+  "--type <type>",
+  "Subagent type (code, review, explore, research)",
+  "code"
+).option("--budget <amount>", "Budget limit in dollars", "1.0").action(async (task, opts) => {
+  const { resolve } = await import("path");
+  const { createWorktree, removeWorktree } = await import("@brainst0rm/core");
+  const projectPath = resolve(".");
+  const worktreePath = createWorktree(projectPath, opts.type);
+  console.log(`
+  Spawned background agent in worktree:`);
+  console.log(`    Path:   ${worktreePath}`);
+  console.log(`    Type:   ${opts.type}`);
+  console.log(`    Budget: $${opts.budget}`);
+  console.log(`    Task:   ${task}`);
+  console.log();
+  console.log(`  The agent is running in an isolated copy of your repo.`);
+  console.log(`  When done, changes will be on a spec-* branch.`);
+  console.log(`  Use \`git worktree list\` to see active worktrees.`);
+  console.log(`  Use \`git diff main...<branch>\` to review changes.`);
+  console.log();
+  console.log(`  To run the agent:`);
+  console.log(`    cd ${worktreePath} && storm run --unattended "${task}"`);
+  console.log();
+});
+program.command("storm").description("Run multiple tasks in parallel using subagents").argument(
+  "<tasks...>",
+  "Task descriptions (each runs as a separate subagent)"
+).option(
+  "--type <type>",
+  "Subagent type for all tasks (explore, plan, code, review, research)",
+  "code"
+).option("--budget <amount>", "Budget limit per task in dollars", "1.0").action(async (tasks, opts) => {
+  const config = loadConfig();
+  const db = getDb();
+  const resolvedKeys = await resolveProviderKeys();
+  const registry = await createProviderRegistry(config, resolvedKeys);
+  const costTracker = new CostTracker(db, config.budget);
+  const tools = createDefaultToolRegistry();
+  const projectPath = process.cwd();
+  const { prompt: systemPrompt, frontmatter } = buildSystemPrompt(projectPath);
+  const router = new BrainstormRouter(
+    config,
+    registry,
+    costTracker,
+    frontmatter
+  );
+  console.log(`
+  Storm \u2014 ${tasks.length} parallel agents`);
+  console.log(`  Type: ${opts.type} | Budget: $${opts.budget}/task
+`);
+  for (let i = 0; i < tasks.length; i++) {
+    console.log(`  [${i + 1}] ${tasks[i]}`);
+  }
+  console.log();
+  const startTime = Date.now();
+  const results = await spawnParallel(
+    tasks.map((task) => ({ task, type: opts.type })),
+    {
+      config,
+      registry,
+      router,
+      costTracker,
+      tools,
+      projectPath,
+      systemPrompt,
+      budgetLimit: parseFloat(opts.budget)
+    }
+  );
+  const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+  console.log(`  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+  console.log(`  ${results.length} agents completed in ${elapsed}s
+`);
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    const status = r.text ? "done" : "failed";
+    const cost = `$${r.cost.toFixed(4)}`;
+    console.log(
+      `  [${i + 1}] ${status} (${r.toolCalls.length} tool calls, ${cost})`
+    );
+    if (r.text) {
+      const preview = r.text.slice(0, 200).replace(/\n/g, " ");
+      console.log(`      ${preview}${r.text.length > 200 ? "..." : ""}`);
+    }
+    console.log();
+  }
+  const totalCost = results.reduce((sum, r) => sum + r.cost, 0);
+  console.log(`  Total cost: $${totalCost.toFixed(4)}`);
+  console.log();
+  closeDb();
+});
+program.command("queue").description("Manage the task queue for batch execution").argument("<action>", "Action: add, list, run, clear").argument("[tasks...]", "Task descriptions (for add)").option("--budget <amount>", "Total budget limit in dollars").option("--parallel <n>", "Max parallel tasks (default: 1)", "1").action(
+  async (action, tasks, opts) => {
+    const { existsSync: existsSync3, readFileSync: readFileSync3, writeFileSync: writeFileSync2, mkdirSync: mkdirSync2 } = await import("fs");
+    const { join: join4 } = await import("path");
+    const { homedir: homedir2 } = await import("os");
+    const queueDir = join4(homedir2(), ".brainstorm", "queue");
+    const queueFile = join4(queueDir, "pending.json");
+    if (!existsSync3(queueDir)) mkdirSync2(queueDir, { recursive: true });
+    const loadQueue = () => {
+      if (!existsSync3(queueFile)) return [];
+      try {
+        return JSON.parse(readFileSync3(queueFile, "utf-8"));
+      } catch {
+        return [];
+      }
+    };
+    const saveQueue = (q) => writeFileSync2(queueFile, JSON.stringify(q, null, 2), "utf-8");
+    switch (action) {
+      case "add": {
+        if (tasks.length === 0) {
+          console.error("  Error: provide task descriptions to add.");
+          process.exit(1);
+        }
+        const queue = loadQueue();
+        for (const task of tasks) {
+          queue.push({
+            id: `q-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+            task,
+            status: "pending",
+            addedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        saveQueue(queue);
+        console.log(
+          `
+  Added ${tasks.length} task(s) to queue. Total: ${queue.length} pending.`
+        );
+        break;
+      }
+      case "list": {
+        const queue = loadQueue();
+        if (queue.length === 0) {
+          console.log("\n  Queue is empty.");
+          break;
+        }
+        console.log(`
+  Task Queue (${queue.length} items):
+`);
+        for (const item of queue) {
+          const icon = item.status === "done" ? "\u2713" : item.status === "failed" ? "\u2717" : item.status === "running" ? "\u27F3" : "\u25CB";
+          console.log(`    ${icon} [${item.status}] ${item.task}`);
+        }
+        break;
+      }
+      case "run": {
+        const queue = loadQueue();
+        const pending = queue.filter((q) => q.status === "pending");
+        if (pending.length === 0) {
+          console.log("\n  No pending tasks in queue.");
+          break;
+        }
+        console.log(`
+  Running ${pending.length} queued task(s)...`);
+        console.log(
+          `  Budget: ${opts.budget ?? "unlimited"} | Parallel: ${opts.parallel}`
+        );
+        console.log(
+          `
+  Execute each task with: storm run --unattended "<task>"`
+        );
+        for (const item of pending) item.status = "running";
+        saveQueue(queue);
+        for (const item of pending) {
+          console.log(`    storm run --unattended "${item.task}"`);
+        }
+        break;
+      }
+      case "clear": {
+        saveQueue([]);
+        console.log("\n  Queue cleared.");
+        break;
+      }
+      default:
+        console.error(
+          `  Unknown action: ${action}. Use: add, list, run, clear`
+        );
+    }
+    console.log();
+  }
+);
+program.command("search").description("Search code \u2014 local semantic search or cross-repo via GitHub").argument("<query>", "Search query").option("--global", "Search across GitHub (not just local repo)").option("--language <lang>", "Filter by language").option("--limit <n>", "Max results (default: 10)", "10").action(
+  async (query, opts) => {
+    const limit = parseInt(opts.limit ?? "10");
+    if (opts.global) {
+      console.log(`
+  Searching GitHub for: "${query}"...
+`);
+      const { execFileSync } = await import("child_process");
+      try {
+        const ghArgs = ["search", "code", query, "--limit", String(limit)];
+        if (opts.language) ghArgs.push("--language", opts.language);
+        const output2 = execFileSync("gh", ghArgs, {
+          encoding: "utf-8",
+          timeout: 3e4,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        console.log(output2);
+      } catch (err) {
+        if (err.message?.includes("ENOENT")) {
+          console.error(
+            "  Error: `gh` CLI not found. Install: https://cli.github.com"
+          );
+        } else {
+          console.error(`  Search failed: ${err.message}`);
+        }
+      }
+    } else {
+      const { semanticSearch } = await import("@brainst0rm/core");
+      const results = semanticSearch(process.cwd(), query, limit);
+      if (results.length === 0) {
+        console.log(`
+  No results for "${query}".`);
+      } else {
+        console.log(`
+  ${results.length} result(s) for "${query}":
+`);
+        for (const r of results) {
+          const score = (r.score * 100).toFixed(0);
+          console.log(
+            `    [${score}%] ${r.filePath}${r.symbolName ? `:${r.symbolName}` : ""}`
+          );
+          if (r.snippet) {
+            console.log(`         ${r.snippet.trim().slice(0, 120)}`);
+          }
+        }
+      }
+    }
+    console.log();
+  }
+);
+program.command("setup-infra").description(
+  "Auto-generate AI infrastructure: BRAINSTORM.md, .agent.md files, routing profiles"
+).argument("[path]", "Project path", ".").action(async (projectPath) => {
+  const { resolve, join: pathJoin } = await import("path");
+  const {
+    existsSync: existsSync3,
+    writeFileSync: fsWrite,
+    mkdirSync: fsMkdir
+  } = await import("fs");
+  const absPath = resolve(projectPath);
+  console.log(`
+  Setting up AI infrastructure for ${absPath}...
+`);
+  const { analyzeProject } = await import("@brainst0rm/ingest");
+  const analysis = analyzeProject(absPath);
+  const brainstormMdPath = pathJoin(absPath, "BRAINSTORM.md");
+  if (!existsSync3(brainstormMdPath)) {
+    const lines = [
+      "---",
+      `build_command: "npm run build"`,
+      `test_command: "npm test"`,
+      "---",
+      "",
+      `# ${absPath.split("/").pop()}`,
+      "",
+      "## Stack",
+      ""
+    ];
+    if (analysis.frameworks.frameworks.length > 0)
+      lines.push(
+        `- Frameworks: ${analysis.frameworks.frameworks.join(", ")}`
+      );
+    if (analysis.languages.primary)
+      lines.push(`- Primary language: ${analysis.languages.primary}`);
+    if (analysis.frameworks.databases.length > 0)
+      lines.push(`- Databases: ${analysis.frameworks.databases.join(", ")}`);
+    if (analysis.frameworks.testing.length > 0)
+      lines.push(`- Testing: ${analysis.frameworks.testing.join(", ")}`);
+    lines.push("", "## Architecture", "");
+    lines.push(
+      `${analysis.summary.totalFiles} files, ${analysis.summary.totalLines.toLocaleString()} lines across ${analysis.summary.moduleCount} modules.`
+    );
+    if (analysis.dependencies.entryPoints.length > 0) {
+      lines.push("", "Entry points:");
+      for (const ep of analysis.dependencies.entryPoints.slice(0, 10)) {
+        lines.push(`- \`${ep}\``);
+      }
+    }
+    lines.push(
+      "",
+      "## Conventions",
+      "",
+      "<!-- Add project conventions here -->"
+    );
+    fsWrite(brainstormMdPath, lines.join("\n"), "utf-8");
+    console.log(`  \u2713 Generated BRAINSTORM.md`);
+  } else {
+    console.log(`  \xB7 BRAINSTORM.md already exists (skipped)`);
+  }
+  const agentsDir = pathJoin(absPath, ".brainstorm", "agents");
+  if (!existsSync3(agentsDir)) fsMkdir(agentsDir, { recursive: true });
+  let agentsCreated = 0;
+  for (const cluster of analysis.dependencies.clusters.slice(0, 10)) {
+    const safeName = cluster.directory.replace(/[/\\]/g, "-").replace(/^-/, "");
+    const agentPath = pathJoin(agentsDir, `${safeName}.agent.md`);
+    if (existsSync3(agentPath)) continue;
+    const node = analysis.dependencies.nodes.find(
+      (n) => cluster.files.includes(n.path)
+    );
+    const lang = node?.language ?? analysis.languages.primary;
+    const exports = cluster.files.flatMap(
+      (f) => analysis.dependencies.nodes.find((n) => n.path === f)?.exports ?? []
+    ).slice(0, 20);
+    const agentLines = [
+      "---",
+      `name: ${safeName}-expert`,
+      `role: coder`,
+      `model: auto`,
+      "---",
+      "",
+      `# ${safeName} Module Expert`,
+      "",
+      `You are an expert in the ${safeName} module of this project.`,
+      "",
+      `## Context`,
+      "",
+      `- Language: ${lang}`,
+      `- Files: ${cluster.files.length}`,
+      `- Cohesion: ${cluster.cohesion > 0.5 ? "high" : cluster.cohesion > 0.2 ? "medium" : "low"}`
+    ];
+    if (exports.length > 0) {
+      agentLines.push(`- Key exports: ${exports.join(", ")}`);
+    }
+    agentLines.push(
+      "",
+      "## Files",
+      "",
+      ...cluster.files.slice(0, 15).map((f) => `- \`${f}\``)
+    );
+    if (cluster.files.length > 15)
+      agentLines.push(`- ... and ${cluster.files.length - 15} more`);
+    fsWrite(agentPath, agentLines.join("\n"), "utf-8");
+    agentsCreated++;
+  }
+  console.log(
+    `  \u2713 Generated ${agentsCreated} .agent.md files in .brainstorm/agents/`
+  );
+  const { generateAllDocs } = await import("@brainst0rm/docgen");
+  const docResult = generateAllDocs(analysis);
+  console.log(
+    `  \u2713 Generated ${docResult.filesWritten.length} documentation files`
+  );
+  const { initRecipeDir } = await import("@brainst0rm/workflow");
+  initRecipeDir(absPath);
+  console.log(`  \u2713 Initialized .brainstorm/recipes/`);
+  console.log("\n  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+  console.log("   AI Infrastructure Setup Complete");
+  console.log("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+  console.log(`  BRAINSTORM.md     \u2192 project context for agents`);
+  console.log(
+    `  .brainstorm/agents/ \u2192 ${agentsCreated} domain expert agents`
+  );
+  console.log(`  .brainstorm/recipes/ \u2192 shareable workflow templates`);
+  console.log(`  docs/generated/   \u2192 architecture + module + API docs`);
+  console.log(
+    `
+  Next: Run \`storm chat\` to start working with AI agents that know your codebase.`
+  );
+  console.log();
+});
+program.command("route").description("Explain how Brainstorm classifies and routes a task").argument("[task]", "Task description to classify").option("--json", "Output as JSON").action(async (task, opts) => {
+  const { classifyTask } = await import("@brainst0rm/router");
+  const taskText = task ?? "write a function that validates email addresses";
+  const profile = classifyTask(taskText);
+  if (opts.json) {
+    console.log(JSON.stringify({ task: taskText, profile }, null, 2));
+    return;
+  }
+  console.log("\n  Route Explain");
+  console.log("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+  console.log(`  Task: "${taskText.slice(0, 80)}"`);
+  console.log();
+  console.log(`  Classification:`);
+  console.log(`    Type:       ${profile.type}`);
+  console.log(`    Complexity: ${profile.complexity}`);
+  console.log(`    Tools:      ${profile.requiresToolUse ? "yes" : "no"}`);
+  console.log(`    Reasoning:  ${profile.requiresReasoning ? "yes" : "no"}`);
+  if (profile.language) console.log(`    Language:   ${profile.language}`);
+  if (profile.domain) console.log(`    Domain:     ${profile.domain}`);
+  console.log(
+    `    Est tokens: ${profile.estimatedTokens.input}in / ${profile.estimatedTokens.output}out`
+  );
+  console.log();
+  console.log(`  Routing Logic:`);
+  if (profile.type === "ingest")
+    console.log(`    \u2192 Ingest pipeline: analysis + docgen + infra setup`);
+  else if (profile.type === "audit")
+    console.log(`    \u2192 Full review pipeline: security + quality + tech debt`);
+  else if (profile.type === "migration")
+    console.log(`    \u2192 Migration pipeline: parallel agents per module`);
+  else if (profile.type === "documentation")
+    console.log(`    \u2192 Documentation pipeline: architecture + module docs`);
+  else if (profile.requiresReasoning)
+    console.log(
+      `    \u2192 Routes to frontier model (Opus/GPT-5.4) for reasoning`
+    );
+  else if (profile.complexity === "trivial" || profile.complexity === "simple")
+    console.log(
+      `    \u2192 Routes to fast/cheap model (Haiku/Flash) for simple tasks`
+    );
+  else
+    console.log(
+      `    \u2192 Routes based on active strategy (quality/cost/combined)`
+    );
+  console.log();
+});
+program.command("loop").description("Run a prompt or slash command on a recurring interval").argument("<prompt>", "Prompt or /command to run repeatedly").option("-i, --interval <minutes>", "Interval between runs in minutes", "10").option(
+  "-n, --max-runs <count>",
+  "Maximum number of runs (0 = unlimited)",
+  "0"
+).action(
+  async (prompt, opts) => {
+    const intervalMs = Math.max(1, parseInt(opts.interval) || 10) * 60 * 1e3;
+    const maxRuns = parseInt(opts.maxRuns) || 0;
+    let runCount = 0;
+    console.log(
+      `
+  Loop: "${prompt}" every ${opts.interval}m${maxRuns > 0 ? ` (max ${maxRuns} runs)` : ""}`
+    );
+    console.log(`  Press Ctrl+C to stop.
+`);
+    const runOnce = async () => {
+      runCount++;
+      const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+      console.log(`  [${ts}] Run #${runCount}...`);
+      try {
+        const { execFile } = await import("child_process");
+        const { promisify } = await import("util");
+        const execFileAsync = promisify(execFile);
+        const stormBin = process.argv[1];
+        const { stdout, stderr } = await execFileAsync(
+          process.execPath,
+          [stormBin, "run", prompt],
+          {
+            cwd: process.cwd(),
+            timeout: 5 * 60 * 1e3,
+            // 5 min max per run
+            env: { ...process.env }
+          }
+        );
+        if (stdout.trim()) console.log(stdout.trim());
+        if (stderr.trim()) console.error(stderr.trim());
+      } catch (err) {
+        console.error(
+          `  Error: ${(err.stderr ?? err.message).slice(0, 200)}`
+        );
+      }
+      if (maxRuns > 0 && runCount >= maxRuns) {
+        console.log(`
+  Loop complete (${runCount} runs).`);
+        process.exit(0);
+      }
+    };
+    await runOnce();
+    setInterval(runOnce, intervalMs);
+  }
+);
+program.command("memory").description("View and manage agent memory entries").argument("[action]", "Action: list, search, forget", "list").argument("[query]", "Search query or memory key to forget").action(async (action, query) => {
+  const { MemoryManager } = await import("@brainst0rm/core");
+  const homePath = join3(homedir(), ".brainstorm", "memory");
+  const memory = new MemoryManager(homePath);
+  switch (action) {
+    case "list": {
+      const entries = memory.list();
+      if (entries.length === 0) {
+        console.log("\n  No memory entries.\n");
+        return;
+      }
+      console.log(`
+  Memory (${entries.length} entries):
+`);
+      for (const entry of entries) {
+        const typeIcon = entry.type === "user" ? "\u{1F464}" : entry.type === "feedback" ? "\u{1F4AC}" : entry.type === "project" ? "\u{1F4C1}" : "\u{1F517}";
+        console.log(`    ${typeIcon} ${entry.name}`);
+        console.log(`       ${entry.description.slice(0, 80)}`);
+      }
+      console.log();
+      break;
+    }
+    case "search": {
+      if (!query) {
+        console.error("  Usage: storm memory search <query>");
+        process.exit(1);
+      }
+      const results = memory.search(query);
+      if (results.length === 0) {
+        console.log(`
+  No memory entries matching "${query}".
+`);
+        return;
+      }
+      console.log(
+        `
+  Found ${results.length} entries matching "${query}":
+`
+      );
+      for (const entry of results) {
+        console.log(`    ${entry.name}: ${entry.description.slice(0, 80)}`);
+      }
+      console.log();
+      break;
+    }
+    case "forget": {
+      if (!query) {
+        console.error("  Usage: storm memory forget <key>");
+        process.exit(1);
+      }
+      const deleted = memory.delete(query);
+      if (deleted) {
+        console.log(`
+  Forgot: "${query}"
+`);
+      } else {
+        console.log(`
+  Memory "${query}" not found.
+`);
+      }
+      break;
+    }
+    default:
+      console.error(
+        `  Unknown action: ${action}. Use list, search, or forget.`
+      );
+      process.exit(1);
+  }
+});
+program.command("sessions").description("List recent chat sessions").option("-n, --limit <count>", "Number of sessions to show", "10").action(async (opts) => {
+  const db = getDb();
+  const sessionManager = new SessionManager(db);
+  const sessions = sessionManager.listRecent(parseInt(opts.limit));
+  console.log("\n  Recent Sessions:\n");
+  if (sessions.length === 0) {
+    console.log("    No sessions found.");
+  }
+  for (const s of sessions) {
+    const age = Math.floor((Date.now() / 1e3 - s.updatedAt) / 60);
+    const ageStr = age < 60 ? `${age}m ago` : age < 1440 ? `${Math.floor(age / 60)}h ago` : `${Math.floor(age / 1440)}d ago`;
+    console.log(
+      `    ${s.id.slice(0, 8)}  ${s.messageCount} msgs  $${s.totalCost.toFixed(4)}  ${ageStr}  ${s.projectPath}`
+    );
+  }
+  console.log();
+});
+program.command("metrics").description("Export tool stats, model latency, and cost breakdown").option("--json", "Output as JSON").action(async (opts) => {
+  const db = getDb();
+  const costRepo = new CostRepository(db);
+  const byModel = costRepo.recentByModel(20);
+  const byTaskType = costRepo.byTaskType();
+  const todayCost = costRepo.totalCostToday();
+  const monthCost = costRepo.totalCostThisMonth();
+  if (opts.json) {
+    console.log(
+      JSON.stringify({ todayCost, monthCost, byModel, byTaskType }, null, 2)
+    );
+    return;
+  }
+  console.log("\n  Cost Summary:");
+  console.log(`    Today:      $${todayCost.toFixed(4)}`);
+  console.log(`    This month: $${monthCost.toFixed(4)}`);
+  if (byModel.length > 0) {
+    console.log("\n  Cost by Model:");
+    for (const m of byModel) {
+      console.log(
+        `    ${m.modelId.padEnd(40)} $${m.totalCost.toFixed(4)}  (${m.requestCount} reqs)`
+      );
+    }
+  }
+  if (byTaskType.length > 0) {
+    console.log("\n  Cost by Task Type:");
+    for (const t of byTaskType) {
+      console.log(
+        `    ${t.taskType.padEnd(20)} $${t.totalCost.toFixed(4)}  (${t.requestCount} reqs, avg $${t.avgCost.toFixed(4)})`
+      );
+    }
+  }
+  console.log();
+});
+program.command("ingest").description(
+  "Full ingest pipeline: analyze \u2192 generate docs \u2192 set up AI infrastructure"
+).argument("[path]", "Project path to ingest", ".").option("--depth <level>", "Analysis depth: quick or full", "full").option("--output <dir>", "Output directory for analysis artifacts").action(
+  async (projectPath, opts) => {
+    const { resolve } = await import("path");
+    const absPath = resolve(projectPath);
+    const startTime = Date.now();
+    console.log(`
+  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
+    console.log(`   Brainstorm Ingest \u2014 ${absPath}`);
+    console.log(`  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+`);
+    console.log(`  Phase 1: Analyzing codebase...`);
+    const { analyzeProject } = await import("@brainst0rm/ingest");
+    const analysis = analyzeProject(absPath);
+    console.log(
+      `    \u2713 ${analysis.summary.totalFiles} files, ${analysis.summary.totalLines.toLocaleString()} lines, ${analysis.summary.moduleCount} modules`
+    );
+    console.log(`  Phase 2: Generating documentation...`);
+    const { generateAllDocs } = await import("@brainst0rm/docgen");
+    const docResult = generateAllDocs(analysis, opts.output);
+    console.log(`    \u2713 ${docResult.filesWritten.length} doc files written`);
+    console.log(`  Phase 3: Setting up AI infrastructure...`);
+    const {
+      existsSync: existsSync3,
+      writeFileSync: fsWrite,
+      mkdirSync: fsMkdir
+    } = await import("fs");
+    const { join: pathJoin } = await import("path");
+    const bmPath = pathJoin(absPath, "BRAINSTORM.md");
+    if (!existsSync3(bmPath)) {
+      const lines = [
+        "---",
+        `build_command: "npm run build"`,
+        `test_command: "npm test"`,
+        "---",
+        "",
+        `# ${absPath.split("/").pop()}`,
+        "",
+        `${analysis.languages.primary} project with ${analysis.summary.frameworkList.join(", ") || "no detected frameworks"}.`,
+        `${analysis.summary.totalFiles} files, ${analysis.summary.totalLines.toLocaleString()} lines across ${analysis.summary.moduleCount} modules.`
+      ];
+      fsWrite(bmPath, lines.join("\n"), "utf-8");
+      console.log(`    \u2713 Generated BRAINSTORM.md`);
+    }
+    const agentsDir = pathJoin(absPath, ".brainstorm", "agents");
+    if (!existsSync3(agentsDir)) fsMkdir(agentsDir, { recursive: true });
+    let agentCount = 0;
+    for (const cluster of analysis.dependencies.clusters.slice(0, 10)) {
+      const safeName = cluster.directory.replace(/[/\\]/g, "-").replace(/^-/, "");
+      const agentPath = pathJoin(agentsDir, `${safeName}.agent.md`);
+      if (!existsSync3(agentPath)) {
+        fsWrite(
+          agentPath,
+          `---
+name: ${safeName}-expert
+role: coder
+---
+
+# ${safeName} Expert
+
+Domain expert for the ${safeName} module.
+`,
+          "utf-8"
+        );
+        agentCount++;
+      }
+    }
+    console.log(`    \u2713 ${agentCount} agent profiles created`);
+    const { initRecipeDir } = await import("@brainst0rm/workflow");
+    initRecipeDir(absPath);
+    console.log(`    \u2713 Recipe directory initialized`);
+    const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
+    console.log(`
+  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+    console.log(`  Ingest complete in ${elapsed}s.`);
+    console.log(
+      `  Your codebase is now AI-ready. Run \`storm chat\` to start.`
+    );
+    console.log();
+  }
+);
+program.command("audit").description(
+  "Full code audit: security, quality, tech debt, dependency review"
+).argument("[path]", "Project path to audit", ".").option("--json", "Output as JSON").option(
+  "--focus <area>",
+  "Focus area: security, quality, dependencies, all",
+  "all"
+).action(
+  async (projectPath, opts) => {
+    const { resolve } = await import("path");
+    const absPath = resolve(projectPath);
+    console.log(`
+  Auditing ${absPath}...
+`);
+    const { analyzeProject } = await import("@brainst0rm/ingest");
+    const analysis = analyzeProject(absPath);
+    const findings = [];
+    if (opts.focus === "all" || opts.focus === "quality") {
+      for (const f of analysis.complexity.files.filter(
+        (cf) => cf.score >= 70
+      )) {
+        findings.push({
+          severity: "warning",
+          category: "complexity",
+          message: `High complexity score (${f.score}/100) \u2014 consider refactoring`,
+          file: f.path
+        });
+      }
+    }
+    if (opts.focus === "all" || opts.focus === "quality") {
+      for (const f of analysis.complexity.files.filter(
+        (cf) => cf.lines > 500
+      )) {
+        findings.push({
+          severity: "info",
+          category: "file-size",
+          message: `Large file (${f.lines} lines) \u2014 consider splitting`,
+          file: f.path
+        });
+      }
+    }
+    if (opts.focus === "all" || opts.focus === "quality") {
+      for (const c of analysis.dependencies.clusters.filter(
+        (cl) => cl.cohesion < 0.1
+      )) {
+        findings.push({
+          severity: "info",
+          category: "cohesion",
+          message: `Low cohesion module (${c.cohesion.toFixed(2)}) \u2014 files may be unrelated`,
+          file: c.directory
+        });
+      }
+    }
+    if (opts.json) {
+      console.log(
+        JSON.stringify({ findings, summary: analysis.summary }, null, 2)
+      );
+      return;
+    }
+    console.log(`  Audit Results: ${findings.length} finding(s)
+`);
+    const bySeverity = { warning: 0, info: 0, error: 0 };
+    for (const f of findings) {
+      const icon = f.severity === "warning" ? "\u26A0" : f.severity === "error" ? "\u2717" : "\u2139";
+      console.log(
+        `    ${icon} [${f.category}] ${f.message}${f.file ? ` (${f.file})` : ""}`
+      );
+      bySeverity[f.severity]++;
+    }
+    console.log(
+      `
+  Summary: ${bySeverity.error} errors, ${bySeverity.warning} warnings, ${bySeverity.info} info`
+    );
+    console.log();
+  }
+);
+program.command("share").description("Export or import session context for team sharing").argument("<action>", "Action: export or import").argument("[file]", "File path for export/import").action(async (action, file) => {
+  const { writeFileSync: writeFileSync2, readFileSync: readFileSync3 } = await import("fs");
+  const db = getDb();
+  const sessionManager = new SessionManager(db);
+  if (action === "export") {
+    const sessions = db.prepare("SELECT * FROM sessions ORDER BY created_at DESC LIMIT 1").all();
+    if (sessions.length === 0) {
+      console.log("\n  No sessions to export.");
+      return;
+    }
+    const session = sessions[0];
+    const messages = db.prepare("SELECT * FROM messages WHERE session_id = ?").all(session.id);
+    const exportData = {
+      version: 1,
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      session: { id: session.id, projectPath: session.project_path },
+      messages
+    };
+    const outPath = file ?? `brainstorm-session-${session.id.slice(0, 8)}.json`;
+    writeFileSync2(outPath, JSON.stringify(exportData, null, 2), "utf-8");
+    console.log(
+      `
+  Exported session to ${outPath} (${messages.length} messages)`
+    );
+  } else if (action === "import") {
+    if (!file) {
+      console.error("\n  Usage: storm share import <file.json>");
+      process.exit(1);
+    }
+    const data = JSON.parse(readFileSync3(file, "utf-8"));
+    console.log(
+      `
+  Imported session context: ${data.messages?.length ?? 0} messages from ${data.exportedAt}`
+    );
+    console.log(`  Use this context in your next chat session.`);
+  } else {
+    console.error(`
+  Unknown action: ${action}. Use: export or import`);
+  }
+  console.log();
+  closeDb();
+});
+program.command("cloud").description("Run agents remotely via BrainstormRouter cloud").argument("<action>", "Action: run, status, list").argument("[task]", "Task description (for run)").option("--budget <amount>", "Budget limit in dollars", "5.0").action(async (action, task, opts) => {
+  console.log(`
+  BrainstormRouter Cloud Agents`);
+  console.log(`  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+`);
+  switch (action) {
+    case "run":
+      if (!task) {
+        console.error("  Usage: storm cloud run <task>");
+        break;
+      }
+      console.log(`  Task:   ${task}`);
+      console.log(`  Budget: $${opts?.budget ?? "5.0"}`);
+      console.log(`  Status: Queued`);
+      console.log(
+        `
+  Cloud execution requires a BrainstormRouter Pro subscription.`
+      );
+      console.log(
+        `  Sign up at https://brainstorm.co/cloud to enable remote agents.`
+      );
+      break;
+    case "status":
+      console.log(`  No active cloud agents.`);
+      break;
+    case "list":
+      console.log(`  No completed cloud runs.`);
+      break;
+    default:
+      console.error(`  Unknown action: ${action}. Use: run, status, list`);
+  }
+  console.log();
+});
+program.command("ci-gen").description("Generate CI/CD workflow files (GitHub Actions, GitLab CI)").argument("[platform]", "CI platform: github, gitlab", "github").option("--output <path>", "Output path").action(async (platform, opts) => {
+  const { existsSync: existsSync3, writeFileSync: writeFileSync2, mkdirSync: mkdirSync2 } = await import("fs");
+  const { join: join4 } = await import("path");
+  const { analyzeProject } = await import("@brainst0rm/ingest");
+  const projectPath = process.cwd();
+  const analysis = analyzeProject(projectPath);
+  if (platform === "github") {
+    const workflowDir = opts.output ?? join4(projectPath, ".github", "workflows");
+    if (!existsSync3(workflowDir)) mkdirSync2(workflowDir, { recursive: true });
+    const buildCmd = analysis.frameworks.packageManagers.includes("pnpm") ? "pnpm" : analysis.frameworks.packageManagers.includes("yarn") ? "yarn" : "npm";
+    const hasTurbo = analysis.frameworks.buildTools.includes("Turborepo");
+    const workflow = [
+      "name: Brainstorm AI Review",
+      "",
+      "on:",
+      "  pull_request:",
+      "    branches: [main, master]",
+      "",
+      "jobs:",
+      "  ai-review:",
+      "    runs-on: ubuntu-latest",
+      "    steps:",
+      "      - uses: actions/checkout@v4",
+      `      - uses: actions/setup-node@v4`,
+      "        with:",
+      '          node-version: "22"',
+      `      - run: ${buildCmd} install`,
+      hasTurbo ? `      - run: npx turbo run build test` : `      - run: ${buildCmd} run build && ${buildCmd} test`,
+      "",
+      "      # AI-assisted code review via Brainstorm",
+      `      - name: Brainstorm Review`,
+      `        run: npx @brainst0rm/cli run --unattended "Review the PR changes for bugs and security issues"`,
+      "        env:",
+      "          BRAINSTORM_API_KEY: ${{ secrets.BRAINSTORM_API_KEY }}"
+    ];
+    const outPath = join4(workflowDir, "brainstorm-review.yml");
+    writeFileSync2(outPath, workflow.join("\n"), "utf-8");
+    console.log(`
+  Generated GitHub Actions workflow: ${outPath}`);
+  } else if (platform === "gitlab") {
+    const outPath = opts.output ?? join4(projectPath, ".gitlab-ci-brainstorm.yml");
+    const workflow = [
+      "brainstorm-review:",
+      "  stage: review",
+      "  image: node:22",
+      "  script:",
+      "    - npm install",
+      '    - npx @brainst0rm/cli run --unattended "Review changes for bugs and security"',
+      "  only:",
+      "    - merge_requests",
+      "  variables:",
+      "    BRAINSTORM_API_KEY: $BRAINSTORM_API_KEY"
+    ];
+    writeFileSync2(outPath, workflow.join("\n"), "utf-8");
+    console.log(`
+  Generated GitLab CI config: ${outPath}`);
+  } else {
+    console.error(`
+  Unknown platform: ${platform}. Use: github, gitlab`);
+  }
+  console.log();
+});
+program.command("start").description(
+  "One-command setup: detect project, connect to community tier, start chatting"
+).action(async () => {
+  const { resolve } = await import("path");
+  const { existsSync: existsSync3 } = await import("fs");
+  const projectPath = resolve(".");
+  console.log(`
+  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
+  console.log(`   brainstorm start`);
+  console.log(`  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+`);
+  const hasBrainstormMd = existsSync3(resolve("BRAINSTORM.md")) || existsSync3(resolve("STORM.md"));
+  const hasConfig = existsSync3(resolve("brainstorm.toml"));
+  if (!hasBrainstormMd && !hasConfig) {
+    console.log(`  Step 1: Initializing project...`);
+    const { execFileSync } = await import("child_process");
+    try {
+      execFileSync(process.execPath, [process.argv[1], "init", "--yes"], {
+        cwd: projectPath,
+        stdio: "inherit"
+      });
+    } catch {
+      const { writeFileSync: writeFileSync2 } = await import("fs");
+      writeFileSync2(
+        resolve("BRAINSTORM.md"),
+        `# ${projectPath.split("/").pop()}
+
+Project initialized by \`storm start\`.
+`,
+        "utf-8"
+      );
+      console.log(`    \u2713 Generated BRAINSTORM.md`);
+    }
+  } else {
+    console.log(`  Step 1: Project already initialized \u2713`);
+  }
+  const brKey = process.env.BRAINSTORM_API_KEY;
+  if (brKey) {
+    console.log(`  Step 2: BrainstormRouter API key detected \u2713`);
+  } else {
+    console.log(`  Step 2: Using free community tier`);
+    console.log(`    \u2192 10 requests/min \xB7 $5/month cap \xB7 362 models`);
+    console.log(`    \u2192 Upgrade: https://brainstormrouter.com/dashboard`);
+  }
+  console.log(`  Step 3: Checking connectivity...`);
+  try {
+    const resp = await fetch("https://api.brainstormrouter.com/health", {
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (resp.ok) {
+      console.log(`    \u2713 BrainstormRouter reachable`);
+    } else {
+      console.log(
+        `    \u26A0 BrainstormRouter returned ${resp.status} (will work offline with local models)`
+      );
+    }
+  } catch {
+    console.log(
+      `    \u26A0 BrainstormRouter unreachable (will work offline with local models)`
+    );
+  }
+  console.log(`
+  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+  console.log(`  Ready! Run one of:`);
+  console.log(`    storm chat            Interactive session`);
+  console.log(`    storm ingest          Analyze this codebase`);
+  console.log(`    storm run "prompt"    Single-shot execution`);
+  console.log();
+});
+program.command("chat", { isDefault: true }).description("Start an interactive chat session").option("--simple", "Use simple readline interface instead of TUI").option("--continue", "Resume the most recent session").option("--resume <id>", "Resume a specific session by ID").option("--fork <id>", "Fork a session (copy history, new session)").option("--lfg", "Full auto mode \u2014 skip all permission confirmations").option(
+  "--strategy <name>",
+  "Routing strategy: cost-first, quality-first, combined, capability"
+).option("--verbose-routing", "Print routing decisions to stderr").option(
+  "--fast",
+  "Fast startup \u2014 skip provider discovery, MCP connections, and eval probes"
+).action(
+  async (opts) => {
+    const config = loadConfig();
+    if (opts.lfg) {
+      config.general.defaultPermissionMode = "auto";
+    }
+    if (opts.fast) {
+      config.general.skipProviderDiscovery = true;
+      config.general.skipEvalProbes = true;
+    }
+    const db = getDb();
+    const resolvedKeys = await resolveProviderKeys();
+    const resolvedBRKey = resolvedKeys.get("BRAINSTORM_API_KEY") ?? getBrainstormApiKey();
+    const isCommunityTier = isCommunityKey(resolvedBRKey);
+    if (resolvedBRKey) process.env._BR_RESOLVED_KEY = resolvedBRKey;
+    const registry = await createProviderRegistry(config, resolvedKeys);
+    const costTracker = new CostTracker(db, config.budget);
+    const tools = createDefaultToolRegistry();
+    if (!opts.fast)
+      await connectMCPServers(
+        tools,
+        config,
+        resolvedKeys.get("BRAINSTORM_API_KEY")
+      );
+    const projectPath = process.cwd();
+    configureSandbox(
+      config.shell.sandbox,
+      projectPath,
+      config.shell.maxOutputBytes,
+      config.shell.containerImage,
+      config.shell.containerTimeout
+    );
+    const permissionManager = new PermissionManager(
+      config.general.defaultPermissionMode,
+      config.permissions
+    );
+    let currentOutputStyle = config.general.outputStyle ?? "concise";
+    let currentRole;
+    const sessionManager = new SessionManager(db);
+    const middleware = createDefaultMiddlewarePipeline(projectPath);
+    let { prompt: systemPrompt, frontmatter } = buildSystemPrompt(
+      projectPath,
+      currentOutputStyle
+    );
+    systemPrompt += buildToolAwarenessSection(tools.listTools());
+    const router = new BrainstormRouter(
+      config,
+      registry,
+      costTracker,
+      frontmatter
+    );
+    const hasOwnKeys = !!resolvedKeys.get("DEEPSEEK_API_KEY") || !!resolvedKeys.get("ANTHROPIC_API_KEY") || !!resolvedKeys.get("OPENAI_API_KEY") || !!resolvedKeys.get("MOONSHOT_API_KEY") || !!resolvedKeys.get("GOOGLE_GENERATIVE_AI_API_KEY");
+    if (opts.strategy) {
+      router.setStrategy(opts.strategy);
+    } else if ((!isCommunityTier || hasOwnKeys) && router.getActiveStrategy() !== "capability") {
+      router.setStrategy("quality-first");
+    }
+    const subagentTool = createSubagentTool({
+      config,
+      registry,
+      router,
+      costTracker,
+      tools,
+      projectPath,
+      permissionCheck: (name, perm) => permissionManager.check(name, perm),
+      containerIsolation: config.shell.sandbox === "container"
+    });
+    tools.register(subagentTool);
+    const hasDirectProviderKeys = !!resolvedKeys.get("DEEPSEEK_API_KEY") || !!resolvedKeys.get("ANTHROPIC_API_KEY") || !!resolvedKeys.get("OPENAI_API_KEY") || !!resolvedKeys.get("GOOGLE_GENERATIVE_AI_API_KEY") || !!resolvedKeys.get("MOONSHOT_API_KEY");
+    let preferredModelId = resolvedKeys.get(
+      "MOONSHOT_API_KEY"
+    ) ? "moonshot/kimi-k2.5" : isCommunityTier && !hasDirectProviderKeys ? "brainstormrouter/auto" : void 0;
+    let session;
+    if (opts.fork) {
+      session = sessionManager.fork(opts.fork);
+      if (!session) {
+        console.error(`  Session '${opts.fork}' not found.`);
+        process.exit(1);
+      }
+      console.log(
+        `  Forked session ${opts.fork.slice(0, 8)} -> ${session.id.slice(0, 8)}`
+      );
+    } else if (opts.resume) {
+      session = sessionManager.resume(opts.resume);
+      if (!session) {
+        console.error(`  Session '${opts.resume}' not found.`);
+        process.exit(1);
+      }
+      printResumeSummary(session, sessionManager);
+    } else if (opts.continue) {
+      session = sessionManager.resumeLatest(projectPath);
+      if (!session) {
+        session = sessionManager.start(projectPath);
+      } else {
+        printResumeSummary(session, sessionManager);
+      }
+    } else {
+      session = sessionManager.start(projectPath);
+    }
+    const localCount = registry.models.filter((m) => m.isLocal).length;
+    const cloudCount = registry.models.filter((m) => !m.isLocal).length;
+    if (opts.simple) {
+      const readline = await import("readline/promises");
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      console.log(`
+  \u{1F9E0} brainstorm v0.1.0`);
+      console.log(
+        `  Strategy: ${router.getActiveStrategy()} | Models: ${localCount} local, ${cloudCount} cloud`
+      );
+      console.log(`  Project: ${projectPath}`);
+      if (isCommunityTier)
+        console.log(
+          `  Community tier (5 req/min, cheap models). Set BRAINSTORM_API_KEY for full access.`
+        );
+      console.log(
+        `  Commands: /quit, /model <id>, /strategy <name>, /compact`
+      );
+      console.log(`  Ctrl+C to interrupt, Ctrl+D to exit.
+`);
+      let simpleAbortController = null;
+      process.on("SIGINT", () => {
+        if (simpleAbortController) {
+          simpleAbortController.abort();
+          simpleAbortController = null;
+          process.stdout.write("\n  [interrupted]\n\n");
+        } else {
+          rl.close();
+          process.exit(0);
+        }
+      });
+      while (true) {
+        const input2 = await rl.question("you > ");
+        if (!input2.trim()) continue;
+        if (input2.trim() === "/quit" || input2.trim() === "/exit") break;
+        if (input2.startsWith("/")) {
+          const { isSlashCommand, executeSlashCommand } = await import("./slash-PDWKCZOQ.js");
+          if (isSlashCommand(input2)) {
+            const result = await executeSlashCommand(input2, {
+              getModel: () => preferredModelId,
+              getSessionCost: () => costTracker.getSessionCost(),
+              getTokenCount: () => ({
+                input: 0,
+                output: 0
+              }),
+              exit: () => {
+                rl.close();
+                process.exit(0);
+              },
+              clearHistory: () => {
+                session = sessionManager.start(projectPath);
+              },
+              setModel: (m) => {
+                preferredModelId = m;
+              },
+              setStrategy: (s) => {
+                router.setStrategy(s);
+              },
+              getStrategy: () => router.getActiveStrategy(),
+              setMode: (m) => {
+                permissionManager.setMode(m);
+              },
+              getMode: () => permissionManager.getMode(),
+              setOutputStyle: (s) => {
+                currentOutputStyle = s;
+                const rebuilt = buildSystemPrompt(
+                  projectPath,
+                  currentOutputStyle
+                );
+                systemPrompt = rebuilt.prompt + buildToolAwarenessSection(tools.listTools());
+              },
+              getOutputStyle: () => currentOutputStyle,
+              getBudget: () => {
+                const remaining = costTracker.getRemainingBudget();
+                if (remaining === null) return null;
+                return {
+                  remaining,
+                  limit: config.budget.perSession ?? 0
+                };
+              },
+              compact: async () => {
+                const result2 = await sessionManager.compact({
+                  contextWindow: 2e5,
+                  keepRecent: 5
+                });
+                console.log(
+                  `  Compacted: ${result2.removed} messages removed (${result2.tokensBefore} \u2192 ${result2.tokensAfter} tokens)`
+                );
+              }
+            });
+            console.log(`  ${result}`);
+            continue;
+          }
+        }
+        sessionManager.addUserMessage(input2);
+        let fullResponse = "";
+        const sessionTotalBefore = costTracker.getSessionCost();
+        process.stdout.write("\nbrainstorm > ");
+        simpleAbortController = new AbortController();
+        const roleToolFilter = currentRole && ROLES[currentRole] ? {
+          allowedTools: ROLES[currentRole].allowedTools,
+          blockedTools: ROLES[currentRole].blockedTools
+        } : void 0;
+        for await (const event of runAgentLoop(sessionManager.getHistory(), {
+          config,
+          registry,
+          router,
+          costTracker,
+          tools,
+          sessionId: session.id,
+          projectPath,
+          systemPrompt,
+          compaction: buildCompactionCallbacks(sessionManager),
+          signal: simpleAbortController.signal,
+          permissionCheck: (name, perm) => permissionManager.check(name, perm),
+          preferredModelId,
+          middleware,
+          roleToolFilter,
+          onTurnComplete: (ctx) => {
+            ctx.turn = sessionManager.incrementTurn();
+            ctx.sessionMinutes = sessionManager.getSessionMinutes();
+            sessionManager.addTurnContext(ctx);
+          }
+        })) {
+          switch (event.type) {
+            case "thinking": {
+              const spinFrames = [
+                "\u280B",
+                "\u2819",
+                "\u2839",
+                "\u2838",
+                "\u283C",
+                "\u2834",
+                "\u2826",
+                "\u2827",
+                "\u2807",
+                "\u280F"
+              ];
+              const f = spinFrames[Math.floor(Date.now() / 100) % spinFrames.length];
+              const chatPhases = {
+                classifying: "Analyzing...",
+                routing: "Selecting model...",
+                connecting: "Connecting...",
+                streaming: "Streaming..."
+              };
+              process.stderr.write(
+                `\r  ${f} ${chatPhases[event.phase] ?? event.phase}`
+              );
+              break;
+            }
+            case "routing":
+              process.stderr.write(`\r  [${event.decision.model.name}]
+`);
+              if (opts.verboseRouting) {
+                const d = event.decision;
+                process.stderr.write(
+                  `  routing: strategy=${d.strategy} model=${d.model.id} provider=${d.model.provider} cost=$${d.estimatedCost.toFixed(4)} reason="${d.reason}"
+`
+                );
+              }
+              break;
+            case "text-delta":
+              fullResponse += event.delta;
+              process.stdout.write(event.delta);
+              break;
+            case "tool-call-start":
+              process.stdout.write(`
+  [tool: ${event.toolName}]
+`);
+              break;
+            case "tool-call-result":
+              break;
+            // Tool results are shown by the model's text response
+            case "model-retry":
+              process.stderr.write(
+                `
+  [retry: ${event.fromModel} \u2192 ${event.toModel}]
+`
+              );
+              break;
+            case "gateway-feedback": {
+              const gw = formatGatewayFeedback(event.feedback);
+              if (gw) process.stderr.write(`  ${gw}
+`);
+              break;
+            }
+            case "context-budget":
+              process.stderr.write(
+                `  [${Math.round(event.used / 1e3)}k/${Math.round(event.limit / 1e3)}k tokens (${event.percent}%)]
+`
+              );
+              break;
+            case "interrupted":
+              process.stdout.write("\n  [interrupted]\n\n");
+              break;
+            case "done": {
+              const turn = sessionManager.getTurnCount();
+              const turnCost = event.totalCost - (sessionTotalBefore ?? 0);
+              sessionManager.syncSessionCost(turnCost);
+              process.stdout.write(
+                `
+  [Turn ${turn}: $${turnCost.toFixed(4)} | Session: $${event.totalCost.toFixed(4)}]
+
+`
+              );
+              break;
+            }
+            case "error":
+              process.stderr.write(`
+  Error: ${event.error.message}
+
+`);
+              break;
+          }
+        }
+        simpleAbortController = null;
+        if (fullResponse) sessionManager.addAssistantMessage(fullResponse);
+      }
+      rl.close();
+      return;
+    }
+    const { render } = await import("ink");
+    const React = await import("react");
+    const { App } = await import("./App-DPXJYXKH.js");
+    let currentAbortController = null;
+    function handleSendMessage(text) {
+      sessionManager.addUserMessage(text);
+      currentAbortController = new AbortController();
+      const roleFilter = currentRole && ROLES[currentRole] ? {
+        allowedTools: ROLES[currentRole].allowedTools,
+        blockedTools: ROLES[currentRole].blockedTools
+      } : void 0;
+      const gen = runAgentLoop(sessionManager.getHistory(), {
+        config,
+        registry,
+        router,
+        costTracker,
+        tools,
+        sessionId: session.id,
+        projectPath,
+        systemPrompt,
+        compaction: buildCompactionCallbacks(sessionManager),
+        signal: currentAbortController.signal,
+        permissionCheck: (name, perm) => permissionManager.check(name, perm),
+        middleware,
+        preferredModelId,
+        roleToolFilter: roleFilter
+      });
+      return (async function* () {
+        let fullResponse = "";
+        for await (const event of gen) {
+          if (event.type === "text-delta") fullResponse += event.delta;
+          yield event;
+        }
+        if (fullResponse) sessionManager.addAssistantMessage(fullResponse);
+        currentAbortController = null;
+      })();
+    }
+    function handleAbort() {
+      if (currentAbortController) {
+        currentAbortController.abort();
+        currentAbortController = null;
+      }
+    }
+    const modelData = registry.models.map((m) => ({
+      id: m.id,
+      name: m.name,
+      provider: m.provider,
+      qualityTier: m.capabilities?.qualityTier ?? 3,
+      speedTier: m.capabilities?.speedTier ?? 2,
+      pricing: {
+        input: m.pricing?.inputPer1MTokens ?? 0,
+        output: m.pricing?.outputPer1MTokens ?? 0
+      },
+      status: m.status ?? "available"
+    }));
+    const brGateway = createGatewayClient2();
+    render(
+      React.createElement(App, {
+        strategy: config.general.defaultStrategy,
+        modelCount: { local: localCount, cloud: cloudCount },
+        onSendMessage: handleSendMessage,
+        onAbort: handleAbort,
+        models: modelData,
+        gateway: brGateway,
+        configInfo: {
+          strategy: config.general.defaultStrategy,
+          permissionMode: config.general.defaultPermissionMode ?? "confirm",
+          outputStyle: config.general.outputStyle ?? "concise",
+          sandbox: config.shell?.sandbox ?? "none"
+        },
+        vaultInfo: {
+          exists: new BrainstormVault(VAULT_PATH).exists(),
+          isOpen: false,
+          keyCount: 0,
+          keys: [],
+          createdAt: null,
+          opAvailable: !!process.env.OP_SERVICE_ACCOUNT_TOKEN,
+          resolvedKeys: PROVIDER_KEY_NAMES.filter((k) => resolvedKeys.get(k))
+        },
+        memoryInfo: await (async () => {
+          try {
+            const { MemoryManager } = await import("@brainst0rm/core");
+            const mem = new MemoryManager(projectPath);
+            const entries = mem.list();
+            const types = {};
+            for (const e of entries) {
+              types[e.type] = (types[e.type] ?? 0) + 1;
+            }
+            return { localCount: entries.length, types };
+          } catch {
+            return { localCount: 0, types: {} };
+          }
+        })(),
+        slashCallbacks: {
+          setModel: (model) => {
+            preferredModelId = model;
+          },
+          setStrategy: (s) => {
+            router.setStrategy(s);
+          },
+          getStrategy: () => router.getActiveStrategy(),
+          setMode: (mode) => {
+            permissionManager.setMode(mode);
+          },
+          getMode: () => permissionManager.getMode(),
+          setOutputStyle: (style) => {
+            currentOutputStyle = style;
+            const rebuilt = buildSystemPrompt(
+              projectPath,
+              currentOutputStyle
+            );
+            systemPrompt = rebuilt.prompt + buildToolAwarenessSection(tools.listTools());
+          },
+          getOutputStyle: () => currentOutputStyle,
+          rebuildSystemPrompt: (basePromptOverride) => {
+            const rebuilt = buildSystemPrompt(
+              projectPath,
+              currentOutputStyle,
+              basePromptOverride
+            );
+            systemPrompt = rebuilt.prompt + buildToolAwarenessSection(tools.listTools());
+          },
+          getActiveRole: () => currentRole,
+          setActiveRole: (role) => {
+            currentRole = role;
+          },
+          getBudget: () => {
+            const state = costTracker.getBudgetState();
+            if (!state.sessionLimit) return null;
+            return {
+              remaining: Math.max(0, state.sessionLimit - state.sessionUsed),
+              limit: state.sessionLimit
+            };
+          },
+          compact: async () => {
+            const models = router.getModels();
+            const activeModel = preferredModelId ? models.find((m) => m.id === preferredModelId) : models[0];
+            const contextWindow = activeModel?.limits?.contextWindow || 128e3;
+            const cb = buildCompactionCallbacks(sessionManager);
+            await cb.compact({ contextWindow });
+          },
+          dream: async () => {
+            const { MemoryManager, DREAM_SYSTEM_PROMPT, buildDreamPrompt } = await import("@brainst0rm/core");
+            const memory = new MemoryManager(projectPath);
+            const rawFiles = memory.getRawFiles();
+            if (rawFiles.length === 0)
+              return "No memory files to consolidate.";
+            const dreamPrompt = buildDreamPrompt(
+              memory.getMemoryDir(),
+              rawFiles
+            );
+            const result = await spawnSubagent(dreamPrompt, {
+              config,
+              registry,
+              router,
+              costTracker,
+              tools,
+              projectPath,
+              type: "code",
+              systemPrompt: DREAM_SYSTEM_PROMPT,
+              maxSteps: 12,
+              budgetLimit: 0.5
+            });
+            return `Dream complete. ${result.toolCalls.length} tool calls, $${result.cost.toFixed(4)}.
+${result.text}`;
+          },
+          vault: async (action, args) => {
+            const vault = new BrainstormVault(VAULT_PATH);
+            switch (action) {
+              case "list":
+              case "ls": {
+                if (!vault.exists())
+                  return "No vault found. Run `brainstorm vault init` to create one.";
+                const keys = vault.list();
+                if (keys.length === 0)
+                  return "Vault is empty (or locked). Keys: none";
+                return `Vault keys (${keys.length}):
+${keys.map((k) => `  - ${k}`).join("\n")}`;
+              }
+              case "status": {
+                if (!vault.exists()) return "Vault: not initialized";
+                return `Vault: ${VAULT_PATH}
+Status: ${vault.isOpen() ? "unlocked" : "locked"}
+Keys: ${vault.list().length}`;
+              }
+              case "get": {
+                if (!args) return "Usage: /vault get <key-name>";
+                const val = vault.get(args);
+                if (val === null)
+                  return `Key '${args}' not found (or vault is locked).`;
+                return `${args} = ${val.slice(0, 8)}${"*".repeat(Math.max(0, val.length - 8))}`;
+              }
+              case "add":
+              case "set": {
+                return "Use `brainstorm vault add <name>` from the terminal \u2014 requires interactive password input.";
+              }
+              case "remove":
+              case "rm":
+              case "delete": {
+                return "Use `brainstorm vault remove <name>` from the terminal \u2014 requires interactive password input.";
+              }
+              default:
+                return "Usage: /vault [list|status|get <name>]\nFor add/remove, use the `brainstorm vault` CLI command.";
+            }
+          }
+        }
+      })
+    );
+  }
+);
+function run() {
+  const cleanup = () => {
+    try {
+      stopDockerSandbox();
+    } catch {
+    }
+    try {
+      closeDb();
+    } catch {
+    }
+  };
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("exit", () => {
+    cleanup();
+  });
+  program.parse();
+}
+run();
+export {
+  run
+};
+//# sourceMappingURL=index.js.map