@nathapp/nax 0.35.0 → 0.36.0

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";
 
@@ -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;
@@ -20412,7 +20657,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.35.0",
+    version: "0.36.0",
     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("78b52b0"))
+        return "78b52b0";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -23778,6 +24023,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 +24242,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");
@@ -24512,7 +24850,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 +24895,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();
@@ -24939,7 +25251,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 +25298,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 +25358,95 @@ function isValidVerdict(obj) {
     return false;
   return true;
 }
+function coerceVerdict(obj) {
+  try {
+    const verdictStr = String(obj.verdict ?? "").toUpperCase();
+    const approved = verdictStr === "PASS" || verdictStr === "APPROVED" || 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);
@@ -25096,14 +25466,26 @@ async function readVerdict(workdir) {
       });
       return null;
     }
-    if (!isValidVerdict(parsed)) {
-      logger.warn("tdd", "Verifier verdict file missing required fields \u2014 ignoring", {
-        path: verdictPath,
-        content: JSON.stringify(parsed).slice(0, 500)
-      });
-      return null;
+    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;
+      }
     }
-    return parsed;
+    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,
@@ -25424,6 +25806,7 @@ var init_orchestrator2 = __esm(() => {
   init_config();
   init_greenfield();
   init_logger2();
+  init_git();
   init_verification();
   init_rectification_gate();
   init_session_runner();
@@ -25469,34 +25852,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 +25859,7 @@ var init_execution = __esm(() => {
   init_triggers();
   init_logger2();
   init_tdd();
+  init_git();
   executionStage = {
     name: "execution",
     enabled: () => true,
@@ -25578,7 +25934,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);
@@ -26616,6 +26972,7 @@ function reverseMapTestToSource(testFiles, workdir) {
 }
 var _smartRunnerDeps;
 var init_smart_runner = __esm(() => {
+  init_git();
   _smartRunnerDeps = {
     getChangedSourceFiles,
     mapSourceToTests,
@@ -26851,6 +27208,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 +27221,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 +27234,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 +27245,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 +27334,8 @@ var init_routing2 = __esm(() => {
     computeStoryContentHash,
     applyDecomposition,
     runDecompose,
-    checkStoryOversized
+    checkStoryOversized,
+    getAgent
   };
 });
 
@@ -28065,10 +28426,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 +28620,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 +29771,7 @@ var init_run_initialization = __esm(() => {
   init_errors3();
   init_logger2();
   init_prd();
+  init_git();
 });
 
 // src/execution/lifecycle/run-setup.ts
@@ -30947,6 +31355,7 @@ var init_iteration_runner = __esm(() => {
   init_logger2();
   init_runner();
   init_stages();
+  init_git();
   init_dry_run();
   init_pipeline_result_handler();
 });
@@ -31515,6 +31924,7 @@ var _regressionDeps;
 var init_run_regression = __esm(() => {
   init_logger2();
   init_prd();
+  init_git();
   init_verification();
   init_rectification_loop();
   init_runners();
@@ -62594,9 +63004,6 @@ var {
   Help
 } = import__.default;
 
-// bin/nax.ts
-init_agents();
-
 // src/cli/analyze.ts
 init_acceptance();
 init_registry();
@@ -64717,6 +65124,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 +65162,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 +65224,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 +65281,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 +65369,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 +65690,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 +65762,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 +66187,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 +66246,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 +66260,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 +74338,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 {