@nathapp/nax 0.35.0 → 0.36.1

package/dist/nax.js

@@ -2552,22 +2552,9 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
-// src/agents/types.ts
-var CompleteError;
-var init_types = __esm(() => {
-  CompleteError = class CompleteError extends Error {
-    exitCode;
-    constructor(message, exitCode) {
-      super(message);
-      this.exitCode = exitCode;
-      this.name = "CompleteError";
-    }
-  };
-});
-
 // src/logging/types.ts
 var EMOJI;
-var init_types2 = __esm(() => {
+var init_types = __esm(() => {
   EMOJI = {
     success: "\u2713",
     failure: "\u2717",
@@ -2820,13 +2807,13 @@ function createNoopChalk() {
 }
 var init_formatter = __esm(() => {
   init_source();
-  init_types2();
+  init_types();
 });
 
 // src/logging/index.ts
 var init_logging = __esm(() => {
   init_formatter();
-  init_types2();
+  init_types();
 });
 
 // src/logger/formatters.ts
@@ -3037,6 +3024,636 @@ var init_logger2 = __esm(() => {
   init_formatters();
 });
 
+// src/acceptance/generator.ts
+function parseAcceptanceCriteria(specContent) {
+  const criteria = [];
+  const lines = specContent.split(`
+`);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+    const acMatch = line.match(/^\s*-?\s*(?:\[.\])?\s*(AC-\d+):\s*(.+)$/i);
+    if (acMatch) {
+      const id = acMatch[1].toUpperCase();
+      const text = acMatch[2].trim();
+      criteria.push({
+        id,
+        text,
+        lineNumber
+      });
+    }
+  }
+  return criteria;
+}
+function buildAcceptanceTestPrompt(criteria, featureName, codebaseContext) {
+  const criteriaList = criteria.map((ac) => `${ac.id}: ${ac.text}`).join(`
+`);
+  return `You are a test engineer. Generate acceptance tests for the "${featureName}" feature based on the acceptance criteria below.
+
+CODEBASE CONTEXT:
+${codebaseContext}
+
+ACCEPTANCE CRITERIA:
+${criteriaList}
+
+Generate a complete acceptance.test.ts file using bun:test framework. Follow these rules:
+
+1. **One test per AC**: Each acceptance criterion maps to exactly one test
+2. **Test observable behavior only**: No implementation details, only user-facing behavior
+3. **Independent tests**: No shared state between tests
+4. **Integration-level**: Tests should be runnable without mocking (use real implementations)
+5. **Clear test names**: Use format "AC-N: <description>" for test names
+6. **Async where needed**: Use async/await for operations that may be asynchronous
+
+Use this structure:
+
+\`\`\`typescript
+import { describe, test, expect } from "bun:test";
+
+describe("${featureName} - Acceptance Tests", () => {
+  test("AC-1: <description>", async () => {
+    // Test implementation
+  });
+
+  test("AC-2: <description>", async () => {
+    // Test implementation
+  });
+});
+\`\`\`
+
+**Important**:
+- Import the feature code being tested
+- Set up any necessary test fixtures
+- Use expect() assertions to verify behavior
+- Clean up resources if needed (close connections, delete temp files)
+
+Respond with ONLY the TypeScript test code (no markdown code fences, no explanation).`;
+}
+async function generateAcceptanceTests(adapter, options) {
+  const logger = getLogger();
+  const criteria = parseAcceptanceCriteria(options.specContent);
+  if (criteria.length === 0) {
+    logger.warn("acceptance", "\u26A0 No acceptance criteria found in spec.md");
+    return {
+      testCode: generateSkeletonTests(options.featureName, []),
+      criteria: []
+    };
+  }
+  logger.info("acceptance", "Found acceptance criteria", { count: criteria.length });
+  const prompt = buildAcceptanceTestPrompt(criteria, options.featureName, options.codebaseContext);
+  try {
+    const skipPerms = options.config.quality?.dangerouslySkipPermissions ?? true;
+    const permArgs = skipPerms ? ["--dangerously-skip-permissions"] : [];
+    const cmd = [adapter.binary, "--model", options.modelDef.model, ...permArgs, "-p", prompt];
+    const proc = Bun.spawn(cmd, {
+      cwd: options.workdir,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: {
+        ...process.env,
+        ...options.modelDef.env || {}
+      }
+    });
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    if (exitCode !== 0) {
+      logger.warn("acceptance", "\u26A0 Agent test generation failed", { stderr });
+      return {
+        testCode: generateSkeletonTests(options.featureName, criteria),
+        criteria
+      };
+    }
+    const testCode = extractTestCode(stdout);
+    return {
+      testCode,
+      criteria
+    };
+  } catch (error) {
+    logger.warn("acceptance", "\u26A0 Agent test generation error", { error: error.message });
+    return {
+      testCode: generateSkeletonTests(options.featureName, criteria),
+      criteria
+    };
+  }
+}
+function extractTestCode(output) {
+  const fenceMatch = output.match(/```(?:typescript|ts)?\s*([\s\S]*?)\s*```/);
+  if (fenceMatch) {
+    return fenceMatch[1].trim();
+  }
+  const importMatch = output.match(/import\s+{[\s\S]+/);
+  if (importMatch) {
+    return importMatch[0].trim();
+  }
+  return output.trim();
+}
+function generateSkeletonTests(featureName, criteria) {
+  const tests = criteria.map((ac) => {
+    return `  test("${ac.id}: ${ac.text}", async () => {
+    // TODO: Implement acceptance test for ${ac.id}
+    // ${ac.text}
+    expect(true).toBe(false); // Replace with actual test
+  });`;
+  }).join(`
+
+`);
+  return `import { describe, test, expect } from "bun:test";
+
+describe("${featureName} - Acceptance Tests", () => {
+${tests || "  // No acceptance criteria found"}
+});
+`;
+}
+var init_generator = __esm(() => {
+  init_logger2();
+});
+
+// src/acceptance/fix-generator.ts
+function findRelatedStories(failedAC, prd) {
+  const relatedStoryIds = [];
+  for (const story of prd.userStories) {
+    for (const ac of story.acceptanceCriteria) {
+      if (ac.includes(failedAC)) {
+        relatedStoryIds.push(story.id);
+        break;
+      }
+    }
+  }
+  if (relatedStoryIds.length > 0) {
+    return relatedStoryIds;
+  }
+  const passedStories = prd.userStories.filter((s) => s.status === "passed").map((s) => s.id);
+  return passedStories.slice(0, 5);
+}
+function buildFixPrompt(failedAC, acText, testOutput, relatedStories, prd) {
+  const relatedStoriesText = relatedStories.map((id) => {
+    const story = prd.userStories.find((s) => s.id === id);
+    if (!story)
+      return "";
+    return `${story.id}: ${story.title}
+  ${story.description}`;
+  }).filter(Boolean).join(`
+
+`);
+  return `You are a debugging expert. A feature acceptance test has failed.
+
+FAILED ACCEPTANCE CRITERION:
+${failedAC}: ${acText}
+
+TEST FAILURE OUTPUT:
+${testOutput}
+
+RELATED STORIES (implemented this functionality):
+${relatedStoriesText}
+
+Your task: Generate a fix story description that will make the acceptance test pass.
+
+Requirements:
+1. Analyze the test failure to understand the root cause
+2. Identify what needs to change in the code
+3. Write a clear, actionable fix description (2-4 sentences)
+4. Focus on the specific issue, not general improvements
+5. Reference the relevant story IDs if needed
+
+Respond with ONLY the fix description (no JSON, no markdown, just the description text).`;
+}
+async function generateFixStories(adapter, options) {
+  const { failedACs, testOutput, prd, specContent, workdir, modelDef } = options;
+  const fixStories = [];
+  const acTextMap = parseACTextFromSpec(specContent);
+  const logger = getLogger();
+  for (let i = 0;i < failedACs.length; i++) {
+    const failedAC = failedACs[i];
+    const acText = acTextMap[failedAC] || "No description available";
+    logger.info("acceptance", "Generating fix for failed AC", { failedAC });
+    const relatedStories = findRelatedStories(failedAC, prd);
+    if (relatedStories.length === 0) {
+      logger.warn("acceptance", "\u26A0 No related stories found for failed AC \u2014 skipping", { failedAC });
+      continue;
+    }
+    const prompt = buildFixPrompt(failedAC, acText, testOutput, relatedStories, prd);
+    try {
+      const skipPerms = options.config.quality?.dangerouslySkipPermissions ?? true;
+      const permArgs = skipPerms ? ["--dangerously-skip-permissions"] : [];
+      const cmd = [adapter.binary, "--model", modelDef.model, ...permArgs, "-p", prompt];
+      const proc = Bun.spawn(cmd, {
+        cwd: workdir,
+        stdout: "pipe",
+        stderr: "pipe",
+        env: {
+          ...process.env,
+          ...modelDef.env || {}
+        }
+      });
+      const exitCode = await proc.exited;
+      const stdout = await new Response(proc.stdout).text();
+      const stderr = await new Response(proc.stderr).text();
+      if (exitCode !== 0) {
+        logger.warn("acceptance", "\u26A0 Agent fix generation failed", { failedAC, stderr });
+        fixStories.push({
+          id: `US-FIX-${String(i + 1).padStart(3, "0")}`,
+          title: `Fix: ${failedAC}`,
+          failedAC,
+          testOutput,
+          relatedStories,
+          description: `Fix the implementation to make ${failedAC} pass. Related stories: ${relatedStories.join(", ")}.`
+        });
+        continue;
+      }
+      const fixDescription = stdout.trim();
+      fixStories.push({
+        id: `US-FIX-${String(i + 1).padStart(3, "0")}`,
+        title: `Fix: ${failedAC} \u2014 ${acText.slice(0, 50)}`,
+        failedAC,
+        testOutput,
+        relatedStories,
+        description: fixDescription
+      });
+      logger.info("acceptance", "\u2713 Generated fix story", { storyId: fixStories[fixStories.length - 1].id });
+    } catch (error) {
+      logger.warn("acceptance", "\u26A0 Error generating fix", {
+        failedAC,
+        error: error.message
+      });
+      fixStories.push({
+        id: `US-FIX-${String(i + 1).padStart(3, "0")}`,
+        title: `Fix: ${failedAC}`,
+        failedAC,
+        testOutput,
+        relatedStories,
+        description: `Fix the implementation to make ${failedAC} pass. Related stories: ${relatedStories.join(", ")}.`
+      });
+    }
+  }
+  return fixStories;
+}
+function parseACTextFromSpec(specContent) {
+  const map = {};
+  const lines = specContent.split(`
+`);
+  for (const line of lines) {
+    const acMatch = line.match(/^\s*-?\s*(?:\[.\])?\s*(AC-\d+):\s*(.+)$/i);
+    if (acMatch) {
+      const id = acMatch[1].toUpperCase();
+      const text = acMatch[2].trim();
+      map[id] = text;
+    }
+  }
+  return map;
+}
+function convertFixStoryToUserStory(fixStory) {
+  return {
+    id: fixStory.id,
+    title: fixStory.title,
+    description: fixStory.description,
+    acceptanceCriteria: [`Fix ${fixStory.failedAC}`],
+    tags: ["fix", "acceptance-failure"],
+    dependencies: fixStory.relatedStories,
+    status: "pending",
+    passes: false,
+    escalations: [],
+    attempts: 0,
+    contextFiles: []
+  };
+}
+var init_fix_generator = __esm(() => {
+  init_logger2();
+});
+
+// src/acceptance/index.ts
+var init_acceptance = __esm(() => {
+  init_generator();
+  init_fix_generator();
+});
+
+// src/agents/types.ts
+var CompleteError;
+var init_types2 = __esm(() => {
+  CompleteError = class CompleteError extends Error {
+    exitCode;
+    constructor(message, exitCode) {
+      super(message);
+      this.exitCode = exitCode;
+      this.name = "CompleteError";
+    }
+  };
+});
+
+// src/agents/adapters/aider.ts
+class AiderAdapter {
+  name = "aider";
+  displayName = "Aider";
+  binary = "aider";
+  capabilities = {
+    supportedTiers: ["balanced"],
+    maxContextTokens: 20000,
+    features: new Set(["refactor"])
+  };
+  async isInstalled() {
+    const path = _aiderCompleteDeps.which("aider");
+    return path !== null;
+  }
+  buildCommand(options) {
+    return ["aider", "--message", options.prompt, "--yes"];
+  }
+  async run(options) {
+    const cmd = this.buildCommand(options);
+    const startTime = Date.now();
+    const proc = _aiderCompleteDeps.spawn(cmd, {
+      stdout: "pipe",
+      stderr: "inherit"
+    });
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    const durationMs = Date.now() - startTime;
+    return {
+      success: exitCode === 0,
+      exitCode,
+      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS),
+      rateLimited: false,
+      durationMs,
+      estimatedCost: 0,
+      pid: proc.pid
+    };
+  }
+  async complete(prompt, options) {
+    const cmd = ["aider", "--message", prompt, "--yes"];
+    if (options?.model) {
+      cmd.push("--model", options.model);
+    }
+    const proc = _aiderCompleteDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const trimmed = stdout.trim();
+    if (exitCode !== 0) {
+      const errorDetails = stderr.trim() || trimmed;
+      const errorMessage = errorDetails || `complete() failed with exit code ${exitCode}`;
+      throw new CompleteError(errorMessage, exitCode);
+    }
+    if (!trimmed) {
+      throw new CompleteError("complete() returned empty output");
+    }
+    return trimmed;
+  }
+  async plan(_options) {
+    throw new Error("AiderAdapter.plan() not implemented");
+  }
+  async decompose(_options) {
+    throw new Error("AiderAdapter.decompose() not implemented");
+  }
+}
+var _aiderCompleteDeps, MAX_AGENT_OUTPUT_CHARS = 5000;
+var init_aider = __esm(() => {
+  init_types2();
+  _aiderCompleteDeps = {
+    which(name) {
+      return Bun.which(name);
+    },
+    spawn(cmd, opts) {
+      return Bun.spawn(cmd, opts);
+    }
+  };
+});
+
+// src/agents/adapters/codex.ts
+class CodexAdapter {
+  name = "codex";
+  displayName = "Codex";
+  binary = "codex";
+  capabilities = {
+    supportedTiers: ["fast", "balanced"],
+    maxContextTokens: 8000,
+    features: new Set(["tdd", "refactor"])
+  };
+  async isInstalled() {
+    const path = _codexRunDeps.which("codex");
+    return path !== null;
+  }
+  buildCommand(options) {
+    return ["codex", "-q", "--prompt", options.prompt];
+  }
+  async run(options) {
+    const cmd = this.buildCommand(options);
+    const startTime = Date.now();
+    const proc = _codexRunDeps.spawn(cmd, {
+      cwd: options.workdir,
+      stdout: "pipe",
+      stderr: "inherit"
+    });
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    const durationMs = Date.now() - startTime;
+    return {
+      success: exitCode === 0,
+      exitCode,
+      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS2),
+      rateLimited: false,
+      durationMs,
+      estimatedCost: 0,
+      pid: proc.pid
+    };
+  }
+  async complete(prompt, _options) {
+    const cmd = ["codex", "-q", "--prompt", prompt];
+    const proc = _codexCompleteDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const trimmed = stdout.trim();
+    if (exitCode !== 0) {
+      const errorDetails = stderr.trim() || trimmed;
+      const errorMessage = errorDetails || `complete() failed with exit code ${exitCode}`;
+      throw new CompleteError(errorMessage, exitCode);
+    }
+    if (!trimmed) {
+      throw new CompleteError("complete() returned empty output");
+    }
+    return trimmed;
+  }
+  async plan(_options) {
+    throw new Error("CodexAdapter.plan() not implemented");
+  }
+  async decompose(_options) {
+    throw new Error("CodexAdapter.decompose() not implemented");
+  }
+}
+var _codexRunDeps, _codexCompleteDeps, MAX_AGENT_OUTPUT_CHARS2 = 5000;
+var init_codex = __esm(() => {
+  init_types2();
+  _codexRunDeps = {
+    which(name) {
+      return Bun.which(name);
+    },
+    spawn(cmd, opts) {
+      return Bun.spawn(cmd, opts);
+    }
+  };
+  _codexCompleteDeps = {
+    spawn(cmd, opts) {
+      return Bun.spawn(cmd, opts);
+    }
+  };
+});
+
+// src/agents/adapters/gemini.ts
+class GeminiAdapter {
+  name = "gemini";
+  displayName = "Gemini CLI";
+  binary = "gemini";
+  capabilities = {
+    supportedTiers: ["fast", "balanced", "powerful"],
+    maxContextTokens: 1e6,
+    features: new Set(["tdd", "review", "refactor"])
+  };
+  async isInstalled() {
+    const path = _geminiRunDeps.which("gemini");
+    if (path === null) {
+      return false;
+    }
+    try {
+      const proc = _geminiRunDeps.spawn(["gemini", "--version"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await proc.exited;
+      if (exitCode !== 0) {
+        return false;
+      }
+      const stdout = await new Response(proc.stdout).text();
+      const lowerOut = stdout.toLowerCase();
+      if (lowerOut.includes("not logged in")) {
+        return false;
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  buildCommand(options) {
+    return ["gemini", "-p", options.prompt];
+  }
+  async run(options) {
+    const cmd = this.buildCommand(options);
+    const startTime = Date.now();
+    const proc = _geminiRunDeps.spawn(cmd, {
+      cwd: options.workdir,
+      stdout: "pipe",
+      stderr: "inherit"
+    });
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    const durationMs = Date.now() - startTime;
+    return {
+      success: exitCode === 0,
+      exitCode,
+      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS3),
+      rateLimited: false,
+      durationMs,
+      estimatedCost: 0,
+      pid: proc.pid
+    };
+  }
+  async complete(prompt, _options) {
+    const cmd = ["gemini", "-p", prompt];
+    const proc = _geminiCompleteDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const trimmed = stdout.trim();
+    if (exitCode !== 0) {
+      const errorDetails = stderr.trim() || trimmed;
+      const errorMessage = errorDetails || `complete() failed with exit code ${exitCode}`;
+      throw new CompleteError(errorMessage, exitCode);
+    }
+    if (!trimmed) {
+      throw new CompleteError("complete() returned empty output");
+    }
+    return trimmed;
+  }
+  async plan(_options) {
+    throw new Error("GeminiAdapter.plan() not implemented");
+  }
+  async decompose(_options) {
+    throw new Error("GeminiAdapter.decompose() not implemented");
+  }
+}
+var _geminiRunDeps, _geminiCompleteDeps, MAX_AGENT_OUTPUT_CHARS3 = 5000;
+var init_gemini = __esm(() => {
+  init_types2();
+  _geminiRunDeps = {
+    which(name) {
+      return Bun.which(name);
+    },
+    spawn(cmd, opts) {
+      return Bun.spawn(cmd, opts);
+    }
+  };
+  _geminiCompleteDeps = {
+    spawn(cmd, opts) {
+      return Bun.spawn(cmd, opts);
+    }
+  };
+});
+
+// src/agents/adapters/opencode.ts
+class OpenCodeAdapter {
+  name = "opencode";
+  displayName = "OpenCode";
+  binary = "opencode";
+  capabilities = {
+    supportedTiers: ["fast", "balanced"],
+    maxContextTokens: 8000,
+    features: new Set(["tdd", "refactor"])
+  };
+  async isInstalled() {
+    const path = _opencodeCompleteDeps.which("opencode");
+    return path !== null;
+  }
+  buildCommand(_options) {
+    throw new Error("OpenCodeAdapter.buildCommand() not implemented");
+  }
+  async run(_options) {
+    throw new Error("OpenCodeAdapter.run() not implemented");
+  }
+  async complete(prompt, _options) {
+    const cmd = ["opencode", "--prompt", prompt];
+    const proc = _opencodeCompleteDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const trimmed = stdout.trim();
+    if (exitCode !== 0) {
+      const errorDetails = stderr.trim() || trimmed;
+      const errorMessage = errorDetails || `complete() failed with exit code ${exitCode}`;
+      throw new CompleteError(errorMessage, exitCode);
+    }
+    if (!trimmed) {
+      throw new CompleteError("complete() returned empty output");
+    }
+    return trimmed;
+  }
+  async plan(_options) {
+    throw new Error("OpenCodeAdapter.plan() not implemented");
+  }
+  async decompose(_options) {
+    throw new Error("OpenCodeAdapter.decompose() not implemented");
+  }
+}
+var _opencodeCompleteDeps;
+var init_opencode = __esm(() => {
+  init_types2();
+  _opencodeCompleteDeps = {
+    which(name) {
+      return Bun.which(name);
+    },
+    spawn(cmd, opts) {
+      return Bun.spawn(cmd, opts);
+    }
+  };
+});
+
 // src/execution/pid-registry.ts
 import { existsSync } from "fs";
 
@@ -3297,7 +3914,7 @@ ${output.slice(0, 500)}`);
       acceptanceCriteria: Array.isArray(record.acceptanceCriteria) ? record.acceptanceCriteria : ["Implementation complete"],
       tags: Array.isArray(record.tags) ? record.tags : [],
       dependencies: Array.isArray(record.dependencies) ? record.dependencies : [],
-      complexity: validateComplexity(record.complexity),
+      complexity: coerceComplexity(record.complexity),
       contextFiles: Array.isArray(record.contextFiles) ? record.contextFiles : Array.isArray(record.relevantFiles) ? record.relevantFiles : [],
       relevantFiles: Array.isArray(record.relevantFiles) ? record.relevantFiles : [],
       reasoning: String(record.reasoning || "No reasoning provided"),
@@ -3311,7 +3928,7 @@ ${output.slice(0, 500)}`);
   }
   return stories;
 }
-function validateComplexity(value) {
+function coerceComplexity(value) {
   if (value === "simple" || value === "medium" || value === "complex" || value === "expert") {
     return value;
   }
@@ -18032,7 +18649,7 @@ class ClaudeCodeAdapter {
     return {
       success: exitCode === 0 && !timedOut,
       exitCode: actualExitCode,
-      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS),
+      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS4),
       stderr: stderr.slice(-MAX_AGENT_STDERR_CHARS),
       rateLimited,
       durationMs,
@@ -18168,13 +18785,13 @@ class ClaudeCodeAdapter {
     };
   }
 }
-var MAX_AGENT_OUTPUT_CHARS = 5000, MAX_AGENT_STDERR_CHARS = 1000, SIGKILL_GRACE_PERIOD_MS = 5000, _completeDeps, _decomposeDeps, _runOnceDeps;
+var MAX_AGENT_OUTPUT_CHARS4 = 5000, MAX_AGENT_STDERR_CHARS = 1000, SIGKILL_GRACE_PERIOD_MS = 5000, _completeDeps, _decomposeDeps, _runOnceDeps;
 var init_claude = __esm(() => {
   init_pid_registry();
   init_logger2();
   init_claude_plan();
   init_cost();
-  init_types();
+  init_types2();
   _completeDeps = {
     spawn(cmd, opts) {
       return Bun.spawn(cmd, opts);
@@ -18192,90 +18809,28 @@ var init_claude = __esm(() => {
   };
 });
 
-// src/agents/adapters/codex.ts
-class CodexAdapter {
-  name = "codex";
-  displayName = "Codex";
-  binary = "codex";
-  capabilities = {
-    supportedTiers: ["fast", "balanced"],
-    maxContextTokens: 8000,
-    features: new Set(["tdd", "refactor"])
-  };
-  async isInstalled() {
-    const path = _codexRunDeps.which("codex");
-    return path !== null;
-  }
-  buildCommand(options) {
-    return ["codex", "-q", "--prompt", options.prompt];
-  }
-  async run(options) {
-    const cmd = this.buildCommand(options);
-    const startTime = Date.now();
-    const proc = _codexRunDeps.spawn(cmd, {
-      cwd: options.workdir,
-      stdout: "pipe",
-      stderr: "inherit"
-    });
-    const exitCode = await proc.exited;
-    const stdout = await new Response(proc.stdout).text();
-    const durationMs = Date.now() - startTime;
-    return {
-      success: exitCode === 0,
-      exitCode,
-      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS2),
-      rateLimited: false,
-      durationMs,
-      estimatedCost: 0,
-      pid: proc.pid
-    };
-  }
-  async complete(prompt, _options) {
-    const cmd = ["codex", "-q", "--prompt", prompt];
-    const proc = _codexCompleteDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
-    const exitCode = await proc.exited;
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    const trimmed = stdout.trim();
-    if (exitCode !== 0) {
-      const errorDetails = stderr.trim() || trimmed;
-      const errorMessage = errorDetails || `complete() failed with exit code ${exitCode}`;
-      throw new CompleteError(errorMessage, exitCode);
-    }
-    if (!trimmed) {
-      throw new CompleteError("complete() returned empty output");
-    }
-    return trimmed;
-  }
-  async plan(_options) {
-    throw new Error("CodexAdapter.plan() not implemented");
-  }
-  async decompose(_options) {
-    throw new Error("CodexAdapter.decompose() not implemented");
-  }
-}
-var _codexRunDeps, _codexCompleteDeps, MAX_AGENT_OUTPUT_CHARS2 = 5000;
-var init_codex = __esm(() => {
-  init_types();
-  _codexRunDeps = {
-    which(name) {
-      return Bun.which(name);
-    },
-    spawn(cmd, opts) {
-      return Bun.spawn(cmd, opts);
-    }
-  };
-  _codexCompleteDeps = {
-    spawn(cmd, opts) {
-      return Bun.spawn(cmd, opts);
-    }
-  };
-});
-
 // src/agents/registry.ts
+var exports_registry = {};
+__export(exports_registry, {
+  getInstalledAgents: () => getInstalledAgents,
+  getAllAgentNames: () => getAllAgentNames,
+  getAgent: () => getAgent,
+  checkAgentHealth: () => checkAgentHealth,
+  ALL_AGENTS: () => ALL_AGENTS
+});
+function getAllAgentNames() {
+  return ALL_AGENTS.map((a) => a.name);
+}
 function getAgent(name) {
   return ALL_AGENTS.find((a) => a.name === name);
 }
+async function getInstalledAgents() {
+  const results = await Promise.all(ALL_AGENTS.map(async (agent) => ({
+    agent,
+    installed: await agent.isInstalled()
+  })));
+  return results.filter((r) => r.installed).map((r) => r.agent);
+}
 async function checkAgentHealth() {
   return Promise.all(ALL_AGENTS.map(async (agent) => ({
     name: agent.name,
@@ -18285,330 +18840,20 @@ async function checkAgentHealth() {
 }
 var ALL_AGENTS;
 var init_registry = __esm(() => {
+  init_aider();
   init_codex();
+  init_gemini();
+  init_opencode();
   init_claude();
   ALL_AGENTS = [
     new ClaudeCodeAdapter,
-    new CodexAdapter
+    new CodexAdapter,
+    new OpenCodeAdapter,
+    new GeminiAdapter,
+    new AiderAdapter
   ];
 });
 
-// src/agents/validation.ts
-function validateAgentForTier(agent, tier) {
-  return agent.capabilities.supportedTiers.includes(tier);
-}
-
-// src/agents/index.ts
-var init_agents = __esm(() => {
-  init_types();
-  init_claude();
-  init_registry();
-  init_cost();
-});
-
-// src/acceptance/generator.ts
-function parseAcceptanceCriteria(specContent) {
-  const criteria = [];
-  const lines = specContent.split(`
-`);
-  for (let i = 0;i < lines.length; i++) {
-    const line = lines[i];
-    const lineNumber = i + 1;
-    const acMatch = line.match(/^\s*-?\s*(?:\[.\])?\s*(AC-\d+):\s*(.+)$/i);
-    if (acMatch) {
-      const id = acMatch[1].toUpperCase();
-      const text = acMatch[2].trim();
-      criteria.push({
-        id,
-        text,
-        lineNumber
-      });
-    }
-  }
-  return criteria;
-}
-function buildAcceptanceTestPrompt(criteria, featureName, codebaseContext) {
-  const criteriaList = criteria.map((ac) => `${ac.id}: ${ac.text}`).join(`
-`);
-  return `You are a test engineer. Generate acceptance tests for the "${featureName}" feature based on the acceptance criteria below.
-
-CODEBASE CONTEXT:
-${codebaseContext}
-
-ACCEPTANCE CRITERIA:
-${criteriaList}
-
-Generate a complete acceptance.test.ts file using bun:test framework. Follow these rules:
-
-1. **One test per AC**: Each acceptance criterion maps to exactly one test
-2. **Test observable behavior only**: No implementation details, only user-facing behavior
-3. **Independent tests**: No shared state between tests
-4. **Integration-level**: Tests should be runnable without mocking (use real implementations)
-5. **Clear test names**: Use format "AC-N: <description>" for test names
-6. **Async where needed**: Use async/await for operations that may be asynchronous
-
-Use this structure:
-
-\`\`\`typescript
-import { describe, test, expect } from "bun:test";
-
-describe("${featureName} - Acceptance Tests", () => {
-  test("AC-1: <description>", async () => {
-    // Test implementation
-  });
-
-  test("AC-2: <description>", async () => {
-    // Test implementation
-  });
-});
-\`\`\`
-
-**Important**:
-- Import the feature code being tested
-- Set up any necessary test fixtures
-- Use expect() assertions to verify behavior
-- Clean up resources if needed (close connections, delete temp files)
-
-Respond with ONLY the TypeScript test code (no markdown code fences, no explanation).`;
-}
-async function generateAcceptanceTests(adapter, options) {
-  const logger = getLogger();
-  const criteria = parseAcceptanceCriteria(options.specContent);
-  if (criteria.length === 0) {
-    logger.warn("acceptance", "\u26A0 No acceptance criteria found in spec.md");
-    return {
-      testCode: generateSkeletonTests(options.featureName, []),
-      criteria: []
-    };
-  }
-  logger.info("acceptance", "Found acceptance criteria", { count: criteria.length });
-  const prompt = buildAcceptanceTestPrompt(criteria, options.featureName, options.codebaseContext);
-  try {
-    const skipPerms = options.config.quality?.dangerouslySkipPermissions ?? true;
-    const permArgs = skipPerms ? ["--dangerously-skip-permissions"] : [];
-    const cmd = [adapter.binary, "--model", options.modelDef.model, ...permArgs, "-p", prompt];
-    const proc = Bun.spawn(cmd, {
-      cwd: options.workdir,
-      stdout: "pipe",
-      stderr: "pipe",
-      env: {
-        ...process.env,
-        ...options.modelDef.env || {}
-      }
-    });
-    const exitCode = await proc.exited;
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    if (exitCode !== 0) {
-      logger.warn("acceptance", "\u26A0 Agent test generation failed", { stderr });
-      return {
-        testCode: generateSkeletonTests(options.featureName, criteria),
-        criteria
-      };
-    }
-    const testCode = extractTestCode(stdout);
-    return {
-      testCode,
-      criteria
-    };
-  } catch (error48) {
-    logger.warn("acceptance", "\u26A0 Agent test generation error", { error: error48.message });
-    return {
-      testCode: generateSkeletonTests(options.featureName, criteria),
-      criteria
-    };
-  }
-}
-function extractTestCode(output) {
-  const fenceMatch = output.match(/```(?:typescript|ts)?\s*([\s\S]*?)\s*```/);
-  if (fenceMatch) {
-    return fenceMatch[1].trim();
-  }
-  const importMatch = output.match(/import\s+{[\s\S]+/);
-  if (importMatch) {
-    return importMatch[0].trim();
-  }
-  return output.trim();
-}
-function generateSkeletonTests(featureName, criteria) {
-  const tests = criteria.map((ac) => {
-    return `  test("${ac.id}: ${ac.text}", async () => {
-    // TODO: Implement acceptance test for ${ac.id}
-    // ${ac.text}
-    expect(true).toBe(false); // Replace with actual test
-  });`;
-  }).join(`
-
-`);
-  return `import { describe, test, expect } from "bun:test";
-
-describe("${featureName} - Acceptance Tests", () => {
-${tests || "  // No acceptance criteria found"}
-});
-`;
-}
-var init_generator = __esm(() => {
-  init_logger2();
-});
-
-// src/acceptance/fix-generator.ts
-function findRelatedStories(failedAC, prd) {
-  const relatedStoryIds = [];
-  for (const story of prd.userStories) {
-    for (const ac of story.acceptanceCriteria) {
-      if (ac.includes(failedAC)) {
-        relatedStoryIds.push(story.id);
-        break;
-      }
-    }
-  }
-  if (relatedStoryIds.length > 0) {
-    return relatedStoryIds;
-  }
-  const passedStories = prd.userStories.filter((s) => s.status === "passed").map((s) => s.id);
-  return passedStories.slice(0, 5);
-}
-function buildFixPrompt(failedAC, acText, testOutput, relatedStories, prd) {
-  const relatedStoriesText = relatedStories.map((id) => {
-    const story = prd.userStories.find((s) => s.id === id);
-    if (!story)
-      return "";
-    return `${story.id}: ${story.title}
-  ${story.description}`;
-  }).filter(Boolean).join(`
-
-`);
-  return `You are a debugging expert. A feature acceptance test has failed.
-
-FAILED ACCEPTANCE CRITERION:
-${failedAC}: ${acText}
-
-TEST FAILURE OUTPUT:
-${testOutput}
-
-RELATED STORIES (implemented this functionality):
-${relatedStoriesText}
-
-Your task: Generate a fix story description that will make the acceptance test pass.
-
-Requirements:
-1. Analyze the test failure to understand the root cause
-2. Identify what needs to change in the code
-3. Write a clear, actionable fix description (2-4 sentences)
-4. Focus on the specific issue, not general improvements
-5. Reference the relevant story IDs if needed
-
-Respond with ONLY the fix description (no JSON, no markdown, just the description text).`;
-}
-async function generateFixStories(adapter, options) {
-  const { failedACs, testOutput, prd, specContent, workdir, modelDef } = options;
-  const fixStories = [];
-  const acTextMap = parseACTextFromSpec(specContent);
-  const logger = getLogger();
-  for (let i = 0;i < failedACs.length; i++) {
-    const failedAC = failedACs[i];
-    const acText = acTextMap[failedAC] || "No description available";
-    logger.info("acceptance", "Generating fix for failed AC", { failedAC });
-    const relatedStories = findRelatedStories(failedAC, prd);
-    if (relatedStories.length === 0) {
-      logger.warn("acceptance", "\u26A0 No related stories found for failed AC \u2014 skipping", { failedAC });
-      continue;
-    }
-    const prompt = buildFixPrompt(failedAC, acText, testOutput, relatedStories, prd);
-    try {
-      const skipPerms = options.config.quality?.dangerouslySkipPermissions ?? true;
-      const permArgs = skipPerms ? ["--dangerously-skip-permissions"] : [];
-      const cmd = [adapter.binary, "--model", modelDef.model, ...permArgs, "-p", prompt];
-      const proc = Bun.spawn(cmd, {
-        cwd: workdir,
-        stdout: "pipe",
-        stderr: "pipe",
-        env: {
-          ...process.env,
-          ...modelDef.env || {}
-        }
-      });
-      const exitCode = await proc.exited;
-      const stdout = await new Response(proc.stdout).text();
-      const stderr = await new Response(proc.stderr).text();
-      if (exitCode !== 0) {
-        logger.warn("acceptance", "\u26A0 Agent fix generation failed", { failedAC, stderr });
-        fixStories.push({
-          id: `US-FIX-${String(i + 1).padStart(3, "0")}`,
-          title: `Fix: ${failedAC}`,
-          failedAC,
-          testOutput,
-          relatedStories,
-          description: `Fix the implementation to make ${failedAC} pass. Related stories: ${relatedStories.join(", ")}.`
-        });
-        continue;
-      }
-      const fixDescription = stdout.trim();
-      fixStories.push({
-        id: `US-FIX-${String(i + 1).padStart(3, "0")}`,
-        title: `Fix: ${failedAC} \u2014 ${acText.slice(0, 50)}`,
-        failedAC,
-        testOutput,
-        relatedStories,
-        description: fixDescription
-      });
-      logger.info("acceptance", "\u2713 Generated fix story", { storyId: fixStories[fixStories.length - 1].id });
-    } catch (error48) {
-      logger.warn("acceptance", "\u26A0 Error generating fix", {
-        failedAC,
-        error: error48.message
-      });
-      fixStories.push({
-        id: `US-FIX-${String(i + 1).padStart(3, "0")}`,
-        title: `Fix: ${failedAC}`,
-        failedAC,
-        testOutput,
-        relatedStories,
-        description: `Fix the implementation to make ${failedAC} pass. Related stories: ${relatedStories.join(", ")}.`
-      });
-    }
-  }
-  return fixStories;
-}
-function parseACTextFromSpec(specContent) {
-  const map2 = {};
-  const lines = specContent.split(`
-`);
-  for (const line of lines) {
-    const acMatch = line.match(/^\s*-?\s*(?:\[.\])?\s*(AC-\d+):\s*(.+)$/i);
-    if (acMatch) {
-      const id = acMatch[1].toUpperCase();
-      const text = acMatch[2].trim();
-      map2[id] = text;
-    }
-  }
-  return map2;
-}
-function convertFixStoryToUserStory(fixStory) {
-  return {
-    id: fixStory.id,
-    title: fixStory.title,
-    description: fixStory.description,
-    acceptanceCriteria: [`Fix ${fixStory.failedAC}`],
-    tags: ["fix", "acceptance-failure"],
-    dependencies: fixStory.relatedStories,
-    status: "pending",
-    passes: false,
-    escalations: [],
-    attempts: 0,
-    contextFiles: []
-  };
-}
-var init_fix_generator = __esm(() => {
-  init_logger2();
-});
-
-// src/acceptance/index.ts
-var init_acceptance = __esm(() => {
-  init_generator();
-  init_fix_generator();
-});
-
 // src/decompose/apply.ts
 function applyDecomposition(prd, result) {
   const { subStories } = result;
@@ -19226,7 +19471,7 @@ Your complexity classification will determine the execution strategy:
 Respond with ONLY this JSON (no markdown, no explanation):
 {"complexity":"simple|medium|complex|expert","modelTier":"fast|balanced|powerful","reasoning":"<one line>"}`;
 }
-function buildBatchPrompt(stories, config2) {
+function buildBatchRoutingPrompt(stories, config2) {
   const storyBlocks = stories.map((story, idx) => {
     const criteria = story.acceptanceCriteria.map((c, i) => `   ${i + 1}. ${c}`).join(`
 `);
@@ -19406,7 +19651,7 @@ async function routeBatch(stories, context) {
     throw new Error("No agent adapter available for batch routing (AA-003)");
   }
   const modelTier = llmConfig.model ?? "fast";
-  const prompt = buildBatchPrompt(stories, config2);
+  const prompt = buildBatchRoutingPrompt(stories, config2);
   try {
     const output = await callLlm(adapter, modelTier, prompt, config2);
     const decisions = parseBatchResponse(output, stories, config2);
@@ -19828,7 +20073,7 @@ var init_routing = __esm(() => {
 });
 
 // src/decompose/validators/complexity.ts
-function validateComplexity2(substories, maxComplexity) {
+function validateComplexity(substories, maxComplexity) {
   const errors3 = [];
   const warnings = [];
   const maxOrder = COMPLEXITY_ORDER[maxComplexity];
@@ -20140,7 +20385,7 @@ function runAllValidators(originalStory, substories, existingStories, config2) {
   const results = [
     validateOverlap(substories, existingStories),
     validateCoverage(originalStory, substories),
-    validateComplexity2(substories, maxComplexity),
+    validateComplexity(substories, maxComplexity),
     validateDependencies(substories, existingIds)
   ];
   const errors3 = results.flatMap((r) => r.errors);
@@ -20412,7 +20657,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.35.0",
+    version: "0.36.1",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -20473,8 +20718,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("a5e44ea"))
-        return "a5e44ea";
+      if (/^[0-9a-f]{6,10}$/.test("b241bab"))
+        return "b241bab";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -20847,6 +21092,12 @@ class InteractionChain {
   async prompt(request) {
     await this.send(request);
     const response = await this.receive(request.id, request.timeout);
+    if (response.action === "choose" && response.value && request.options) {
+      const matched = request.options.find((o) => o.key === response.value);
+      if (matched) {
+        return { ...response, action: matched.key };
+      }
+    }
     return response;
   }
   async cancel(requestId) {
@@ -22436,9 +22687,17 @@ class ReviewOrchestrator {
         const changedFiles = await getChangedFiles(workdir);
         const pluginResults = [];
         for (const reviewer of reviewers) {
-          logger?.info("review", `Running plugin reviewer: ${reviewer.name}`);
+          logger?.info("review", `Running plugin reviewer: ${reviewer.name}`, {
+            changedFiles: changedFiles.length
+          });
           try {
             const result = await reviewer.check(workdir, changedFiles);
+            logger?.info("review", `Plugin reviewer result: ${reviewer.name}`, {
+              passed: result.passed,
+              exitCode: result.exitCode,
+              output: result.output?.slice(0, 500),
+              findings: result.findings?.length ?? 0
+            });
             pluginResults.push({
               name: reviewer.name,
               passed: result.passed,
@@ -22457,6 +22716,7 @@ class ReviewOrchestrator {
             }
           } catch (error48) {
             const errorMsg = error48 instanceof Error ? error48.message : String(error48);
+            logger?.warn("review", `Plugin reviewer threw error: ${reviewer.name}`, { error: errorMsg });
             pluginResults.push({ name: reviewer.name, passed: false, output: "", error: errorMsg });
             builtIn.pluginReviewers = pluginResults;
             return {
@@ -22714,12 +22974,14 @@ var init_completion = __esm(() => {
   };
 });
 
+// src/optimizer/types.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+
 // src/constitution/loader.ts
 import { existsSync as existsSync13 } from "fs";
 import { join as join14 } from "path";
-function estimateTokens(text) {
-  return Math.ceil(text.length / 3);
-}
 function truncateToTokens(text, maxTokens) {
   const maxChars = maxTokens * 3;
   if (text.length <= maxChars) {
@@ -22969,32 +23231,29 @@ var init_auto_detect = __esm(() => {
 });
 
 // src/context/elements.ts
-function estimateTokens2(text) {
-  return Math.ceil(text.length / CHARS_PER_TOKEN);
-}
 function createStoryContext(story, priority) {
   const content = formatStoryAsText(story);
-  return { type: "story", storyId: story.id, content, priority, tokens: estimateTokens2(content) };
+  return { type: "story", storyId: story.id, content, priority, tokens: estimateTokens(content) };
 }
 function createDependencyContext(story, priority) {
   const content = formatStoryAsText(story);
-  return { type: "dependency", storyId: story.id, content, priority, tokens: estimateTokens2(content) };
+  return { type: "dependency", storyId: story.id, content, priority, tokens: estimateTokens(content) };
 }
 function createErrorContext(errorMessage, priority) {
-  return { type: "error", content: errorMessage, priority, tokens: estimateTokens2(errorMessage) };
+  return { type: "error", content: errorMessage, priority, tokens: estimateTokens(errorMessage) };
 }
 function createProgressContext(progressText, priority) {
-  return { type: "progress", content: progressText, priority, tokens: estimateTokens2(progressText) };
+  return { type: "progress", content: progressText, priority, tokens: estimateTokens(progressText) };
 }
 function createFileContext(filePath, content, priority) {
-  return { type: "file", filePath, content, priority, tokens: estimateTokens2(content) };
+  return { type: "file", filePath, content, priority, tokens: estimateTokens(content) };
 }
 function createTestCoverageContext(content, tokens, priority) {
   return { type: "test-coverage", content, priority, tokens };
 }
 function createPriorFailuresContext(failures, priority) {
   const content = formatPriorFailures(failures);
-  return { type: "prior-failures", content, priority, tokens: estimateTokens2(content) };
+  return { type: "prior-failures", content, priority, tokens: estimateTokens(content) };
 }
 function formatPriorFailures(failures) {
   if (!failures || failures.length === 0) {
@@ -23065,7 +23324,6 @@ function formatStoryAsText(story) {
   return parts.join(`
 `);
 }
-var CHARS_PER_TOKEN = 3;
 var init_elements = __esm(() => {
   init_logger2();
 });
@@ -23222,7 +23480,7 @@ function truncateToTokenBudget(files, maxTokens, preferredDetail) {
   for (let i = startIndex;i < detailLevels.length; i++) {
     const detail = detailLevels[i];
     const summary = formatTestSummary(files, detail);
-    const tokens = estimateTokens2(summary);
+    const tokens = estimateTokens(summary);
     if (tokens <= maxTokens) {
       return { summary, detail, truncated: i !== startIndex };
     }
@@ -23232,7 +23490,7 @@ function truncateToTokenBudget(files, maxTokens, preferredDetail) {
     truncatedFiles = truncatedFiles.slice(0, truncatedFiles.length - 1);
     const summary = `${formatTestSummary(truncatedFiles, "names-only")}
 ... and ${files.length - truncatedFiles.length} more test files`;
-    if (estimateTokens2(summary) <= maxTokens) {
+    if (estimateTokens(summary) <= maxTokens) {
       return { summary, detail: "names-only", truncated: true };
     }
   }
@@ -23255,13 +23513,12 @@ async function generateTestCoverageSummary(options) {
   }
   const totalTests = files.reduce((sum, f) => sum + f.testCount, 0);
   const { summary } = truncateToTokenBudget(files, maxTokens, detail);
-  const tokens = estimateTokens2(summary);
+  const tokens = estimateTokens(summary);
   return { files, totalTests, summary, tokens };
 }
 var COMMON_TEST_DIRS;
 var init_test_scanner = __esm(() => {
   init_logger2();
-  init_builder3();
   COMMON_TEST_DIRS = ["test", "tests", "__tests__", "src/__tests__", "spec"];
 });
 
@@ -23778,6 +24035,68 @@ ${pluginMarkdown}` : pluginMarkdown;
   };
 });
 
+// src/agents/validation.ts
+function validateAgentForTier(agent, tier) {
+  return agent.capabilities.supportedTiers.includes(tier);
+}
+
+// src/agents/version-detection.ts
+async function getAgentVersion(binaryName) {
+  try {
+    const proc = _versionDetectionDeps.spawn([binaryName, "--version"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      return null;
+    }
+    const stdout = await new Response(proc.stdout).text();
+    const versionLine = stdout.trim().split(`
+`)[0];
+    const versionMatch = versionLine.match(/v?(\d+\.\d+(?:\.\d+)?(?:[-+][\w.]+)?)/);
+    if (versionMatch) {
+      return versionMatch[0];
+    }
+    return versionLine || null;
+  } catch {
+    return null;
+  }
+}
+async function getAgentVersions() {
+  const agents = await getInstalledAgents();
+  const agentsByName = new Map(agents.map((a) => [a.name, a]));
+  const { ALL_AGENTS: ALL_AGENTS2 } = await Promise.resolve().then(() => (init_registry(), exports_registry));
+  const versions2 = await Promise.all(ALL_AGENTS2.map(async (agent) => {
+    const version2 = agentsByName.has(agent.name) ? await getAgentVersion(agent.binary) : null;
+    return {
+      name: agent.name,
+      displayName: agent.displayName,
+      version: version2,
+      installed: agentsByName.has(agent.name)
+    };
+  }));
+  return versions2;
+}
+var _versionDetectionDeps;
+var init_version_detection = __esm(() => {
+  init_registry();
+  _versionDetectionDeps = {
+    spawn(cmd, opts) {
+      return Bun.spawn(cmd, opts);
+    }
+  };
+});
+
+// src/agents/index.ts
+var init_agents = __esm(() => {
+  init_types2();
+  init_claude();
+  init_registry();
+  init_cost();
+  init_version_detection();
+});
+
 // src/tdd/isolation.ts
 function isTestFile(filePath) {
   return TEST_PATTERNS.some((pattern) => pattern.test(filePath));
@@ -23935,7 +24254,38 @@ async function hasCommitsForStory(workdir, storyId, maxCommits = 20) {
 function detectMergeConflict(output) {
   return output.includes("CONFLICT") || output.includes("conflict");
 }
+async function autoCommitIfDirty(workdir, stage, role, storyId) {
+  const logger = getSafeLogger();
+  try {
+    const statusProc = Bun.spawn(["git", "status", "--porcelain"], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const statusOutput = await new Response(statusProc.stdout).text();
+    await statusProc.exited;
+    if (!statusOutput.trim())
+      return;
+    logger?.warn(stage, `Agent did not commit after ${role} session \u2014 auto-committing`, {
+      role,
+      storyId,
+      dirtyFiles: statusOutput.trim().split(`
+`).length
+    });
+    const addProc = Bun.spawn(["git", "add", "-A"], { cwd: workdir, stdout: "pipe", stderr: "pipe" });
+    await addProc.exited;
+    const commitProc = Bun.spawn(["git", "commit", "-m", `chore(${storyId}): auto-commit after ${role} session`], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    await commitProc.exited;
+  } catch {}
+}
 var GIT_TIMEOUT_MS = 1e4;
+var init_git = __esm(() => {
+  init_logger2();
+});
 // src/verification/executor.ts
 async function drainWithDeadline(proc, deadlineMs) {
   const EMPTY = Symbol("timeout");
@@ -24420,7 +24770,7 @@ var init_cleanup = __esm(() => {
 });
 
 // src/tdd/prompts.ts
-function buildImplementerRectificationPrompt(failures, story, contextMarkdown, config2) {
+function buildImplementerRectificationPrompt(failures, story, _contextMarkdown, config2) {
   return createRectificationPrompt(failures, story, config2);
 }
 var init_prompts = __esm(() => {
@@ -24512,7 +24862,7 @@ async function runRectificationLoop(story, config2, workdir, agent, implementerT
         exitCode: rectifyResult.exitCode
       });
     }
-    await autoCommitIfDirty(workdir, "rectification", story.id, logger);
+    await autoCommitIfDirty(workdir, "tdd", "rectification", story.id);
     const rectifyIsolation = lite ? undefined : await verifyImplementerIsolation(workdir, rectifyBeforeRef);
     if (rectifyIsolation && !rectifyIsolation.passed) {
       logger.error("tdd", "Rectification violated isolation", {
@@ -24557,35 +24907,9 @@ async function runRectificationLoop(story, config2, workdir, agent, implementerT
   logger.info("tdd", "Full suite gate passed", { storyId: story.id });
   return true;
 }
-async function autoCommitIfDirty(workdir, role, storyId, logger) {
-  try {
-    const statusProc = Bun.spawn(["git", "status", "--porcelain"], {
-      cwd: workdir,
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const statusOutput = await new Response(statusProc.stdout).text();
-    await statusProc.exited;
-    if (!statusOutput.trim())
-      return;
-    logger.warn("tdd", `Agent did not commit after ${role} session \u2014 auto-committing`, {
-      role,
-      storyId,
-      dirtyFiles: statusOutput.trim().split(`
-`).length
-    });
-    const addProc = Bun.spawn(["git", "add", "-A"], { cwd: workdir, stdout: "pipe", stderr: "pipe" });
-    await addProc.exited;
-    const commitProc = Bun.spawn(["git", "commit", "-m", `chore(${storyId}): auto-commit after ${role} session`], {
-      cwd: workdir,
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    await commitProc.exited;
-  } catch {}
-}
 var init_rectification_gate = __esm(() => {
   init_config();
+  init_git();
   init_verification();
   init_cleanup();
   init_isolation();
@@ -24596,9 +24920,9 @@ var init_rectification_gate = __esm(() => {
 function buildConventionsSection() {
   return `# Conventions
 
-` + `Follow existing code patterns and conventions. Write idiomatic, maintainable code.
+Follow existing code patterns and conventions. Write idiomatic, maintainable code.
 
-` + "When running tests, run ONLY test files related to your changes (e.g. `bun test ./test/specific.test.ts`). " + "NEVER run `bun test` without a file filter \u2014 full suite output will flood your context window and cause failures.\n\n" + "Commit your changes when done using conventional commit format (e.g. `feat:`, `fix:`, `test:`).";
+Commit your changes when done using conventional commit format (e.g. \`feat:\`, \`fix:\`, \`test:\`).`;
 }
 
 // src/prompts/sections/isolation.ts
@@ -24607,29 +24931,39 @@ function buildIsolationSection(roleOrMode, mode) {
     return buildIsolationSection("test-writer", roleOrMode);
   }
   const role = roleOrMode;
-  const header = `# Isolation Rules
-
-`;
+  const header = "# Isolation Rules";
   const footer = `
 
 ${TEST_FILTER_RULE}`;
   if (role === "test-writer") {
     const m = mode ?? "strict";
     if (m === "strict") {
-      return `${header}isolation scope: Only create or modify files in the test/ directory. Tests must fail because the feature is not yet implemented. Do NOT modify any source files in src/.${footer}`;
+      return `${header}
+
+isolation scope: Only create or modify files in the test/ directory. Tests must fail because the feature is not yet implemented. Do NOT modify any source files in src/.${footer}`;
     }
-    return `${header}isolation scope: Create test files in test/. MAY read src/ files and MAY import from src/ to ensure correct types/interfaces. May create minimal stubs in src/ if needed to make imports work, but do NOT implement real logic.${footer}`;
+    return `${header}
+
+isolation scope: Create test files in test/. MAY read src/ files and MAY import from src/ to ensure correct types/interfaces. May create minimal stubs in src/ if needed to make imports work, but do NOT implement real logic.${footer}`;
   }
   if (role === "implementer") {
-    return `${header}isolation scope: Implement source code in src/ to make tests pass. Do not modify test files. Run tests frequently to track progress.${footer}`;
+    return `${header}
+
+isolation scope: Implement source code in src/ to make tests pass. Do not modify test files. Run tests frequently to track progress.${footer}`;
   }
   if (role === "verifier") {
-    return `${header}isolation scope: Read-only inspection. Review all test results, implementation code, and acceptance criteria compliance. You MAY write a verdict file (.nax-verifier-verdict.json) and apply legitimate fixes if needed.${footer}`;
+    return `${header}
+
+isolation scope: Read-only inspection. Review all test results, implementation code, and acceptance criteria compliance. You MAY write a verdict file (.nax-verifier-verdict.json) and apply legitimate fixes if needed.${footer}`;
   }
   if (role === "single-session") {
-    return `${header}isolation scope: Create test files in test/ directory, then implement source code in src/ to make tests pass. Both directories are in scope for this session.${footer}`;
+    return `${header}
+
+isolation scope: Create test files in test/ directory, then implement source code in src/ to make tests pass. Both directories are in scope for this session.${footer}`;
   }
-  return `${header}isolation scope: You may modify both src/ and test/ files. Write failing tests FIRST, then implement to make them pass.`;
+  return `${header}
+
+isolation scope: You may modify both src/ and test/ files. Write failing tests FIRST, then implement to make them pass.`;
 }
 var TEST_FILTER_RULE;
 var init_isolation2 = __esm(() => {
@@ -24647,76 +24981,76 @@ function buildRoleTaskSection(roleOrVariant, variant) {
     if (v === "standard") {
       return `# Role: Implementer
 
-` + `Your task: make failing tests pass.
+Your task: make failing tests pass.
 
-` + `Instructions:
-` + `- Implement source code in src/ to make tests pass
-` + `- Do NOT modify test files
-` + `- Run tests frequently to track progress
-` + `- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
-` + "- Goal: all tests green, all changes committed";
+Instructions:
+- Implement source code in src/ to make tests pass
+- Do NOT modify test files
+- Run tests frequently to track progress
+- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
+- Goal: all tests green, all changes committed`;
     }
     return `# Role: Implementer (Lite)
 
-` + `Your task: Write tests AND implement the feature in a single session.
+Your task: Write tests AND implement the feature in a single session.
 
-` + `Instructions:
-` + `- Write tests first (test/ directory), then implement (src/ directory)
-` + `- All tests must pass by the end
-` + `- Use Bun test (describe/test/expect)
-` + `- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
-` + "- Goal: all tests green, all criteria met, all changes committed";
+Instructions:
+- Write tests first (test/ directory), then implement (src/ directory)
+- All tests must pass by the end
+- Use Bun test (describe/test/expect)
+- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
+- Goal: all tests green, all criteria met, all changes committed`;
   }
   if (role === "test-writer") {
     return `# Role: Test-Writer
 
-` + `Your task: Write comprehensive failing tests for the feature.
+Your task: Write comprehensive failing tests for the feature.
 
-` + `Instructions:
-` + `- Create test files in test/ directory that cover acceptance criteria
-` + `- Tests must fail initially (RED phase) \u2014 the feature is not yet implemented
-` + `- Use Bun test (describe/test/expect)
-` + `- Write clear test names that document expected behavior
-` + `- Focus on behavior, not implementation details
-` + "- Goal: comprehensive test suite ready for implementation";
+Instructions:
+- Create test files in test/ directory that cover acceptance criteria
+- Tests must fail initially (RED phase) \u2014 the feature is not yet implemented
+- Use Bun test (describe/test/expect)
+- Write clear test names that document expected behavior
+- Focus on behavior, not implementation details
+- Goal: comprehensive test suite ready for implementation`;
   }
   if (role === "verifier") {
     return `# Role: Verifier
 
-` + `Your task: Review and verify the implementation against acceptance criteria.
+Your task: Review and verify the implementation against acceptance criteria.
 
-` + `Instructions:
-` + `- Review all test results \u2014 verify tests pass
-` + `- Check that implementation meets all acceptance criteria
-` + `- Inspect code quality, error handling, and edge cases
-` + `- Verify test modifications (if any) are legitimate fixes
-` + `- Write a detailed verdict with reasoning
-` + "- Goal: provide comprehensive verification and quality assurance";
+Instructions:
+- Review all test results \u2014 verify tests pass
+- Check that implementation meets all acceptance criteria
+- Inspect code quality, error handling, and edge cases
+- Verify test modifications (if any) are legitimate fixes
+- Write a detailed verdict with reasoning
+- Goal: provide comprehensive verification and quality assurance`;
   }
   if (role === "single-session") {
     return `# Role: Single-Session
 
-` + `Your task: Write tests AND implement the feature in a single focused session.
+Your task: Write tests AND implement the feature in a single focused session.
 
-` + `Instructions:
-` + `- Phase 1: Write comprehensive tests (test/ directory)
-` + `- Phase 2: Implement to make all tests pass (src/ directory)
-` + `- Use Bun test (describe/test/expect)
-` + `- Run tests frequently throughout implementation
-` + `- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
-` + "- Goal: all tests passing, all changes committed, full story complete";
+Instructions:
+- Phase 1: Write comprehensive tests (test/ directory)
+- Phase 2: Implement to make all tests pass (src/ directory)
+- Use Bun test (describe/test/expect)
+- Run tests frequently throughout implementation
+- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
+- Goal: all tests passing, all changes committed, full story complete`;
   }
   return `# Role: TDD-Simple
 
-` + `Your task: Write failing tests FIRST, then implement to make them pass.
+Your task: Write failing tests FIRST, then implement to make them pass.
 
-` + `Instructions:
-` + `- RED phase: Write failing tests FIRST for the acceptance criteria
-` + `- RED phase: Run the tests to confirm they fail
-` + `- GREEN phase: Implement the minimum code to make tests pass
-` + `- REFACTOR phase: Refactor while keeping tests green
-` + `- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
-` + "- Goal: all tests passing, feature complete, all changes committed";
+Instructions:
+- RED phase: Write failing tests FIRST for the acceptance criteria
+- RED phase: Run the tests to confirm they fail
+- GREEN phase: Implement the minimum code to make tests pass
+- REFACTOR phase: Refactor while keeping tests green
+- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
+- Goal: all tests passing, feature complete, all changes committed`;
 }
 
 // src/prompts/sections/story.ts
@@ -24734,6 +25068,69 @@ ${story.description}
 ${criteria}`;
 }
 
+// src/prompts/sections/verdict.ts
+function buildVerdictSection(story) {
+  return `# Verdict Instructions
+
+## Write Verdict File
+
+After completing your verification, you **MUST** write a verdict file at the **project root**:
+
+**File:** \`.nax-verifier-verdict.json\`
+
+Set \`approved: true\` when ALL of these conditions are met:
+- All tests pass
+- Implementation is clean and follows conventions
+- All acceptance criteria met
+- Any test modifications by implementer are legitimate fixes
+
+Set \`approved: false\` when ANY of these conditions are true:
+- Tests are failing and you cannot fix them
+- The implementer loosened test assertions to mask bugs
+- Critical acceptance criteria are not met
+- Code quality is poor (security issues, severe bugs, etc.)
+
+**Full JSON schema example** (fill in all fields with real values):
+
+\`\`\`json
+{
+  "version": 1,
+  "approved": true,
+  "tests": {
+    "allPassing": true,
+    "passCount": 42,
+    "failCount": 0
+  },
+  "testModifications": {
+    "detected": false,
+    "files": [],
+    "legitimate": true,
+    "reasoning": "No test files were modified by the implementer"
+  },
+  "acceptanceCriteria": {
+    "allMet": true,
+    "criteria": [
+      { "criterion": "Example criterion", "met": true }
+    ]
+  },
+  "quality": {
+    "rating": "good",
+    "issues": []
+  },
+  "fixes": [],
+  "reasoning": "All tests pass, implementation is clean, all acceptance criteria are met."
+}
+\`\`\`
+
+**Field notes:**
+- \`quality.rating\` must be one of: \`"good"\`, \`"acceptable"\`, \`"poor"\`
+- \`testModifications.files\` \u2014 list any test files the implementer changed
+- \`fixes\` \u2014 list any fixes you applied yourself during this verification session
+- \`reasoning\` \u2014 brief summary of your overall assessment
+
+When done, commit any fixes with message: "fix: verify and adjust ${story.title}"`;
+}
+
 // src/prompts/loader.ts
 var exports_loader = {};
 __export(exports_loader, {
@@ -24809,6 +25206,9 @@ ${this._constitution}`);
     if (this._story) {
       sections.push(buildStorySection(this._story));
     }
+    if (this._role === "verifier" && this._story) {
+      sections.push(buildVerdictSection(this._story));
+    }
     const isolation = this._options.isolation;
     sections.push(buildIsolationSection(this._role, isolation));
     if (this._contextMd) {
@@ -24897,7 +25297,7 @@ async function rollbackToRef(workdir, ref) {
   }
   logger.info("tdd", "Successfully rolled back git changes", { ref });
 }
-async function runTddSession(role, agent, story, config2, workdir, modelTier, beforeRef, contextMarkdown, lite = false, skipIsolation = false) {
+async function runTddSession(role, agent, story, config2, workdir, modelTier, beforeRef, contextMarkdown, lite = false, skipIsolation = false, constitution) {
   const startTime = Date.now();
   let prompt;
   switch (role) {
@@ -24905,7 +25305,7 @@ async function runTddSession(role, agent, story, config2, workdir, modelTier, be
       prompt = await PromptBuilder.for("test-writer", { isolation: lite ? "lite" : "strict" }).withLoader(workdir, config2).story(story).context(contextMarkdown).build();
       break;
     case "implementer":
-      prompt = await PromptBuilder.for("implementer", { variant: lite ? "lite" : "standard" }).withLoader(workdir, config2).story(story).context(contextMarkdown).build();
+      prompt = await PromptBuilder.for("implementer", { variant: lite ? "lite" : "standard" }).withLoader(workdir, config2).story(story).context(contextMarkdown).constitution(constitution).build();
       break;
     case "verifier":
       prompt = await PromptBuilder.for("verifier").withLoader(workdir, config2).story(story).context(contextMarkdown).build();
@@ -24939,7 +25339,7 @@ async function runTddSession(role, agent, story, config2, workdir, modelTier, be
       exitCode: result.exitCode
     });
   }
-  await autoCommitIfDirty2(workdir, role, story.id);
+  await autoCommitIfDirty(workdir, "tdd", role, story.id);
   let isolation;
   if (!skipIsolation) {
     if (role === "test-writer") {
@@ -24986,42 +25386,11 @@ async function runTddSession(role, agent, story, config2, workdir, modelTier, be
     estimatedCost: result.estimatedCost
   };
 }
-async function autoCommitIfDirty2(workdir, role, storyId) {
-  const logger = getLogger();
-  try {
-    const statusProc = Bun.spawn(["git", "status", "--porcelain"], {
-      cwd: workdir,
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const statusOutput = await new Response(statusProc.stdout).text();
-    await statusProc.exited;
-    if (!statusOutput.trim())
-      return;
-    logger.warn("tdd", `Agent did not commit after ${role} session \u2014 auto-committing`, {
-      role,
-      storyId,
-      dirtyFiles: statusOutput.trim().split(`
-`).length
-    });
-    const addProc = Bun.spawn(["git", "add", "-A"], {
-      cwd: workdir,
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    await addProc.exited;
-    const commitProc = Bun.spawn(["git", "commit", "-m", `chore(${storyId}): auto-commit after ${role} session`], {
-      cwd: workdir,
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    await commitProc.exited;
-  } catch {}
-}
 var init_session_runner = __esm(() => {
   init_config();
   init_logger2();
   init_prompts2();
+  init_git();
   init_cleanup();
   init_isolation();
 });
@@ -25077,6 +25446,95 @@ function isValidVerdict(obj) {
     return false;
   return true;
 }
+function coerceVerdict(obj) {
+  try {
+    const verdictStr = String(obj.verdict ?? "").toUpperCase();
+    const approved = verdictStr === "PASS" || verdictStr === "APPROVED" || verdictStr.startsWith("VERIFIED") || verdictStr.includes("ALL ACCEPTANCE CRITERIA MET") || obj.approved === true;
+    let passCount = 0;
+    let failCount = 0;
+    let allPassing = approved;
+    const summary = obj.verification_summary;
+    if (summary?.test_results && typeof summary.test_results === "string") {
+      const match = summary.test_results.match(/(\d+)\/(\d+)/);
+      if (match) {
+        passCount = Number.parseInt(match[1], 10);
+        const total = Number.parseInt(match[2], 10);
+        failCount = total - passCount;
+        allPassing = failCount === 0;
+      }
+    }
+    if (obj.tests && typeof obj.tests === "object") {
+      const t = obj.tests;
+      if (typeof t.passCount === "number")
+        passCount = t.passCount;
+      if (typeof t.failCount === "number")
+        failCount = t.failCount;
+      if (typeof t.allPassing === "boolean")
+        allPassing = t.allPassing;
+    }
+    const criteria = [];
+    let allMet = approved;
+    const acReview = obj.acceptance_criteria_review;
+    if (acReview) {
+      for (const [key, val] of Object.entries(acReview)) {
+        if (key.startsWith("criterion") && val && typeof val === "object") {
+          const c = val;
+          const met = String(c.status ?? "").toUpperCase() === "SATISFIED" || c.met === true;
+          criteria.push({
+            criterion: String(c.name ?? c.criterion ?? key),
+            met,
+            note: c.evidence ? String(c.evidence).slice(0, 200) : undefined
+          });
+          if (!met)
+            allMet = false;
+        }
+      }
+    }
+    if (obj.acceptanceCriteria && typeof obj.acceptanceCriteria === "object") {
+      const ac = obj.acceptanceCriteria;
+      if (typeof ac.allMet === "boolean")
+        allMet = ac.allMet;
+      if (Array.isArray(ac.criteria)) {
+        for (const c of ac.criteria) {
+          if (c && typeof c === "object") {
+            criteria.push(c);
+          }
+        }
+      }
+    }
+    if (criteria.length === 0 && summary?.acceptance_criteria && typeof summary.acceptance_criteria === "string") {
+      const acMatch = summary.acceptance_criteria.match(/(\d+)\/(\d+)/);
+      if (acMatch) {
+        const met = Number.parseInt(acMatch[1], 10);
+        const total = Number.parseInt(acMatch[2], 10);
+        allMet = met === total;
+      }
+    }
+    let rating = "acceptable";
+    const qualityStr = summary?.code_quality ? String(summary.code_quality).toLowerCase() : obj.quality && typeof obj.quality === "object" ? String(obj.quality.rating ?? "acceptable").toLowerCase() : "acceptable";
+    if (qualityStr === "high" || qualityStr === "good")
+      rating = "good";
+    else if (qualityStr === "low" || qualityStr === "poor")
+      rating = "poor";
+    return {
+      version: 1,
+      approved,
+      tests: { allPassing, passCount, failCount },
+      testModifications: {
+        detected: false,
+        files: [],
+        legitimate: true,
+        reasoning: "Not assessed in free-form verdict"
+      },
+      acceptanceCriteria: { allMet, criteria },
+      quality: { rating, issues: [] },
+      fixes: Array.isArray(obj.fixes) ? obj.fixes : [],
+      reasoning: typeof obj.reasoning === "string" ? obj.reasoning : typeof obj.overall_status === "string" ? obj.overall_status : summary?.overall_status ? String(summary.overall_status) : `Coerced from free-form verdict: ${verdictStr}`
+    };
+  } catch {
+    return null;
+  }
+}
 async function readVerdict(workdir) {
   const logger = getLogger();
   const verdictPath = path8.join(workdir, VERDICT_FILE);
@@ -25086,24 +25544,47 @@ async function readVerdict(workdir) {
     if (!exists) {
       return null;
     }
-    let parsed;
+    let rawText;
     try {
-      parsed = await file2.json();
-    } catch (parseErr) {
-      logger.warn("tdd", "Verifier verdict file is not valid JSON \u2014 ignoring", {
+      rawText = await file2.text();
+    } catch (readErr) {
+      logger.warn("tdd", "Failed to read verifier verdict file", {
         path: verdictPath,
-        error: String(parseErr)
+        error: String(readErr)
       });
       return null;
     }
-    if (!isValidVerdict(parsed)) {
-      logger.warn("tdd", "Verifier verdict file missing required fields \u2014 ignoring", {
+    let parsed;
+    try {
+      parsed = JSON.parse(rawText);
+    } catch (parseErr) {
+      logger.warn("tdd", "Verifier verdict file is not valid JSON \u2014 ignoring", {
         path: verdictPath,
-        content: JSON.stringify(parsed).slice(0, 500)
+        error: String(parseErr),
+        rawContent: rawText.slice(0, 1000)
       });
       return null;
     }
-    return parsed;
+    if (isValidVerdict(parsed)) {
+      return parsed;
+    }
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const coerced = coerceVerdict(parsed);
+      if (coerced) {
+        logger.info("tdd", "Coerced free-form verdict to structured format", {
+          path: verdictPath,
+          approved: coerced.approved,
+          passCount: coerced.tests.passCount,
+          failCount: coerced.tests.failCount
+        });
+        return coerced;
+      }
+    }
+    logger.warn("tdd", "Verifier verdict file missing required fields and coercion failed \u2014 ignoring", {
+      path: verdictPath,
+      content: JSON.stringify(parsed).slice(0, 500)
+    });
+    return null;
   } catch (err) {
     logger.warn("tdd", "Failed to read verifier verdict file \u2014 ignoring", {
       path: verdictPath,
@@ -25182,6 +25663,7 @@ async function runThreeSessionTdd(options) {
     workdir,
     modelTier,
     contextMarkdown,
+    constitution,
     dryRun = false,
     lite = false,
     _recursionDepth = 0
@@ -25243,7 +25725,7 @@ async function runThreeSessionTdd(options) {
   let session1;
   if (!isRetry) {
     const testWriterTier = config2.tdd.sessionTiers?.testWriter ?? "balanced";
-    session1 = await runTddSession("test-writer", agent, story, config2, workdir, testWriterTier, session1Ref, contextMarkdown, lite, lite);
+    session1 = await runTddSession("test-writer", agent, story, config2, workdir, testWriterTier, session1Ref, contextMarkdown, lite, lite, constitution);
     sessions.push(session1);
   }
   if (session1 && !session1.success) {
@@ -25305,7 +25787,7 @@ async function runThreeSessionTdd(options) {
   });
   const session2Ref = await captureGitRef(workdir) ?? "HEAD";
   const implementerTier = config2.tdd.sessionTiers?.implementer ?? modelTier;
-  const session2 = await runTddSession("implementer", agent, story, config2, workdir, implementerTier, session2Ref, contextMarkdown, lite, lite);
+  const session2 = await runTddSession("implementer", agent, story, config2, workdir, implementerTier, session2Ref, contextMarkdown, lite, lite, constitution);
   sessions.push(session2);
   if (!session2.success) {
     needsHumanReview = true;
@@ -25324,7 +25806,7 @@ async function runThreeSessionTdd(options) {
   const fullSuiteGatePassed = await runFullSuiteGate(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger);
   const session3Ref = await captureGitRef(workdir) ?? "HEAD";
   const verifierTier = config2.tdd.sessionTiers?.verifier ?? "fast";
-  const session3 = await runTddSession("verifier", agent, story, config2, workdir, verifierTier, session3Ref, undefined, false, false);
+  const session3 = await runTddSession("verifier", agent, story, config2, workdir, verifierTier, session3Ref, undefined, false, false, constitution);
   sessions.push(session3);
   const verdict = await readVerdict(workdir);
   await cleanupVerdict(workdir);
@@ -25424,6 +25906,7 @@ var init_orchestrator2 = __esm(() => {
   init_config();
   init_greenfield();
   init_logger2();
+  init_git();
   init_verification();
   init_rectification_gate();
   init_session_runner();
@@ -25469,34 +25952,6 @@ function routeTddFailure(failureCategory, isLiteMode, ctx, reviewReason) {
     reason: reviewReason || "Three-session TDD requires review"
   };
 }
-async function autoCommitIfDirty3(workdir, role, storyId) {
-  try {
-    const statusProc = Bun.spawn(["git", "status", "--porcelain"], {
-      cwd: workdir,
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const statusOutput = await new Response(statusProc.stdout).text();
-    await statusProc.exited;
-    if (!statusOutput.trim())
-      return;
-    const logger = getLogger();
-    logger.warn("execution", `Agent did not commit after ${role} session \u2014 auto-committing`, {
-      role,
-      storyId,
-      dirtyFiles: statusOutput.trim().split(`
-`).length
-    });
-    const addProc = Bun.spawn(["git", "add", "-A"], { cwd: workdir, stdout: "pipe", stderr: "pipe" });
-    await addProc.exited;
-    const commitProc = Bun.spawn(["git", "commit", "-m", `chore(${storyId}): auto-commit after ${role} session`], {
-      cwd: workdir,
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    await commitProc.exited;
-  } catch {}
-}
 var executionStage, _executionDeps;
 var init_execution = __esm(() => {
   init_agents();
@@ -25504,6 +25959,7 @@ var init_execution = __esm(() => {
   init_triggers();
   init_logger2();
   init_tdd();
+  init_git();
   executionStage = {
     name: "execution",
     enabled: () => true,
@@ -25530,6 +25986,7 @@ var init_execution = __esm(() => {
           workdir: ctx.workdir,
           modelTier: ctx.routing.modelTier,
           contextMarkdown: ctx.contextMarkdown,
+          constitution: ctx.constitution?.content,
           dryRun: false,
           lite: isLiteMode
         });
@@ -25553,6 +26010,28 @@ var init_execution = __esm(() => {
               lite: tddResult.lite,
               failureCategory: tddResult.failureCategory
             });
+            if (ctx.interaction) {
+              try {
+                await ctx.interaction.send({
+                  id: `human-review-${ctx.story.id}-${Date.now()}`,
+                  type: "notify",
+                  featureName: ctx.featureDir ? ctx.featureDir.split("/").pop() ?? "unknown" : "unknown",
+                  storyId: ctx.story.id,
+                  stage: "execution",
+                  summary: `\u26A0\uFE0F Human review needed: ${ctx.story.id}`,
+                  detail: `Story: ${ctx.story.title}
+Reason: ${tddResult.reviewReason ?? "No reason provided"}
+Category: ${tddResult.failureCategory ?? "unknown"}`,
+                  fallback: "continue",
+                  createdAt: Date.now()
+                });
+              } catch (notifyErr) {
+                logger.warn("execution", "Failed to send human review notification", {
+                  storyId: ctx.story.id,
+                  error: String(notifyErr)
+                });
+              }
+            }
           }
           return routeTddFailure(tddResult.failureCategory, isLiteMode, ctx, tddResult.reviewReason);
         }
@@ -25578,7 +26057,7 @@ var init_execution = __esm(() => {
         dangerouslySkipPermissions: ctx.config.execution.dangerouslySkipPermissions
       });
       ctx.agentResult = result;
-      await autoCommitIfDirty3(ctx.workdir, "single-session", ctx.story.id);
+      await autoCommitIfDirty(ctx.workdir, "execution", "single-session", ctx.story.id);
       const combinedOutput = (result.output ?? "") + (result.stderr ?? "");
       if (_executionDeps.detectMergeConflict(combinedOutput) && ctx.interaction && isTriggerEnabled("merge-conflict", ctx.config)) {
         const shouldProceed = await _executionDeps.checkMergeConflict({ featureName: ctx.prd.feature, storyId: ctx.story.id }, ctx.config, ctx.interaction);
@@ -25623,16 +26102,11 @@ var init_execution = __esm(() => {
   };
 });
 
-// src/optimizer/types.ts
-function estimateTokens4(text) {
-  return Math.ceil(text.length / 4);
-}
-
 // src/optimizer/noop.optimizer.ts
 class NoopOptimizer {
   name = "noop";
   async optimize(input) {
-    const tokens = estimateTokens4(input.prompt);
+    const tokens = estimateTokens(input.prompt);
     return {
       prompt: input.prompt,
       originalTokens: tokens,
@@ -25648,7 +26122,7 @@ var init_noop_optimizer = () => {};
 class RuleBasedOptimizer {
   name = "rule-based";
   async optimize(input) {
-    const originalTokens = estimateTokens4(input.prompt);
+    const originalTokens = estimateTokens(input.prompt);
     const appliedRules = [];
     let optimized = input.prompt;
     const config2 = {
@@ -25677,13 +26151,13 @@ class RuleBasedOptimizer {
       }
     }
     if (config2.maxPromptTokens) {
-      const currentTokens = estimateTokens4(optimized);
+      const currentTokens = estimateTokens(optimized);
       if (currentTokens > config2.maxPromptTokens) {
         optimized = this.trimToMaxTokens(optimized, config2.maxPromptTokens);
         appliedRules.push("maxPromptTokens");
       }
     }
-    const optimizedTokens = estimateTokens4(optimized);
+    const optimizedTokens = estimateTokens(optimized);
     const savings = originalTokens > 0 ? (originalTokens - optimizedTokens) / originalTokens : 0;
     return {
       prompt: optimized,
@@ -25726,7 +26200,7 @@ ${newContextSection}`);
     return prompt;
   }
   trimToMaxTokens(prompt, maxTokens) {
-    const currentTokens = estimateTokens4(prompt);
+    const currentTokens = estimateTokens(prompt);
     if (currentTokens <= maxTokens) {
       return prompt;
     }
@@ -25865,7 +26339,7 @@ var init_optimizer2 = __esm(() => {
 });
 
 // src/execution/prompts.ts
-function buildBatchPrompt2(stories, contextMarkdown, constitution) {
+function buildBatchPrompt(stories, contextMarkdown, constitution) {
   const storyPrompts = stories.map((story, idx) => {
     return `## Story ${idx + 1}: ${story.id} \u2014 ${story.title}
 
@@ -25923,7 +26397,7 @@ var init_prompt = __esm(() => {
       const isBatch = ctx.stories.length > 1;
       let prompt;
       if (isBatch) {
-        prompt = buildBatchPrompt2(ctx.stories, ctx.contextMarkdown, ctx.constitution);
+        prompt = buildBatchPrompt(ctx.stories, ctx.contextMarkdown, ctx.constitution);
       } else {
         const role = ctx.routing.testStrategy === "tdd-simple" ? "tdd-simple" : "single-session";
         const builder = PromptBuilder.for(role).withLoader(ctx.workdir, ctx.config).story(ctx.story).context(ctx.contextMarkdown).constitution(ctx.constitution?.content);
@@ -26211,7 +26685,6 @@ ${rectificationPrompt}`;
 var init_rectification_loop = __esm(() => {
   init_agents();
   init_config();
-  init_progress();
   init_test_output_parser();
   init_logger2();
   init_prd();
@@ -26616,6 +27089,7 @@ function reverseMapTestToSource(testFiles, workdir) {
 }
 var _smartRunnerDeps;
 var init_smart_runner = __esm(() => {
+  init_git();
   _smartRunnerDeps = {
     getChangedSourceFiles,
     mapSourceToTests,
@@ -26851,6 +27325,7 @@ async function runDecompose(story, prd, config2, _workdir) {
 }
 var routingStage, _routingDeps;
 var init_routing2 = __esm(() => {
+  init_registry();
   init_greenfield();
   init_builder2();
   init_triggers();
@@ -26863,6 +27338,8 @@ var init_routing2 = __esm(() => {
     enabled: () => true,
     async execute(ctx) {
       const logger = getLogger();
+      const agentName = ctx.config.execution?.agent ?? "claude";
+      const adapter = _routingDeps.getAgent(agentName);
       const hasExistingRouting = ctx.story.routing !== undefined;
       const hasContentHash = ctx.story.routing?.contentHash !== undefined;
       let currentHash;
@@ -26874,7 +27351,7 @@ var init_routing2 = __esm(() => {
       const isCacheHit = hasExistingRouting && (!hasContentHash || hashMatch);
       let routing;
       if (isCacheHit) {
-        routing = await _routingDeps.routeStory(ctx.story, { config: ctx.config }, ctx.workdir, ctx.plugins);
+        routing = await _routingDeps.routeStory(ctx.story, { config: ctx.config, adapter }, ctx.workdir, ctx.plugins);
         if (ctx.story.routing?.complexity)
           routing.complexity = ctx.story.routing.complexity;
         if (!hasContentHash && ctx.story.routing?.testStrategy)
@@ -26885,7 +27362,7 @@ var init_routing2 = __esm(() => {
           routing.modelTier = _routingDeps.complexityToModelTier(routing.complexity, ctx.config);
         }
       } else {
-        routing = await _routingDeps.routeStory(ctx.story, { config: ctx.config }, ctx.workdir, ctx.plugins);
+        routing = await _routingDeps.routeStory(ctx.story, { config: ctx.config, adapter }, ctx.workdir, ctx.plugins);
         currentHash = currentHash ?? _routingDeps.computeStoryContentHash(ctx.story);
         ctx.story.routing = {
           ...ctx.story.routing ?? {},
@@ -26974,7 +27451,8 @@ var init_routing2 = __esm(() => {
     computeStoryContentHash,
     applyDecomposition,
     runDecompose,
-    checkStoryOversized
+    checkStoryOversized,
+    getAgent
   };
 });
 
@@ -28065,10 +28543,55 @@ async function checkPromptOverrideFiles(config2, workdir) {
 }
 var init_checks_warnings = () => {};
 
+// src/precheck/checks-agents.ts
+async function checkMultiAgentHealth() {
+  try {
+    const versions2 = await getAgentVersions();
+    const installed = versions2.filter((v) => v.installed);
+    const notInstalled = versions2.filter((v) => !v.installed);
+    const lines = [];
+    if (installed.length > 0) {
+      lines.push(`Installed agents (${installed.length}):`);
+      for (const agent of installed) {
+        const versionStr = agent.version ? ` v${agent.version}` : " (version unknown)";
+        lines.push(`  \u2022 ${agent.displayName}${versionStr}`);
+      }
+    } else {
+      lines.push("No additional agents detected (using default configured agent)");
+    }
+    if (notInstalled.length > 0) {
+      lines.push(`
+Available but not installed (${notInstalled.length}):`);
+      for (const agent of notInstalled) {
+        lines.push(`  \u2022 ${agent.displayName}`);
+      }
+    }
+    const message = lines.join(`
+`);
+    return {
+      name: "multi-agent-health",
+      tier: "warning",
+      passed: true,
+      message
+    };
+  } catch (error48) {
+    return {
+      name: "multi-agent-health",
+      tier: "warning",
+      passed: true,
+      message: `Agent detection: ${error48 instanceof Error ? error48.message : "Unknown error"}`
+    };
+  }
+}
+var init_checks_agents = __esm(() => {
+  init_version_detection();
+});
+
 // src/precheck/checks.ts
 var init_checks3 = __esm(() => {
   init_checks_blockers();
   init_checks_warnings();
+  init_checks_agents();
 });
 
 // src/precheck/story-size-gate.ts
@@ -28214,7 +28737,8 @@ async function runPrecheck(config2, prd, options) {
       () => checkPendingStories(prd),
       () => checkOptionalCommands(config2, workdir),
       () => checkGitignoreCoversNax(workdir),
-      () => checkPromptOverrideFiles(config2, workdir)
+      () => checkPromptOverrideFiles(config2, workdir),
+      () => checkMultiAgentHealth()
     ];
     for (const checkFn of tier2Checks) {
       const result = await checkFn();
@@ -29364,6 +29888,7 @@ var init_run_initialization = __esm(() => {
   init_errors3();
   init_logger2();
   init_prd();
+  init_git();
 });
 
 // src/execution/lifecycle/run-setup.ts
@@ -30947,6 +31472,7 @@ var init_iteration_runner = __esm(() => {
   init_logger2();
   init_runner();
   init_stages();
+  init_git();
   init_dry_run();
   init_pipeline_result_handler();
 });
@@ -31515,6 +32041,7 @@ var _regressionDeps;
 var init_run_regression = __esm(() => {
   init_logger2();
   init_prd();
+  init_git();
   init_verification();
   init_rectification_loop();
   init_runners();
@@ -62594,9 +63121,6 @@ var {
   Help
 } = import__.default;
 
-// bin/nax.ts
-init_agents();
-
 // src/cli/analyze.ts
 init_acceptance();
 init_registry();
@@ -64717,6 +65241,25 @@ var claudeGenerator = {
   generate: generateClaudeConfig
 };
 
+// src/context/generators/codex.ts
+function generateCodexConfig(context) {
+  const header = `# Codex Instructions
+
+This file is auto-generated from \`nax/context.md\`.
+DO NOT EDIT MANUALLY \u2014 run \`nax generate\` to regenerate.
+
+---
+
+`;
+  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
+  return header + metaSection + context.markdown;
+}
+var codexGenerator = {
+  name: "codex",
+  outputFile: "codex.md",
+  generate: generateCodexConfig
+};
+
 // src/context/generators/cursor.ts
 function generateCursorRules(context) {
   const header = `# Project Rules
@@ -64736,6 +65279,25 @@ var cursorGenerator = {
   generate: generateCursorRules
 };
 
+// src/context/generators/gemini.ts
+function generateGeminiConfig(context) {
+  const header = `# Gemini CLI Context
+
+This file is auto-generated from \`nax/context.md\`.
+DO NOT EDIT MANUALLY \u2014 run \`nax generate\` to regenerate.
+
+---
+
+`;
+  const metaSection = context.metadata ? formatMetadataSection(context.metadata) : "";
+  return header + metaSection + context.markdown;
+}
+var geminiGenerator = {
+  name: "gemini",
+  outputFile: "GEMINI.md",
+  generate: generateGeminiConfig
+};
+
 // src/context/generators/opencode.ts
 function generateOpencodeConfig(context) {
   const header = `# Agent Instructions
@@ -64779,10 +65341,12 @@ var windsurfGenerator = {
 // src/context/generator.ts
 var GENERATORS = {
   claude: claudeGenerator,
+  codex: codexGenerator,
   opencode: opencodeGenerator,
   cursor: cursorGenerator,
   windsurf: windsurfGenerator,
-  aider: aiderGenerator
+  aider: aiderGenerator,
+  gemini: geminiGenerator
 };
 async function loadContextContent(options, config2) {
   if (!existsSync18(options.contextPath)) {
@@ -64834,7 +65398,7 @@ async function generateAll(options, config2) {
 }
 
 // src/cli/generate.ts
-var VALID_AGENTS = ["claude", "opencode", "cursor", "windsurf", "aider"];
+var VALID_AGENTS = ["claude", "codex", "opencode", "cursor", "windsurf", "aider", "gemini"];
 async function generateCommand(options) {
   const workdir = process.cwd();
   const contextPath = options.context ? join24(workdir, options.context) : join24(workdir, "nax/context.md");
@@ -64922,19 +65486,19 @@ var FIELD_DESCRIPTIONS = {
   "models.fast": "Fast model for lightweight tasks (e.g., haiku)",
   "models.balanced": "Balanced model for general coding (e.g., sonnet)",
   "models.powerful": "Powerful model for complex tasks (e.g., opus)",
-  autoMode: "Auto mode configuration for agent orchestration",
+  autoMode: "Auto mode configuration for agent orchestration. Enables multi-agent routing with model tier selection per task complexity and escalation on failures.",
   "autoMode.enabled": "Enable automatic agent selection and escalation",
-  "autoMode.defaultAgent": "Default agent to use (e.g., claude, codex)",
-  "autoMode.fallbackOrder": "Fallback order when agent is rate-limited",
-  "autoMode.complexityRouting": "Model tier per complexity level",
-  "autoMode.complexityRouting.simple": "Model tier for simple tasks",
-  "autoMode.complexityRouting.medium": "Model tier for medium tasks",
-  "autoMode.complexityRouting.complex": "Model tier for complex tasks",
-  "autoMode.complexityRouting.expert": "Model tier for expert tasks",
-  "autoMode.escalation": "Escalation settings for failed stories",
+  "autoMode.defaultAgent": "Default agent to use when no specific agent is requested. Examples: 'claude' (Claude Code), 'codex' (GitHub Copilot), 'opencode' (OpenCode). The agent handles the main coding tasks.",
+  "autoMode.fallbackOrder": 'Fallback order for agent selection when the primary agent is rate-limited, unavailable, or fails. Tries each agent in sequence until one succeeds. Example: ["claude", "codex", "opencode"] means try Claude first, then Copilot, then OpenCode.',
+  "autoMode.complexityRouting": "Model tier routing rules mapped to story complexity levels. Determines which model (fast/balanced/powerful) to use based on task complexity: simple \u2192 fast, medium \u2192 balanced, complex \u2192 powerful, expert \u2192 powerful.",
+  "autoMode.complexityRouting.simple": "Model tier for simple tasks (low complexity, straightforward changes)",
+  "autoMode.complexityRouting.medium": "Model tier for medium tasks (moderate complexity, multi-file changes)",
+  "autoMode.complexityRouting.complex": "Model tier for complex tasks (high complexity, architectural decisions)",
+  "autoMode.complexityRouting.expert": "Model tier for expert tasks (highest complexity, novel problems, design patterns)",
+  "autoMode.escalation": "Escalation settings for failed stories. When a story fails after max attempts at current tier, escalate to the next tier in tierOrder. Enables progressive use of more powerful models.",
   "autoMode.escalation.enabled": "Enable tier escalation on failure",
-  "autoMode.escalation.tierOrder": "Ordered tier escalation with per-tier attempt budgets",
-  "autoMode.escalation.escalateEntireBatch": "Escalate all stories in batch when one fails",
+  "autoMode.escalation.tierOrder": 'Ordered tier escalation chain with per-tier attempt budgets. Format: [{"tier": "fast", "attempts": 2}, {"tier": "balanced", "attempts": 2}, {"tier": "powerful", "attempts": 1}]. Allows each tier to attempt fixes before escalating to the next.',
+  "autoMode.escalation.escalateEntireBatch": "When enabled, escalate all stories in a batch if one fails. When disabled, only the failing story escalates (allows parallel attempts at different tiers).",
   routing: "Model routing strategy configuration",
   "routing.strategy": "Routing strategy: keyword | llm | manual | adaptive | custom",
   "routing.customStrategyPath": "Path to custom routing strategy (if strategy=custom)",
@@ -65243,8 +65807,11 @@ function displayConfigWithDescriptions(obj, path13, sources, indent = 0) {
     const currentPathStr = currentPath.join(".");
     const description = FIELD_DESCRIPTIONS[currentPathStr];
     if (description) {
-      const isPromptsSubSection = currentPathStr.startsWith("prompts.");
-      const comment = isPromptsSubSection ? `${currentPathStr}: ${description}` : description;
+      const pathParts = currentPathStr.split(".");
+      const isDirectSubsection = pathParts.length === 2;
+      const isKeySection = ["prompts", "autoMode", "models", "routing"].includes(pathParts[0]);
+      const shouldIncludePath = isKeySection && isDirectSubsection;
+      const comment = shouldIncludePath ? `${currentPathStr}: ${description}` : description;
       console.log(`${indentStr}# ${comment}`);
     }
     if (value !== null && typeof value === "object" && !Array.isArray(value)) {
@@ -65312,6 +65879,55 @@ function formatValueForTable(value) {
   }
   return String(value);
 }
+// src/cli/agents.ts
+init_registry();
+init_version_detection();
+async function agentsListCommand(config2, _workdir) {
+  const agentVersions = await Promise.all(ALL_AGENTS.map(async (agent) => ({
+    name: agent.name,
+    displayName: agent.displayName,
+    binary: agent.binary,
+    version: await getAgentVersion(agent.binary),
+    installed: await agent.isInstalled(),
+    capabilities: agent.capabilities,
+    isDefault: config2.autoMode.defaultAgent === agent.name
+  })));
+  const rows = agentVersions.map((info) => {
+    const status = info.installed ? "installed" : "unavailable";
+    const versionStr = info.version || "-";
+    const defaultMarker = info.isDefault ? " (default)" : "";
+    return {
+      name: info.displayName + defaultMarker,
+      status,
+      version: versionStr,
+      binary: info.binary,
+      tiers: info.capabilities.supportedTiers.join(", ")
+    };
+  });
+  if (rows.length === 0) {
+    console.log("No agents available.");
+    return;
+  }
+  const widths = {
+    name: Math.max(5, ...rows.map((r) => r.name.length)),
+    status: Math.max(6, ...rows.map((r) => r.status.length)),
+    version: Math.max(7, ...rows.map((r) => r.version.length)),
+    binary: Math.max(6, ...rows.map((r) => r.binary.length)),
+    tiers: Math.max(5, ...rows.map((r) => r.tiers.length))
+  };
+  console.log(`
+Available Agents:
+`);
+  console.log(`${pad2("Agent", widths.name)}  ${pad2("Status", widths.status)}  ${pad2("Version", widths.version)}  ${pad2("Binary", widths.binary)}  ${pad2("Tiers", widths.tiers)}`);
+  console.log(`${"-".repeat(widths.name)}  ${"-".repeat(widths.status)}  ${"-".repeat(widths.version)}  ${"-".repeat(widths.binary)}  ${"-".repeat(widths.tiers)}`);
+  for (const row of rows) {
+    console.log(`${pad2(row.name, widths.name)}  ${pad2(row.status, widths.status)}  ${pad2(row.version, widths.version)}  ${pad2(row.binary, widths.binary)}  ${pad2(row.tiers, widths.tiers)}`);
+  }
+  console.log();
+}
+function pad2(str, width) {
+  return str.padEnd(width);
+}
 // src/commands/diagnose.ts
 async function diagnose(options) {
   await diagnoseCommand(options);
@@ -65688,7 +66304,7 @@ var ANSI_RE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
 function visibleLength(str) {
   return str.replace(ANSI_RE, "").length;
 }
-function pad2(str, width) {
+function pad3(str, width) {
   const padding = Math.max(0, width - visibleLength(str));
   return str + " ".repeat(padding);
 }
@@ -65747,12 +66363,12 @@ async function runsCommand(options = {}) {
     date: 11
   };
   const header = [
-    pad2(source_default.bold("RUN ID"), COL.runId),
-    pad2(source_default.bold("PROJECT"), COL.project),
-    pad2(source_default.bold("FEATURE"), COL.feature),
-    pad2(source_default.bold("STATUS"), COL.status),
-    pad2(source_default.bold("STORIES"), COL.stories),
-    pad2(source_default.bold("DURATION"), COL.duration),
+    pad3(source_default.bold("RUN ID"), COL.runId),
+    pad3(source_default.bold("PROJECT"), COL.project),
+    pad3(source_default.bold("FEATURE"), COL.feature),
+    pad3(source_default.bold("STATUS"), COL.status),
+    pad3(source_default.bold("STORIES"), COL.stories),
+    pad3(source_default.bold("DURATION"), COL.duration),
     source_default.bold("DATE")
   ].join("  ");
   console.log();
@@ -65761,12 +66377,12 @@ async function runsCommand(options = {}) {
   for (const row of displayed) {
     const colored = colorStatus(row.status);
     const line = [
-      pad2(row.runId, COL.runId),
-      pad2(row.project, COL.project),
-      pad2(row.feature, COL.feature),
-      pad2(colored, COL.status + (colored.length - visibleLength(colored))),
-      pad2(`${row.passed}/${row.total}`, COL.stories),
-      pad2(formatDuration3(row.durationMs), COL.duration),
+      pad3(row.runId, COL.runId),
+      pad3(row.project, COL.project),
+      pad3(row.feature, COL.feature),
+      pad3(colored, COL.status + (colored.length - visibleLength(colored))),
+      pad3(`${row.passed}/${row.total}`, COL.stories),
+      pad3(formatDuration3(row.durationMs), COL.duration),
       formatDate(row.registeredAt)
     ].join("  ");
     console.log(line);
@@ -73839,16 +74455,21 @@ program2.command("analyze").description("Parse spec.md into prd.json via agent d
     process.exit(1);
   }
 });
-program2.command("agents").description("Check available coding agents").action(async () => {
-  const health = await checkAgentHealth();
-  console.log(source_default.bold(`
-Coding Agents:
-`));
-  for (const agent of health) {
-    const status = agent.installed ? source_default.green("\u2705 installed") : source_default.red("\u274C not found");
-    console.log(`  ${agent.displayName.padEnd(15)} ${status}`);
+program2.command("agents").description("List available coding agents with status and capabilities").option("-d, --dir <path>", "Project directory", process.cwd()).action(async (options) => {
+  let workdir;
+  try {
+    workdir = validateDirectory(options.dir);
+  } catch (err) {
+    console.error(source_default.red(`Invalid directory: ${err.message}`));
+    process.exit(1);
+  }
+  try {
+    const config2 = await loadConfig(workdir);
+    await agentsListCommand(config2, workdir);
+  } catch (err) {
+    console.error(source_default.red(`Error: ${err.message}`));
+    process.exit(1);
   }
-  console.log();
 });
 program2.command("config").description("Display effective merged configuration").option("--explain", "Show detailed field descriptions", false).option("--diff", "Show only fields where project overrides global", false).action(async (options) => {
   try {