compound-agent 1.2.7 → 1.2.9

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { getLlama, resolveModelFile } from 'node-llama-cpp';
-import { mkdirSync, writeFileSync, statSync, existsSync, readFileSync, unlinkSync, chmodSync, readdirSync } from 'fs';
+import { mkdirSync, writeFileSync, statSync, existsSync, unlinkSync, readFileSync, chmodSync, readdirSync } from 'fs';
 import { homedir } from 'os';
 import { join, dirname, resolve, relative } from 'path';
 import * as fs from 'fs/promises';
@@ -1733,7 +1733,13 @@ var CLAUDE_HOOK_MARKERS = [
   "compound-agent load-session",
   "ca hooks run user-prompt",
   "ca hooks run post-tool-failure",
-  "ca hooks run post-tool-success"
+  "ca hooks run post-tool-success",
+  "ca hooks run phase-guard",
+  "ca hooks run read-tracker",
+  "ca hooks run stop-audit",
+  // v1.2.9 canonical names
+  "ca hooks run post-read",
+  "ca hooks run phase-audit"
 ];
 var CLAUDE_HOOK_CONFIG = {
   matcher: "",
@@ -1780,11 +1786,32 @@ var CLAUDE_POST_TOOL_SUCCESS_HOOK_CONFIG = {
     }
   ]
 };
