@brainst0rm/cli 0.13.0 → 0.14.0

package/dist/dist-Z4SBSK4Q.js

@@ -0,0 +1,1639 @@
+import "./chunk-PR4QN5HX.js";
+
+// ../onboard/dist/index.js
+import { createLogger } from "@brainst0rm/shared";
+import { analyzeProject } from "@brainst0rm/ingest";
+import { existsSync } from "fs";
+import { execFileSync } from "child_process";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join } from "path";
+import { writeFileSync, mkdirSync, existsSync as existsSync3 } from "fs";
+import { join as join2 } from "path";
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync4 } from "fs";
+import { join as join3 } from "path";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync5 } from "fs";
+import { join as join4 } from "path";
+import { writeFileSync as writeFileSync4, existsSync as existsSync6 } from "fs";
+import { join as join5, basename } from "path";
+var ALL_PHASES = [
+  "static-analysis",
+  "deep-exploration",
+  "team-assembly",
+  "routing-rules",
+  "workflow-gen",
+  "brainstorm-md",
+  "verification"
+];
+var PHASE_LABELS = {
+  "static-analysis": "Static Analysis",
+  "deep-exploration": "Deep Exploration",
+  "team-assembly": "Team Assembly",
+  "routing-rules": "Routing Rules",
+  "workflow-gen": "Workflow Generation",
+  "brainstorm-md": "BRAINSTORM.md",
+  verification: "Verification"
+};
+function inferBudget(analysis) {
+  const files = analysis.summary.totalFiles;
+  const complexity = analysis.summary.avgComplexity;
+  let base;
+  if (files < 50) base = 2;
+  else if (files < 500) base = 5;
+  else base = 10;
+  const multiplier = complexity > 15 ? 1.5 : 1;
+  return Math.round(base * multiplier * 100) / 100;
+}
+function createBudgetTracker(totalBudget) {
+  let spent = 0;
+  return {
+    get total() {
+      return totalBudget;
+    },
+    get spent() {
+      return Math.round(spent * 1e3) / 1e3;
+    },
+    get remaining() {
+      return Math.round((totalBudget - spent) * 1e3) / 1e3;
+    },
+    canAfford(estimatedCost) {
+      return spent + estimatedCost <= totalBudget;
+    },
+    record(cost) {
+      spent += cost;
+      return spent <= totalBudget;
+    }
+  };
+}
+var PHASE_COST_ESTIMATES = {
+  "static-analysis": 0,
+  "deep-exploration": 0.25,
+  "team-assembly": 0.4,
+  "routing-rules": 0.06,
+  "workflow-gen": 0.08,
+  "brainstorm-md": 0.15,
+  verification: 0
+};
+function runStaticAnalysis(projectPath) {
+  const analysis = analyzeProject(projectPath);
+  const gitSummary = collectGitSummary(projectPath);
+  return { analysis, gitSummary };
+}
+function collectGitSummary(projectPath) {
+  const gitDir = `${projectPath}/.git`;
+  if (!existsSync(gitDir)) return "";
+  try {
+    const log2 = execFileSync(
+      "git",
+      ["log", "--oneline", "--stat", "--no-color", "-30"],
+      {
+        cwd: projectPath,
+        encoding: "utf-8",
+        timeout: 1e4
+      }
+    );
+    return log2.trim();
+  } catch {
+    return "";
+  }
+}
+function runVerification(context) {
+  const result = {
+    agentsValid: true,
+    agentErrors: [],
+    routingValid: true,
+    routingErrors: [],
+    recipesValid: true,
+    recipeErrors: [],
+    brainstormMdValid: true,
+    brainstormMdErrors: []
+  };
+  if (context.agents) {
+    for (const agent of context.agents) {
+      const errors = validateAgentContent(agent.id, agent.content);
+      if (errors.length > 0) {
+        result.agentsValid = false;
+        result.agentErrors.push(...errors);
+      }
+    }
+  }
+  if (context.routingRules) {
+    for (const rule of context.routingRules) {
+      if (!rule.match || !rule.agentId) {
+        result.routingValid = false;
+        result.routingErrors.push(
+          `Rule missing required fields: match="${rule.match}", agentId="${rule.agentId}"`
+        );
+      }
+      if (context.agents && !context.agents.some((a) => a.id === rule.agentId)) {
+        result.routingValid = false;
+        result.routingErrors.push(
+          `Rule references unknown agent "${rule.agentId}"`
+        );
+      }
+    }
+  }
+  if (context.recipes) {
+    for (const recipe of context.recipes) {
+      const errors = validateRecipeContent(recipe.filename, recipe.content);
+      if (errors.length > 0) {
+        result.recipesValid = false;
+        result.recipeErrors.push(...errors);
+      }
+    }
+  }
+  if (context.brainstormMd) {
+    const errors = validateBrainstormMd(context.brainstormMd);
+    if (errors.length > 0) {
+      result.brainstormMdValid = false;
+      result.brainstormMdErrors.push(...errors);
+    }
+  }
+  return result;
+}
+function validateAgentContent(id, content) {
+  const errors = [];
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!fmMatch) {
+    errors.push(`Agent "${id}": missing YAML frontmatter (---)`);
+    return errors;
+  }
+  const frontmatter = fmMatch[1];
+  const body = fmMatch[2].trim();
+  if (!/^name:\s*.+$/m.test(frontmatter)) {
+    errors.push(`Agent "${id}": missing "name" field in frontmatter`);
+  }
+  if (!/^role:\s*.+$/m.test(frontmatter)) {
+    errors.push(`Agent "${id}": missing "role" field in frontmatter`);
+  }
+  if (!body) {
+    errors.push(`Agent "${id}": empty system prompt body`);
+  }
+  return errors;
+}
+function validateRecipeContent(filename, content) {
+  const errors = [];
+  if (!content.includes("name:")) {
+    errors.push(`Recipe "${filename}": missing "name" field`);
+  }
+  if (!content.includes("steps:")) {
+    errors.push(`Recipe "${filename}": missing "steps" field`);
+  }
+  return errors;
+}
+function validateBrainstormMd(content) {
+  const errors = [];
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!fmMatch) {
+    return errors;
+  }
+  const frontmatter = fmMatch[1];
+  if (!/version:\s*1/.test(frontmatter)) {
+    errors.push("BRAINSTORM.md: frontmatter missing version: 1");
+  }
+  return errors;
+}
+function buildExplorationPrompt(analysis, fileContents, gitSummary) {
+  const sections = [];
+  sections.push(`You are analyzing a codebase to understand its conventions, domain concepts, and development workflow.
+Your goal: produce a JSON object that captures everything a new AI agent would need to know before writing code in this project.
+
+## Project Overview
+- Path: ${analysis.projectPath}
+- Primary language: ${analysis.summary.primaryLanguage}
+- Frameworks: ${analysis.summary.frameworkList.join(", ") || "none detected"}
+- Files: ${analysis.summary.totalFiles}, Lines: ${analysis.summary.totalLines.toLocaleString()}
+- Modules: ${analysis.summary.moduleCount}
+- Entry points: ${analysis.summary.entryPointCount}
+- API routes: ${analysis.summary.apiRouteCount}
+- Avg complexity: ${analysis.summary.avgComplexity.toFixed(1)}
+- Hotspots: ${analysis.summary.hotspotCount}`);
+  if (fileContents.size > 0) {
+    sections.push("\n## Key Files\n");
+    for (const [path, content] of fileContents) {
+      sections.push(`### ${path}
+\`\`\`
+${content}
+\`\`\`
+`);
+    }
+  }
+  if (gitSummary) {
+    sections.push(
+      `## Recent Git History (last 30 commits)
+\`\`\`
+${gitSummary}
+\`\`\``
+    );
+  }
+  if (analysis.frameworks.frameworks.length > 0) {
+    sections.push(`## Detected Stack
+- Frameworks: ${analysis.frameworks.frameworks.join(", ")}
+- Build tools: ${analysis.frameworks.buildTools.join(", ") || "none"}
+- Databases: ${analysis.frameworks.databases.join(", ") || "none"}
+- Testing: ${analysis.frameworks.testing.join(", ") || "none"}
+- CI/CD: ${analysis.frameworks.ci?.join(", ") || "none"}
+- Deployment: ${analysis.frameworks.deployment?.join(", ") || "none"}`);
+  }
+  if (analysis.dependencies.entryPoints.length > 0) {
+    sections.push(
+      `## Entry Points
+${analysis.dependencies.entryPoints.slice(0, 10).map((e) => `- ${e}`).join("\n")}`
+    );
+  }
+  if (analysis.complexity.summary.hotspots.length > 0) {
+    sections.push(
+      `## Complexity Hotspots
+${analysis.complexity.summary.hotspots.slice(0, 10).map((h) => `- ${h}`).join("\n")}`
+    );
+  }
+  sections.push(`
+## Instructions
+
+Analyze all the information above and respond with a JSON object matching this exact schema:
+
+\`\`\`json
+{
+  "conventions": {
+    "naming": {
+      "variables": "camelCase | snake_case | PascalCase",
+      "files": "kebab-case | camelCase | PascalCase | snake_case",
+      "components": "PascalCase (if applicable)",
+      "exports": "named | default | barrel"
+    },
+    "errorHandling": "description of error handling patterns",
+    "testingPatterns": "description of testing approach and file organization",
+    "importStyle": "description of import patterns",
+    "stateManagement": "description if frontend (null if not applicable)",
+    "apiPatterns": "description of API design patterns (null if not applicable)",
+    "customRules": ["any other conventions discovered"]
+  },
+  "domainConcepts": [
+    {
+      "name": "concept name",
+      "definition": "what this concept means in the project",
+      "relatedFiles": ["path/to/relevant/files"]
+    }
+  ],
+  "gitWorkflow": {
+    "commitStyle": "conventional commits | freeform | prefixed | etc.",
+    "branchStrategy": "trunk-based | gitflow | github flow | unknown",
+    "prPatterns": "squash merge | merge commits | rebase | unknown",
+    "typicalPRSize": "small (<100 lines) | medium (100-500) | large (500+)",
+    "activeContributors": 1
+  },
+  "cicdSetup": {
+    "provider": "github-actions | vercel | circleci | none | etc.",
+    "stages": ["lint", "test", "build", "deploy"],
+    "deployTarget": "vercel | aws | docker | do-app-platform | none | etc.",
+    "hasPreCommitHooks": false
+  },
+  "keyFiles": [
+    {
+      "path": "relative/path",
+      "purpose": "what this file does",
+      "summary": "2-3 sentence summary"
+    }
+  ],
+  "projectPurpose": "One paragraph describing what this project does, its target users, and its primary value proposition."
+}
+\`\`\`
+
+Important:
+- Base ALL answers on the actual file contents and git history provided above
+- For conventions, look at actual patterns in the code \u2014 don't guess
+- For domain concepts, identify the core business/technical abstractions unique to this project
+- For git workflow, analyze the commit messages and file change patterns
+- Include 3-10 domain concepts and 5-15 key files
+- Respond ONLY with the JSON object, no markdown fencing or explanation`);
+  return sections.join("\n\n");
+}
+var MAX_LINES_PER_FILE = 100;
+var MAX_FILES = 20;
+var MAX_TOTAL_CHARS = 5e4;
+async function runDeepExploration(context, dispatcher) {
+  const { analysis } = context;
+  const gitSummary = context._gitSummary ?? "";
+  const selectedFiles = selectKeyFiles(analysis);
+  const fileContents = readSelectedFiles(analysis.projectPath, selectedFiles);
+  const prompt = buildExplorationPrompt(analysis, fileContents, gitSummary);
+  const response = await dispatcher.generate(prompt, 0.3);
+  let exploration;
+  try {
+    exploration = parseExplorationResponse(response.text);
+  } catch (error) {
+    exploration = createFallbackResult(analysis);
+  }
+  const conceptCount = exploration.domainConcepts.length;
+  const conventionCount = countConventions(exploration.conventions);
+  const workflowDesc = exploration.gitWorkflow.branchStrategy;
+  return {
+    contextPatch: { exploration },
+    cost: response.cost,
+    summary: `${conventionCount} conventions, ${conceptCount} domain concepts, ${workflowDesc} workflow`
+  };
+}
+function selectKeyFiles(analysis) {
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (path) => {
+    if (seen.has(path) || files.length >= MAX_FILES) return;
+    seen.add(path);
+    files.push(path);
+  };
+  for (const ep of analysis.dependencies.entryPoints.slice(0, 5)) {
+    add(ep);
+  }
+  const configFiles = [
+    "package.json",
+    "tsconfig.json",
+    "tsconfig.base.json",
+    ".eslintrc.json",
+    ".eslintrc.js",
+    ".eslintrc.cjs",
+    "eslint.config.js",
+    "eslint.config.mjs",
+    ".prettierrc",
+    ".prettierrc.json",
+    "prettier.config.js",
+    "turbo.json",
+    "vercel.json",
+    "next.config.js",
+    "next.config.mjs",
+    "next.config.ts",
+    "vite.config.ts",
+    "vitest.config.ts",
+    "jest.config.ts",
+    "jest.config.js",
+    "Dockerfile",
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    ".github/workflows/ci.yml",
+    ".github/workflows/ci.yaml",
+    ".github/workflows/test.yml",
+    ".github/workflows/deploy.yml"
+  ];
+  for (const cf of configFiles) {
+    const fullPath = join(analysis.projectPath, cf);
+    if (existsSync2(fullPath)) {
+      add(cf);
+    }
+  }
+  for (const readme of ["README.md", "readme.md", "Readme.md"]) {
+    const fullPath = join(analysis.projectPath, readme);
+    if (existsSync2(fullPath)) {
+      add(readme);
+      break;
+    }
+  }
+  const testFile = findTestFile(analysis);
+  if (testFile) add(testFile);
+  for (const cluster of analysis.dependencies.clusters.slice(0, 5)) {
+    const hottest = findHottestFile(analysis, cluster.files);
+    if (hottest) add(hottest);
+  }
+  return files;
+}
+function findTestFile(analysis) {
+  for (const node of analysis.dependencies.nodes) {
+    if (node.path.includes(".test.") || node.path.includes(".spec.") || node.path.includes("__tests__/")) {
+      return node.path;
+    }
+  }
+  return null;
+}
+function findHottestFile(analysis, files) {
+  let best = null;
+  for (const f of files) {
+    const fc = analysis.complexity.files.find((c) => c.path === f);
+    if (fc && (!best || fc.score > best.score)) {
+      best = { path: fc.path, score: fc.score };
+    }
+  }
+  return best?.path ?? files[0] ?? null;
+}
+function readSelectedFiles(projectPath, files) {
+  const contents = /* @__PURE__ */ new Map();
+  let totalChars = 0;
+  for (const file of files) {
+    const fullPath = join(projectPath, file);
+    if (!existsSync2(fullPath)) continue;
+    try {
+      const raw = readFileSync(fullPath, "utf-8");
+      const lines = raw.split("\n").slice(0, MAX_LINES_PER_FILE);
+      const truncated = lines.join("\n");
+      if (totalChars + truncated.length > MAX_TOTAL_CHARS) break;
+      contents.set(file, truncated);
+      totalChars += truncated.length;
+    } catch {
+    }
+  }
+  return contents;
+}
+function parseExplorationResponse(text) {
+  let json = text.trim();
+  if (json.startsWith("```")) {
+    json = json.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+  }
+  const parsed = JSON.parse(json);
+  if (!parsed.conventions || !parsed.domainConcepts || !parsed.gitWorkflow) {
+    throw new Error("Missing required fields in exploration response");
+  }
+  return parsed;
+}
+function createFallbackResult(analysis) {
+  return {
+    conventions: {
+      naming: {
+        variables: "unknown",
+        files: "unknown",
+        exports: "unknown"
+      },
+      errorHandling: "unknown",
+      testingPatterns: analysis.frameworks.testing.length > 0 ? `Uses ${analysis.frameworks.testing.join(", ")}` : "No testing framework detected",
+      importStyle: "unknown",
+      customRules: []
+    },
+    domainConcepts: [],
+    gitWorkflow: {
+      commitStyle: "unknown",
+      branchStrategy: "unknown",
+      prPatterns: "unknown",
+      typicalPRSize: "unknown",
+      activeContributors: 1
+    },
+    cicdSetup: {
+      provider: analysis.frameworks.ci?.[0] ?? "none",
+      stages: [],
+      deployTarget: analysis.frameworks.deployment?.[0] ?? "none",
+      hasPreCommitHooks: false
+    },
+    keyFiles: [],
+    projectPurpose: `A ${analysis.summary.primaryLanguage} project using ${analysis.summary.frameworkList.join(", ") || "no detected frameworks"}.`
+  };
+}
+function countConventions(conventions) {
+  let count = 0;
+  if (conventions.naming.variables !== "unknown") count++;
+  if (conventions.naming.files !== "unknown") count++;
+  if (conventions.naming.components) count++;
+  if (conventions.naming.exports !== "unknown") count++;
+  if (conventions.errorHandling !== "unknown") count++;
+  if (conventions.testingPatterns && !conventions.testingPatterns.startsWith("No"))
+    count++;
+  if (conventions.importStyle !== "unknown") count++;
+  if (conventions.stateManagement) count++;
+  if (conventions.apiPatterns) count++;
+  count += conventions.customRules.length;
+  return count;
+}
+function buildAssemblyPrompt(analysis, exploration, candidates) {
+  const sections = [];
+  sections.push(`You are designing a team of specialized AI agents for a codebase. Each agent needs a rich system prompt that embeds the project's actual conventions, domain knowledge, and module context.
+
+## Project
+${exploration?.projectPurpose ?? `A ${analysis.summary.primaryLanguage} project with ${analysis.summary.totalFiles} files.`}
+
+## Stack
+- Language: ${analysis.summary.primaryLanguage}
+- Frameworks: ${analysis.summary.frameworkList.join(", ") || "none"}
+- Testing: ${analysis.frameworks.testing.join(", ") || "none"}
+- Modules: ${analysis.summary.moduleCount}
+- Complexity: avg ${analysis.summary.avgComplexity.toFixed(1)}`);
+  if (exploration) {
+    sections.push(`## Conventions
+- Naming: variables=${exploration.conventions.naming.variables}, files=${exploration.conventions.naming.files}
+- Error handling: ${exploration.conventions.errorHandling}
+- Testing: ${exploration.conventions.testingPatterns}
+- Imports: ${exploration.conventions.importStyle}${exploration.conventions.stateManagement ? `
+- State: ${exploration.conventions.stateManagement}` : ""}${exploration.conventions.apiPatterns ? `
+- API: ${exploration.conventions.apiPatterns}` : ""}
+- Rules: ${exploration.conventions.customRules.join("; ") || "none"}`);
+    if (exploration.domainConcepts.length > 0) {
+      sections.push(`## Domain Concepts
+${exploration.domainConcepts.map((c) => `- **${c.name}**: ${c.definition}`).join("\n")}`);
+    }
+  }
+  sections.push(`## Agent Candidates
+
+Generate a .agent.md system prompt for EACH of the following agents. The system prompt should be 10-30 lines of markdown that a code-writing AI reads before starting work.
+
+${candidates.map((c, i) => {
+    let desc = `### Agent ${i + 1}: ${c.id} (${c.role})
+- Rationale: ${c.rationale}`;
+    if (c.tools) desc += `
+- Allowed tools: ${c.tools.join(", ")}`;
+    if (c.moduleScope) {
+      desc += `
+- Module scope: ${c.moduleScope.directory} (${c.moduleScope.files.length} files, cohesion: ${c.moduleScope.cohesion.toFixed(2)})`;
+    }
+    return desc;
+  }).join("\n\n")}`);
+  sections.push(`## Instructions
+
+For each agent candidate, generate a complete .agent.md file. Respond with a JSON array of objects:
+
+\`\`\`json
+[
+  {
+    "id": "agent-id",
+    "role": "role",
+    "modelHint": "quality | capable | cheap",
+    "tools": ["tool1", "tool2"] or "all",
+    "maxSteps": 10,
+    "budget": 5.0,
+    "systemPrompt": "The full markdown system prompt content..."
+  }
+]
+\`\`\`
+
+Each systemPrompt MUST include:
+1. A clear role definition (what this agent does)
+2. Project-specific conventions (from the conventions section above)
+3. Domain concepts relevant to this agent's scope
+4. Specific do's and don'ts for this codebase
+5. Module context if the agent has a module scope
+
+Keep prompts actionable and specific. Avoid generic advice like "write clean code."
+Respond ONLY with the JSON array, no markdown fencing or explanation.`);
+  return sections.join("\n\n");
+}
+async function runTeamAssembly(context, dispatcher) {
+  const { analysis, exploration } = context;
+  const candidates = detectCandidates(analysis);
+  const prompt = buildAssemblyPrompt(analysis, exploration, candidates);
+  const response = await dispatcher.generate(prompt, 0.5);
+  let enrichedAgents;
+  try {
+    let json = response.text.trim();
+    if (json.startsWith("```")) {
+      json = json.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+    }
+    enrichedAgents = JSON.parse(json);
+  } catch {
+    enrichedAgents = candidates.map((c) => ({
+      id: c.id,
+      role: c.role,
+      modelHint: c.modelHint,
+      tools: c.tools,
+      systemPrompt: buildFallbackPrompt(c, analysis)
+    }));
+  }
+  const agentsDir = join2(analysis.projectPath, ".brainstorm", "agents");
+  if (!existsSync3(agentsDir)) mkdirSync(agentsDir, { recursive: true });
+  const agents = [];
+  const filesWritten = [];
+  for (const enriched of enrichedAgents) {
+    const candidate = candidates.find((c) => c.id === enriched.id);
+    const filePath = join2(agentsDir, `${enriched.id}.agent.md`);
+    const content = formatAgentMd(enriched);
+    writeFileSync(filePath, content, "utf-8");
+    agents.push({
+      id: enriched.id,
+      role: enriched.role,
+      filePath,
+      content,
+      rationale: candidate?.rationale ?? "LLM-generated"
+    });
+    filesWritten.push(filePath);
+  }
+  const roleList = agents.map((a) => a.id).join(", ");
+  return {
+    contextPatch: { agents },
+    cost: response.cost,
+    summary: `${agents.length} agents: ${roleList}`,
+    filesWritten
+  };
+}
+function detectCandidates(analysis) {
+  const candidates = [];
+  candidates.push({
+    id: "architect",
+    role: "architect",
+    rationale: "Every project needs high-level design guidance",
+    modelHint: "quality"
+  });
+  candidates.push({
+    id: "code-reviewer",
+    role: "code-reviewer",
+    rationale: "Code review is critical for quality",
+    tools: ["file_read", "grep", "glob", "git_diff", "git_log"],
+    modelHint: "capable"
+  });
+  const frontendFrameworks = [
+    "react",
+    "nextjs",
+    "next.js",
+    "vue",
+    "angular",
+    "svelte"
+  ];
+  if (analysis.frameworks.frameworks.some(
+    (f) => frontendFrameworks.includes(f.toLowerCase())
+  )) {
+    candidates.push({
+      id: "frontend-expert",
+      role: "coder",
+      rationale: `Frontend framework detected: ${analysis.frameworks.frameworks.filter((f) => frontendFrameworks.includes(f.toLowerCase())).join(", ")}`,
+      modelHint: "capable"
+    });
+  }
+  if (analysis.summary.apiRouteCount > 0) {
+    candidates.push({
+      id: "api-expert",
+      role: "coder",
+      rationale: `${analysis.summary.apiRouteCount} API routes detected`,
+      modelHint: "capable"
+    });
+  }
+  if (analysis.frameworks.testing.length > 0) {
+    candidates.push({
+      id: "qa",
+      role: "qa",
+      rationale: `Testing with ${analysis.frameworks.testing.join(", ")}`,
+      modelHint: "capable"
+    });
+  }
+  if (analysis.frameworks.ci && analysis.frameworks.ci.length > 0) {
+    candidates.push({
+      id: "devops",
+      role: "devops",
+      rationale: `CI/CD detected: ${analysis.frameworks.ci.join(", ")}`,
+      tools: ["file_read", "file_write", "grep", "glob", "shell"],
+      modelHint: "capable"
+    });
+  }
+  if (analysis.summary.avgComplexity > 10 || analysis.summary.hotspotCount > 5) {
+    candidates.push({
+      id: "security-reviewer",
+      role: "security-reviewer",
+      rationale: `High complexity (avg ${analysis.summary.avgComplexity.toFixed(1)}) warrants security review`,
+      tools: ["file_read", "grep", "glob"],
+      modelHint: "quality"
+    });
+  }
+  const topClusters = analysis.dependencies.clusters.filter((c) => c.files.length >= 3).sort((a, b) => b.files.length - a.files.length).slice(0, 3);
+  for (const cluster of topClusters) {
+    const safeName = cluster.directory.replace(/[/\\]/g, "-").replace(/^-/, "").replace(/-$/, "");
+    if (!safeName || candidates.some((c) => c.id === `${safeName}-expert`))
+      continue;
+    candidates.push({
+      id: `${safeName}-expert`,
+      role: "coder",
+      rationale: `Module "${cluster.directory}" has ${cluster.files.length} files`,
+      moduleScope: cluster,
+      modelHint: "capable"
+    });
+  }
+  return candidates;
+}
+function formatAgentMd(agent) {
+  const lines = ["---"];
+  lines.push(`name: ${agent.id}`);
+  lines.push(`role: ${agent.role}`);
+  lines.push(`model: ${agent.modelHint ?? "capable"}`);
+  if (agent.tools && agent.tools !== "all") {
+    lines.push(`tools: [${agent.tools.map((t) => `"${t}"`).join(", ")}]`);
+  }
+  if (agent.maxSteps) lines.push(`max_steps: ${agent.maxSteps}`);
+  if (agent.budget) lines.push(`budget: ${agent.budget}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(agent.systemPrompt);
+  return lines.join("\n");
+}
+function buildFallbackPrompt(candidate, analysis) {
+  const lines = [
+    `# ${candidate.id}`,
+    "",
+    `You are a ${candidate.role} for a ${analysis.summary.primaryLanguage} project.`,
+    "",
+    `## Context`,
+    `- Language: ${analysis.summary.primaryLanguage}`,
+    `- Frameworks: ${analysis.summary.frameworkList.join(", ") || "none"}`,
+    `- ${analysis.summary.totalFiles} files, ${analysis.summary.totalLines.toLocaleString()} lines`
+  ];
+  if (candidate.moduleScope) {
+    lines.push(
+      "",
+      `## Module Scope: ${candidate.moduleScope.directory}`,
+      `- Files: ${candidate.moduleScope.files.length}`,
+      `- Cohesion: ${candidate.moduleScope.cohesion > 0.5 ? "high" : candidate.moduleScope.cohesion > 0.2 ? "medium" : "low"}`
+    );
+  }
+  return lines.join("\n");
+}
+function buildRoutingPrompt(analysis, agents, heuristicRules) {
+  return `You are configuring task routing for an AI coding assistant. Each task should be routed to the most appropriate specialized agent.
+
+## Available Agents
+${agents.map((a) => `- **${a.id}** (${a.role}): ${a.rationale}`).join("\n")}
+
+## Project Context
+- Language: ${analysis.summary.primaryLanguage}
+- Frameworks: ${analysis.summary.frameworkList.join(", ") || "none"}
+- ${analysis.summary.apiRouteCount} API routes, ${analysis.summary.moduleCount} modules
+
+## Heuristic Rules (auto-generated)
+These rules were generated from static analysis. Review them and add any project-specific rules.
+
+${heuristicRules.map((r) => `- match: "${r.match}" \u2192 agent: ${r.agentId} (${r.modelHint ?? "auto"}) \u2014 ${r.rationale}`).join("\n")}
+
+## Instructions
+
+Return a JSON array of routing rules. Include the heuristic rules (adjusted if needed) plus any additional project-specific rules.
+
+\`\`\`json
+[
+  {
+    "match": "task type or keyword pattern",
+    "agentId": "agent-id",
+    "modelHint": "quality | capable | cheap",
+    "rationale": "why this rule exists"
+  }
+]
+\`\`\`
+
+Guidelines:
+- "match" should be a task type (code-generation, debugging, refactoring, etc.) or keyword pattern
+- Every agent should have at least one routing rule
+- Security-sensitive tasks should route to quality-tier models
+- Simple fixes can use cheap-tier models
+- Respond ONLY with the JSON array`;
+}
+async function runRoutingRules(context, dispatcher) {
+  const { analysis, agents } = context;
+  if (!agents || agents.length === 0) {
+    return {
+      contextPatch: { routingRules: [] },
+      cost: 0,
+      summary: "No agents to route to (skipped)"
+    };
+  }
+  const heuristicRules = generateHeuristicRules(analysis, agents);
+  const prompt = buildRoutingPrompt(analysis, agents, heuristicRules);
+  const response = await dispatcher.generate(prompt, 0.08);
+  let rules;
+  try {
+    let json = response.text.trim();
+    if (json.startsWith("```")) {
+      json = json.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+    }
+    rules = JSON.parse(json);
+  } catch {
+    rules = heuristicRules;
+  }
+  const brainstormDir = join3(analysis.projectPath, ".brainstorm");
+  if (!existsSync4(brainstormDir)) mkdirSync2(brainstormDir, { recursive: true });
+  const routingPath = join3(brainstormDir, "routing.yaml");
+  const yamlContent = formatRoutingYaml(rules);
+  writeFileSync2(routingPath, yamlContent, "utf-8");
+  return {
+    contextPatch: { routingRules: rules },
+    cost: response.cost,
+    summary: `${rules.length} routing rules`,
+    filesWritten: [routingPath]
+  };
+}
+function generateHeuristicRules(analysis, agents) {
+  const rules = [];
+  const agentIds = new Set(agents.map((a) => a.id));
+  if (agentIds.has("code-reviewer")) {
+    rules.push({
+      match: "code-review",
+      agentId: "code-reviewer",
+      modelHint: "capable",
+      rationale: "Route review tasks to dedicated reviewer"
+    });
+  }
+  if (agentIds.has("architect")) {
+    rules.push({
+      match: "architecture",
+      agentId: "architect",
+      modelHint: "quality",
+      rationale: "Design tasks need quality-tier reasoning"
+    });
+    rules.push({
+      match: "refactoring",
+      agentId: "architect",
+      modelHint: "quality",
+      rationale: "Refactoring needs architectural awareness"
+    });
+  }
+  if (agentIds.has("frontend-expert")) {
+    rules.push({
+      match: "frontend",
+      agentId: "frontend-expert",
+      modelHint: "capable",
+      rationale: "Frontend-specific tasks"
+    });
+    rules.push({
+      match: "component",
+      agentId: "frontend-expert",
+      modelHint: "capable",
+      rationale: "Component creation/modification"
+    });
+  }
+  if (agentIds.has("api-expert")) {
+    rules.push({
+      match: "api",
+      agentId: "api-expert",
+      modelHint: "capable",
+      rationale: `${analysis.summary.apiRouteCount} API routes in project`
+    });
+    rules.push({
+      match: "endpoint",
+      agentId: "api-expert",
+      modelHint: "capable",
+      rationale: "Endpoint creation/modification"
+    });
+  }
+  if (agentIds.has("qa")) {
+    rules.push({
+      match: "test",
+      agentId: "qa",
+      modelHint: "capable",
+      rationale: "Test writing and debugging"
+    });
+  }
+  if (agentIds.has("security-reviewer")) {
+    rules.push({
+      match: "security",
+      agentId: "security-reviewer",
+      modelHint: "quality",
+      rationale: "Security tasks need thorough analysis"
+    });
+    rules.push({
+      match: "audit",
+      agentId: "security-reviewer",
+      modelHint: "quality",
+      rationale: "Code audits are security-adjacent"
+    });
+  }
+  if (agentIds.has("devops")) {
+    rules.push({
+      match: "deploy",
+      agentId: "devops",
+      modelHint: "capable",
+      rationale: "Deployment and infrastructure tasks"
+    });
+    rules.push({
+      match: "ci",
+      agentId: "devops",
+      modelHint: "capable",
+      rationale: "CI/CD pipeline tasks"
+    });
+  }
+  const coderAgent = agents.find(
+    (a) => a.role === "coder" && !a.id.includes("-expert")
+  );
+  if (coderAgent) {
+    rules.push({
+      match: "code-generation",
+      agentId: coderAgent.id,
+      modelHint: "capable",
+      rationale: "General code generation"
+    });
+  }
+  const debugAgent = agents.find((a) => a.role === "debugger") ?? coderAgent;
+  if (debugAgent) {
+    rules.push({
+      match: "debugging",
+      agentId: debugAgent.id,
+      modelHint: "capable",
+      rationale: "Bug investigation and fixing"
+    });
+  }
+  return rules;
+}
+function formatRoutingYaml(rules) {
+  const lines = [
+    "# Brainstorm Routing Rules",
+    "# Generated by `storm onboard` \u2014 maps task patterns to specialized agents.",
+    "#",
+    "# Format: match pattern \u2192 agent ID, model tier, rationale",
+    "# Edit freely \u2014 these rules override heuristic routing.",
+    "",
+    "rules:"
+  ];
+  for (const rule of rules) {
+    lines.push(`  - match: "${rule.match}"`);
+    lines.push(`    agent: ${rule.agentId}`);
+    if (rule.modelHint) lines.push(`    model: ${rule.modelHint}`);
+    lines.push(`    # ${rule.rationale}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function buildWorkflowPrompt(analysis, exploration, heuristicRecipes) {
+  return `You are customizing workflow recipes for a project. Each recipe defines a multi-step workflow where AI agents collaborate.
+
+## Project
+- Language: ${analysis.summary.primaryLanguage}
+- Frameworks: ${analysis.summary.frameworkList.join(", ") || "none"}
+- Testing: ${analysis.frameworks.testing.join(", ") || "none"}
+${exploration ? `- Conventions: ${exploration.conventions.testingPatterns}
+- Error handling: ${exploration.conventions.errorHandling}
+- Commit style: ${exploration.gitWorkflow.commitStyle}
+- CI stages: ${exploration.cicdSetup.stages.join(" \u2192 ") || "unknown"}` : ""}
+
+## Heuristic Recipes
+These recipes were auto-generated. Customize the step descriptions to match this project's conventions.
+
+${heuristicRecipes.map((r) => `### ${r.filename}
+\`\`\`yaml
+${r.content}
+\`\`\``).join("\n\n")}
+
+## Instructions
+
+Return a JSON array of customized recipes. Keep the same structure but improve the step descriptions to be project-specific.
+
+\`\`\`json
+[
+  {
+    "filename": "recipe-name.yaml",
+    "content": "full YAML content",
+    "description": "what this recipe does"
+  }
+]
+\`\`\`
+
+Guidelines:
+- Reference actual testing frameworks (${analysis.frameworks.testing.join(", ") || "none"})
+- Reference actual build tools (${analysis.frameworks.buildTools.join(", ") || "none"})
+- Step descriptions should be actionable and project-specific
+- Keep YAML syntax valid
+- Respond ONLY with the JSON array`;
+}
+async function runWorkflowGen(context, dispatcher) {
+  const { analysis, exploration } = context;
+  const heuristicRecipes = generateHeuristicRecipes(analysis);
+  if (heuristicRecipes.length === 0) {
+    return {
+      contextPatch: { recipes: [] },
+      cost: 0,
+      summary: "No recipes generated (project too simple)"
+    };
+  }
+  const prompt = buildWorkflowPrompt(analysis, exploration, heuristicRecipes);
+  const response = await dispatcher.generate(prompt, 0.1);
+  let recipes;
+  try {
+    let json = response.text.trim();
+    if (json.startsWith("```")) {
+      json = json.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
+    }
+    recipes = JSON.parse(json);
+  } catch {
+    recipes = heuristicRecipes;
+  }
+  const recipesDir = join4(analysis.projectPath, ".brainstorm", "recipes");
+  if (!existsSync5(recipesDir)) mkdirSync3(recipesDir, { recursive: true });
+  const filesWritten = [];
+  for (const recipe of recipes) {
+    const recipePath = join4(recipesDir, recipe.filename);
+    writeFileSync3(recipePath, recipe.content, "utf-8");
+    filesWritten.push(recipePath);
+  }
+  const recipeNames = recipes.map((r) => r.filename.replace(".yaml", "")).join(", ");
+  return {
+    contextPatch: { recipes },
+    cost: response.cost,
+    summary: `${recipes.length} recipes: ${recipeNames}`,
+    filesWritten
+  };
+}
+function generateHeuristicRecipes(analysis) {
+  const recipes = [];
+  const frameworks = analysis.frameworks.frameworks.map((f) => f.toLowerCase());
+  const hasTests = analysis.frameworks.testing.length > 0;
+  const hasCI = analysis.frameworks.ci && analysis.frameworks.ci.length > 0;
+  const isMonorepo = frameworks.includes("turborepo") || frameworks.includes("lerna");
+  if (hasTests) {
+    const testTool = analysis.frameworks.testing[0] ?? "test runner";
+    recipes.push({
+      filename: "pr-ready.yaml",
+      content: buildPrReadyRecipe(analysis, testTool),
+      description: "Full PR workflow: plan \u2192 implement \u2192 test \u2192 review"
+    });
+  }
+  if (isMonorepo) {
+    recipes.push({
+      filename: "multi-package-change.yaml",
+      content: buildMultiPackageRecipe(analysis),
+      description: "Coordinate changes across multiple packages"
+    });
+  }
+  if (hasCI) {
+    recipes.push({
+      filename: "deploy-flow.yaml",
+      content: buildDeployRecipe(analysis),
+      description: "Implement \u2192 verify \u2192 deploy pipeline"
+    });
+  }
+  return recipes;
+}
+function buildPrReadyRecipe(analysis, testTool) {
+  const buildCmd = inferBuildCmd(analysis);
+  const testCmd = inferTestCmd(analysis, testTool);
+  return `name: PR Ready
+description: Full workflow from plan to review-ready PR
+communication: handoff
+maxIterations: 2
+steps:
+  - id: plan
+    role: architect
+    description: "Analyze the task and create an implementation plan with file changes needed"
+    output: spec
+    outputSchema: implementation-spec
+
+  - id: implement
+    role: coder
+    description: "Implement the changes according to the plan"
+    input: [spec]
+    output: code
+
+  - id: test
+    role: qa
+    description: "Run ${testTool} tests and verify the changes work correctly (${testCmd})"
+    input: [spec, code]
+    output: test-result
+
+  - id: review
+    role: code-reviewer
+    description: "Review for correctness, conventions, and potential issues"
+    input: [spec, code, test-result]
+    output: review
+    review: true
+    loopBack: implement
+`;
+}
+function buildMultiPackageRecipe(analysis) {
+  return `name: Multi-Package Change
+description: Coordinate changes across multiple monorepo packages
+communication: handoff
+maxIterations: 2
+steps:
+  - id: plan
+    role: architect
+    description: "Map which packages need changes and their dependency order"
+    output: spec
+    outputSchema: implementation-spec
+
+  - id: implement
+    role: coder
+    description: "Implement changes in dependency order \u2014 leaf packages first, dependents after"
+    input: [spec]
+    output: code
+
+  - id: verify
+    role: qa
+    description: "Run full monorepo build (npx turbo run build) and tests to verify cross-package compatibility"
+    input: [spec, code]
+    output: test-result
+
+  - id: review
+    role: code-reviewer
+    description: "Review for cross-package consistency and interface contracts"
+    input: [spec, code, test-result]
+    output: review
+    review: true
+    loopBack: implement
+`;
+}
+function buildDeployRecipe(analysis) {
+  return `name: Deploy Flow
+description: Implement, verify, and prepare for deployment
+communication: handoff
+maxIterations: 2
+steps:
+  - id: implement
+    role: coder
+    description: "Implement the changes"
+    output: code
+
+  - id: verify
+    role: qa
+    description: "Run build and tests to verify deployment readiness"
+    input: [code]
+    output: test-result
+
+  - id: deploy-prep
+    role: devops
+    description: "Review deployment configuration and prepare deployment steps"
+    input: [code, test-result]
+    output: deploy-plan
+
+  - id: review
+    role: code-reviewer
+    description: "Final review before deployment"
+    input: [code, test-result, deploy-plan]
+    output: review
+    review: true
+    loopBack: implement
+`;
+}
+function inferBuildCmd(analysis) {
+  const frameworks = analysis.frameworks.frameworks.map((f) => f.toLowerCase());
+  if (frameworks.includes("turborepo")) return "npx turbo run build";
+  return "npm run build";
+}
+function inferTestCmd(analysis, testTool) {
+  const lower = testTool.toLowerCase();
+  if (lower.includes("vitest")) return "npx vitest run";
+  if (lower.includes("jest")) return "npx jest";
+  if (lower.includes("pytest")) return "pytest";
+  return "npm test";
+}
+function buildEnrichmentPrompt(analysis, exploration, agents) {
+  const sections = [];
+  sections.push(`You are writing the prose sections of a BRAINSTORM.md file \u2014 a context document that AI agents read before working on this project. Write concise, actionable content.
+
+## Project
+${exploration?.projectPurpose ?? `A ${analysis.summary.primaryLanguage} project with ${analysis.summary.totalFiles} files.`}
+
+## Stack
+- Language: ${analysis.summary.primaryLanguage}
+- Frameworks: ${analysis.summary.frameworkList.join(", ") || "none"}
+- ${analysis.summary.totalFiles} files, ${analysis.summary.totalLines.toLocaleString()} lines, ${analysis.summary.moduleCount} modules`);
+  if (exploration) {
+    sections.push(`## Discovered Conventions
+- Naming: variables=${exploration.conventions.naming.variables}, files=${exploration.conventions.naming.files}, exports=${exploration.conventions.naming.exports}
+- Error handling: ${exploration.conventions.errorHandling}
+- Testing: ${exploration.conventions.testingPatterns}
+- Imports: ${exploration.conventions.importStyle}${exploration.conventions.stateManagement ? `
+- State management: ${exploration.conventions.stateManagement}` : ""}${exploration.conventions.apiPatterns ? `
+- API patterns: ${exploration.conventions.apiPatterns}` : ""}
+- Custom rules: ${exploration.conventions.customRules.join("; ") || "none"}`);
+    if (exploration.domainConcepts.length > 0) {
+      sections.push(`## Domain Concepts
+${exploration.domainConcepts.map((c) => `- **${c.name}**: ${c.definition}`).join("\n")}`);
+    }
+    sections.push(`## Development Workflow
+- Commits: ${exploration.gitWorkflow.commitStyle}
+- Branching: ${exploration.gitWorkflow.branchStrategy}
+- PRs: ${exploration.gitWorkflow.prPatterns}
+- CI/CD: ${exploration.cicdSetup.provider}, stages: ${exploration.cicdSetup.stages.join(" \u2192 ") || "unknown"}
+- Deploy target: ${exploration.cicdSetup.deployTarget}`);
+  }
+  if (agents && agents.length > 0) {
+    sections.push(`## Generated Agents
+${agents.map((a) => `- **${a.id}** (${a.role}): ${a.rationale}`).join("\n")}`);
+  }
+  sections.push(`## Instructions
+
+Write THREE sections as markdown. Each section should be 2-5 paragraphs of actionable content.
+
+**Section 1: Architecture**
+Describe the project's architecture: how modules relate, data flow, key abstractions, and the overall design philosophy. Reference specific directories and files.
+
+**Section 2: Gotchas**
+List 3-8 things a new developer (or AI agent) would trip over. Include non-obvious conventions, surprising behaviors, common mistakes, and "don't do X, do Y instead" guidance.
+
+**Section 3: Anti-Patterns**
+List 2-5 patterns to avoid in this codebase, with brief explanations of why.
+
+Respond with ONLY the three markdown sections (with ## headers), no JSON, no code fences around the whole response.`);
+  return sections.join("\n\n");
+}
+async function runBrainstormMd(context, dispatcher) {
+  const { analysis, exploration, agents } = context;
+  const projectName = basename(analysis.projectPath);
+  const frontmatter = buildFrontmatter(analysis, exploration);
+  const staticSections = buildStaticSections(
+    analysis,
+    exploration,
+    agents?.map((a) => ({ id: a.id, role: a.role }))
+  );
+  let proseSections = "";
+  let cost = 0;
+  const prompt = buildEnrichmentPrompt(analysis, exploration, agents);
+  const response = await dispatcher.explore(prompt, 0.2);
+  proseSections = response.text;
+  cost = response.cost;
+  const content = assembleBrainstormMd(
+    frontmatter,
+    projectName,
+    staticSections,
+    proseSections
+  );
+  const outputPath = join5(analysis.projectPath, "BRAINSTORM.md");
+  const isUpdate = existsSync6(outputPath);
+  writeFileSync4(outputPath, content, "utf-8");
+  return {
+    contextPatch: { brainstormMd: content },
+    cost,
+    summary: `${isUpdate ? "Updated" : "Generated"} with conventions, domain glossary, architecture`,
+    filesWritten: [outputPath]
+  };
+}
+function buildFrontmatter(analysis, exploration) {
+  const lines = ["---", "version: 1"];
+  lines.push(`name: ${basename(analysis.projectPath)}`);
+  const type = inferProjectType(analysis);
+  if (type) lines.push(`type: ${type}`);
+  const lang = mapLanguage(analysis.summary.primaryLanguage);
+  if (lang) lines.push(`language: ${lang}`);
+  const framework = mapFramework(analysis.frameworks.frameworks);
+  lines.push(`framework: ${framework}`);
+  const runtime = inferRuntime(analysis);
+  lines.push(`runtime: ${runtime}`);
+  const deploy = inferDeployTarget(analysis, exploration);
+  lines.push(`deploy: ${deploy}`);
+  const buildCmd = inferBuildCommand(analysis);
+  if (buildCmd) lines.push(`build_command: "${buildCmd}"`);
+  const testCmd = inferTestCommand(analysis);
+  if (testCmd) lines.push(`test_command: "${testCmd}"`);
+  if (analysis.dependencies.entryPoints.length > 0) {
+    const eps = analysis.dependencies.entryPoints.slice(0, 5).map((e) => `"${e}"`).join(", ");
+    lines.push(`entry_points: [${eps}]`);
+  }
+  lines.push("routing:");
+  lines.push(`  typical_complexity: ${inferComplexity(analysis)}`);
+  lines.push(`  budget_tier: ${inferBudgetTier(analysis)}`);
+  lines.push("---");
+  return lines.join("\n");
+}
+function buildStaticSections(analysis, exploration, agents) {
+  const sections = [];
+  sections.push("## Stack\n");
+  if (analysis.summary.primaryLanguage)
+    sections.push(`- **Language:** ${analysis.summary.primaryLanguage}`);
+  if (analysis.summary.frameworkList.length > 0)
+    sections.push(
+      `- **Frameworks:** ${analysis.summary.frameworkList.join(", ")}`
+    );
+  if (analysis.frameworks.databases.length > 0)
+    sections.push(
+      `- **Databases:** ${analysis.frameworks.databases.join(", ")}`
+    );
+  if (analysis.frameworks.testing.length > 0)
+    sections.push(`- **Testing:** ${analysis.frameworks.testing.join(", ")}`);
+  if (analysis.frameworks.buildTools.length > 0)
+    sections.push(`- **Build:** ${analysis.frameworks.buildTools.join(", ")}`);
+  sections.push(
+    `- **Size:** ${analysis.summary.totalFiles} files, ${analysis.summary.totalLines.toLocaleString()} lines, ${analysis.summary.moduleCount} modules`
+  );
+  if (exploration) {
+    sections.push("\n## Conventions\n");
+    const c = exploration.conventions;
+    sections.push(
+      `- **Naming:** variables=${c.naming.variables}, files=${c.naming.files}, exports=${c.naming.exports}`
+    );
+    sections.push(`- **Error handling:** ${c.errorHandling}`);
+    sections.push(`- **Testing:** ${c.testingPatterns}`);
+    sections.push(`- **Imports:** ${c.importStyle}`);
+    if (c.stateManagement)
+      sections.push(`- **State management:** ${c.stateManagement}`);
+    if (c.apiPatterns) sections.push(`- **API patterns:** ${c.apiPatterns}`);
+    if (c.customRules.length > 0) {
+      for (const rule of c.customRules) {
+        sections.push(`- ${rule}`);
+      }
+    }
+  }
+  if (exploration && exploration.domainConcepts.length > 0) {
+    sections.push("\n## Domain Glossary\n");
+    for (const concept of exploration.domainConcepts) {
+      sections.push(`- **${concept.name}:** ${concept.definition}`);
+    }
+  }
+  if (exploration && exploration.keyFiles.length > 0) {
+    sections.push("\n## Key Files\n");
+    for (const kf of exploration.keyFiles) {
+      sections.push(`- \`${kf.path}\` \u2014 ${kf.purpose}`);
+    }
+  }
+  if (agents && agents.length > 0) {
+    sections.push("\n## AI Team\n");
+    for (const a of agents) {
+      sections.push(`- **${a.id}** (${a.role})`);
+    }
+  }
+  return sections.join("\n");
+}
+function assembleBrainstormMd(frontmatter, projectName, staticSections, proseSections) {
+  const parts = [frontmatter, "", `# ${projectName}`, "", staticSections];
+  if (proseSections) {
+    parts.push("", proseSections.trim());
+  }
+  return parts.join("\n") + "\n";
+}
+function inferProjectType(analysis) {
+  const frameworks = analysis.frameworks.frameworks.map((f) => f.toLowerCase());
+  if (frameworks.includes("turborepo") || frameworks.includes("lerna"))
+    return "monorepo";
+  if (frameworks.some(
+    (f) => ["nextjs", "react", "vue", "angular", "svelte"].includes(f)
+  ))
+    return "app";
+  if (analysis.dependencies.entryPoints.some(
+    (e) => e.includes("cli") || e.includes("bin")
+  ))
+    return "cli";
+  if (analysis.summary.apiRouteCount > 0) return "api";
+  return null;
+}
+function mapLanguage(primary) {
+  const map = {
+    TypeScript: "typescript",
+    JavaScript: "typescript",
+    Python: "python",
+    Rust: "rust",
+    Go: "go",
+    Java: "java"
+  };
+  return map[primary] ?? null;
+}
+function mapFramework(frameworks) {
+  const lower = frameworks.map((f) => f.toLowerCase());
+  if (lower.includes("nextjs") || lower.includes("next.js")) return "nextjs";
+  if (lower.includes("hono")) return "hono";
+  if (lower.includes("fastapi")) return "fastapi";
+  if (lower.includes("express")) return "express";
+  return "none";
+}
+function inferRuntime(analysis) {
+  const lang = analysis.summary.primaryLanguage.toLowerCase();
+  if (lang === "python") return "python";
+  if (lang === "go") return "go";
+  return "node";
+}
+function inferDeployTarget(analysis, exploration) {
+  if (exploration?.cicdSetup.deployTarget && exploration.cicdSetup.deployTarget !== "none") {
+    return exploration.cicdSetup.deployTarget;
+  }
+  const deploy = analysis.frameworks.deployment ?? [];
+  if (deploy.some((d) => d.toLowerCase().includes("vercel"))) return "vercel";
+  if (deploy.some((d) => d.toLowerCase().includes("docker"))) return "docker";
+  return "none";
+}
+function inferBuildCommand(analysis) {
+  const frameworks = analysis.frameworks.frameworks.map((f) => f.toLowerCase());
+  if (frameworks.includes("turborepo")) return "npx turbo run build";
+  if (analysis.summary.primaryLanguage === "TypeScript" || analysis.summary.primaryLanguage === "JavaScript")
+    return "npm run build";
+  if (analysis.summary.primaryLanguage === "Python") return null;
+  if (analysis.summary.primaryLanguage === "Go") return "go build ./...";
+  return null;
+}
+function inferTestCommand(analysis) {
+  if (analysis.frameworks.testing.length === 0) return null;
+  const frameworks = analysis.frameworks.frameworks.map((f) => f.toLowerCase());
+  if (frameworks.includes("turborepo")) return "npx turbo run test";
+  if (analysis.frameworks.testing.some((t) => t.toLowerCase().includes("vitest")))
+    return "npx vitest run";
+  if (analysis.frameworks.testing.some((t) => t.toLowerCase().includes("jest")))
+    return "npx jest";
+  if (analysis.frameworks.testing.some((t) => t.toLowerCase().includes("pytest")))
+    return "pytest";
+  return "npm test";
+}
+function inferComplexity(analysis) {
+  const avg = analysis.summary.avgComplexity;
+  if (avg < 5) return "simple";
+  if (avg < 10) return "moderate";
+  if (avg < 20) return "complex";
+  return "expert";
+}
+function inferBudgetTier(analysis) {
+  const files = analysis.summary.totalFiles;
+  if (files < 50) return "low";
+  if (files < 500) return "standard";
+  return "premium";
+}
+var log = createLogger("onboard");
+var LLM_PHASES = [
+  "deep-exploration",
+  "team-assembly",
+  "routing-rules",
+  "workflow-gen",
+  "brainstorm-md"
+];
+async function* runOnboardPipeline(options, dispatcher) {
+  const startTime = Date.now();
+  const phases = options.phases ?? ALL_PHASES;
+  const filesWritten = [];
+  const phasesRun = [];
+  const phasesSkipped = [];
+  let context = null;
+  let budget = null;
+  if (phases.includes("static-analysis")) {
+    const phaseStart = Date.now();
+    yield {
+      type: "phase-started",
+      phase: "static-analysis",
+      description: "Analyzing codebase structure"
+    };
+    try {
+      const { analysis, gitSummary } = runStaticAnalysis(options.projectPath);
+      context = { analysis };
+      context._gitSummary = gitSummary;
+      const totalBudget = options.budget ?? inferBudget(analysis);
+      budget = createBudgetTracker(totalBudget);
+      const summary = [
+        `${analysis.summary.totalFiles} files`,
+        `${analysis.summary.totalLines.toLocaleString()} lines`,
+        `${analysis.summary.moduleCount} modules`,
+        analysis.summary.primaryLanguage,
+        ...analysis.summary.frameworkList.slice(0, 3)
+      ].join(", ");
+      phasesRun.push("static-analysis");
+      yield {
+        type: "phase-completed",
+        phase: "static-analysis",
+        cost: 0,
+        durationMs: Date.now() - phaseStart,
+        summary
+      };
+    } catch (error) {
+      yield {
+        type: "phase-failed",
+        phase: "static-analysis",
+        error: error instanceof Error ? error.message : String(error)
+      };
+      return;
+    }
+  }
+  if (!context) {
+    yield {
+      type: "phase-failed",
+      phase: "static-analysis",
+      error: "Static analysis is required but was not included in phases"
+    };
+    return;
+  }
+  if (!budget) {
+    budget = createBudgetTracker(options.budget ?? 5);
+  }
+  const estimatedTotal = phases.filter((p) => LLM_PHASES.includes(p)).reduce((sum, p) => sum + (PHASE_COST_ESTIMATES[p] ?? 0), 0);
+  yield {
+    type: "onboard-started",
+    options,
+    estimatedBudget: Math.round(estimatedTotal * 100) / 100
+  };
+  if (!options.staticOnly && dispatcher) {
+    for (const phase of LLM_PHASES) {
+      if (!phases.includes(phase)) continue;
+      const estimate = PHASE_COST_ESTIMATES[phase] ?? 0;
+      if (estimate > 0 && !budget.canAfford(estimate)) {
+        yield {
+          type: "budget-warning",
+          spent: budget.spent,
+          remaining: budget.remaining
+        };
+        yield {
+          type: "phase-skipped",
+          phase,
+          reason: `Budget insufficient (need ~$${estimate.toFixed(2)}, have $${budget.remaining.toFixed(2)})`
+        };
+        phasesSkipped.push(phase);
+        continue;
+      }
+      if (options.dryRun) {
+        yield {
+          type: "phase-skipped",
+          phase,
+          reason: `Dry run \u2014 would cost ~$${estimate.toFixed(2)}`
+        };
+        phasesSkipped.push(phase);
+        continue;
+      }
+      const phaseStart = Date.now();
+      yield {
+        type: "phase-started",
+        phase,
+        description: getPhaseDescription(phase)
+      };
+      try {
+        const result = await runLLMPhase(phase, context, dispatcher);
+        const cost = result.cost;
+        budget.record(cost);
+        Object.assign(context, result.contextPatch);
+        if (result.filesWritten) {
+          filesWritten.push(...result.filesWritten);
+          for (const f of result.filesWritten) {
+            yield { type: "file-written", path: f, description: phase };
+          }
+        }
+        phasesRun.push(phase);
+        yield {
+          type: "phase-completed",
+          phase,
+          cost,
+          durationMs: Date.now() - phaseStart,
+          summary: result.summary
+        };
+      } catch (error) {
+        yield {
+          type: "phase-failed",
+          phase,
+          error: error instanceof Error ? error.message : String(error)
+        };
+        phasesSkipped.push(phase);
+      }
+    }
+  } else {
+    for (const phase of LLM_PHASES) {
+      if (!phases.includes(phase)) continue;
+      yield {
+        type: "phase-skipped",
+        phase,
+        reason: options.staticOnly ? "Static-only mode" : "No LLM dispatcher provided"
+      };
+      phasesSkipped.push(phase);
+    }
+  }
+  if (phases.includes("verification")) {
+    const phaseStart = Date.now();
+    yield {
+      type: "phase-started",
+      phase: "verification",
+      description: "Validating generated artifacts"
+    };
+    const verification = runVerification(context);
+    context.verification = verification;
+    phasesRun.push("verification");
+    const counts = [];
+    if (context.agents) {
+      counts.push(
+        `${context.agents.length} agents ${verification.agentsValid ? "valid" : "INVALID"}`
+      );
+    }
+    if (context.routingRules) {
+      counts.push(
+        `${context.routingRules.length} rules ${verification.routingValid ? "valid" : "INVALID"}`
+      );
+    }
+    if (context.recipes) {
+      counts.push(
+        `${context.recipes.length} recipes ${verification.recipesValid ? "valid" : "INVALID"}`
+      );
+    }
+    if (context.brainstormMd) {
+      counts.push(
+        `BRAINSTORM.md ${verification.brainstormMdValid ? "valid" : "INVALID"}`
+      );
+    }
+    yield {
+      type: "phase-completed",
+      phase: "verification",
+      cost: 0,
+      durationMs: Date.now() - phaseStart,
+      summary: counts.join(", ") || "No artifacts to verify"
+    };
+  }
+  yield {
+    type: "onboard-completed",
+    result: {
+      context,
+      filesWritten,
+      totalCost: budget.spent,
+      totalDurationMs: Date.now() - startTime,
+      phasesRun,
+      phasesSkipped
+    }
+  };
+}
+async function runLLMPhase(phase, context, dispatcher) {
+  switch (phase) {
+    case "deep-exploration":
+      return runDeepExploration(context, dispatcher);
+    case "team-assembly":
+      return runTeamAssembly(context, dispatcher);
+    case "routing-rules":
+      return runRoutingRules(context, dispatcher);
+    case "workflow-gen":
+      return runWorkflowGen(context, dispatcher);
+    case "brainstorm-md":
+      return runBrainstormMd(context, dispatcher);
+    default:
+      throw new Error(`Unknown LLM phase: ${phase}`);
+  }
+}
+function getPhaseDescription(phase) {
+  switch (phase) {
+    case "deep-exploration":
+      return "Reading key files, discovering conventions and domain concepts";
+    case "team-assembly":
+      return "Generating specialized agents with project-specific knowledge";
+    case "routing-rules":
+      return "Creating task-to-agent routing rules";
+    case "workflow-gen":
+      return "Building project-specific workflow recipes";
+    case "brainstorm-md":
+      return "Generating enhanced BRAINSTORM.md with real conventions";
+    default:
+      return PHASE_LABELS[phase] ?? phase;
+  }
+}
+export {
+  ALL_PHASES,
+  PHASE_LABELS,
+  createBudgetTracker,
+  inferBudget,
+  runOnboardPipeline,
+  runStaticAnalysis,
+  runVerification
+};
+//# sourceMappingURL=dist-Z4SBSK4Q.js.map