compound-agent 1.6.1 → 1.6.4

package/dist/cli.js

@@ -120,7 +120,9 @@ __export(nomic_exports, {
   embedTexts: () => embedTexts,
   getEmbedding: () => getEmbedding,
   isModelAvailable: () => isModelAvailable,
-  unloadEmbedding: () => unloadEmbedding
+  unloadEmbedding: () => unloadEmbedding,
+  unloadEmbeddingResources: () => unloadEmbeddingResources,
+  withEmbedding: () => withEmbedding
 });
 async function getEmbedding() {
   if (embeddingContext) return embeddingContext;
@@ -147,23 +149,44 @@ async function getEmbedding() {
   })();
   return pendingInit;
 }
-function unloadEmbedding() {
-  if (embeddingContext) {
-    embeddingContext.dispose().catch(() => {
-    });
-    embeddingContext = null;
+async function unloadEmbeddingResources() {
+  const pending = pendingInit;
+  if (pending) {
+    try {
+      await pending;
+    } catch {
+    }
   }
-  if (modelInstance) {
-    modelInstance.dispose().catch(() => {
-    });
-    modelInstance = null;
+  const context = embeddingContext;
+  const model = modelInstance;
+  const llama = llamaInstance;
+  embeddingContext = null;
+  modelInstance = null;
+  llamaInstance = null;
+  pendingInit = null;
+  const disposals = [];
+  if (context) {
+    disposals.push(context.dispose());
   }
-  if (llamaInstance) {
-    llamaInstance.dispose().catch(() => {
-    });
-    llamaInstance = null;
+  if (model) {
+    disposals.push(model.dispose());
+  }
+  if (llama) {
+    disposals.push(llama.dispose());
+  }
+  if (disposals.length > 0) {
+    await Promise.allSettled(disposals);
+  }
+}
+function unloadEmbedding() {
+  void unloadEmbeddingResources();
+}
+async function withEmbedding(fn) {
+  try {
+    return await fn();
+  } finally {
+    await unloadEmbeddingResources();
   }
-  pendingInit = null;
 }
 async function embedText(text) {
   const ctx = await getEmbedding();
@@ -203,7 +226,9 @@ __export(embeddings_exports, {
   isModelAvailable: () => isModelAvailable,
   isModelUsable: () => isModelUsable,
   resolveModel: () => resolveModel,
-  unloadEmbedding: () => unloadEmbedding
+  unloadEmbedding: () => unloadEmbedding,
+  unloadEmbeddingResources: () => unloadEmbeddingResources,
+  withEmbedding: () => withEmbedding
 });
 var init_embeddings = __esm({
   "src/memory/embeddings/index.ts"() {
@@ -2291,7 +2316,7 @@ async function runBackgroundEmbed(repoRoot) {
   const start = Date.now();
   writeEmbedStatus(repoRoot, { state: "running", startedAt: (/* @__PURE__ */ new Date()).toISOString() });
   try {
-    const result = await embedChunks(repoRoot, { onlyMissing: true });
+    const result = await withEmbedding(async () => embedChunks(repoRoot, { onlyMissing: true }));
     writeEmbedStatus(repoRoot, {
       state: "completed",
       chunksEmbedded: result.chunksEmbedded,
@@ -2306,7 +2331,6 @@ async function runBackgroundEmbed(repoRoot) {
       durationMs: Date.now() - start
     });
   } finally {
-    unloadEmbedding();
     closeKnowledgeDb();
     lock.release();
   }
@@ -2369,8 +2393,8 @@ function parseBdShowDeps(raw) {
 init_compound();
 init_embeddings();
 init_storage();
-function registerCompoundCommands(program2) {
-  program2.command("compound").description("Synthesize cross-cutting patterns from lessons").action(async () => {
+function registerCompoundCommands(program) {
+  program.command("compound").description("Synthesize cross-cutting patterns from lessons").action(async () => {
     const repoRoot = getRepoRoot();
     const { items } = await readMemoryItems(repoRoot);
     if (items.length === 0) {
@@ -2385,18 +2409,22 @@ function registerCompoundCommands(program2) {
       return;
     }
     openDb(repoRoot);
-    const embeddings = [];
+    let embeddings;
     try {
-      for (const item of items) {
-        const text = `${item.trigger} ${item.insight}`;
-        const hash = contentHash(item.trigger, item.insight);
-        let vec = getCachedEmbedding(repoRoot, item.id, hash);
-        if (!vec) {
-          vec = await embedText(text);
-          setCachedEmbedding(repoRoot, item.id, vec, hash);
+      embeddings = await withEmbedding(async () => {
+        const vecs = [];
+        for (const item of items) {
+          const text = `${item.trigger} ${item.insight}`;
+          const hash = contentHash(item.trigger, item.insight);
+          let vec = getCachedEmbedding(repoRoot, item.id, hash);
+          if (!vec) {
+            vec = await embedText(text);
+            setCachedEmbedding(repoRoot, item.id, vec, hash);
+          }
+          vecs.push(vec);
         }
-        embeddings.push(vec);
-      }
+        return vecs;
+      });
     } catch (err) {
       console.error(`Error computing embeddings: ${err instanceof Error ? err.message : String(err)}`);
       console.error("Run: npx ca download-model");
@@ -2707,7 +2735,7 @@ function playBannerAudio() {
       return null;
     }
     proc.unref();
-    const cleanup2 = () => {
+    const cleanup = () => {
       try {
         proc.kill();
       } catch {
@@ -2729,7 +2757,7 @@ function playBannerAudio() {
       } catch {
       }
     });
-    return { stop: cleanup2 };
+    return { stop: cleanup };
   } catch {
     return null;
   }
@@ -5678,6 +5706,32 @@ $ARGUMENTS
 **MANDATORY FIRST STEP -- NON-NEGOTIABLE**: Use the Read tool to open and read \`.claude/skills/compound/researcher/SKILL.md\` NOW. Do NOT proceed until you have read the complete skill file.
 
 Then: scan docs/compound/research/ for gaps, propose topics via AskUserQuestion, spawn parallel researcher subagents.
+`,
+  "agentic-audit.md": `---
+name: compound:agentic-audit
+description: Audit codebase against the 15-principle agentic manifesto
+argument-hint: "<scope or focus area>"
+---
+$ARGUMENTS
+
+# Agentic Audit
+
+**MANDATORY FIRST STEP -- NON-NEGOTIABLE**: Use the Read tool to open and read \`.claude/skills/compound/agentic/SKILL.md\` NOW. Do NOT proceed until you have read the complete skill file.
+
+Run in **audit** mode. Score all 15 principles, produce the report, offer beads epic.
+`,
+  "agentic-setup.md": `---
+name: compound:agentic-setup
+description: Set up codebase for agentic AI development (audit-first)
+argument-hint: "<scope or focus area>"
+---
+$ARGUMENTS
+
+# Agentic Setup
+
+**MANDATORY FIRST STEP -- NON-NEGOTIABLE**: Use the Read tool to open and read \`.claude/skills/compound/agentic/SKILL.md\` NOW. Do NOT proceed until you have read the complete skill file.
+
+Run in **setup** mode. Audit first, then propose and create files to fill gaps.
 `,
   // =========================================================================
   // Utility commands (kept: learn-that, check-that, prime)
@@ -5799,7 +5853,7 @@ npx ca doctor
   settings.json                # Claude Code hooks
   plugin.json                  # Plugin manifest
   agents/compound/             # Subagent definitions
-  commands/compound/           # Slash commands (spec-dev, plan, work, review, compound, cook-it)
+  commands/compound/           # Slash commands (spec-dev, plan, work, review, compound, cook-it, agentic-audit, agentic-setup)
   skills/compound/             # Phase skills + agent role skills
   lessons/
     index.jsonl                # Memory items (git-tracked source of truth)
@@ -6160,6 +6214,22 @@ Skills are instructions that Claude reads before executing each phase. They live
 
 **What it does**: Analyzes beads epics for knowledge gaps, checks existing docs coverage, proposes research topics for user confirmation, spawns parallel researcher subagents, and stores output at \`docs/compound/research/<topic>/<slug>.md\`.
 
+### \`/compound:agentic-audit\`
+
+**Purpose**: Audit a codebase against the 15-principle Agentic Codebase Manifesto.
+
+**When invoked**: When evaluating a codebase's readiness for AI agent collaboration.
+
+**What it does**: Detects the project stack, scores all 15 principles (0-2) with specific evidence across 3 pillars (Codebase Memory, Implementation Feedbacks, Mapping the Context) plus cross-cutting concerns. Produces a scored report (out of 30) with prioritized actions and offers to create a beads epic for improvements.
+
+### \`/compound:agentic-setup\`
+
+**Purpose**: Set up a codebase for agentic AI development (runs audit first).
+
+**When invoked**: When you want to improve a codebase's agentic readiness by filling gaps.
+
+**What it does**: Runs the full audit first, then proposes concrete remediation actions for each gap found. Creates real content (AGENTS.md, docs/, ADRs, lint configs) generated from actual codebase analysis. Asks for user approval before each file creation.
+
 ---
 
 ## Skill invocation
@@ -6176,7 +6246,10 @@ Skills are invoked as Claude Code slash commands:
 /compound:research         # Spawn research subagent
 /compound:test-clean       # Clean test artifacts
 /compound:get-a-phd <focus>       # Deep research for agent knowledge
-/compound:learn            # Capture a lesson from context
+/compound:agentic-audit    # Audit codebase against agentic manifesto
+/compound:agentic-setup    # Audit then set up agentic infrastructure
+/compound:learn-that       # Conversation-aware lesson capture with confirmation
+/compound:check-that       # Search lessons and apply to current work
 /compound:prime            # Prime session with workflow context
 \`\`\`
 
@@ -6330,6 +6403,12 @@ Work is not complete until \`git push\` succeeds.
 };
 
 // src/setup/templates/skills.ts
+var _bc = "\x1B[96m";
+var _cn = "\x1B[36m";
+var _gr = "\x1B[32m";
+var _mg = "\x1B[35m";
+var _yl = "\x1B[33m";
+var _rs = "\x1B[0m";
 var PHASE_SKILLS = {
   "spec-dev": `---
 name: Spec Dev
@@ -6819,16 +6898,6 @@ description: Full-cycle orchestrator chaining all five phases with gates and con
 
 ## Overview
 
-\`\`\`
-
-\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
- \u2502\u2592\u2592\u2592\u2592\u2592\u2502
- \u2590\u259B\u2588\u2588\u2588\u259C\u258C o
-\u259D\u259C\u2588\u2588\u2588\u2588\u2588\u259B\u2598|
-  \u2598\u2598 \u259D\u259D
-Let's cook!
-\`\`\`
-
 Chain all 5 phases end-to-end: Spec Dev, Plan, Work, Review, Compound. This skill governs the orchestration -- phase sequencing, gates, progress tracking, and error recovery.
 
 ## CRITICAL RULE -- READ BEFORE EXECUTE
@@ -6841,6 +6910,29 @@ Before starting EACH phase, you MUST use the Read tool to open its skill file:
 
 Do NOT proceed from memory. Read the skill, then follow it exactly.
 
+## Session Start
+When a cooking session begins, IMMEDIATELY print the brain banner below (copy it verbatim):
+
+        ___    ___
+    .."\`)  "\`.."  "(\`\`.
+  .'; _..=. ${_bc}::${_rs} \`-'._ ;\`.
+ : ) ;"\`':._. ${_bc}::${_rs}_.      ( :.
+.:-"   _.  \`"${_cn}##${_rs}"\` "._ \`-:\\
+/."   -"\`  ._.${_bc}::${_rs}._.  .'"  ".:
+: :    ( -: \`" ${_bc}::${_rs} "\` :- )    : )
+( .":==._ ' \`'=._${_cn}##${_rs}_.=' ' _.==: .'
+(:  \`, \`"\`    \`"${_cn}##${_rs}"\`    \`"\` .'\`".)
+ \\\`'  \`"--.  "- )( -" ..--"\` \`-/
+ (" (_."\`  ="""-..."\`...-""= "._) ")
+  "..__..-"  )${_gr}%${_rs}\`..'\`${_gr}%${_rs}(  "-..__.."
+       (#"...'\\\\${_gr}%%%%${_rs}/\`..."#)
+        \`${_mg}######${_rs}\`--'${_mg}######${_rs}"
+          "${_mg}###${_rs}")${_yl}@@${_rs}(\`${_mg}###${_rs}"
+               \\${_yl}@@${_rs}/
+             Claw'd
+
+Then proceed with the protocol below.
+
 ## Phase Execution Protocol
 0. Initialize state: \`npx ca phase-check init <epic-id>\`
 For each phase:
@@ -6966,6 +7058,251 @@ Apply the agreed changes:
 - Full test suite passes after changes
 - Coverage not degraded
 - Findings captured in compound-agent memory
+`,
+  "agentic": `---
+name: Agentic Codebase
+description: Audit and set up a codebase for agentic AI development using the 15-principle manifesto
+---
+
+# Agentic Codebase Skill
+
+## Overview
+
+Assess and improve a codebase's readiness for AI agent collaboration. Based on the 15-principle Agentic Codebase Manifesto organized across 3 pillars.
+
+This skill operates in two modes:
+- **Mode: audit** -- Score the codebase against all 15 principles, produce a report with evidence and prioritized actions
+- **Mode: setup** -- Run audit first, then incrementally fill gaps with real content generated from codebase analysis
+
+Mode is set by the calling command (\\\`/compound:agentic-audit\\\` or \\\`/compound:agentic-setup\\\`). The command wrapper tells you which mode to run -- do not parse \\\`$ARGUMENTS\\\` for mode detection.
+
+## Stack Detection
+
+Before auditing, detect the project stack to adapt checks:
+1. Look for package.json (Node/TS), pyproject.toml or setup.py (Python), Cargo.toml (Rust), go.mod (Go), Makefile, CMakeLists.txt (C/C++)
+2. Check for framework markers: next.config, django, fastapi, express, etc.
+3. Identify build/test/lint commands from config files
+4. Store detected stack for use in principle checks and AGENTS.md generation
+
+## Audit Methodology
+
+### Scoring Rubric
+Each principle is scored:
+- **0 (Absent)**: No evidence of this principle in the codebase
+- **1 (Partial)**: Some evidence but incomplete or inconsistent
+- **2 (Present)**: Clear, consistent implementation
+
+Adapt criteria to the detected stack. For example: "strict mode" means TypeScript strict, Python mypy --strict, or Rust default safety. "Linter" means ESLint, pylint/ruff, clippy, golangci-lint, etc. Score based on the ecosystem's equivalent tooling.
+
+### The 15 Principles
+
+#### Pillar I: Codebase Memory (Traceability) -- max 8 points
+
+**P1. Repository is the only truth**
+Check: All context an agent needs lives in version control
+Evidence: Look for docs/ directory, inline documentation, config files
+Score 0: No docs directory, no README beyond boilerplate
+Score 1: README exists but key context lives elsewhere
+Score 2: Comprehensive docs/, config, and context all in-repo
+
+**P2. Trace decisions, not just outcomes**
+Check: Architectural decisions have recorded rationale
+Evidence: Look for docs/adr/, docs/decisions/, ADR files
+Score 0: No decision records
+Score 1: Some decisions documented but inconsistent format
+Score 2: ADR directory with structured records
+
+**P3. Never answer the same question twice**
+Check: Solutions/fixes are documented to prevent rediscovery
+Evidence: Solutions docs, post-mortems, troubleshooting guides, or a memory system
+Score 0: No solutions documentation
+Score 1: Scattered notes but no systematic approach
+Score 2: Structured solutions docs or integrated memory system
+
+**P4. Knowledge is infrastructure**
+Check: Documentation is versioned alongside code
+Evidence: Specs, research, standards co-located in repo
+Score 0: Documentation lives outside version control
+Score 1: Some docs in repo but key knowledge is external
+Score 2: All project knowledge versioned in docs/
+
+#### Pillar II: Implementation Feedbacks (Mechanical Verification) -- max 8 points
+
+**P5. Test is specification**
+Check: Tests define behavior before or alongside implementation
+Evidence: Test files, coverage tooling, test-first patterns
+Score 0: No tests or minimal coverage
+Score 1: Tests exist but post-hoc or inconsistent
+Score 2: Comprehensive test suite with test-driven patterns
+
+**P6. Constraints are multipliers**
+Check: Linters, type checkers, architectural rules configured and enforced
+Evidence: ESLint/pylint/clippy config, TypeScript strict mode, CI enforcement
+Score 0: No linting or type checking
+Score 1: Linter exists but not enforced in CI
+Score 2: Strict linting + type checking enforced in CI
+
+**P7. Write feedback for machines**
+Check: Error messages, logs, and output are structured for agent consumption
+Evidence: Structured logging, clear error messages with context
+Score 0: Unstructured logs, generic error messages
+Score 1: Some structured logging but inconsistent
+Score 2: Structured logging throughout, remediation hints in errors
+
+**P8. Fight entropy continuously**
+Check: Active maintenance processes prevent drift
+Evidence: Automated formatting, dependency updates, quality monitoring
+Score 0: No automated maintenance
+Score 1: Basic formatting but no proactive monitoring
+Score 2: Automated formatting + dependency updates + quality tracking
+
+#### Pillar III: Mapping the Context (Navigable Structure) -- max 8 points
+
+**P9. Map, not manual**
+Check: Entry point document provides a navigable map, not an encyclopedia
+Evidence: AGENTS.md, CLAUDE.md, or similar
+Score 0: No agent-facing entry point document
+Score 1: README exists but not optimized for agents
+Score 2: Dedicated AGENTS.md or CLAUDE.md with commands, structure, conventions
+
+**P10. Explicit over implicit, always**
+Check: Types, naming, patterns are explicit
+Evidence: Type annotations, consistent naming, documented conventions
+Score 0: No type annotations, inconsistent naming
+Score 1: Some types but gaps, or undocumented conventions
+Score 2: Full type coverage, documented naming conventions
+
+**P11. Modularity is non-negotiable**
+Check: Single responsibility per file, clear boundaries
+Evidence: File sizes, module organization, dependency structure
+Score 0: Monolithic files (>500 LOC common), unclear boundaries
+Score 1: Some modular structure but large files remain
+Score 2: Consistent small files, clear APIs, enforced boundaries
+
+**P12. Structure in layers, govern by inheritance**
+Check: Layered architecture with explicit dependency rules
+Evidence: Layer separation, import rules, dependency graph
+Score 0: No discernible layering
+Score 1: Informal layers but no enforcement
+Score 2: Explicit layers with enforced dependency directions
+
+#### Cross-Cutting -- max 6 points
+
+**P13. Simplicity compounds**
+Check: Prefer boring technologies, minimal abstractions
+Evidence: Dependency count, abstraction depth
+Score 0: Over-engineered with many abstractions
+Score 1: Moderate complexity, some unnecessary abstractions
+Score 2: Minimal dependencies, straightforward patterns
+
+**P14. Human designs the system, not the output**
+Check: Human effort in system design (tests, docs, constraints)
+Evidence: Quality of test harnesses, documentation, CI/CD
+Score 0: No investment in development infrastructure
+Score 1: Some tooling but gaps in key areas
+Score 2: Strong CI, testing framework, documentation system
+
+**P15. Parallelize by decomposition**
+Check: Work can be split into independent units
+Evidence: Module independence, clear interfaces, minimal coupling
+Score 0: Tightly coupled, hard to work on independently
+Score 1: Some independent modules but shared state
+Score 2: Well-decomposed with clear interfaces
+
+### Audit Execution Steps
+
+1. Run \\\`npx ca search "agentic codebase"\\\` for relevant lessons
+2. Detect project stack (see Stack Detection above)
+3. Use Glob and Grep to check for evidence of each principle:
+   - Glob for: docs/**, *.test.*, .eslintrc*, AGENTS.md, CLAUDE.md
+   - Grep for: type annotations, structured logging, ADR format
+   - Read key files: README, config files, sample source files
+4. Score each principle (0-2) with specific evidence
+5. Aggregate scores by pillar and compute total out of 30
+6. Generate prioritized actions (score-0 first, then score-1)
+7. Present report to user
+
+### Report Format
+
+Present as markdown tables per pillar:
+
+Pillar I: Codebase Memory -- X/8
+| # | Principle | Score | Evidence |
+|---|-----------|-------|----------|
+| P1 | Repository is the only truth | 0/1/2 | finding |
+...repeat for all pillars with separator rows...
+
+**Overall Score: X/30**
+
+### Priority Actions
+1. [Score-0 items first, most impactful]
+2. ...
+
+After presenting, use \\\`AskUserQuestion\\\`: "Create a beads epic with issues for improvements?"
+If yes, create epic via bd create and individual issues.
+
+## Setup Methodology
+
+### Prerequisites
+Run the full audit first. Setup only addresses gaps found by the audit.
+
+### Setup Execution Steps
+
+1. Present audit findings summary
+2. For each principle scored 0 or 1, propose a concrete action:
+
+**P1/P4 gaps**: Create docs/ skeleton (INDEX.md, adr/, standards/) with real content from analysis
+**P2 gaps**: Create ADR template and first ADR from actual architecture analysis
+**P3 gaps**: Suggest solutions documentation structure
+**P5 gaps**: Suggest test framework setup based on detected stack
+**P6 gaps**: Suggest linter/type checker configuration for detected stack
+**P7 gaps**: Suggest structured logging patterns for detected stack
+**P9 gaps**: Generate AGENTS.md by analyzing actual codebase (build commands, structure, conventions)
+**P10 gaps**: Suggest type annotation and strict mode settings
+**P11 gaps**: Identify files >500 LOC, suggest refactoring targets
+**P12 gaps**: Document layer structure and suggest import lint rules (e.g., eslint-plugin-import boundaries, Rust mod visibility)
+**P13 gaps**: Flag over-abstraction (deep inheritance, excessive wrappers), suggest simplification targets
+**P14 gaps**: Suggest CI pipeline improvements, test harness setup, or pre-commit hooks for detected stack
+**P15 gaps**: Identify tightly coupled modules, suggest interface extraction for parallel workability
+**P8 gaps**: Suggest automated formatting (prettier/black/rustfmt), dependency update tooling (renovate/dependabot), and quality monitoring
+
+3. Before each action, use \\\`AskUserQuestion\\\`: "Create [file]? Preview: [content]"
+4. Only create/modify files the user approves
+5. Never overwrite existing files without explicit approval
+
+### Setup Completion Gate
+After all approved actions are applied, verify:
+- List all files created/modified during setup
+- Run quality gates if available (\\\`pnpm test\\\`, \\\`pnpm lint\\\`, or stack equivalent)
+- Confirm no existing files were overwritten without approval
+- Present summary: principles addressed, files created, remaining gaps
+
+## Memory Integration
+
+- Before analysis: \\\`npx ca search "agentic codebase"\\\` for relevant lessons
+- After completing: offer \\\`npx ca learn\\\` to capture insights
+
+## Common Pitfalls
+
+- Scoring too generously without specific evidence for score 2
+- Generating template content instead of analyzing the actual codebase
+- Overwriting existing files without asking
+- Not detecting the project stack before generating content
+- Creating too many files at once instead of prioritizing
+- Forgetting to offer beads epic creation after audit
+
+## Quality Criteria
+
+- All 15 principles assessed with specific evidence
+- Scores justified with findings
+- Pillar totals and overall score calculated correctly
+- Actions prioritized (score-0 before score-1)
+- Stack detected and checks adapted accordingly
+- User consulted via AskUserQuestion at key decisions
+- Memory searched before analysis
+- Setup mode ran audit first
+- No files overwritten without approval
+- Generated content based on actual codebase analysis
 `
 };
 var PHASE_SKILL_REFERENCES = {
@@ -7591,12 +7928,12 @@ function registerPhaseSubcommands(phaseCheck, getDryRun, repoRoot) {
     console.log("Phase state cleaned.");
   });
 }
-function registerPhaseCheckCommand(program2) {
-  const phaseCheck = program2.command("phase-check").description("Manage cook-it phase state").option("--dry-run", "Show what would be done without making changes");
+function registerPhaseCheckCommand(program) {
+  const phaseCheck = program.command("phase-check").description("Manage cook-it phase state").option("--dry-run", "Show what would be done without making changes");
   const getDryRun = () => phaseCheck.opts().dryRun ?? false;
   const repoRoot = () => getRepoRoot();
   registerPhaseSubcommands(phaseCheck, getDryRun, repoRoot);
-  program2.command("phase-clean").description("Remove phase state file (alias for `phase-check clean`)").action(() => {
+  program.command("phase-clean").description("Remove phase state file (alias for `phase-check clean`)").action(() => {
     cleanPhaseState(repoRoot());
     console.log("Phase state cleaned.");
   });
@@ -7879,8 +8216,8 @@ async function runStopAuditHook() {
     console.log(JSON.stringify({}));
   }
 }
-function registerHooksCommand(program2) {
-  const hooksCommand = program2.command("hooks").description("Git hooks management");
+function registerHooksCommand(program) {
+  const hooksCommand = program.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) {
@@ -8805,8 +9142,8 @@ function registerClaudeSubcommand(setupCommand) {
   });
 }
 init_embeddings();
-function registerDownloadModelCommand(program2) {
-  program2.command("download-model").description("Download the embedding model for semantic search").option("--json", "Output as JSON").action(async (options) => {
+function registerDownloadModelCommand(program) {
+  program.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);
@@ -8876,8 +9213,9 @@ async function handleModelAndEmbed(repoRoot, opts) {
     } catch {
     }
     try {
+      const { withEmbedding: withEmbedding2 } = await Promise.resolve().then(() => (init_embeddings(), embeddings_exports));
       const { preWarmLessonEmbeddings: preWarmLessonEmbeddings2 } = await Promise.resolve().then(() => (init_prewarm(), prewarm_exports));
-      await preWarmLessonEmbeddings2(repoRoot);
+      await withEmbedding2(async () => preWarmLessonEmbeddings2(repoRoot));
     } catch {
     }
   }
@@ -9010,8 +9348,8 @@ function printPnpmConfigStatus2(result) {
     console.log(`  pnpm config: Added onlyBuiltDependencies [${result.added.join(", ")}]`);
   }
 }
-function registerInitCommand(program2) {
-  program2.command("init").description("Initialize compound-agent in this repository").option("--skip-agents", "Skip AGENTS.md modification").option("--skip-hooks", "Skip git hooks installation").option("--skip-claude", "Skip Claude Code hooks installation").option("--skip-model", "Skip embedding model download").option("--json", "Output result as JSON").option("--update", "Run upgrade logic on existing install").action(async function(options) {
+function registerInitCommand(program) {
+  program.command("init").description("Initialize compound-agent in this repository").option("--skip-agents", "Skip AGENTS.md modification").option("--skip-hooks", "Skip git hooks installation").option("--skip-claude", "Skip Claude Code hooks installation").option("--skip-model", "Skip embedding model download").option("--json", "Output result as JSON").option("--update", "Run upgrade logic on existing install").action(async function(options) {
     await initAction(this, options);
   });
 }
@@ -9238,14 +9576,14 @@ async function deleteAction(ids, options) {
     }
   }
 }
-function registerCrudCommands(program2) {
-  program2.command("show <id>").description("Show details of a specific lesson").option("--json", "Output as JSON").action(async (id, options) => {
+function registerCrudCommands(program) {
+  program.command("show <id>").description("Show details of a specific lesson").option("--json", "Output as JSON").action(async (id, options) => {
     await showAction(id, options);
   });
-  program2.command("update <id>").description("Update a lesson").option("--insight <text>", "Update insight").option("--trigger <text>", "Update trigger").option("--evidence <text>", "Update evidence").option("--severity <level>", "Update severity (low/medium/high)").option("--tags <tags>", "Update tags (comma-separated)").option("--confirmed <bool>", "Update confirmed status (true/false)").option("--json", "Output as JSON").action(async (id, options) => {
+  program.command("update <id>").description("Update a lesson").option("--insight <text>", "Update insight").option("--trigger <text>", "Update trigger").option("--evidence <text>", "Update evidence").option("--severity <level>", "Update severity (low/medium/high)").option("--tags <tags>", "Update tags (comma-separated)").option("--confirmed <bool>", "Update confirmed status (true/false)").option("--json", "Output as JSON").action(async (id, options) => {
     await updateAction(id, options);
   });
-  program2.command("delete <ids...>").description("Soft delete lessons (creates tombstone)").option("--json", "Output as JSON").action(async (ids, options) => {
+  program.command("delete <ids...>").description("Soft delete lessons (creates tombstone)").option("--json", "Output as JSON").action(async (ids, options) => {
     await deleteAction(ids, options);
   });
 }
@@ -9351,8 +9689,8 @@ var STATUS_ICONS = {
   fail: "FAIL",
   warn: "WARN"
 };
-function registerDoctorCommand(program2) {
-  program2.command("doctor").description("Verify external dependencies and project health").action(async () => {
+function registerDoctorCommand(program) {
+  program.command("doctor").description("Verify external dependencies and project health").action(async () => {
     const repoRoot = getRepoRoot();
     const checks = await runDoctor(repoRoot);
     console.log("Compound Agent Health Check:\n");
@@ -9378,8 +9716,8 @@ function registerDoctorCommand(program2) {
 
 // src/commands/management-invalidation.ts
 init_storage();
-function registerInvalidationCommands(program2) {
-  program2.command("wrong <id>").description("Mark a lesson as invalid/wrong").option("-r, --reason <text>", "Reason for invalidation").action(async function(id, options) {
+function registerInvalidationCommands(program) {
+  program.command("wrong <id>").description("Mark a lesson as invalid/wrong").option("-r, --reason <text>", "Reason for invalidation").action(async function(id, options) {
     const repoRoot = getRepoRoot();
     const { items } = await readMemoryItems(repoRoot);
     const lesson = items.find((l) => l.id === id);
@@ -9403,7 +9741,7 @@ function registerInvalidationCommands(program2) {
       console.log(`  Reason: ${options.reason}`);
     }
   });
-  program2.command("validate <id>").description("Re-enable a previously invalidated lesson").action(async function(id) {
+  program.command("validate <id>").description("Re-enable a previously invalidated lesson").action(async function(id) {
     const repoRoot = getRepoRoot();
     const { items } = await readMemoryItems(repoRoot);
     const lesson = items.find((l) => l.id === id);
@@ -9500,11 +9838,11 @@ async function importAction(file) {
     console.log(`Imported ${imported} ${lessonWord}`);
   }
 }
-function registerIOCommands(program2) {
-  program2.command("export").description("Export lessons as JSON to stdout").option("--since <date>", "Only include lessons created after this date (ISO8601)").option("--tags <tags>", "Filter by tags (comma-separated, OR logic)").action(async (options) => {
+function registerIOCommands(program) {
+  program.command("export").description("Export lessons as JSON to stdout").option("--since <date>", "Only include lessons created after this date (ISO8601)").option("--tags <tags>", "Filter by tags (comma-separated, OR logic)").action(async (options) => {
     await exportAction(options);
   });
-  program2.command("import <file>").description("Import lessons from a JSONL file").action(async (file) => {
+  program.command("import <file>").description("Import lessons from a JSONL file").action(async (file) => {
     await importAction(file);
   });
 }
@@ -9604,14 +9942,14 @@ async function statsAction() {
   console.log(`Retrievals: ${totalRetrievals} total, ${avgRetrievals} avg per lesson`);
   console.log(`Storage: ${formatBytes(totalSize)} (index: ${formatBytes(indexSize)}, data: ${formatBytes(dataSize)})`);
 }
-function registerMaintenanceCommands(program2) {
-  program2.command("compact").description("Compact lessons: remove tombstones and invalid records").option("-f, --force", "Run compaction even if below threshold").option("--dry-run", "Show what would be done without making changes").action(async (options) => {
+function registerMaintenanceCommands(program) {
+  program.command("compact").description("Compact lessons: remove tombstones and invalid records").option("-f, --force", "Run compaction even if below threshold").option("--dry-run", "Show what would be done without making changes").action(async (options) => {
     await compactAction(options);
   });
-  program2.command("rebuild").description("Rebuild SQLite index from JSONL").option("-f, --force", "Force rebuild even if unchanged").action(async (options) => {
+  program.command("rebuild").description("Rebuild SQLite index from JSONL").option("-f, --force", "Force rebuild even if unchanged").action(async (options) => {
     await rebuildAction(options);
   });
-  program2.command("stats").description("Show database health and statistics").action(async () => {
+  program.command("stats").description("Show database health and statistics").action(async () => {
     await statsAction();
   });
 }
@@ -9731,8 +10069,8 @@ ${formattedLessons}
   }
   return output;
 }
-function registerPrimeCommand(program2) {
-  program2.command("prime").description("Output context for Claude Code (guidelines + top lessons)").action(async () => {
+function registerPrimeCommand(program) {
+  program.command("prime").description("Output context for Claude Code (guidelines + top lessons)").action(async () => {
     const output = await getPrimeContext();
     console.log(output);
   });
@@ -9743,8 +10081,8 @@ function formatFinding(finding) {
   const filePart = finding.file ? ` ${finding.file}` : "";
   return `${label} [${finding.source}]${filePart} -- ${finding.issue}`;
 }
-function registerAuditCommands(program2) {
-  program2.command("audit").description("Run audit checks against the codebase").option("--json", "Output as JSON").option("--no-rules", "Skip rule checks").option("--no-patterns", "Skip pattern checks").option("--no-lessons", "Skip lesson checks").action(async function() {
+function registerAuditCommands(program) {
+  program.command("audit").description("Run audit checks against the codebase").option("--json", "Output as JSON").option("--no-rules", "Skip rule checks").option("--no-patterns", "Skip pattern checks").option("--no-lessons", "Skip lesson checks").action(async function() {
     const repoRoot = getRepoRoot();
     const { quiet } = getGlobalOpts(this);
     const opts = this.opts();
@@ -9840,8 +10178,8 @@ async function disableReviewer(repoRoot, name) {
 }
 
 // src/commands/reviewer.ts
-function registerReviewerCommand(program2) {
-  const reviewer = program2.command("reviewer").description("Manage external code reviewers (gemini, codex)");
+function registerReviewerCommand(program) {
+  const reviewer = program.command("reviewer").description("Manage external code reviewers (gemini, codex)");
   reviewer.command("enable <name>").description(`Enable an external reviewer (${VALID_REVIEWERS.join(", ")})`).action(async (name) => {
     const repoRoot = getRepoRoot();
     try {
@@ -9890,8 +10228,8 @@ function registerReviewerCommand(program2) {
     }
   });
 }
-function registerRulesCommands(program2) {
-  const rulesCmd = program2.command("rules").description("Run repository-defined rule checks");
+function registerRulesCommands(program) {
+  const rulesCmd = program.command("rules").description("Run repository-defined rule checks");
   rulesCmd.command("check").description("Check codebase against rules in .claude/rules.json").action(function() {
     const repoRoot = getRepoRoot();
     const { quiet } = getGlobalOpts(this);
@@ -10002,8 +10340,8 @@ function formatTestSummary(summary, logPath) {
   lines.push(`LOG: Full output at ${logPath}`);
   return lines.join("\n");
 }
-function registerTestSummaryCommand(program2) {
-  program2.command("test-summary").description("Run tests and output a compact summary").option("--fast", "Run pnpm test:fast instead of pnpm test").option("--cmd <command>", "Custom test command to run").action((options) => {
+function registerTestSummaryCommand(program) {
+  program.command("test-summary").description("Run tests and output a compact summary").option("--fast", "Run pnpm test:fast instead of pnpm test").option("--cmd <command>", "Custom test command to run").action((options) => {
     const repoRoot = getRepoRoot();
     let testCmd = "pnpm test";
     if (options.cmd) {
@@ -10098,8 +10436,8 @@ var STATUS_LABEL = {
   pass: "PASS",
   fail: "FAIL"
 };
-function registerVerifyGatesCommand(program2) {
-  program2.command("verify-gates <epic-id>").description("Verify workflow gates are satisfied before epic closure").action(async (epicId) => {
+function registerVerifyGatesCommand(program) {
+  program.command("verify-gates <epic-id>").description("Verify workflow gates are satisfied before epic closure").action(async (epicId) => {
     try {
       const checks = await runVerifyGates(epicId, { repoRoot: getRepoRoot() });
       console.log(`Gate checks for epic ${epicId}:
@@ -10129,114 +10467,37 @@ function registerVerifyGatesCommand(program2) {
 }
 
 // src/changelog-data.ts
-var CHANGELOG_RECENT = `## [1.6.1] - 2026-03-05
-
-### Changed
-
-- **Renamed brainstorm phase to spec-dev**: The \`/compound:brainstorm\` slash command is now \`/compound:spec-dev\`. The phase focuses on structured specification development using EARS notation, Mermaid diagrams, and Socratic dialogue rather than open-ended brainstorming. Old \`brainstorm.md\` command files are auto-cleaned during upgrade.
-- **Integration test stability**: Reduced integration test parallelism (\`maxForks: 1\`) and increased timeouts to 60s to eliminate non-deterministic ETIMEDOUT failures under load.
-
-### Added
-
-- **Spec reference file**: \`.claude/skills/compound/spec-dev/references/spec-guide.md\` provides quick-reference material for EARS patterns, Mermaid diagram selection, NL ambiguity detection, and trade-off documentation frameworks. Installed automatically during \`ca setup\`.
-- **Hook error visibility**: Hook runners now log errors to stderr when \`CA_DEBUG\` environment variable is set, instead of silently swallowing all failures.
-- **check-plan stdin safety**: \`ca check-plan\` now enforces a 30-second timeout and 1MB size limit when reading from stdin, preventing hangs in CI/CD environments.
-- **Embed lock expiry**: Embedding lock files now expire after 1 hour as a safety valve against zombie processes holding locks indefinitely.
-- **Phase-state backward compatibility**: Legacy \`lfg_active\` field in phase state files is automatically migrated to \`cookit_active\` on read.
-- **clean-lessons scope messaging**: \`ca clean-lessons\` now reports when non-lesson items are excluded from analysis.
+var CHANGELOG_RECENT = `## [1.6.4] - 2026-03-07
 
 ### Fixed
 
-- **Missing spec-guide.md**: The reference file was declared in skill templates and CHANGELOG but never generated during setup. Now installed alongside phase skills.
-- **Upgrade cleanup for lfg.md**: Added \`lfg.md\` to deprecated commands list so \`ca setup --update\` removes stale lfg command files from upgraded repos.
-- **Docs template terminology**: WORKFLOW.md template now uses "Spec Dev" instead of "Brainstorm" for Phase 1.
-- **Test file naming**: Renamed \`brainstorm-phase.test.ts\` to \`spec-dev-phase.test.ts\` to match the refactored phase name.
-- **Library bundle cleanup**: Moved CLI-only re-exports (\`registerWatchCommand\`, \`registerLoopCommands\`) out of the library barrel to eliminate unused import warnings in \`dist/index.js\`.
-- **plan.test.ts embedding guard**: Added \`skipIf(skipEmbedding)\` to unguarded test that calls \`retrieveForPlan\` without mocking.
-- **Agent template test count**: Updated setup.test.ts to expect 9 agent templates (was 8), matching the actual AGENT_TEMPLATES count after \`lessons-reviewer.md\` was added.
-
-## [1.6.0] - 2026-03-02
-
-### Added
-
-- **\`ca watch\` command**: Live pretty-printer for infinity loop trace files. Tails \`agent_logs/trace_*.jsonl\` and formats stream-json events (tool calls, text deltas, token usage, epic markers) with colored output. Supports \`--epic <id>\` to watch a specific epic and \`--no-follow\` for one-shot reads.
-- **Stream-json micro logging**: Generated infinity loop scripts now use \`--output-format stream-json --include-partial-messages\` to capture structured JSONL event traces alongside the existing macro text log. Trace files written to \`agent_logs/trace_<epic>-<ts>.jsonl\` with \`.latest\` symlink for easy discovery.
-- **\`/compound:learn-that\` slash command**: Conversation-aware lesson capture with user confirmation before saving
-- **\`/compound:check-that\` slash command**: Search lessons and proactively apply them to current work
-- **Eager knowledge embedding**: Knowledge chunks from \`docs/\` are now embedded for semantic search when the model is available
-  - \`ca index-docs --embed\` embeds chunks after indexing
-  - \`ca init\` now downloads the embedding model (with \`--skip-model\` opt-out) and installs the post-commit hook
-  - Background embedding spawns after \`ca init\`/\`ca setup\` so users can start working immediately
-  - PID-based lock file prevents concurrent embedding processes
-  - Status file (\`embed-status.json\`) tracks background embedding progress
-- **New modules**: \`embed-chunks.ts\`, \`embed-lock.ts\`, \`embed-status.ts\`, \`embed-background.ts\` with full test coverage
-
-### Removed
-
-- **\`/compound:learn\` slash command**: Replaced by \`/compound:learn-that\` with conversation-aware capture and user confirmation
-- **\`ca worktree\` command family**: All five subcommands (\`create\`, \`merge\`, \`list\`, \`cleanup\`, \`wire-deps\`) removed. Claude Code now provides native \`EnterWorktree\` support. Running \`ca worktree\` prints a deprecation notice.
-- **\`/compound:set-worktree\` slash command**: Use Claude Code's native worktree workflow instead.
-- **Conditional Merge gate in \`verify-gates\`**: Only Review and Compound gates remain.
-- **\`shortId\` utility**: Dead code after worktree removal, cleaned up.
+- **Embedding memory leak**: Every \`npx ca search\` spawned a process that loaded the ~150MB native embedding model. Without explicit cleanup, native threads kept processes alive as zombies. During heavy usage (Claude Code subagents), 32+ processes accumulated = 4.5GB leaked.
+  - \`withEmbedding(fn)\` scoped wrapper guarantees cleanup via try/finally. All 9 command-layer consumers migrated from manual try/finally to this single API.
+  - ESLint rule \`require-embedding-cleanup\` catches any file importing \`embedText\`/\`getEmbedding\` without a cleanup function. Scoped to \`src/commands/\` and \`src/setup/\`.
+  - \`cli-app.ts\` backstop: top-level finally in \`runProgram()\` catches anything the above two miss.
+- **\`embedText\` probe inside \`withEmbedding\` scope**: \`clean-lessons\` command was calling \`embedText\` outside of \`withEmbedding\`, leaking the model on every invocation.
+- **Agentic skill report format**: Markdown table was missing \`|---|\` separator row, rendering as plain text in some renderers.
+- **Agentic skill missing setup remediation**: 5 of 15 principles (P8, P12-P15) had no setup actions. Added concrete remediation guidance for each.
+- **Agentic skill missing completion gate**: Other skills have phase gates; the agentic skill was missing one. Added Setup Completion Gate with verification steps.
+- **Agentic skill stack-biased scoring**: Rubric was TypeScript-heavy. Added language-neutral scoring guidance (mypy, clippy, ruff equivalents).
+- **Agentic skill \`$ARGUMENTS\` dead code**: Mode is set by the calling command (\`/compound:agentic-audit\` or \`/compound:agentic-setup\`), not parsed from \`$ARGUMENTS\`.
+- **Docs template missing agentic commands**: \`SKILLS.md\` template now lists \`agentic-audit\` and \`agentic-setup\` in the command inventory.
 
-### Changed
+## [1.6.3] - 2026-03-05
 
-- **Loop script uses piped stream splitting**: Claude invocation changed from \`&>\` capture to a \`tee | extract_text\` pipeline. Raw JSONL streams to trace file while extracted text feeds the macro log for marker detection. Backwards compatible \u2014 all existing markers (EPIC_COMPLETE, EPIC_FAILED, HUMAN_REQUIRED) still work.
-- **\`ca setup --update\` now cleans deprecated paths**: Automatically removes stale worktree skill/command files from \`.claude/\` and \`.gemini/\` directories.
-- **\`ca setup\` also cleans deprecated paths**: Fresh setup runs now remove stale files from prior versions.
-- **SKILLS.md template**: Command inventory now lists all 11 slash commands (was 7).
+### Changed
 
-### Fixed
+- **Cook-it session banner**: Replaced "Claude the Cooker" chef ASCII art with rscr's detailed front-view brain ASCII art ("Claw'd"). Brain features ANSI-colored augmentation zones: cyan neural interface (\`##\`), bright cyan signal crosslinks (\`::\`), green bio-circuits (\`%\`), magenta data highways (\`######\`), and yellow power nodes (\`@@\`).
 
-- **Eager embedding hardening** (production readiness fixes from triple review):
-  - **P0**: Background worker spawn now resolves \`dist/cli.js\` deterministically instead of relying on \`npx ca\` (which failed silently in dev/built contexts)
-  - **P0**: \`embed-worker\` command hidden from \`ca --help\` output
-  - **P1**: Stale lock recovery uses atomic delete-then-\`wx\` to prevent two processes both reclaiming
-  - **P1**: DB connection opened after lock acquisition to prevent leak on contention
-  - **P1**: \`--embed\` now throws when model unavailable (was silently returning 0)
-  - **P2**: Batch embedding (16 chunks per call) with per-batch SQLite transactions (was 1 fsync per row)
-  - **P2**: \`EmbedStatus\` rewritten as discriminated union; removed dead \`chunksTotal\` field
-  - **P2**: \`readLock\` validates JSON shape instead of blind \`as\` cast
-  - **P2**: Vector batch length assertion guards against short responses from embedding backend
-  - **P3**: Extracted \`indexAndSpawnEmbed()\` shared helper \u2014 \`init.ts\` and \`all.ts\` no longer duplicate logic
-  - **P3**: \`ca setup\` now prints feedback when background embedding spawns
-  - **P3**: \`filesErrored\` count shown in \`ca index-docs\` output
-  - **P3**: Barrel re-exports consolidated through \`./memory/knowledge/index.js\`
-- **\`EPIC_ID_PATTERN\` duplication**: \`loop.ts\` now uses distinctly named \`LOOP_EPIC_ID_PATTERN\` to avoid confusion with the canonical pattern in \`cli-utils.ts\`.
-- **Stale worktree lesson invalidated**: Memory item \`Ld204372e\` marked invalid to prevent irrelevant context injection.
-
-### Performance
-
-- **Eliminate double model initialization**: \`ca search\` now uses \`isModelAvailable()\` (fs.existsSync, zero cost) instead of \`isModelUsable()\` which loaded the 278MB native model just to probe availability, then loaded it again for actual embedding
-- **Bulk-read cached embeddings**: \`getCachedEmbeddingsBulk()\` replaces N individual \`getCachedEmbedding()\` SQLite queries with a single bulk read
-- **Eliminate redundant JSONL parsing**: \`searchVector()\` and \`findSimilarLessons()\` now use \`readAllFromSqlite()\` after \`syncIfNeeded()\` instead of re-parsing the JSONL file
-- **Float32Array consistency**: Lesson embedding path now keeps \`Float32Array\` from node-llama-cpp instead of converting via \`Array.from()\` (4x memory savings per vector)
-- **Pre-warm lesson embedding cache**: \`ca init\` now pre-computes embeddings for all lessons with missing or stale cache entries, eliminating cold-start latency on first search
-- **Graceful embedding fallback**: \`ca search\` falls back to keyword-only search on runtime embedding failures instead of crashing
-
-## [1.5.0] - 2026-02-24
-
-### Added
-
-- **Gemini CLI compatibility adapter**: \`ca setup gemini\` scaffolds \`.gemini/\` directory with hook scripts, TOML slash commands, and inlined skills -- bridging compound-agent to work with Google's Gemini CLI via the Adapter Pattern
-- **Gemini hooks**: Maps SessionStart, BeforeAgent, BeforeTool, AfterTool to compound-agent's existing hook pipeline (\`ca prime\`, \`ca hooks run user-prompt\`, \`ca hooks run phase-guard\`, \`ca hooks run post-tool-success\`)
-- **Gemini TOML commands**: Auto-generates \`.gemini/commands/compound/*.toml\` using \`@{path}\` file injection to maintain a single source of truth with Claude commands
-- **Gemini skills proxying**: Inlines phase and agent role skill content into \`.gemini/skills/\` with YAML frontmatter
-- **23 integration tests** for the Gemini adapter covering hooks, settings.json, TOML commands, skills, and dry-run mode
+## [1.6.2] - 2026-03-05
 
 ### Fixed
 
-- **Gemini hook stderr leak**: Corrected \`2>&1 > /dev/null\` (leaks stderr to stdout, corrupting JSON) to \`> /dev/null 2>&1\`
-- **Gemini TOML file injection syntax**: Changed \`@path\` to \`@{path}\` (Gemini CLI requires curly braces)
-- **Gemini skill file injection**: Skills now inline content instead of using \`@{path}\` which only works in TOML prompt fields, not SKILL.md
-- **Gemini phase guard always allowing**: Hook now checks \`ca hooks run phase-guard\` exit code and returns structured \`{"decision": "deny"}\` on failure (exit 0, not exit 2, so Gemini parses the reason from stdout)
-- **Gemini BeforeTool matcher incomplete**: Added \`create_file\` to BeforeTool and AfterTool matchers alongside \`replace\` and \`write_file\`
-- **TOML description escaping**: \`parseDescription\` now escapes \`\\\` and \`"\` to prevent malformed TOML output
-- **Flaky embedding test**: Added 15s timeout to \`isModelUsable\` test`;
+- **Cook-it session banner**: The cook-it skill now instructs Claude to print the "Claude the Cooker" ASCII chef banner at the very start of every cooking session.`;
 
 // src/commands/about.ts
-function registerAboutCommand(program2) {
-  program2.command("about").description("Show version, animation, and recent changelog").action(async () => {
+function registerAboutCommand(program) {
+  program.command("about").description("Show version, animation, and recent changelog").action(async () => {
     if (process.stdout.isTTY) {
       await playInstallBanner();
     } else {
@@ -10248,22 +10509,23 @@ function registerAboutCommand(program2) {
 }
 
 // src/commands/knowledge.ts
+init_embeddings();
 init_sqlite_knowledge();
 var MAX_DISPLAY_TEXT = 200;
-function registerKnowledgeCommand(program2) {
-  program2.command("knowledge <query>").description("Search docs knowledge base").option("-n, --limit <number>", "Maximum results", "6").action(async function(query, opts) {
+function registerKnowledgeCommand(program) {
+  program.command("knowledge <query>").description("Search docs knowledge base").option("-n, --limit <number>", "Maximum results", "6").action(async function(query, opts) {
     const globalOpts = getGlobalOpts(this);
+    let limit;
+    try {
+      limit = parseLimit(opts.limit, "limit");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Invalid limit";
+      console.error(formatError("knowledge", "INVALID_LIMIT", message, "Use -n with a positive integer"));
+      process.exitCode = 1;
+      return;
+    }
+    const repoRoot = getRepoRoot();
     try {
-      let limit;
-      try {
-        limit = parseLimit(opts.limit, "limit");
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Invalid limit";
-        console.error(formatError("knowledge", "INVALID_LIMIT", message, "Use -n with a positive integer"));
-        process.exitCode = 1;
-        return;
-      }
-      const repoRoot = getRepoRoot();
       openKnowledgeDb(repoRoot);
       if (getChunkCount(repoRoot) === 0) {
         try {
@@ -10279,7 +10541,7 @@ function registerKnowledgeCommand(program2) {
           out.info(`Auto-index failed (${msg}). Run manually: npx ca index-docs`);
         }
       }
-      const results = await searchKnowledge(repoRoot, query, { limit });
+      const results = await withEmbedding(async () => searchKnowledge(repoRoot, query, { limit }));
       if (results.length === 0) {
         out.info("No matching results found.");
         return;
@@ -10307,15 +10569,15 @@ function registerKnowledgeCommand(program2) {
 // src/commands/knowledge-index.ts
 init_embeddings();
 init_sqlite_knowledge();
-function registerKnowledgeIndexCommand(program2) {
-  program2.command("index-docs").description("Index docs/ directory into knowledge base").option("--force", "Re-index all files (ignore cache)").option("--embed", "Embed chunks for semantic search").action(async function(options) {
+function registerKnowledgeIndexCommand(program) {
+  program.command("index-docs").description("Index docs/ directory into knowledge base").option("--force", "Re-index all files (ignore cache)").option("--embed", "Embed chunks for semantic search").action(async function(options) {
     const repoRoot = getRepoRoot();
     out.info("Indexing docs/ directory...");
     try {
-      const result = await indexDocs(repoRoot, {
+      const result = await withEmbedding(async () => indexDocs(repoRoot, {
         force: options.force,
         embed: options.embed
-      });
+      }));
       const skippedPart = result.filesSkipped > 0 ? ` (${result.filesSkipped} skipped)` : "";
       const deletedPart = result.chunksDeleted > 0 ? `, ${result.chunksDeleted} deleted` : "";
       const duration = (result.durationMs / 1e3).toFixed(1);
@@ -10330,11 +10592,10 @@ function registerKnowledgeIndexCommand(program2) {
       }
       out.info(`Duration: ${duration}s`);
     } finally {
-      unloadEmbedding();
       closeKnowledgeDb();
     }
   });
-  program2.command("embed-worker <repoRoot>", { hidden: true }).description("Internal: background embedding worker").action(async (repoRoot) => {
+  program.command("embed-worker <repoRoot>", { hidden: true }).description("Internal: background embedding worker").action(async (repoRoot) => {
     const { runBackgroundEmbed: runBackgroundEmbed2 } = await Promise.resolve().then(() => (init_embed_background(), embed_background_exports));
     await runBackgroundEmbed2(repoRoot);
   });
@@ -10401,22 +10662,21 @@ async function cleanLessonsAction() {
     process.exitCode = 1;
     return;
   }
-  try {
-    await embedText("test");
-  } catch (e) {
-    console.error(
-      formatError(
-        "clean-lessons",
-        "MODEL_UNUSABLE",
-        `Embedding model failed to initialize: ${e instanceof Error ? e.message : String(e)}`,
-        "Check model compatibility"
-      )
-    );
-    process.exitCode = 1;
-    unloadEmbedding();
-    return;
-  }
-  try {
+  await withEmbedding(async () => {
+    try {
+      await embedText("test");
+    } catch (e) {
+      console.error(
+        formatError(
+          "clean-lessons",
+          "MODEL_UNUSABLE",
+          `Embedding model failed to initialize: ${e instanceof Error ? e.message : String(e)}`,
+          "Check model compatibility"
+        )
+      );
+      process.exitCode = 1;
+      return;
+    }
     await syncIfNeeded(repoRoot);
     const { items } = await readMemoryItems(repoRoot);
     const activeItems = items.filter((item) => !item.invalidatedAt && item.type === "lesson");
@@ -10429,12 +10689,10 @@ async function cleanLessonsAction() {
       return;
     }
     printReport(pairs);
-  } finally {
-    unloadEmbedding();
-  }
+  });
 }
-function registerCleanLessonsCommand(program2) {
-  program2.command("clean-lessons").description("Analyze lessons for semantic duplicates and contradictions").action(cleanLessonsAction);
+function registerCleanLessonsCommand(program) {
+  program.command("clean-lessons").description("Analyze lessons for semantic duplicates and contradictions").action(cleanLessonsAction);
 }
 
 // src/commands/capture.ts
@@ -10561,9 +10819,9 @@ async function checkSimilarityPostCapture(repoRoot, item) {
     if (!isModelAvailable2()) return;
     const { syncIfNeeded: syncIfNeeded2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
     const { findSimilarLessons: findSimilarLessons2 } = await Promise.resolve().then(() => (init_vector(), vector_exports));
-    const { embedText: embedText2, unloadEmbedding: unloadEmbedding2 } = await Promise.resolve().then(() => (init_nomic(), nomic_exports));
+    const { embedText: embedText2, withEmbedding: withEmbedding2 } = await Promise.resolve().then(() => (init_nomic(), nomic_exports));
     const chalk6 = await import('chalk');
-    try {
+    await withEmbedding2(async () => {
       await embedText2("test");
       await syncIfNeeded2(repoRoot);
       const similar = await findSimilarLessons2(repoRoot, item.insight, { excludeId: item.id });
@@ -10576,9 +10834,7 @@ async function checkSimilarityPostCapture(repoRoot, item) {
         console.log("");
         console.log(`Run ${chalk6.default.bold("'npx ca clean-lessons'")} to review and resolve.`);
       }
-    } finally {
-      unloadEmbedding2();
-    }
+    });
   } catch (err) {
     if (process.env["CA_DEBUG"]) {
       process.stderr.write(`[CA_DEBUG] checkSimilarityPostCapture catch: ${err instanceof Error ? err.message : String(err)}
@@ -10706,17 +10962,18 @@ async function handleCapture(cmd, options) {
     outputCapturePreview(lesson);
   }
 }
-function registerCaptureCommands(program2) {
-  program2.command("learn <insight>").description("Capture a new memory item (lesson, solution, pattern, or preference)").option("-t, --trigger <text>", "What triggered this lesson").option("--tags <tags>", "Comma-separated tags", "").option("-s, --severity <level>", "Lesson severity: high, medium, low").option("-y, --yes", "Skip confirmation").option("--citation <file:line>", "Source file (optionally with :line number)").option("--citation-commit <hash>", "Git commit hash for citation").option("--type <type>", "Memory item type: lesson, solution, pattern, preference", "lesson").option("--pattern-bad <code>", "Bad pattern example (required when --type pattern)").option("--pattern-good <code>", "Good pattern example (required when --type pattern)").action(async function(insight, options) {
+function registerCaptureCommands(program) {
+  program.command("learn <insight>").description("Capture a new memory item (lesson, solution, pattern, or preference)").option("-t, --trigger <text>", "What triggered this lesson").option("--tags <tags>", "Comma-separated tags", "").option("-s, --severity <level>", "Lesson severity: high, medium, low").option("-y, --yes", "Skip confirmation").option("--citation <file:line>", "Source file (optionally with :line number)").option("--citation-commit <hash>", "Git commit hash for citation").option("--type <type>", "Memory item type: lesson, solution, pattern, preference", "lesson").option("--pattern-bad <code>", "Bad pattern example (required when --type pattern)").option("--pattern-good <code>", "Good pattern example (required when --type pattern)").action(async function(insight, options) {
     await handleLearn(this, insight, options);
   });
-  program2.command("detect").description("Detect learning triggers from input").requiredOption("--input <file>", "Path to JSON input file").option("--save", "Save proposed lesson (requires --yes)").option("-y, --yes", "Confirm save (required with --save)").option("--json", "Output result as JSON").action(async (options) => {
+  program.command("detect").description("Detect learning triggers from input").requiredOption("--input <file>", "Path to JSON input file").option("--save", "Save proposed lesson (requires --yes)").option("-y, --yes", "Confirm save (required with --save)").option("--json", "Output result as JSON").action(async (options) => {
     await handleDetect(options);
   });
-  program2.command("capture").description("Capture a lesson from trigger/insight or input file").option("-t, --trigger <text>", "What triggered this lesson").option("-i, --insight <text>", "The insight or lesson learned").option("--input <file>", "Path to JSON input file (alternative to trigger/insight)").option("--json", "Output result as JSON").option("-y, --yes", "Skip confirmation and save immediately").action(async function(options) {
+  program.command("capture").description("Capture a lesson from trigger/insight or input file").option("-t, --trigger <text>", "What triggered this lesson").option("-i, --insight <text>", "The insight or lesson learned").option("--input <file>", "Path to JSON input file (alternative to trigger/insight)").option("--json", "Output result as JSON").option("-y, --yes", "Skip confirmation and save immediately").action(async function(options) {
     await handleCapture(this, options);
   });
 }
+init_embeddings();
 init_storage();
 init_search2();
 function parseLimitOrNull(rawLimit, optionName, commandName) {
@@ -10812,23 +11069,23 @@ async function searchAction(cmd, query, options) {
   }
   const { verbose, quiet } = getGlobalOpts(cmd);
   await syncIfNeeded(repoRoot);
-  let results;
-  if (isModelAvailable()) {
-    try {
-      const candidateLimit = limit * CANDIDATE_MULTIPLIER;
-      const [vectorResults, keywordResults] = await Promise.all([
-        searchVector(repoRoot, query, { limit: candidateLimit }),
-        searchKeywordScored(repoRoot, query, candidateLimit)
-      ]);
-      const merged = mergeHybridResults(vectorResults, keywordResults, { minScore: MIN_HYBRID_SCORE });
-      const ranked = rankLessons(merged);
-      results = ranked.slice(0, limit).map((r) => r.lesson);
-    } catch {
-      results = await searchKeyword(repoRoot, query, limit);
+  const results = await withEmbedding(async () => {
+    if (isModelAvailable()) {
+      try {
+        const candidateLimit = limit * CANDIDATE_MULTIPLIER;
+        const [vectorResults, keywordResults] = await Promise.all([
+          searchVector(repoRoot, query, { limit: candidateLimit }),
+          searchKeywordScored(repoRoot, query, candidateLimit)
+        ]);
+        const merged = mergeHybridResults(vectorResults, keywordResults, { minScore: MIN_HYBRID_SCORE });
+        const ranked = rankLessons(merged);
+        return ranked.slice(0, limit).map((r) => r.lesson);
+      } catch {
+        return await searchKeyword(repoRoot, query, limit);
+      }
     }
-  } else {
-    results = await searchKeyword(repoRoot, query, limit);
-  }
+    return await searchKeyword(repoRoot, query, limit);
+  });
   if (results.length > 0) {
     incrementRetrievalCount(repoRoot, results.map((lesson) => lesson.id));
   }
@@ -10962,7 +11219,7 @@ async function checkPlanAction(cmd, options) {
     return;
   }
   try {
-    const result = await retrieveForPlan(repoRoot, planText, limit);
+    const result = await withEmbedding(async () => retrieveForPlan(repoRoot, planText, limit));
     if (options.json) {
       outputCheckPlanJson(result.lessons);
       return;
@@ -10986,48 +11243,48 @@ async function checkPlanAction(cmd, options) {
     process.exitCode = 1;
   }
 }
-function registerRetrievalCommands(program2) {
-  program2.command("search <query>").description("Search lessons").option("-n, --limit <number>", "Maximum results", DEFAULT_SEARCH_LIMIT).action(async function(query, options) {
+function registerRetrievalCommands(program) {
+  program.command("search <query>").description("Search lessons").option("-n, --limit <number>", "Maximum results", DEFAULT_SEARCH_LIMIT).action(async function(query, options) {
     await searchAction(this, query, options);
   });
-  program2.command("list").description("List all lessons").option("-n, --limit <number>", "Maximum results", DEFAULT_LIST_LIMIT).option("--invalidated", "Show only invalidated lessons").action(async function(options) {
+  program.command("list").description("List all lessons").option("-n, --limit <number>", "Maximum results", DEFAULT_LIST_LIMIT).option("--invalidated", "Show only invalidated lessons").action(async function(options) {
     await listAction(this, options);
   });
-  program2.command("load-session").description("Load high-severity lessons for session context").option("--json", "Output as JSON").action(async function(options) {
+  program.command("load-session").description("Load high-severity lessons for session context").option("--json", "Output as JSON").action(async function(options) {
     await loadSessionAction(this, options);
   });
-  program2.command("check-plan").description("Check plan against relevant lessons").option("--plan <text>", "Plan text to check").option("--json", "Output as JSON").option("-n, --limit <number>", "Maximum results", DEFAULT_CHECK_PLAN_LIMIT).action(async function(options) {
+  program.command("check-plan").description("Check plan against relevant lessons").option("--plan <text>", "Plan text to check").option("--json", "Output as JSON").option("-n, --limit <number>", "Maximum results", DEFAULT_CHECK_PLAN_LIMIT).action(async function(options) {
     await checkPlanAction(this, options);
   });
 }
 
 // src/commands/index.ts
-function registerSetupCommands(program2) {
-  registerInitCommand(program2);
-  registerHooksCommand(program2);
-  const setupCommand = program2.command("setup");
+function registerSetupCommands(program) {
+  registerInitCommand(program);
+  registerHooksCommand(program);
+  const setupCommand = program.command("setup");
   registerSetupAllCommand(setupCommand);
   registerClaudeSubcommand(setupCommand);
   registerGeminiSubcommand(setupCommand);
-  registerDownloadModelCommand(program2);
-}
-function registerManagementCommands(program2) {
-  registerInvalidationCommands(program2);
-  registerMaintenanceCommands(program2);
-  registerIOCommands(program2);
-  registerPrimeCommand(program2);
-  registerCrudCommands(program2);
-  registerAuditCommands(program2);
-  registerDoctorCommand(program2);
-  registerReviewerCommand(program2);
-  registerRulesCommands(program2);
-  registerTestSummaryCommand(program2);
-  registerVerifyGatesCommand(program2);
-  registerAboutCommand(program2);
-  registerKnowledgeCommand(program2);
-  registerKnowledgeIndexCommand(program2);
-  registerCleanLessonsCommand(program2);
-  program2.command("worktree").description("(removed) Use Claude Code native worktree support").action(() => {
+  registerDownloadModelCommand(program);
+}
+function registerManagementCommands(program) {
+  registerInvalidationCommands(program);
+  registerMaintenanceCommands(program);
+  registerIOCommands(program);
+  registerPrimeCommand(program);
+  registerCrudCommands(program);
+  registerAuditCommands(program);
+  registerDoctorCommand(program);
+  registerReviewerCommand(program);
+  registerRulesCommands(program);
+  registerTestSummaryCommand(program);
+  registerVerifyGatesCommand(program);
+  registerAboutCommand(program);
+  registerKnowledgeCommand(program);
+  registerKnowledgeIndexCommand(program);
+  registerCleanLessonsCommand(program);
+  program.command("worktree").description("(removed) Use Claude Code native worktree support").action(() => {
     console.error("ca worktree has been removed. Use Claude Code's native EnterWorktree support instead.");
     process.exitCode = 1;
   });
@@ -11376,8 +11633,8 @@ async function handleLoop(cmd, options) {
   out.info("Run it with: " + outputPath);
   out.info("Preview with: LOOP_DRY_RUN=1 " + outputPath);
 }
-function registerLoopCommands(program2) {
-  program2.command("loop").description("Generate infinity loop script for epic tasks").option("--epics <ids...>", "Specific epic IDs to process").option("-o, --output <path>", "Output script path", "./infinity-loop.sh").option("--max-retries <n>", "Max retries per epic on failure", "1").option("--model <model>", "Claude model to use", "claude-opus-4-6").option("--force", "Overwrite existing script").action(async function(options) {
+function registerLoopCommands(program) {
+  program.command("loop").description("Generate infinity loop script for epic tasks").option("--epics <ids...>", "Specific epic IDs to process").option("-o, --output <path>", "Output script path", "./infinity-loop.sh").option("--max-retries <n>", "Max retries per epic on failure", "1").option("--model <model>", "Claude model to use", "claude-opus-4-6").option("--force", "Overwrite existing script").action(async function(options) {
     await handleLoop(this, options);
   });
 }
@@ -11484,15 +11741,15 @@ async function tailFile(filePath, follow) {
     const child = spawn("tail", ["-f", "-n", "+1", filePath], { stdio: ["ignore", "pipe", "ignore"] });
     const rl2 = createInterface({ input: child.stdout });
     rl2.on("line", processLine);
-    const cleanup2 = () => {
+    const cleanup = () => {
       child.kill("SIGTERM");
     };
-    process.on("SIGINT", cleanup2);
-    process.on("SIGTERM", cleanup2);
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
     return new Promise((done) => {
       child.on("close", () => {
-        process.off("SIGINT", cleanup2);
-        process.off("SIGTERM", cleanup2);
+        process.off("SIGINT", cleanup);
+        process.off("SIGTERM", cleanup);
         done();
       });
     });
@@ -11547,8 +11804,8 @@ async function handleWatch(cmd, options) {
   out.info(`Watching: ${traceFile}`);
   await tailFile(traceFile, follow);
 }
-function registerWatchCommand(program2) {
-  program2.command("watch").description("Tail and pretty-print live trace from infinity loop sessions").option("--epic <id>", "Watch a specific epic trace").option("--no-follow", "Print existing trace and exit (no live tail)").action(async function(options) {
+function registerWatchCommand(program) {
+  program.command("watch").description("Tail and pretty-print live trace from infinity loop sessions").option("--epic <id>", "Watch a specific epic trace").option("--no-follow", "Print existing trace and exit (no live tail)").action(async function(options) {
     await handleWatch(this, options);
   });
 }
@@ -11596,7 +11853,8 @@ function commandNeedsSqlite(cmd) {
   return false;
 }
 
-// src/cli.ts
+// src/cli-app.ts
+init_embeddings();
 init_storage();
 function detectPackageManager(cwd) {
   if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
@@ -11660,46 +11918,62 @@ function printBuildToolsHint() {
   }
 }
 
-// src/cli.ts
-function cleanup() {
+// src/cli-app.ts
+async function cleanupCliResources() {
+  try {
+    await unloadEmbeddingResources();
+  } catch {
+  }
   try {
     closeDb();
   } catch {
   }
 }
-process.on("SIGINT", () => {
-  cleanup();
-  process.exit(0);
-});
-process.on("SIGTERM", () => {
-  cleanup();
-  process.exit(0);
-});
-var program = new Command();
-program.option("-v, --verbose", "Show detailed output").option("-q, --quiet", "Suppress non-essential output");
-program.name("ca").description("Semantically-intelligent workflow plugin for Claude Code").version(VERSION);
-registerCaptureCommands(program);
-registerRetrievalCommands(program);
-registerManagementCommands(program);
-registerSetupCommands(program);
-registerCompoundCommands(program);
-registerLoopCommands(program);
-registerWatchCommand(program);
-registerPhaseCheckCommand(program);
-program.hook("preAction", (_thisCommand, actionCommand) => {
-  if (!commandNeedsSqlite(actionCommand)) return;
-  try {
-    ensureSqliteAvailable();
-  } catch (err) {
-    let root;
+function attachSignalHandlers() {
+  const handleSignal = (exitCode) => {
+    void cleanupCliResources().finally(() => process.exit(exitCode));
+  };
+  process.on("SIGINT", () => handleSignal(0));
+  process.on("SIGTERM", () => handleSignal(0));
+}
+function createProgram() {
+  const program = new Command();
+  program.option("-v, --verbose", "Show detailed output").option("-q, --quiet", "Suppress non-essential output");
+  program.name("ca").description("Semantically-intelligent workflow plugin for Claude Code").version(VERSION);
+  registerCaptureCommands(program);
+  registerRetrievalCommands(program);
+  registerManagementCommands(program);
+  registerSetupCommands(program);
+  registerCompoundCommands(program);
+  registerLoopCommands(program);
+  registerWatchCommand(program);
+  registerPhaseCheckCommand(program);
+  program.hook("preAction", (_thisCommand, actionCommand) => {
+    if (!commandNeedsSqlite(actionCommand)) return;
     try {
-      root = getRepoRoot();
-    } catch {
+      ensureSqliteAvailable();
+    } catch (err) {
+      let root;
+      try {
+        root = getRepoRoot();
+      } catch {
+      }
+      printNativeBuildDiagnostic(err, root);
+      process.exit(1);
     }
-    printNativeBuildDiagnostic(err, root);
-    process.exit(1);
+  });
+  return program;
+}
+async function runProgram(program, argv = process.argv) {
+  try {
+    await program.parseAsync(argv);
+  } finally {
+    await cleanupCliResources();
   }
-});
-program.parse();
+}
+
+// src/cli.ts
+attachSignalHandlers();
+await runProgram(createProgram());
 //# sourceMappingURL=cli.js.map
 //# sourceMappingURL=cli.js.map