-var MCP_SERVER_CONFIG = {
-  "compound-agent": {
-    command: "npx",
-    args: ["compound-agent-mcp"]
-  }
+var CLAUDE_PHASE_GUARD_HOOK_CONFIG = {
+  matcher: "Edit|Write",
+  hooks: [
+    {
+      type: "command",
+      command: "npx ca hooks run phase-guard 2>/dev/null || true"
+    }
+  ]
+};
+var CLAUDE_POST_READ_HOOK_CONFIG = {
+  matcher: "Read",
+  hooks: [
+    {
+      type: "command",
+      command: "npx ca hooks run post-read 2>/dev/null || true"
+    }
+  ]
+};
+var CLAUDE_PHASE_AUDIT_HOOK_CONFIG = {
+  matcher: "",
+  hooks: [
+    {
+      type: "command",
+      command: "npx ca hooks run phase-audit 2>/dev/null || true"
+    }
+  ]
 };
 var COMPOUND_AGENT_SECTION_HEADER = "## Compound Agent Integration";
 var CLAUDE_REF_START_MARKER = "<!-- compound-agent:claude-ref:start -->";
@@ -1900,6 +1927,22 @@ var PLUGIN_MANIFEST = {
       {
         matcher: "Bash|Edit|Write",
         hooks: [{ type: "command", command: "npx ca hooks run post-tool-success 2>/dev/null || true" }]
+      },
+      {
+        matcher: "Read",
+        hooks: [{ type: "command", command: "npx ca hooks run post-read 2>/dev/null || true" }]
+      }
+    ],
+    PreToolUse: [
+      {
+        matcher: "Edit|Write",
+        hooks: [{ type: "command", command: "npx ca hooks run phase-guard 2>/dev/null || true" }]
+      }
+    ],
+    Stop: [
+      {
+        matcher: "",
+        hooks: [{ type: "command", command: "npx ca hooks run phase-audit 2>/dev/null || true" }]
       }
     ]
     // Note: PreCommit is handled by git hooks, not Claude Code hooks
@@ -1924,7 +1967,7 @@ async function readClaudeSettings(settingsPath) {
 function hasClaudeHook(settings) {
   const hooks = settings.hooks;
   if (!hooks) return false;
-  const hookTypes = ["SessionStart", "PreCompact", "UserPromptSubmit", "PostToolUseFailure", "PostToolUse"];
+  const hookTypes = ["SessionStart", "PreCompact", "UserPromptSubmit", "PostToolUseFailure", "PostToolUse", "PreToolUse", "Stop"];
   return hookTypes.some((hookType) => {
     const hookArray = hooks[hookType];
     if (!hookArray) return false;
@@ -1936,15 +1979,10 @@ function hasClaudeHook(settings) {
     });
   });
 }
-function addCompoundAgentHook(settings) {
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
+function hasAllCompoundAgentHooks(settings) {
   const hooks = settings.hooks;
-  if (!hooks.SessionStart) {
-    hooks.SessionStart = [];
-  }
-  hooks.SessionStart.push(CLAUDE_HOOK_CONFIG);
+  if (!hooks) return false;
+  return hasHookTypeAny(hooks.SessionStart ?? [], ["ca prime"]) && hasHookTypeAny(hooks.PreCompact ?? [], ["ca prime"]) && hasHookTypeAny(hooks.UserPromptSubmit ?? [], ["ca hooks run user-prompt"]) && hasHookTypeAny(hooks.PostToolUseFailure ?? [], ["ca hooks run post-tool-failure"]) && hasHookTypeAny(hooks.PostToolUse ?? [], ["ca hooks run post-tool-success"]) && hasHookTypeAny(hooks.PostToolUse ?? [], ["ca hooks run post-read", "ca hooks run read-tracker"]) && hasHookTypeAny(hooks.PreToolUse ?? [], ["ca hooks run phase-guard"]) && hasHookTypeAny(hooks.Stop ?? [], ["ca hooks run phase-audit", "ca hooks run stop-audit"]);
 }
 function addAllCompoundAgentHooks(settings) {
   if (!settings.hooks) {
@@ -1954,92 +1992,60 @@ function addAllCompoundAgentHooks(settings) {
   if (!hooks.SessionStart) {
     hooks.SessionStart = [];
   }
-  if (!hasHookType(hooks.SessionStart, "ca prime")) {
+  if (!hasHookTypeAny(hooks.SessionStart, ["ca prime"])) {
     hooks.SessionStart.push(CLAUDE_HOOK_CONFIG);
   }
   if (!hooks.PreCompact) {
     hooks.PreCompact = [];
   }
-  if (!hasHookType(hooks.PreCompact, "ca prime")) {
+  if (!hasHookTypeAny(hooks.PreCompact, ["ca prime"])) {
     hooks.PreCompact.push(CLAUDE_PRECOMPACT_HOOK_CONFIG);
   }
   if (!hooks.UserPromptSubmit) {
     hooks.UserPromptSubmit = [];
   }
-  if (!hasHookType(hooks.UserPromptSubmit, "ca hooks run user-prompt")) {
+  if (!hasHookTypeAny(hooks.UserPromptSubmit, ["ca hooks run user-prompt"])) {
     hooks.UserPromptSubmit.push(CLAUDE_USER_PROMPT_HOOK_CONFIG);
   }
   if (!hooks.PostToolUseFailure) {
     hooks.PostToolUseFailure = [];
   }
-  if (!hasHookType(hooks.PostToolUseFailure, "ca hooks run post-tool-failure")) {
+  if (!hasHookTypeAny(hooks.PostToolUseFailure, ["ca hooks run post-tool-failure"])) {
     hooks.PostToolUseFailure.push(CLAUDE_POST_TOOL_FAILURE_HOOK_CONFIG);
   }
   if (!hooks.PostToolUse) {
     hooks.PostToolUse = [];
   }
-  if (!hasHookType(hooks.PostToolUse, "ca hooks run post-tool-success")) {
+  if (!hasHookTypeAny(hooks.PostToolUse, ["ca hooks run post-tool-success"])) {
     hooks.PostToolUse.push(CLAUDE_POST_TOOL_SUCCESS_HOOK_CONFIG);
   }
-}
-function hasHookType(hookArray, marker) {
-  return hookArray.some((entry) => {
-    const hookEntry = entry;
-    return hookEntry.hooks?.some((h) => h.command?.includes(marker));
-  });
-}
-function getMcpJsonPath(repoRoot) {
-  const root = repoRoot ?? getRepoRoot();
-  return join(root, ".mcp.json");
-}
-async function readMcpJson(mcpPath) {
-  if (!existsSync(mcpPath)) {
-    return {};
+  if (!hasHookTypeAny(hooks.PostToolUse, ["ca hooks run post-read", "ca hooks run read-tracker"])) {
+    hooks.PostToolUse.push(CLAUDE_POST_READ_HOOK_CONFIG);
   }
-  const content = await readFile(mcpPath, "utf-8");
-  return JSON.parse(content);
-}
-async function writeMcpJson(mcpPath, config) {
-  const tempPath = mcpPath + ".tmp";
-  await writeFile(tempPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-  await rename(tempPath, mcpPath);
-}
-async function addMcpServerToMcpJson(repoRoot) {
-  const mcpPath = getMcpJsonPath(repoRoot);
-  const config = await readMcpJson(mcpPath);
-  if (!config.mcpServers) {
-    config.mcpServers = {};
+  if (!hooks.PreToolUse) {
+    hooks.PreToolUse = [];
   }
-  const mcpServers = config.mcpServers;
-  if (mcpServers["compound-agent"]) {
-    return false;
+  if (!hasHookTypeAny(hooks.PreToolUse, ["ca hooks run phase-guard"])) {
+    hooks.PreToolUse.push(CLAUDE_PHASE_GUARD_HOOK_CONFIG);
   }
-  Object.assign(mcpServers, MCP_SERVER_CONFIG);
-  await writeMcpJson(mcpPath, config);
-  return true;
-}
-async function hasMcpServerInMcpJson(repoRoot) {
-  const mcpPath = getMcpJsonPath(repoRoot);
-  const config = await readMcpJson(mcpPath);
-  const mcpServers = config.mcpServers;
-  return !!mcpServers?.["compound-agent"];
-}
-async function removeMcpServerFromMcpJson(repoRoot) {
-  const mcpPath = getMcpJsonPath(repoRoot);
-  const config = await readMcpJson(mcpPath);
-  const mcpServers = config.mcpServers;
-  if (!mcpServers?.["compound-agent"]) {
-    return false;
+  if (!hooks.Stop) {
+    hooks.Stop = [];
   }
-  delete mcpServers["compound-agent"];
-  await writeMcpJson(mcpPath, config);
-  return true;
+  if (!hasHookTypeAny(hooks.Stop, ["ca hooks run phase-audit", "ca hooks run stop-audit"])) {
+    hooks.Stop.push(CLAUDE_PHASE_AUDIT_HOOK_CONFIG);
+  }
+}
+function hasHookTypeAny(hookArray, markers) {
+  return hookArray.some((entry) => {
+    const hookEntry = entry;
+    return hookEntry.hooks?.some((h) => markers.some((marker) => h.command?.includes(marker)));
+  });
 }
 function removeCompoundAgentHook(settings) {
   const hooks = settings.hooks;
   if (!hooks) return false;
   let anyRemoved = false;
-  const hookTypes = ["SessionStart", "PreCompact", "UserPromptSubmit", "PostToolUseFailure", "PostToolUse"];
+  const hookTypes = ["SessionStart", "PreCompact", "UserPromptSubmit", "PostToolUseFailure", "PostToolUse", "PreToolUse", "Stop"];
   for (const hookType of hookTypes) {
     if (!hooks[hookType]) continue;
     const originalLength = hooks[hookType].length;
@@ -2070,11 +2076,11 @@ async function installClaudeHooksForInit(repoRoot) {
   } catch {
     return { installed: false, action: "error", error: "Failed to parse settings.json" };
   }
-  if (hasClaudeHook(settings)) {
+  if (hasAllCompoundAgentHooks(settings)) {
     return { installed: true, action: "already_installed" };
   }
   try {
-    addCompoundAgentHook(settings);
+    addAllCompoundAgentHooks(settings);
     await writeClaudeSettings(settingsPath, settings);
     return { installed: true, action: "installed" };
   } catch (err) {
@@ -2124,120 +2130,743 @@ async function removeClaudeMdReference(repoRoot) {
   return true;
 }
 
-// src/setup/templates/agents-external.ts
-var EXTERNAL_AGENT_TEMPLATES = {
-  "external-reviewer-gemini.md": `---
-name: External Reviewer (Gemini)
-description: Cross-model review using Gemini CLI in headless mode
-model: sonnet
----
-
-# External Reviewer \u2014 Gemini
-
-## Role
-Run a cross-model code review by invoking the Gemini CLI in headless mode. Provides an independent perspective from a different LLM to catch issues Claude may miss.
-
-## Prerequisites
-- Gemini CLI installed (\`npm i -g @google/gemini-cli\`)
-- Authenticated (\`gemini auth login\`)
-
-## Instructions
-1. **Check availability** \u2014 run \`command -v gemini\` via Bash. If not found, report "Gemini CLI not installed \u2014 skipping external review" and stop.
-2. **Gather context**:
-   - Get the beads issue being worked on: \`bd list --status=in_progress\` then \`bd show <id>\` to get the issue title and description.
-   - Get the diff: \`git diff HEAD~1\` (or the appropriate range for this session's changes).
-3. **Build the review prompt** combining beads context + diff:
-   \`\`\`
-   ISSUE: <title>
-   DESCRIPTION: <description>
-   DIFF:
-   <git diff output>
-
-   Review these changes for:
-   1. Correctness bugs and logic errors
-   2. Security vulnerabilities
-   3. Missed edge cases
-   4. Code quality issues
-   Output a numbered list of findings. Be concise and actionable. Skip praise.
-   \`\`\`
-4. **Call Gemini headless**:
-   \`\`\`bash
-   echo "<prompt>" | gemini -p "Review the following code changes" --output-format json
-   \`\`\`
-5. **Parse the response** \u2014 extract the \`.response\` field from the JSON output.
-6. **Present findings** to the user as a numbered list with severity tags (P1/P2/P3).
-7. **If Gemini returns an error** (auth failure, rate limit, timeout), report the error and skip gracefully. Never block the pipeline on external reviewer failure.
-
-## Output Format
-\`\`\`
-## Gemini External Review
-
-**Status**: Completed | Skipped (reason)
-**Findings**: N items
-
-1. [P2] <finding description> \u2014 <file:line>
-2. [P3] <finding description> \u2014 <file:line>
-...
-\`\`\`
-
-## Important
-- This is **advisory, not blocking**. Findings inform but do not gate the pipeline.
-- Do NOT retry more than once on failure.
-- Do NOT feed the entire codebase \u2014 only the diff and issue context.
-`,
-  "external-reviewer-codex.md": `---
-name: External Reviewer (Codex)
-description: Cross-model review using OpenAI Codex CLI in headless mode
-model: sonnet
----
-
-# External Reviewer \u2014 Codex
-
-## Role
-Run a cross-model code review by invoking the OpenAI Codex CLI in headless exec mode. Provides an independent perspective from OpenAI's reasoning models to catch issues Claude may miss.
-
-## Prerequisites
-- Codex CLI installed (\`npm i -g @openai/codex\`)
-- Authenticated (\`codex login --api-key\`)
-
-## Instructions
-1. **Check availability** \u2014 run \`command -v codex\` via Bash. If not found, report "Codex CLI not installed \u2014 skipping external review" and stop.
-2. **Gather context**:
-   - Get the beads issue being worked on: \`bd list --status=in_progress\` then \`bd show <id>\` to get the issue title and description.
-   - Get the diff: \`git diff HEAD~1\` (or the appropriate range for this session's changes).
-3. **Build the review prompt** combining beads context + diff:
-   \`\`\`
-   ISSUE: <title>
-   DESCRIPTION: <description>
-   DIFF:
-   <git diff output>
-
-   Review these changes for:
-   1. Correctness bugs and logic errors
-   2. Security vulnerabilities
-   3. Missed edge cases
-   4. Code quality issues
-   Output a numbered list of findings. Be concise and actionable. Skip praise.
-   \`\`\`
-4. **Call Codex headless**:
-   \`\`\`bash
-   echo "<prompt>" | codex exec --quiet "Review the following code changes for bugs, security issues, and missed edge cases"
-   \`\`\`
-5. **Parse the response** \u2014 Codex exec prints the final answer to stdout.
-6. **Present findings** to the user as a numbered list with severity tags (P1/P2/P3).
-7. **If Codex returns an error** (auth failure, rate limit, timeout), report the error and skip gracefully. Never block the pipeline on external reviewer failure.
+// src/cli-error-format.ts
+function formatError(command, code, message, remediation) {
+  return `ERROR [${command}] ${code}: ${message} \u2014 ${remediation}`;
+}
+var STATE_DIR = ".claude";
+var STATE_FILE = ".ca-phase-state.json";
+var EPIC_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+var PHASES = ["brainstorm", "plan", "work", "review", "compound"];
+var GATES = ["post-plan", "gate-3", "gate-4", "final"];
+var PHASE_INDEX = {
+  brainstorm: 1,
+  plan: 2,
+  work: 3,
+  review: 4,
+  compound: 5
+};
+function getStatePath(repoRoot) {
+  return join(repoRoot, STATE_DIR, STATE_FILE);
+}
+function isPhaseName(value) {
+  return typeof value === "string" && PHASES.includes(value);
+}
+function isGateName(value) {
+  return typeof value === "string" && GATES.includes(value);
+}
+function isIsoDate(value) {
+  if (typeof value !== "string") return false;
+  return !Number.isNaN(Date.parse(value));
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function validatePhaseState(raw) {
+  if (typeof raw !== "object" || raw === null) return false;
+  const state = raw;
+  return typeof state.lfg_active === "boolean" && typeof state.epic_id === "string" && isPhaseName(state.current_phase) && typeof state.phase_index === "number" && state.phase_index >= 1 && state.phase_index <= 5 && isStringArray(state.skills_read) && Array.isArray(state.gates_passed) && state.gates_passed.every((gate) => isGateName(gate)) && isIsoDate(state.started_at);
+}
+function expectedGateForPhase(phaseIndex) {
+  if (phaseIndex === 2) return "post-plan";
+  if (phaseIndex === 3) return "gate-3";
+  if (phaseIndex === 4) return "gate-4";
+  if (phaseIndex === 5) return "final";
+  return null;
+}
+function initPhaseState(repoRoot, epicId) {
+  const dir = join(repoRoot, STATE_DIR);
+  mkdirSync(dir, { recursive: true });
+  const state = {
+    lfg_active: true,
+    epic_id: epicId,
+    current_phase: "brainstorm",
+    phase_index: PHASE_INDEX.brainstorm,
+    skills_read: [],
+    gates_passed: [],
+    started_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync(getStatePath(repoRoot), JSON.stringify(state, null, 2), "utf-8");
+  return state;
+}
+function getPhaseState(repoRoot) {
+  try {
+    const path = getStatePath(repoRoot);
+    if (!existsSync(path)) return null;
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    return validatePhaseState(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function updatePhaseState(repoRoot, partial) {
+  const current = getPhaseState(repoRoot);
+  if (current === null) return null;
+  const updated = {
+    ...current,
+    ...partial
+  };
+  if (!validatePhaseState(updated)) return null;
+  writeFileSync(getStatePath(repoRoot), JSON.stringify(updated, null, 2), "utf-8");
+  return updated;
+}
+function startPhase(repoRoot, phase) {
+  return updatePhaseState(repoRoot, {
+    current_phase: phase,
+    phase_index: PHASE_INDEX[phase]
+  });
+}
+function cleanPhaseState(repoRoot) {
+  try {
+    const path = getStatePath(repoRoot);
+    if (existsSync(path)) unlinkSync(path);
+  } catch {
+  }
+}
+function recordGatePassed(repoRoot, gate) {
+  const current = getPhaseState(repoRoot);
+  if (current === null) return null;
+  const gatesPassed = current.gates_passed.includes(gate) ? current.gates_passed : [...current.gates_passed, gate];
+  const updated = { ...current, gates_passed: gatesPassed };
+  if (gate === "final") {
+    cleanPhaseState(repoRoot);
+    return updated;
+  }
+  writeFileSync(getStatePath(repoRoot), JSON.stringify(updated, null, 2), "utf-8");
+  return updated;
+}
+function printStatusHuman(state) {
+  if (state === null) {
+    console.log("No active LFG session.");
+    return;
+  }
+  console.log("Active LFG Session");
+  console.log(`  Epic: ${state.epic_id}`);
+  console.log(`  Phase: ${state.current_phase} (${state.phase_index}/5)`);
+  console.log(`  Skills read: ${state.skills_read.length === 0 ? "(none)" : state.skills_read.join(", ")}`);
+  console.log(`  Gates passed: ${state.gates_passed.length === 0 ? "(none)" : state.gates_passed.join(", ")}`);
+  console.log(`  Started: ${state.started_at}`);
+}
+function registerPhaseSubcommands(phaseCheck, getDryRun, repoRoot) {
+  phaseCheck.command("init <epic-id>").description("Initialize phase state for an epic").action((epicId) => {
+    if (!EPIC_ID_PATTERN.test(epicId)) {
+      console.error(`Invalid epic ID: "${epicId}"`);
+      process.exit(1);
+    }
+    if (getDryRun()) {
+      console.log(`[dry-run] Would initialize phase state for epic ${epicId} in ${repoRoot()}`);
+      return;
+    }
+    initPhaseState(repoRoot(), epicId);
+    console.log(`Phase state initialized for ${epicId}. Current phase: brainstorm (1/5).`);
+  });
+  phaseCheck.command("start <phase>").description("Start or resume a phase").action((phase) => {
+    if (!isPhaseName(phase)) {
+      console.error(`Invalid phase: "${phase}". Valid phases: ${PHASES.join(", ")}`);
+      process.exit(1);
+    }
+    if (getDryRun()) {
+      console.log(`[dry-run] Would start phase ${phase}`);
+      return;
+    }
+    const state = startPhase(repoRoot(), phase);
+    if (state === null) {
+      console.error("No active phase state. Run: ca phase-check init <epic-id>");
+      process.exit(1);
+    }
+    console.log(`Phase updated: ${state.current_phase} (${state.phase_index}/5).`);
+  });
+  phaseCheck.command("gate <gate-name>").description("Record a phase gate as passed").action((gateName) => {
+    if (!isGateName(gateName)) {
+      console.error(`Invalid gate: "${gateName}". Valid gates: ${GATES.join(", ")}`);
+      process.exit(1);
+    }
+    if (getDryRun()) {
+      console.log(`[dry-run] Would record gate ${gateName}`);
+      return;
+    }
+    const state = recordGatePassed(repoRoot(), gateName);
+    if (state === null) {
+      console.error("No active phase state. Run: ca phase-check init <epic-id>");
+      process.exit(1);
+    }
+    if (gateName === "final") {
+      console.log("Final gate recorded. Phase state cleaned.");
+      return;
+    }
+    console.log(`Gate recorded: ${gateName}.`);
+  });
+  phaseCheck.command("status").description("Show current phase state").option("--json", "Output raw JSON").action((options) => {
+    const state = getPhaseState(repoRoot());
+    if (options.json) {
+      console.log(JSON.stringify(state ?? { lfg_active: false }));
+      return;
+    }
+    printStatusHuman(state);
+  });
+  phaseCheck.command("clean").description("Remove phase state file").action(() => {
+    if (getDryRun()) {
+      console.log("[dry-run] Would delete phase state file");
+      return;
+    }
+    cleanPhaseState(repoRoot());
+    console.log("Phase state cleaned.");
+  });
+}
+function registerPhaseCheckCommand(program2) {
+  const phaseCheck = program2.command("phase-check").description("Manage LFG phase state").option("--dry-run", "Show what would be done without making changes");
+  const getDryRun = () => phaseCheck.opts().dryRun ?? false;
+  const repoRoot = () => process.cwd();
+  registerPhaseSubcommands(phaseCheck, getDryRun, repoRoot);
+  program2.command("phase-clean").description("Remove phase state file (alias for `phase-check clean`)").action(() => {
+    cleanPhaseState(repoRoot());
+    console.log("Phase state cleaned.");
+  });
+}
 
-## Output Format
-\`\`\`
-## Codex External Review
+// src/setup/hooks-phase-guard.ts
+function processPhaseGuard(repoRoot, toolName, _toolInput) {
+  try {
+    if (toolName !== "Edit" && toolName !== "Write") return {};
+    const state = getPhaseState(repoRoot);
+    if (state === null || !state.lfg_active) return {};
+    const expectedSkillPath = `.claude/skills/compound/${state.current_phase}/SKILL.md`;
+    const skillRead = state.skills_read.includes(expectedSkillPath);
+    if (!skillRead) {
+      return {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          additionalContext: `PHASE GUARD WARNING: You are in LFG phase ${state.phase_index}/5 (${state.current_phase}) but have NOT read the skill file yet. Read ${expectedSkillPath} before continuing.`
+        }
+      };
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
 
-**Status**: Completed | Skipped (reason)
-**Findings**: N items
+// src/setup/hooks-read-tracker.ts
+var SKILL_PATH_PATTERN = /(?:^|\/)\.claude\/skills\/compound\/([^/]+)\/SKILL\.md$/;
+function normalizePath(path) {
+  return path.replaceAll("\\", "/");
+}
+function toCanonicalSkillPath(filePath) {
+  const normalized = normalizePath(filePath);
+  const match = SKILL_PATH_PATTERN.exec(normalized);
+  if (!match?.[1]) return null;
+  return `.claude/skills/compound/${match[1]}/SKILL.md`;
+}
+function processReadTracker(repoRoot, toolName, toolInput) {
+  try {
+    if (toolName !== "Read") return {};
+    const state = getPhaseState(repoRoot);
+    if (state === null || !state.lfg_active) return {};
+    const filePath = typeof toolInput.file_path === "string" ? toolInput.file_path : null;
+    if (filePath === null) return {};
+    const canonicalPath = toCanonicalSkillPath(filePath);
+    if (canonicalPath === null) return {};
+    if (!state.skills_read.includes(canonicalPath)) {
+      updatePhaseState(repoRoot, {
+        skills_read: [...state.skills_read, canonicalPath]
+      });
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
 
-1. [P2] <finding description> \u2014 <file:line>
-2. [P3] <finding description> \u2014 <file:line>
-...
-\`\`\`
+// src/setup/hooks-stop-audit.ts
+function hasTransitionEvidence(state) {
+  if (state.phase_index === 5) return true;
+  const nextPhase = PHASES[state.phase_index];
+  if (nextPhase === void 0) return false;
+  const nextSkillPath = `.claude/skills/compound/${nextPhase}/SKILL.md`;
+  return state.skills_read.includes(nextSkillPath);
+}
+function processStopAudit(repoRoot, stopHookActive = false) {
+  try {
+    if (stopHookActive) return {};
+    const state = getPhaseState(repoRoot);
+    if (state === null || !state.lfg_active) return {};
+    const expectedGate = expectedGateForPhase(state.phase_index);
+    if (expectedGate === null) return {};
+    if (state.gates_passed.includes(expectedGate)) return {};
+    if (!hasTransitionEvidence(state)) return {};
+    return {
+      continue: false,
+      stopReason: `PHASE GATE NOT VERIFIED: ${state.current_phase} requires gate '${expectedGate}'. Run: npx ca phase-check gate ${expectedGate}`
+    };
+  } catch {
+    return {};
+  }
+}
+
+// src/setup/hooks.ts
+var HOOK_FILE_MODE = 493;
+var CORRECTION_PATTERNS = [
+  /\bactually\b/i,
+  /\bno[,.]?\s/i,
+  /\bwrong\b/i,
+  /\bthat'?s not right\b/i,
+  /\bthat'?s incorrect\b/i,
+  /\buse .+ instead\b/i,
+  /\bi told you\b/i,
+  /\bi already said\b/i,
+  /\bnot like that\b/i,
+  /\byou forgot\b/i,
+  /\byou missed\b/i,
+  /\bstop\s*(,\s*)?(doing|using|that)\b/i,
+  /\bwait\s*(,\s*)?(that|no|wrong)\b/i
+];
+var HIGH_CONFIDENCE_PLANNING = [
+  /\bdecide\b/i,
+  /\bchoose\b/i,
+  /\bpick\b/i,
+  /\bwhich approach\b/i,
+  /\bwhat do you think\b/i,
+  /\bshould we\b/i,
+  /\bwould you\b/i,
+  /\bhow should\b/i,
+  /\bwhat'?s the best\b/i,
+  /\badd feature\b/i,
+  /\bset up\b/i
+];
+var LOW_CONFIDENCE_PLANNING = [
+  /\bimplement\b/i,
+  /\bbuild\b/i,
+  /\bcreate\b/i,
+  /\brefactor\b/i,
+  /\bfix\b/i,
+  /\bwrite\b/i,
+  /\bdevelop\b/i
+];
+var CORRECTION_REMINDER = "Remember: You have memory tools available - `npx ca learn` to save insights, `npx ca search` to find past solutions.";
+var PLANNING_REMINDER = "If you're uncertain or hesitant, remember your memory tools: `npx ca search` may have relevant context from past sessions.";
+function detectCorrection(prompt) {
+  return CORRECTION_PATTERNS.some((pattern) => pattern.test(prompt));
+}
+function detectPlanning(prompt) {
+  if (HIGH_CONFIDENCE_PLANNING.some((pattern) => pattern.test(prompt))) {
+    return true;
+  }
+  const lowMatches = LOW_CONFIDENCE_PLANNING.filter((pattern) => pattern.test(prompt));
+  return lowMatches.length >= 2;
+}
+function processUserPrompt(prompt) {
+  if (detectCorrection(prompt)) {
+    return {
+      hookSpecificOutput: {
+        hookEventName: "UserPromptSubmit",
+        additionalContext: CORRECTION_REMINDER
+      }
+    };
+  }
+  if (detectPlanning(prompt)) {
+    return {
+      hookSpecificOutput: {
+        hookEventName: "UserPromptSubmit",
+        additionalContext: PLANNING_REMINDER
+      }
+    };
+  }
+  return {};
+}
+var SAME_TARGET_THRESHOLD = 2;
+var TOTAL_FAILURE_THRESHOLD = 3;
+var STATE_FILE_NAME = ".ca-failure-state.json";
+var STATE_MAX_AGE_MS = 60 * 60 * 1e3;
+var failureCount = 0;
+var lastFailedTarget = null;
+var sameTargetCount = 0;
+function defaultState() {
+  return { count: 0, lastTarget: null, sameTargetCount: 0, timestamp: Date.now() };
+}
+function readFailureState(stateDir) {
+  try {
+    const filePath = join(stateDir, STATE_FILE_NAME);
+    if (!existsSync(filePath)) return defaultState();
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (Date.now() - parsed.timestamp > STATE_MAX_AGE_MS) return defaultState();
+    return parsed;
+  } catch {
+    return defaultState();
+  }
+}
+function writeFailureState(stateDir, state) {
+  try {
+    const filePath = join(stateDir, STATE_FILE_NAME);
+    writeFileSync(filePath, JSON.stringify(state), "utf-8");
+  } catch {
+  }
+}
+function deleteStateFile(stateDir) {
+  try {
+    const filePath = join(stateDir, STATE_FILE_NAME);
+    if (existsSync(filePath)) unlinkSync(filePath);
+  } catch {
+  }
+}
+var FAILURE_TIP = "Tip: Multiple failures detected. `npx ca search` may have solutions for similar issues.";
+function resetFailureState(stateDir) {
+  failureCount = 0;
+  lastFailedTarget = null;
+  sameTargetCount = 0;
+  if (stateDir) deleteStateFile(stateDir);
+}
+function getFailureTarget(toolName, toolInput) {
+  if (toolName === "Bash" && typeof toolInput.command === "string") {
+    const trimmed = toolInput.command.trim();
+    const firstSpace = trimmed.indexOf(" ");
+    return firstSpace === -1 ? trimmed : trimmed.slice(0, firstSpace);
+  }
+  if ((toolName === "Edit" || toolName === "Write") && typeof toolInput.file_path === "string") {
+    return toolInput.file_path;
+  }
+  return null;
+}
+function processToolFailure(toolName, toolInput, stateDir) {
+  if (stateDir) {
+    const persisted = readFailureState(stateDir);
+    failureCount = persisted.count;
+    lastFailedTarget = persisted.lastTarget;
+    sameTargetCount = persisted.sameTargetCount;
+  }
+  failureCount++;
+  const target = getFailureTarget(toolName, toolInput);
+  if (target !== null && target === lastFailedTarget) {
+    sameTargetCount++;
+  } else {
+    sameTargetCount = 1;
+    lastFailedTarget = target;
+  }
+  const shouldShowTip = sameTargetCount >= SAME_TARGET_THRESHOLD || failureCount >= TOTAL_FAILURE_THRESHOLD;
+  if (shouldShowTip) {
+    resetFailureState(stateDir);
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PostToolUseFailure",
+        additionalContext: FAILURE_TIP
+      }
+    };
+  }
+  if (stateDir) {
+    writeFailureState(stateDir, {
+      count: failureCount,
+      lastTarget: lastFailedTarget,
+      sameTargetCount,
+      timestamp: Date.now()
+    });
+  }
+  return {};
+}
+function processToolSuccess(stateDir) {
+  resetFailureState(stateDir);
+}
+function hasCompoundAgentHook(content) {
+  return content.includes(HOOK_MARKER);
+}
+async function getGitHooksDir(repoRoot) {
+  const gitDir = join(repoRoot, ".git");
+  if (!existsSync(gitDir)) {
+    return null;
+  }
+  const configPath2 = join(gitDir, "config");
+  if (existsSync(configPath2)) {
+    const config = await readFile(configPath2, "utf-8");
+    const match = /hooksPath\s*=\s*(.+)$/m.exec(config);
+    if (match?.[1]) {
+      const hooksPath = match[1].trim();
+      return hooksPath.startsWith("/") ? hooksPath : join(repoRoot, hooksPath);
+    }
+  }
+  const defaultHooksDir = join(gitDir, "hooks");
+  return existsSync(defaultHooksDir) ? defaultHooksDir : null;
+}
+function findFirstTopLevelExitLine(lines) {
+  let insideFunction = 0;
+  let heredocDelimiter = null;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const trimmed = line.trim();
+    if (heredocDelimiter !== null) {
+      if (trimmed === heredocDelimiter) {
+        heredocDelimiter = null;
+      }
+      continue;
+    }
+    const heredocMatch = /<<-?\s*['"]?(\w+)['"]?/.exec(line);
+    if (heredocMatch?.[1]) {
+      heredocDelimiter = heredocMatch[1];
+      continue;
+    }
+    for (const char of line) {
+      if (char === "{") insideFunction++;
+      if (char === "}") insideFunction = Math.max(0, insideFunction - 1);
+    }
+    if (insideFunction > 0) {
+      continue;
+    }
+    if (/^\s*exit\s+(\d+|\$\w+|\$\?)\s*$/.test(trimmed)) {
+      return i;
+    }
+  }
+  return -1;
+}
+async function installPreCommitHook(repoRoot) {
+  const gitHooksDir = await getGitHooksDir(repoRoot);
+  if (!gitHooksDir) {
+    return { status: "not_git_repo" };
+  }
+  await mkdir(gitHooksDir, { recursive: true });
+  const hookPath = join(gitHooksDir, "pre-commit");
+  if (existsSync(hookPath)) {
+    const content = await readFile(hookPath, "utf-8");
+    if (hasCompoundAgentHook(content)) {
+      return { status: "already_installed" };
+    }
+    const lines = content.split("\n");
+    const exitLineIndex = findFirstTopLevelExitLine(lines);
+    let newContent;
+    if (exitLineIndex === -1) {
+      newContent = content.trimEnd() + "\n" + COMPOUND_AGENT_HOOK_BLOCK;
+    } else {
+      const before = lines.slice(0, exitLineIndex);
+      const after = lines.slice(exitLineIndex);
+      newContent = before.join("\n") + COMPOUND_AGENT_HOOK_BLOCK + after.join("\n");
+    }
+    await writeFile(hookPath, newContent, "utf-8");
+    chmodSync(hookPath, HOOK_FILE_MODE);
+    return { status: "appended" };
+  }
+  await writeFile(hookPath, PRE_COMMIT_HOOK_TEMPLATE, "utf-8");
+  chmodSync(hookPath, HOOK_FILE_MODE);
+  return { status: "installed" };
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function runUserPromptHook() {
+  try {
+    const input = await readStdin();
+    const data = JSON.parse(input);
+    if (!data.prompt) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+    const result = processUserPrompt(data.prompt);
+    console.log(JSON.stringify(result));
+  } catch {
+    console.log(JSON.stringify({}));
+  }
+}
+async function runPostToolFailureHook() {
+  try {
+    const input = await readStdin();
+    const data = JSON.parse(input);
+    if (!data.tool_name) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+    const stateDir = join(process.cwd(), ".claude");
+    const result = processToolFailure(data.tool_name, data.tool_input ?? {}, stateDir);
+    console.log(JSON.stringify(result));
+  } catch {
+    console.log(JSON.stringify({}));
+  }
+}
+async function runPostToolSuccessHook() {
+  try {
+    await readStdin();
+    const stateDir = join(process.cwd(), ".claude");
+    processToolSuccess(stateDir);
+    console.log(JSON.stringify({}));
+  } catch {
+    console.log(JSON.stringify({}));
+  }
+}
+async function runToolHook(processor) {
+  try {
+    const input = await readStdin();
+    const data = JSON.parse(input);
+    if (!data.tool_name) {
+      console.log(JSON.stringify({}));
+      return;
+    }
+    console.log(JSON.stringify(processor(process.cwd(), data.tool_name, data.tool_input ?? {})));
+  } catch {
+    console.log(JSON.stringify({}));
+  }
+}
+async function runStopAuditHook() {
+  try {
+    const input = await readStdin();
+    const data = JSON.parse(input);
+    console.log(JSON.stringify(processStopAudit(process.cwd(), data.stop_hook_active ?? false)));
+  } catch {
+    console.log(JSON.stringify({}));
+  }
+}
+function registerHooksCommand(program2) {
+  const hooksCommand = program2.command("hooks").description("Git hooks management");
+  hooksCommand.command("run <hook>").description("Run a hook script (called by git/Claude hooks)").option("--json", "Output as JSON").action(async (hook, options) => {
+    if (hook === "pre-commit") {
+      if (options.json) {
+        console.log(JSON.stringify({ hook: "pre-commit", message: PRE_COMMIT_MESSAGE }));
+      } else {
+        console.log(PRE_COMMIT_MESSAGE);
+      }
+    } else if (hook === "user-prompt") {
+      await runUserPromptHook();
+    } else if (hook === "post-tool-failure") {
+      await runPostToolFailureHook();
+    } else if (hook === "post-tool-success") {
+      await runPostToolSuccessHook();
+    } else if (hook === "phase-guard") {
+      await runToolHook(processPhaseGuard);
+    } else if (hook === "post-read" || hook === "read-tracker") {
+      await runToolHook(processReadTracker);
+    } else if (hook === "phase-audit" || hook === "stop-audit") {
+      await runStopAuditHook();
+    } else {
+      if (options.json) {
+        console.log(JSON.stringify({ error: `Unknown hook: ${hook}` }));
+      } else {
+        console.error(
+          formatError(
+            "hooks",
+            "UNKNOWN_HOOK",
+            `Unknown hook: ${hook}`,
+            "Valid hooks: pre-commit, user-prompt, post-tool-failure, post-tool-success, post-read (or read-tracker), phase-guard, phase-audit (or stop-audit)"
+          )
+        );
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/setup/templates/agents-external.ts
+var EXTERNAL_AGENT_TEMPLATES = {
+  "external-reviewer-gemini.md": `---
+name: External Reviewer (Gemini)
+description: Cross-model review using Gemini CLI in headless mode
+model: sonnet
+---
+
+# External Reviewer \u2014 Gemini
+
+## Role
+Run a cross-model code review by invoking the Gemini CLI in headless mode. Provides an independent perspective from a different LLM to catch issues Claude may miss.
+
+## Prerequisites
+- Gemini CLI installed (\`npm i -g @google/gemini-cli\`)
+- Authenticated (\`gemini auth login\`)
+
+## Instructions
+1. **Check availability** \u2014 run \`command -v gemini\` via Bash. If not found, report "Gemini CLI not installed \u2014 skipping external review" and stop.
+2. **Gather context**:
+   - Get the beads issue being worked on: \`bd list --status=in_progress\` then \`bd show <id>\` to get the issue title and description.
+   - Get the diff: \`git diff HEAD~1\` (or the appropriate range for this session's changes).
+3. **Build the review prompt** combining beads context + diff:
+   \`\`\`
+   ISSUE: <title>
+   DESCRIPTION: <description>
+   DIFF:
+   <git diff output>
+
+   Review these changes for:
+   1. Correctness bugs and logic errors
+   2. Security vulnerabilities
+   3. Missed edge cases
+   4. Code quality issues
+   Output a numbered list of findings. Be concise and actionable. Skip praise.
+   \`\`\`
+4. **Call Gemini headless**:
+   \`\`\`bash
+   echo "<prompt>" | gemini -p "Review the following code changes" --output-format json
+   \`\`\`
+5. **Parse the response** \u2014 extract the \`.response\` field from the JSON output.
+6. **Present findings** to the user as a numbered list with severity tags (P1/P2/P3).
+7. **If Gemini returns an error** (auth failure, rate limit, timeout), report the error and skip gracefully. Never block the pipeline on external reviewer failure.
+
+## Output Format
+\`\`\`
+## Gemini External Review
+
+**Status**: Completed | Skipped (reason)
+**Findings**: N items
+
+1. [P2] <finding description> \u2014 <file:line>
+2. [P3] <finding description> \u2014 <file:line>
+...
+\`\`\`
+
+## Important
+- This is **advisory, not blocking**. Findings inform but do not gate the pipeline.
+- Do NOT retry more than once on failure.
+- Do NOT feed the entire codebase \u2014 only the diff and issue context.
+`,
+  "external-reviewer-codex.md": `---
+name: External Reviewer (Codex)
+description: Cross-model review using OpenAI Codex CLI in headless mode
+model: sonnet
+---
+
+# External Reviewer \u2014 Codex
+
+## Role
+Run a cross-model code review by invoking the OpenAI Codex CLI in headless exec mode. Provides an independent perspective from OpenAI's reasoning models to catch issues Claude may miss.
+
+## Prerequisites
+- Codex CLI installed (\`npm i -g @openai/codex\`)
+- Authenticated (\`codex login --api-key\`)
+
+## Instructions
+1. **Check availability** \u2014 run \`command -v codex\` via Bash. If not found, report "Codex CLI not installed \u2014 skipping external review" and stop.
+2. **Gather context**:
+   - Get the beads issue being worked on: \`bd list --status=in_progress\` then \`bd show <id>\` to get the issue title and description.
+   - Get the diff: \`git diff HEAD~1\` (or the appropriate range for this session's changes).
+3. **Build the review prompt** combining beads context + diff:
+   \`\`\`
+   ISSUE: <title>
+   DESCRIPTION: <description>
+   DIFF:
+   <git diff output>
+
+   Review these changes for:
+   1. Correctness bugs and logic errors
+   2. Security vulnerabilities
+   3. Missed edge cases
+   4. Code quality issues
+   Output a numbered list of findings. Be concise and actionable. Skip praise.
+   \`\`\`
+4. **Call Codex headless**:
+   \`\`\`bash
+   echo "<prompt>" | codex exec --quiet "Review the following code changes for bugs, security issues, and missed edge cases"
+   \`\`\`
+5. **Parse the response** \u2014 Codex exec prints the final answer to stdout.
+6. **Present findings** to the user as a numbered list with severity tags (P1/P2/P3).
+7. **If Codex returns an error** (auth failure, rate limit, timeout), report the error and skip gracefully. Never block the pipeline on external reviewer failure.
+
+## Output Format
+\`\`\`
+## Codex External Review
+
+**Status**: Completed | Skipped (reason)
+**Findings**: N items
+
+1. [P2] <finding description> \u2014 <file:line>
+2. [P3] <finding description> \u2014 <file:line>
+...
+\`\`\`
 
 ## Important
 - This is **advisory, not blocking**. Findings inform but do not gate the pipeline.
@@ -2926,13 +3555,7 @@ $ARGUMENTS
 
 # Brainstorm
 
-Run the **brainstorm** phase. Follow the brainstorm skill for full instructions.
-
-Key steps:
-- Search memory and explore docs for prior context
-- Clarify scope and constraints via AskUserQuestion
-- Propose 2-3 approaches with tradeoffs
-- Create a beads epic from conclusions
+**MANDATORY FIRST STEP -- NON-NEGOTIABLE**: Use the Read tool to open and read \`.claude/skills/compound/brainstorm/SKILL.md\` NOW. Do NOT proceed until you have read the complete skill file. It contains the full workflow you must follow.
 `,
   "plan.md": `---
 name: compound:plan
@@ -2943,13 +3566,7 @@ $ARGUMENTS
 
 # Plan
 
-Run the **plan** phase. Follow the plan skill for full instructions.
-
-Key steps:
-- Spawn subagents to research constraints and patterns
-- Decompose into tasks with acceptance criteria
-- Create review and compound blocking tasks
-- Verify POST-PLAN gates
+**MANDATORY FIRST STEP -- NON-NEGOTIABLE**: Use the Read tool to open and read \`.claude/skills/compound/plan/SKILL.md\` NOW. Do NOT proceed until you have read the complete skill file. It contains the full workflow you must follow.
 `,
   "work.md": `---
 name: compound:work
@@ -2960,13 +3577,7 @@ $ARGUMENTS
 
 # Work
 
-Run the **work** phase. Follow the work skill for full instructions.
-
-Key steps:
-- Deploy AgentTeam with test-writers and implementers
-- Lead coordinates, delegates, does not code directly
-- Commit incrementally as tests pass
-- Run verification gates before closing tasks
+**MANDATORY FIRST STEP -- NON-NEGOTIABLE**: Use the Read tool to open and read \`.claude/skills/compound/work/SKILL.md\` NOW. Do NOT proceed until you have read the complete skill file. It contains the full workflow you must follow.
 `,
   "review.md": `---
 name: compound:review
@@ -2977,13 +3588,7 @@ $ARGUMENTS
 
 # Review
 
-Run the **review** phase. Follow the review skill for full instructions.
-
-Key steps:
-- Run quality gates, then spawn reviewers in parallel
-- Classify findings as P1/P2/P3
-- Fix all P1 findings before proceeding
-- Submit to /implementation-reviewer as mandatory gate
+**MANDATORY FIRST STEP -- NON-NEGOTIABLE**: Use the Read tool to open and read \`.claude/skills/compound/review/SKILL.md\` NOW. Do NOT proceed until you have read the complete skill file. It contains the full workflow you must follow.
 `,
   "compound.md": `---
 name: compound:compound
@@ -2994,13 +3599,7 @@ $ARGUMENTS
 
 # Compound
 
-Run the **compound** phase. Follow the compound skill for full instructions.
-
-Key steps:
-- Spawn analysis agents in an AgentTeam
-- Apply quality filters, then store via npx ca learn
-- Delegate CCT synthesis to compounding agent
-- Verify FINAL GATE before closing epic
+**MANDATORY FIRST STEP -- NON-NEGOTIABLE**: Use the Read tool to open and read \`.claude/skills/compound/compound/SKILL.md\` NOW. Do NOT proceed until you have read the complete skill file. It contains the full workflow you must follow.
 `,
   "lfg.md": `---
 name: compound:lfg
@@ -3012,13 +3611,7 @@ $ARGUMENTS
 
 # LFG
 
-Run all 5 phases. Follow each phase skill for full instructions.
-
-- Brainstorm: explore and define the problem
-- Plan: decompose into tasks with dependencies
-- Work: delegate to AgentTeam for TDD
-- Review: multi-agent review with severity classification
-- Compound: capture lessons via npx ca learn
+**MANDATORY FIRST STEP -- NON-NEGOTIABLE**: Use the Read tool to open and read \`.claude/skills/compound/lfg/SKILL.md\` NOW. Do NOT proceed until you have read the complete skill file. It contains the full orchestration workflow you must follow.
 `,
   // =========================================================================
   // Utility commands (CLI wrappers)
@@ -3426,6 +4019,76 @@ Before closing the epic:
 - Run \`pnpm test\` and \`pnpm lint\` -- must pass
 If verify-gates fails, the missing phase was SKIPPED. Go back and complete it.
 CRITICAL: 3/5 phases is NOT success. All 5 phases are required.
+`,
+  lfg: `---
+name: LFG
+description: Full-cycle orchestrator chaining all five phases with gates and controls
+---
+
+# LFG Skill
+
+## Overview
+Chain all 5 phases end-to-end: Brainstorm, Plan, Work, Review, Compound. This skill governs the orchestration -- phase sequencing, gates, progress tracking, and error recovery.
+
+## CRITICAL RULE -- READ BEFORE EXECUTE
+Before starting EACH phase, you MUST use the Read tool to open its skill file:
+- .claude/skills/compound/brainstorm/SKILL.md
+- .claude/skills/compound/plan/SKILL.md
+- .claude/skills/compound/work/SKILL.md
+- .claude/skills/compound/review/SKILL.md
+- .claude/skills/compound/compound/SKILL.md
+
+Do NOT proceed from memory. Read the skill, then follow it exactly.
+
+## Phase Execution Protocol
+0. Initialize state: \`npx ca phase-check init <epic-id>\`
+For each phase:
+1. Announce: "[Phase N/5] PHASE_NAME"
+2. Start state: \`npx ca phase-check start <phase>\`
+3. Read the phase skill file (see above)
+4. Run \`npx ca search\` with the current goal -- display results before proceeding
+5. Execute the phase following the skill instructions
+6. Update epic state: \`bd update <epic-id> --notes="Phase: NAME COMPLETE | Next: NEXT"\`
+7. Verify phase gate before proceeding to the next phase
+
+## Phase Gates (MANDATORY)
+- **After Plan**: Run \`bd list --status=open\` and verify Review + Compound tasks exist, then run \`npx ca phase-check gate post-plan\`
+- **After Work (GATE 3)**: \`bd list --status=in_progress\` must be empty. Then run \`npx ca phase-check gate gate-3\`
+- **After Review (GATE 4)**: /implementation-reviewer must have returned APPROVED. Then run \`npx ca phase-check gate gate-4\`
+- **After Compound (FINAL GATE)**: Run \`npx ca verify-gates <epic-id>\` (must PASS), \`pnpm test\`, and \`pnpm lint\`, then run \`npx ca phase-check gate final\` (auto-cleans phase state)
+
+If a gate fails, DO NOT proceed. Fix the issue first.
+
+## Phase Control
+- **Skip phases**: Parse arguments for "from PHASE" (e.g., "from plan"). Skip earlier phases.
+- **Resume**: After interruption, run \`bd show <epic-id>\` and read notes for phase state. Resume from that phase.
+- **Retry**: If a phase fails, report and ask user to retry, skip, or abort via AskUserQuestion.
+- **Progress**: Always announce current phase number before starting.
+
+## Stop Conditions
+- Brainstorm reveals goal is unclear -- stop, ask user
+- Tests produce unresolvable failures -- stop, report
+- Review finds critical security issues -- stop, report
+
+## Common Pitfalls
+- Skipping the Read step for a phase skill (NON-NEGOTIABLE)
+- Not running phase gates between phases
+- Not announcing progress ("[Phase N/5]")
+- Proceeding after a failed gate
+- Not updating epic notes with phase state (loses resume ability)
+- Batching all commits to the end instead of committing incrementally
+
+## Quality Criteria
+- All 5 phases were executed (3/5 is NOT success)
+- Each phase skill was Read before execution
+- Phase gates verified between each transition
+- Epic notes updated after each phase
+- Memory searched at the start of each phase
+- \`npx ca verify-gates\` passed at the end
+
+## SESSION CLOSE -- INVIOLABLE
+Before saying "done": git status, git add, bd sync, git commit, bd sync, git push.
+If phase state gets stuck, use the escape hatch: \`npx ca phase-check clean\` (or \`npx ca phase-clean\`).
 `
 };
 
@@ -3541,7 +4204,7 @@ async function ensureLessonsDirectory(repoRoot) {
   }
   return lessonsDir;
 }
-async function configureClaudeSettings(repoRoot) {
+async function configureClaudeSettings() {
   const settingsPath = getClaudeSettingsPath(false);
   let settings;
   try {
@@ -3549,14 +4212,11 @@ async function configureClaudeSettings(repoRoot) {
   } catch {
     settings = {};
   }
-  const hadHooks = hasClaudeHook(settings);
+  const hadHooks = hasAllCompoundAgentHooks(settings);
   addAllCompoundAgentHooks(settings);
   await writeClaudeSettings(settingsPath, settings);
-  const hadMcp = await hasMcpServerInMcpJson(repoRoot);
-  const mcpAdded = await addMcpServerToMcpJson(repoRoot);
   return {
-    hooks: !hadHooks,
-    mcpServer: mcpAdded && !hadMcp
+    hooks: !hadHooks
   };
 }
 async function runSetup(options) {
@@ -3569,7 +4229,11 @@ async function runSetup(options) {
   await installWorkflowCommands(repoRoot);
   await installPhaseSkills(repoRoot);
   await installAgentRoleSkills(repoRoot);
-  const { hooks, mcpServer } = await configureClaudeSettings(repoRoot);
+  let gitHooks = "skipped";
+  if (!options.skipHooks) {
+    gitHooks = (await installPreCommitHook(repoRoot)).status;
+  }
+  const { hooks } = await configureClaudeSettings();
   let modelStatus = "skipped";
   if (!options.skipModel) {
     try {
@@ -3588,7 +4252,7 @@ async function runSetup(options) {
     lessonsDir,
     agentsMd: agentsMdUpdated,
     hooks,
-    mcpServer,
+    gitHooks,
     model: modelStatus
   };
 }
@@ -3632,10 +4296,6 @@ async function runUninstall(repoRoot, dryRun) {
     }
   } catch {
   }
-  if (await hasMcpServerInMcpJson(repoRoot)) {
-    if (!dryRun) await removeMcpServerFromMcpJson(repoRoot);
-    actions.push("Removed compound-agent from .mcp.json");
-  }
   if (!dryRun) {
     const removed = await removeAgentsSection(repoRoot);
     if (removed) actions.push("Removed compound-agent section from AGENTS.md");
@@ -3709,8 +4369,8 @@ async function runUpdate(repoRoot, dryRun) {
   }
   let configUpdated = false;
   if (!dryRun) {
-    const { hooks, mcpServer } = await configureClaudeSettings(repoRoot);
-    configUpdated = hooks || mcpServer;
+    const { hooks } = await configureClaudeSettings();
+    configUpdated = hooks;
   }
   return { updated, added, skipped, configUpdated };
 }
@@ -3728,557 +4388,291 @@ async function runStatus(repoRoot) {
   let hooksInstalled = false;
   try {
     const settings = await readClaudeSettings(settingsPath);
-    hooksInstalled = hasClaudeHook(settings);
+    hooksInstalled = hasAllCompoundAgentHooks(settings);
   } catch {
   }
   console.log(`  Hooks:              ${hooksInstalled ? "installed" : "not installed"}`);
-  const mcpInstalled = await hasMcpServerInMcpJson(repoRoot);
-  console.log(`  MCP server:         ${mcpInstalled ? "installed" : "not installed"}`);
-}
-function registerSetupAllCommand(setupCommand) {
-  setupCommand.description("One-shot setup: init + hooks + MCP server + model");
-  setupCommand.command("all", { isDefault: true }).description("Run full setup (default)").option("--skip-model", "Skip embedding model download").option("--uninstall", "Remove all generated files and configuration").option("--update", "Regenerate files (preserves user customizations)").option("--status", "Show installation status").option("--dry-run", "Show what would change without changing").action(async (options) => {
-    const repoRoot = getRepoRoot();
-    const dryRun = options.dryRun ?? false;
-    if (options.uninstall) {
-      const prefix = dryRun ? "[dry-run] Would have: " : "";
-      const actions = await runUninstall(repoRoot, dryRun);
-      if (actions.length === 0) {
-        console.log("Nothing to uninstall.");
-      } else {
-        for (const action of actions) {
-          console.log(`  ${prefix}${action}`);
-        }
-        out.success(dryRun ? "Dry run complete (no changes made)" : "Uninstall complete");
-      }
-      return;
-    }
-    if (options.update) {
-      const result2 = await runUpdate(repoRoot, dryRun);
-      const prefix = dryRun ? "[dry-run] " : "";
-      if (result2.updated === 0 && result2.added === 0) {
-        console.log(`${prefix}All generated files are up to date.`);
-      } else {
-        if (result2.updated > 0) console.log(`  ${prefix}Updated: ${result2.updated} file(s)`);
-        if (result2.added > 0) console.log(`  ${prefix}Added: ${result2.added} file(s)`);
-      }
-      if (result2.skipped > 0) console.log(`  Skipped: ${result2.skipped} user-customized file(s)`);
-      if (result2.configUpdated) console.log(`  ${prefix}Config: hooks/MCP updated`);
-      return;
-    }
-    if (options.status) {
-      await runStatus(repoRoot);
-      return;
-    }
-    const result = await runSetup({ skipModel: options.skipModel });
-    out.success("Compound agent setup complete");
-    console.log(`  Lessons directory: ${result.lessonsDir}`);
-    console.log(`  AGENTS.md: ${result.agentsMd ? "Updated" : "Already configured"}`);
-    console.log(`  Claude hooks: ${result.hooks ? "Installed" : "Already configured"}`);
-    console.log(`  MCP server: ${result.mcpServer ? "Registered in .mcp.json" : "Already configured"}`);
-    switch (result.model) {
-      case "skipped":
-        console.log("  Model: Skipped (--skip-model)");
-        break;
-      case "downloaded":
-        console.log("  Model: Downloaded");
-        break;
-      case "already_exists":
-        console.log("  Model: Already exists");
-        break;
-      case "failed":
-        console.log("  Model: Download failed (run `ca download-model` manually)");
-        break;
-    }
-    console.log("");
-    console.log("Next steps:");
-    console.log("  1. Restart Claude Code to load hooks");
-    console.log("  2. Use `npx ca search` and `npx ca learn` commands");
-  });
-}
-
-// src/cli-error-format.ts
-function formatError(command, code, message, remediation) {
-  return `ERROR [${command}] ${code}: ${message} \u2014 ${remediation}`;
-}
-
-// src/setup/claude.ts
-async function handleStatus(alreadyInstalled, displayPath, settingsPath, options) {
-  const repoRoot = getRepoRoot();
-  const learnMdPath = join(repoRoot, ".claude", "commands", "learn.md");
-  const searchMdPath = join(repoRoot, ".claude", "commands", "search.md");
-  const mcpPath = getMcpJsonPath(repoRoot);
-  const learnExists = existsSync(learnMdPath);
-  const searchExists = existsSync(searchMdPath);
-  const mcpExists = existsSync(mcpPath);
-  const mcpInstalled = mcpExists && await hasMcpServerInMcpJson(repoRoot);
-  let status;
-  if (alreadyInstalled && mcpInstalled && learnExists && searchExists) {
-    status = "connected";
-  } else if (alreadyInstalled || mcpInstalled || learnExists || searchExists) {
-    status = "partial";
-  } else {
-    status = "disconnected";
-  }
-  const result = {
-    settingsFile: displayPath,
-    mcpFile: ".mcp.json",
-    exists: existsSync(settingsPath),
-    validJson: true,
-    hookInstalled: alreadyInstalled,
-    mcpInstalled,
-    slashCommands: { learn: learnExists, search: searchExists },
-    status
-  };
-  if (options.json) {
-    console.log(JSON.stringify(result, null, 2));
-    return;
-  }
-  console.log("Claude Code Integration Status");
-  console.log("\u2500".repeat(40));
-  console.log("");
-  console.log(`Hooks file: ${displayPath}`);
-  console.log(`  ${result.exists ? "[ok]" : "[missing]"} File exists`);
-  console.log(`  ${result.validJson ? "[ok]" : "[error]"} Valid JSON`);
-  console.log(`  ${result.hookInstalled ? "[ok]" : "[warn]"} SessionStart hook installed`);
-  console.log("");
-  console.log("MCP config: .mcp.json");
-  console.log(`  ${mcpExists ? "[ok]" : "[missing]"} File exists`);
-  console.log(`  ${mcpInstalled ? "[ok]" : "[warn]"} compound-agent MCP server`);
-  console.log("");
-  console.log("Slash commands:");
-  console.log(`  ${learnExists ? "[ok]" : "[warn]"} /learn command`);
-  console.log(`  ${searchExists ? "[ok]" : "[warn]"} /search command`);
-  console.log("");
-  if (status === "connected") {
-    out.success("All checks passed. Integration is connected.");
-  } else if (status === "partial") {
-    out.warn("Partial setup detected.");
-    console.log("");
-    console.log("Run 'npx ca setup' to complete setup.");
-  } else {
-    out.error("Not connected.");
-    console.log("");
-    console.log("Run 'npx ca setup' to set up Compound Agent.");
-  }
-}
-async function handleUninstall(settings, settingsPath, alreadyInstalled, displayPath, options) {
-  const repoRoot = getRepoRoot();
-  if (options.dryRun) {
-    if (options.json) {
-      console.log(JSON.stringify({ dryRun: true, wouldRemove: alreadyInstalled, location: displayPath }));
-    } else {
-      if (alreadyInstalled) {
-        console.log(`Would remove compound-agent hooks from ${displayPath}`);
-      } else {
-        console.log("No compound-agent hooks to remove");
-      }
-    }
-    return;
-  }
-  const removedHook = removeCompoundAgentHook(settings);
-  if (removedHook) {
-    await writeClaudeSettings(settingsPath, settings);
-  }
-  const removedMcp = await removeMcpServerFromMcpJson(repoRoot);
-  const removedAgents = await removeAgentsSection(repoRoot);
-  const removedClaudeMd = await removeClaudeMdReference(repoRoot);
-  const anyRemoved = removedHook || removedMcp || removedAgents || removedClaudeMd;
-  if (anyRemoved) {
-    if (options.json) {
-      console.log(JSON.stringify({
-        installed: false,
-        location: displayPath,
-        action: "removed",
-        mcpRemoved: removedMcp,
-        agentsMdRemoved: removedAgents,
-        claudeMdRemoved: removedClaudeMd
-      }));
-    } else {
-      out.success("Compound agent removed");
-      if (removedHook) console.log(`  Hooks: ${displayPath}`);
-      if (removedMcp) console.log("  MCP: .mcp.json");
-      if (removedAgents) console.log("  AGENTS.md: Compound Agent section removed");
-      if (removedClaudeMd) console.log("  CLAUDE.md: Compound Agent reference removed");
-    }
-  } else {
-    if (options.json) {
-      console.log(JSON.stringify({ installed: false, location: displayPath, action: "unchanged" }));
-    } else {
-      out.info("No compound agent hooks to remove");
-      if (options.global) {
-        console.log("  Hint: Try without --global to check project settings.");
-      } else {
-        console.log("  Hint: Try with --global flag to check global settings.");
-      }
-    }
-  }
 }
-async function handleInstall(settings, settingsPath, alreadyInstalled, displayPath, options) {
-  if (options.dryRun) {
-    if (options.json) {
-      console.log(JSON.stringify({ dryRun: true, wouldInstall: !alreadyInstalled, location: displayPath }));
-    } else {
-      if (alreadyInstalled) {
-        console.log("Compound agent hooks already installed");
-      } else {
-        console.log(`Would install compound-agent hooks to ${displayPath}`);
-      }
-    }
+function printSetupGitHooksStatus(gitHooks) {
+  if (gitHooks === "skipped") {
+    console.log("  Git hooks: Skipped (--skip-hooks)");
     return;
   }
-  if (alreadyInstalled) {
-    if (options.json) {
-      console.log(JSON.stringify({
-        installed: true,
-        location: displayPath,
-        hooks: ["SessionStart"],
-        action: "unchanged"
-      }));
-    } else {
-      out.info("Compound agent hooks already installed");
-      console.log(`  Location: ${displayPath}`);
-    }
+  if (gitHooks === "not_git_repo") {
+    console.log("  Git hooks: Skipped (not a git repository)");
     return;
   }
-  const fileExists = existsSync(settingsPath);
-  addCompoundAgentHook(settings);
-  await writeClaudeSettings(settingsPath, settings);
-  if (options.json) {
-    console.log(JSON.stringify({
-      installed: true,
-      location: displayPath,
-      hooks: ["SessionStart"],
-      action: fileExists ? "updated" : "created"
-    }));
-  } else {
-    out.success(options.global ? "Claude Code hooks installed (global)" : "Claude Code hooks installed (project-level)");
-    console.log(`  Location: ${displayPath}`);
-    console.log("  Hook: SessionStart (startup|resume|compact)");
-    console.log("");
-    console.log("Lessons will be loaded automatically at session start.");
-    if (!options.global) {
-      console.log("");
-      console.log("Note: Project hooks override global hooks.");
-    }
+  if (gitHooks === "installed") {
+    console.log("  Git hooks: Installed");
+    return;
   }
+  if (gitHooks === "appended") {
+    console.log("  Git hooks: Appended to existing pre-commit hook");
+    return;
+  }
+  console.log("  Git hooks: Already configured");
 }
-function registerClaudeSubcommand(setupCommand) {
-  setupCommand.command("claude").description("Install Claude Code SessionStart hooks").option("--global", "Install to global ~/.claude/ instead of project").option("--uninstall", "Remove compound-agent hooks").option("--status", "Check status of Claude Code integration").option("--dry-run", "Show what would change without writing").option("--json", "Output as JSON").action(async (options) => {
-    const settingsPath = getClaudeSettingsPath(options.global ?? false);
-    const displayPath = options.global ? "~/.claude/settings.json" : ".claude/settings.json";
-    let settings;
-    try {
-      settings = await readClaudeSettings(settingsPath);
-    } catch {
-      if (options.json) {
-        console.log(JSON.stringify({ error: "Failed to parse settings file" }));
+function registerSetupAllCommand(setupCommand) {
+  setupCommand.description("One-shot setup: init + hooks + model");
+  setupCommand.command("all", { isDefault: true }).description("Run full setup (default)").option("--skip-model", "Skip embedding model download").option("--skip-hooks", "Skip git hooks installation").option("--uninstall", "Remove all generated files and configuration").option("--update", "Regenerate files (preserves user customizations)").option("--status", "Show installation status").option("--dry-run", "Show what would change without changing").action(async (options) => {
+    const repoRoot = getRepoRoot();
+    const dryRun = options.dryRun ?? false;
+    if (options.uninstall) {
+      const prefix = dryRun ? "[dry-run] Would have: " : "";
+      const actions = await runUninstall(repoRoot, dryRun);
+      if (actions.length === 0) {
+        console.log("Nothing to uninstall.");
       } else {
-        console.error(formatError("setup", "PARSE_ERROR", "Failed to parse settings file", "Check if JSON is valid"));
+        for (const action of actions) {
+          console.log(`  ${prefix}${action}`);
+        }
+        out.success(dryRun ? "Dry run complete (no changes made)" : "Uninstall complete");
       }
-      process.exit(1);
-    }
-    const alreadyInstalled = hasClaudeHook(settings);
-    if (options.status) {
-      await handleStatus(alreadyInstalled, displayPath, settingsPath, options);
-    } else if (options.uninstall) {
-      await handleUninstall(settings, settingsPath, alreadyInstalled, displayPath, options);
-    } else {
-      await handleInstall(settings, settingsPath, alreadyInstalled, displayPath, options);
+      return;
     }
-  });
-}
-function registerDownloadModelCommand(program2) {
-  program2.command("download-model").description("Download the embedding model for semantic search").option("--json", "Output as JSON").action(async (options) => {
-    const alreadyExisted = isModelAvailable();
-    if (alreadyExisted) {
-      const modelPath2 = join(homedir(), ".node-llama-cpp", "models", MODEL_FILENAME);
-      const size2 = statSync(modelPath2).size;
-      if (options.json) {
-        console.log(JSON.stringify({ success: true, path: modelPath2, size: size2, alreadyExisted: true }));
+    if (options.update) {
+      const result2 = await runUpdate(repoRoot, dryRun);
+      const prefix = dryRun ? "[dry-run] " : "";
+      if (result2.updated === 0 && result2.added === 0) {
+        console.log(`${prefix}All generated files are up to date.`);
       } else {
-        console.log("Model already exists.");
-        console.log(`Path: ${modelPath2}`);
-        console.log(`Size: ${formatBytes(size2)}`);
+        if (result2.updated > 0) console.log(`  ${prefix}Updated: ${result2.updated} file(s)`);
+        if (result2.added > 0) console.log(`  ${prefix}Added: ${result2.added} file(s)`);
       }
+      if (result2.skipped > 0) console.log(`  Skipped: ${result2.skipped} user-customized file(s)`);
+      if (result2.configUpdated) console.log(`  ${prefix}Config: hooks updated`);
       return;
     }
-    if (!options.json) {
-      console.log("Downloading embedding model...");
+    if (options.status) {
+      await runStatus(repoRoot);
+      return;
     }
-    const modelPath = await resolveModel({ cli: !options.json });
-    const size = statSync(modelPath).size;
-    if (options.json) {
-      console.log(JSON.stringify({ success: true, path: modelPath, size, alreadyExisted: false }));
-    } else {
-      console.log(`
-Model downloaded successfully!`);
-      console.log(`Path: ${modelPath}`);
-      console.log(`Size: ${formatBytes(size)}`);
+    const result = await runSetup({ skipModel: options.skipModel, skipHooks: options.skipHooks });
+    out.success("Compound agent setup complete");
+    console.log(`  Lessons directory: ${result.lessonsDir}`);
+    console.log(`  AGENTS.md: ${result.agentsMd ? "Updated" : "Already configured"}`);
+    console.log(`  Claude hooks: ${result.hooks ? "Installed" : "Already configured"}`);
+    printSetupGitHooksStatus(result.gitHooks);
+    switch (result.model) {
+      case "skipped":
+        console.log("  Model: Skipped (--skip-model)");
+        break;
+      case "downloaded":
+        console.log("  Model: Downloaded");
+        break;
+      case "already_exists":
+        console.log("  Model: Already exists");
+        break;
+      case "failed":
+        console.log("  Model: Download failed (run `ca download-model` manually)");
+        break;
     }
+    console.log("");
+    console.log("Next steps:");
+    console.log("  1. Restart Claude Code to load hooks");
+    console.log("  2. Use `npx ca search` and `npx ca learn` commands");
   });
 }
-var HOOK_FILE_MODE = 493;
-var CORRECTION_PATTERNS = [
-  /\bactually\b/i,
-  /\bno[,.]?\s/i,
-  /\bwrong\b/i,
-  /\bthat'?s not right\b/i,
-  /\bthat'?s incorrect\b/i,
-  /\buse .+ instead\b/i,
-  /\bi told you\b/i,
-  /\bi already said\b/i,
-  /\bnot like that\b/i,
-  /\byou forgot\b/i,
-  /\byou missed\b/i,
-  /\bstop\s*(,\s*)?(doing|using|that)\b/i,
-  /\bwait\s*(,\s*)?(that|no|wrong)\b/i
-];
-var HIGH_CONFIDENCE_PLANNING = [
-  /\bdecide\b/i,
-  /\bchoose\b/i,
-  /\bpick\b/i,
-  /\bwhich approach\b/i,
-  /\bwhat do you think\b/i,
-  /\bshould we\b/i,
-  /\bwould you\b/i,
-  /\bhow should\b/i,
-  /\bwhat'?s the best\b/i,
-  /\badd feature\b/i,
-  /\bset up\b/i
-];
-var LOW_CONFIDENCE_PLANNING = [
-  /\bimplement\b/i,
-  /\bbuild\b/i,
-  /\bcreate\b/i,
-  /\brefactor\b/i,
-  /\bfix\b/i,
-  /\bwrite\b/i,
-  /\bdevelop\b/i
-];
-var CORRECTION_REMINDER = "Remember: You have memory tools available - `npx ca learn` to save insights, `npx ca search` to find past solutions.";
-var PLANNING_REMINDER = "If you're uncertain or hesitant, remember your memory tools: `npx ca search` may have relevant context from past sessions.";
-function detectCorrection(prompt) {
-  return CORRECTION_PATTERNS.some((pattern) => pattern.test(prompt));
-}
-function detectPlanning(prompt) {
-  if (HIGH_CONFIDENCE_PLANNING.some((pattern) => pattern.test(prompt))) {
-    return true;
-  }
-  const lowMatches = LOW_CONFIDENCE_PLANNING.filter((pattern) => pattern.test(prompt));
-  return lowMatches.length >= 2;
-}
-function processUserPrompt(prompt) {
-  if (detectCorrection(prompt)) {
-    return {
-      hookSpecificOutput: {
-        hookEventName: "UserPromptSubmit",
-        additionalContext: CORRECTION_REMINDER
-      }
-    };
-  }
-  if (detectPlanning(prompt)) {
-    return {
-      hookSpecificOutput: {
-        hookEventName: "UserPromptSubmit",
-        additionalContext: PLANNING_REMINDER
-      }
-    };
-  }
-  return {};
-}
-var SAME_TARGET_THRESHOLD = 2;
-var TOTAL_FAILURE_THRESHOLD = 3;
-var failureCount = 0;
-var lastFailedTarget = null;
-var sameTargetCount = 0;
-var FAILURE_TIP = "Tip: Multiple failures detected. `npx ca search` may have solutions for similar issues.";
-function resetFailureState() {
-  failureCount = 0;
-  lastFailedTarget = null;
-  sameTargetCount = 0;
-}
-function getFailureTarget(toolName, toolInput) {
-  if (toolName === "Bash" && typeof toolInput.command === "string") {
-    const trimmed = toolInput.command.trim();
-    const firstSpace = trimmed.indexOf(" ");
-    return firstSpace === -1 ? trimmed : trimmed.slice(0, firstSpace);
-  }
-  if ((toolName === "Edit" || toolName === "Write") && typeof toolInput.file_path === "string") {
-    return toolInput.file_path;
-  }
-  return null;
-}
-function processToolFailure(toolName, toolInput) {
-  failureCount++;
-  const target = getFailureTarget(toolName, toolInput);
-  if (target !== null && target === lastFailedTarget) {
-    sameTargetCount++;
+async function handleStatus(alreadyInstalled, displayPath, settingsPath, options) {
+  const repoRoot = getRepoRoot();
+  const learnMdPath = join(repoRoot, ".claude", "commands", "learn.md");
+  const searchMdPath = join(repoRoot, ".claude", "commands", "search.md");
+  const learnExists = existsSync(learnMdPath);
+  const searchExists = existsSync(searchMdPath);
+  let status;
+  if (alreadyInstalled && learnExists && searchExists) {
+    status = "connected";
+  } else if (alreadyInstalled || learnExists || searchExists) {
+    status = "partial";
   } else {
-    sameTargetCount = 1;
-    lastFailedTarget = target;
-  }
-  const shouldShowTip = sameTargetCount >= SAME_TARGET_THRESHOLD || failureCount >= TOTAL_FAILURE_THRESHOLD;
-  if (shouldShowTip) {
-    resetFailureState();
-    return {
-      hookSpecificOutput: {
-        hookEventName: "PostToolUseFailure",
-        additionalContext: FAILURE_TIP
-      }
-    };
+    status = "disconnected";
   }
-  return {};
-}
-function processToolSuccess() {
-  resetFailureState();
-}
-function hasCompoundAgentHook(content) {
-  return content.includes(HOOK_MARKER);
-}
-async function getGitHooksDir(repoRoot) {
-  const gitDir = join(repoRoot, ".git");
-  if (!existsSync(gitDir)) {
-    return null;
+  const result = {
+    settingsFile: displayPath,
+    exists: existsSync(settingsPath),
+    validJson: true,
+    hookInstalled: alreadyInstalled,
+    slashCommands: { learn: learnExists, search: searchExists },
+    status
+  };
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
   }
-  const configPath2 = join(gitDir, "config");
-  if (existsSync(configPath2)) {
-    const config = await readFile(configPath2, "utf-8");
-    const match = /hooksPath\s*=\s*(.+)$/m.exec(config);
-    if (match?.[1]) {
-      const hooksPath = match[1].trim();
-      return hooksPath.startsWith("/") ? hooksPath : join(repoRoot, hooksPath);
-    }
+  console.log("Claude Code Integration Status");
+  console.log("\u2500".repeat(40));
+  console.log("");
+  console.log(`Hooks file: ${displayPath}`);
+  console.log(`  ${result.exists ? "[ok]" : "[missing]"} File exists`);
+  console.log(`  ${result.validJson ? "[ok]" : "[error]"} Valid JSON`);
+  console.log(`  ${result.hookInstalled ? "[ok]" : "[warn]"} Compound Agent hooks installed`);
+  console.log("");
+  console.log("Slash commands:");
+  console.log(`  ${learnExists ? "[ok]" : "[warn]"} /learn command`);
+  console.log(`  ${searchExists ? "[ok]" : "[warn]"} /search command`);
+  console.log("");
+  if (status === "connected") {
+    out.success("All checks passed. Integration is connected.");
+  } else if (status === "partial") {
+    out.warn("Partial setup detected.");
+    console.log("");
+    console.log("Run 'npx ca setup' to complete setup.");
+  } else {
+    out.error("Not connected.");
+    console.log("");
+    console.log("Run 'npx ca setup' to set up Compound Agent.");
   }
-  const defaultHooksDir = join(gitDir, "hooks");
-  return existsSync(defaultHooksDir) ? defaultHooksDir : null;
 }
-function findFirstTopLevelExitLine(lines) {
-  let insideFunction = 0;
-  let heredocDelimiter = null;
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i] ?? "";
-    const trimmed = line.trim();
-    if (heredocDelimiter !== null) {
-      if (trimmed === heredocDelimiter) {
-        heredocDelimiter = null;
+async function handleUninstall(settings, settingsPath, alreadyInstalled, displayPath, options) {
+  const repoRoot = getRepoRoot();
+  if (options.dryRun) {
+    if (options.json) {
+      console.log(JSON.stringify({ dryRun: true, wouldRemove: alreadyInstalled, location: displayPath }));
+    } else {
+      if (alreadyInstalled) {
+        console.log(`Would remove compound-agent hooks from ${displayPath}`);
+      } else {
+        console.log("No compound-agent hooks to remove");
       }
-      continue;
-    }
-    const heredocMatch = /<<-?\s*['"]?(\w+)['"]?/.exec(line);
-    if (heredocMatch?.[1]) {
-      heredocDelimiter = heredocMatch[1];
-      continue;
-    }
-    for (const char of line) {
-      if (char === "{") insideFunction++;
-      if (char === "}") insideFunction = Math.max(0, insideFunction - 1);
-    }
-    if (insideFunction > 0) {
-      continue;
-    }
-    if (/^\s*exit\s+(\d+|\$\w+|\$\?)\s*$/.test(trimmed)) {
-      return i;
     }
+    return;
   }
-  return -1;
-}
-async function installPreCommitHook(repoRoot) {
-  const gitHooksDir = await getGitHooksDir(repoRoot);
-  if (!gitHooksDir) {
-    return { status: "not_git_repo" };
+  const removedHook = removeCompoundAgentHook(settings);
+  if (removedHook) {
+    await writeClaudeSettings(settingsPath, settings);
   }
-  await mkdir(gitHooksDir, { recursive: true });
-  const hookPath = join(gitHooksDir, "pre-commit");
-  if (existsSync(hookPath)) {
-    const content = await readFile(hookPath, "utf-8");
-    if (hasCompoundAgentHook(content)) {
-      return { status: "already_installed" };
+  const removedAgents = await removeAgentsSection(repoRoot);
+  const removedClaudeMd = await removeClaudeMdReference(repoRoot);
+  const anyRemoved = removedHook || removedAgents || removedClaudeMd;
+  if (anyRemoved) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        installed: false,
+        location: displayPath,
+        action: "removed",
+        agentsMdRemoved: removedAgents,
+        claudeMdRemoved: removedClaudeMd
+      }));
+    } else {
+      out.success("Compound agent removed");
+      if (removedHook) console.log(`  Hooks: ${displayPath}`);
+      if (removedAgents) console.log("  AGENTS.md: Compound Agent section removed");
+      if (removedClaudeMd) console.log("  CLAUDE.md: Compound Agent reference removed");
     }
-    const lines = content.split("\n");
-    const exitLineIndex = findFirstTopLevelExitLine(lines);
-    let newContent;
-    if (exitLineIndex === -1) {
-      newContent = content.trimEnd() + "\n" + COMPOUND_AGENT_HOOK_BLOCK;
+  } else {
+    if (options.json) {
+      console.log(JSON.stringify({ installed: false, location: displayPath, action: "unchanged" }));
     } else {
-      const before = lines.slice(0, exitLineIndex);
-      const after = lines.slice(exitLineIndex);
-      newContent = before.join("\n") + COMPOUND_AGENT_HOOK_BLOCK + after.join("\n");
+      out.info("No compound agent hooks to remove");
+      if (options.global) {
+        console.log("  Hint: Try without --global to check project settings.");
+      } else {
+        console.log("  Hint: Try with --global flag to check global settings.");
+      }
     }
-    await writeFile(hookPath, newContent, "utf-8");
-    chmodSync(hookPath, HOOK_FILE_MODE);
-    return { status: "appended" };
-  }
-  await writeFile(hookPath, PRE_COMMIT_HOOK_TEMPLATE, "utf-8");
-  chmodSync(hookPath, HOOK_FILE_MODE);
-  return { status: "installed" };
-}
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
   }
-  return Buffer.concat(chunks).toString("utf-8");
 }
-async function runUserPromptHook() {
-  try {
-    const input = await readStdin();
-    const data = JSON.parse(input);
-    if (!data.prompt) {
-      console.log(JSON.stringify({}));
-      return;
+async function handleInstall(settings, settingsPath, alreadyInstalled, displayPath, options) {
+  if (options.dryRun) {
+    if (options.json) {
+      console.log(JSON.stringify({ dryRun: true, wouldInstall: !alreadyInstalled, location: displayPath }));
+    } else {
+      if (alreadyInstalled) {
+        console.log("Compound agent hooks already installed");
+      } else {
+        console.log(`Would install compound-agent hooks to ${displayPath}`);
+      }
     }
-    const result = processUserPrompt(data.prompt);
-    console.log(JSON.stringify(result));
-  } catch {
-    console.log(JSON.stringify({}));
+    return;
   }
-}
-async function runPostToolFailureHook() {
-  try {
-    const input = await readStdin();
-    const data = JSON.parse(input);
-    if (!data.tool_name) {
-      console.log(JSON.stringify({}));
-      return;
+  if (alreadyInstalled) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        installed: true,
+        location: displayPath,
+        hooks: ["SessionStart", "PreCompact", "UserPromptSubmit", "PostToolUseFailure", "PostToolUse", "PreToolUse", "Stop"],
+        action: "unchanged"
+      }));
+    } else {
+      out.info("Compound agent hooks already installed");
+      console.log(`  Location: ${displayPath}`);
     }
-    const result = processToolFailure(data.tool_name, data.tool_input ?? {});
-    console.log(JSON.stringify(result));
-  } catch {
-    console.log(JSON.stringify({}));
+    return;
   }
-}
-async function runPostToolSuccessHook() {
-  try {
-    await readStdin();
-    processToolSuccess();
-    console.log(JSON.stringify({}));
-  } catch {
-    console.log(JSON.stringify({}));
+  const fileExists = existsSync(settingsPath);
+  addAllCompoundAgentHooks(settings);
+  await writeClaudeSettings(settingsPath, settings);
+  if (options.json) {
+    console.log(JSON.stringify({
+      installed: true,
+      location: displayPath,
+      hooks: ["SessionStart", "PreCompact", "UserPromptSubmit", "PostToolUseFailure", "PostToolUse", "PreToolUse", "Stop"],
+      action: fileExists ? "updated" : "created"
+    }));
+  } else {
+    out.success(options.global ? "Claude Code hooks installed (global)" : "Claude Code hooks installed (project-level)");
+    console.log(`  Location: ${displayPath}`);
+    console.log("  Hooks: SessionStart, PreCompact, UserPromptSubmit, PostToolUseFailure, PostToolUse, PreToolUse, Stop");
+    console.log("");
+    console.log("Lessons will be loaded automatically at session start.");
+    if (!options.global) {
+      console.log("");
+      console.log("Note: Project hooks override global hooks.");
+    }
   }
 }
-function registerHooksCommand(program2) {
-  const hooksCommand = program2.command("hooks").description("Git hooks management");
-  hooksCommand.command("run <hook>").description("Run a hook script (called by git/Claude hooks)").option("--json", "Output as JSON").action(async (hook, options) => {
-    if (hook === "pre-commit") {
+function registerClaudeSubcommand(setupCommand) {
+  setupCommand.command("claude").description("Install Claude Code hooks").option("--global", "Install to global ~/.claude/ instead of project").option("--uninstall", "Remove compound-agent hooks").option("--status", "Check status of Claude Code integration").option("--dry-run", "Show what would change without writing").option("--json", "Output as JSON").action(async (options) => {
+    const settingsPath = getClaudeSettingsPath(options.global ?? false);
+    const displayPath = options.global ? "~/.claude/settings.json" : ".claude/settings.json";
+    let settings;
+    try {
+      settings = await readClaudeSettings(settingsPath);
+    } catch {
       if (options.json) {
-        console.log(JSON.stringify({ hook: "pre-commit", message: PRE_COMMIT_MESSAGE }));
+        console.log(JSON.stringify({ error: "Failed to parse settings file" }));
       } else {
-        console.log(PRE_COMMIT_MESSAGE);
+        console.error(formatError("setup", "PARSE_ERROR", "Failed to parse settings file", "Check if JSON is valid"));
       }
-    } else if (hook === "user-prompt") {
-      await runUserPromptHook();
-    } else if (hook === "post-tool-failure") {
-      await runPostToolFailureHook();
-    } else if (hook === "post-tool-success") {
-      await runPostToolSuccessHook();
+      process.exit(1);
+    }
+    const alreadyInstalled = hasAllCompoundAgentHooks(settings);
+    if (options.status) {
+      await handleStatus(alreadyInstalled, displayPath, settingsPath, options);
+    } else if (options.uninstall) {
+      await handleUninstall(settings, settingsPath, alreadyInstalled, displayPath, options);
     } else {
+      await handleInstall(settings, settingsPath, alreadyInstalled, displayPath, options);
+    }
+  });
+}
+function registerDownloadModelCommand(program2) {
+  program2.command("download-model").description("Download the embedding model for semantic search").option("--json", "Output as JSON").action(async (options) => {
+    const alreadyExisted = isModelAvailable();
+    if (alreadyExisted) {
+      const modelPath2 = join(homedir(), ".node-llama-cpp", "models", MODEL_FILENAME);
+      const size2 = statSync(modelPath2).size;
       if (options.json) {
-        console.log(JSON.stringify({ error: `Unknown hook: ${hook}` }));
+        console.log(JSON.stringify({ success: true, path: modelPath2, size: size2, alreadyExisted: true }));
       } else {
-        console.error(formatError("hooks", "UNKNOWN_HOOK", `Unknown hook: ${hook}`, "Valid hooks: pre-session, post-tool-failure, post-tool-success"));
+        console.log("Model already exists.");
+        console.log(`Path: ${modelPath2}`);
+        console.log(`Size: ${formatBytes(size2)}`);
       }
-      process.exit(1);
+      return;
+    }
+    if (!options.json) {
+      console.log("Downloading embedding model...");
+    }
+    const modelPath = await resolveModel({ cli: !options.json });
+    const size = statSync(modelPath).size;
+    if (options.json) {
+      console.log(JSON.stringify({ success: true, path: modelPath, size, alreadyExisted: false }));
+    } else {
+      console.log(`
+Model downloaded successfully!`);
+      console.log(`Path: ${modelPath}`);
+      console.log(`Size: ${formatBytes(size)}`);
     }
   });
 }
@@ -4604,12 +4998,10 @@ async function runDoctor(repoRoot) {
   let hooksOk = false;
   try {
     const settings = await readClaudeSettings(settingsPath);
-    hooksOk = hasClaudeHook(settings);
+    hooksOk = hasAllCompoundAgentHooks(settings);
   } catch {
   }
   checks.push(hooksOk ? { name: "Claude hooks", status: "pass" } : { name: "Claude hooks", status: "fail", fix: "Run: npx ca setup" });
-  const mcpOk = await hasMcpServerInMcpJson(repoRoot);
-  checks.push(mcpOk ? { name: "MCP server", status: "pass" } : { name: "MCP server", status: "fail", fix: "Run: npx ca setup" });
   let modelOk = false;
   try {
     modelOk = isModelAvailable();
@@ -4947,6 +5339,26 @@ function formatLessonForPrime(lesson) {
   return `- **${lesson.insight}**${tags}
   Learned: ${date} via ${source}`;
 }
+function formatActiveLfgSection(repoRoot) {
+  const state = getPhaseState(repoRoot);
+  if (state === null || !state.lfg_active) return null;
+  const skillsRead = state.skills_read.length === 0 ? "(none)" : state.skills_read.join(", ");
+  const gatesPassed = state.gates_passed.length === 0 ? "(none)" : state.gates_passed.join(", ");
+  return `
+---
+
+# ACTIVE LFG SESSION
+
+Epic: ${state.epic_id}
+Phase: ${state.current_phase} (${state.phase_index}/5)
+Skills read: ${skillsRead}
+Gates passed: ${gatesPassed}
+Started: ${state.started_at}
+
+Resume from phase ${state.current_phase}. Run: \`npx ca phase-check start ${state.current_phase}\`
+Read the skill file first: \`.claude/skills/compound/${state.current_phase}/SKILL.md\`
+`;
+}
 async function getPrimeContext(repoRoot) {
   const root = getRepoRoot();
   try {
@@ -4967,6 +5379,10 @@ Critical lessons from past corrections:
 ${formattedLessons}
 `;
   }
+  const lfgSection = formatActiveLfgSection(root);
+  if (lfgSection !== null) {
+    output += lfgSection;
+  }
   return output;
 }
 function registerPrimeCommand(program2) {
@@ -5271,7 +5687,7 @@ function registerTestSummaryCommand(program2) {
     process.exit(exitCode);
   });
 }
-var EPIC_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+var EPIC_ID_PATTERN2 = /^[a-zA-Z0-9_-]+$/;
 function parseDepsJson(raw) {
   const data = JSON.parse(raw);
   const issue = Array.isArray(data) ? data[0] : data;
@@ -5314,10 +5730,11 @@ function checkGate(deps, prefix, gateName) {
   }
   return { name: gateName, status: "pass" };
 }
-async function runVerifyGates(epicId) {
-  if (!EPIC_ID_PATTERN.test(epicId)) {
+async function runVerifyGates(epicId, options = {}) {
+  if (!EPIC_ID_PATTERN2.test(epicId)) {
     throw new Error(`Invalid epic ID: "${epicId}" (must be alphanumeric with hyphens/underscores)`);
   }
+  const repoRoot = options.repoRoot ?? getRepoRoot();
   const raw = execFileSync("bd", ["show", epicId, "--json"], { encoding: "utf-8" });
   let deps;
   try {
@@ -5326,10 +5743,18 @@ async function runVerifyGates(epicId) {
     const textRaw = execFileSync("bd", ["show", epicId], { encoding: "utf-8" });
     deps = parseDepsText(textRaw);
   }
-  return [
+  const checks = [
     checkGate(deps, "Review:", "Review task"),
     checkGate(deps, "Compound:", "Compound task")
   ];
+  const allPassed = checks.every((check) => check.status === "pass");
+  if (allPassed) {
+    const state = getPhaseState(repoRoot);
+    if (state !== null && state.lfg_active && state.gates_passed.includes("final")) {
+      cleanPhaseState(repoRoot);
+    }
+  }
+  return checks;
 }
 var STATUS_LABEL = {
   pass: "PASS",
@@ -5338,7 +5763,7 @@ var STATUS_LABEL = {
 function registerVerifyGatesCommand(program2) {
   program2.command("verify-gates <epic-id>").description("Verify workflow gates are satisfied before epic closure").action(async (epicId) => {
     try {
-      const checks = await runVerifyGates(epicId);
+      const checks = await runVerifyGates(epicId, { repoRoot: getRepoRoot() });
       console.log(`Gate checks for epic ${epicId}:
 `);
       for (const check of checks) {
@@ -5397,7 +5822,7 @@ function outputCapturePreview(lesson) {
   console.log(`  Insight: ${lesson.insight}`);
   console.log(`  Type: ${lesson.type}`);
   console.log(`  Tags: ${lesson.tags.length > 0 ? lesson.tags.join(", ") : "(none)"}`);
-  console.log("\nTo save: run with --yes flag, or use memory_capture MCP tool");
+  console.log("\nTo save: run with --yes flag");
 }
 function createLessonFromInputFile(result, confirmed) {
   return {
@@ -5605,7 +6030,7 @@ function registerCaptureCommands(program2) {
     await handleCapture(this, options);
   });
 }
-var EPIC_ID_PATTERN2 = /^[a-zA-Z0-9_.-]+$/;
+var EPIC_ID_PATTERN3 = /^[a-zA-Z0-9_.-]+$/;
 function buildScriptHeader(timestamp, maxRetries, model, epicIds) {
   return `#!/usr/bin/env bash
 # Infinity Loop - Generated by: ca loop
@@ -5818,8 +6243,8 @@ function validateOptions(options) {
   }
   if (options.epics) {
     for (const id of options.epics) {
-      if (!EPIC_ID_PATTERN2.test(id)) {
-        throw new Error(`Invalid epic ID "${id}": must match ${EPIC_ID_PATTERN2}`);
+      if (!EPIC_ID_PATTERN3.test(id)) {
+        throw new Error(`Invalid epic ID "${id}": must match ${EPIC_ID_PATTERN3}`);
       }
     }
   }
@@ -6155,6 +6580,7 @@ registerManagementCommands(program);
 registerSetupCommands(program);
 registerCompoundCommands(program);
 registerLoopCommands(program);
+registerPhaseCheckCommand(program);
 program.parse();
 //# sourceMappingURL=cli.js.map
 //# sourceMappingURL=cli.js.map