@nathapp/nax 0.34.0 → 0.36.0

package/dist/nax.js

@@ -3024,796 +3024,6 @@ var init_logger2 = __esm(() => {
   init_formatters();
 });
 
-// src/execution/pid-registry.ts
-import { existsSync } from "fs";
-
-class PidRegistry {
-  workdir;
-  pidsFilePath;
-  pids = new Set;
-  platform;
-  constructor(workdir, platform) {
-    this.workdir = workdir;
-    this.pidsFilePath = `${workdir}/${PID_REGISTRY_FILE}`;
-    this.platform = platform ?? process.platform;
-  }
-  async register(pid) {
-    const logger = getSafeLogger();
-    this.pids.add(pid);
-    const entry = {
-      pid,
-      spawnedAt: new Date().toISOString(),
-      workdir: this.workdir
-    };
-    try {
-      let existingContent = "";
-      if (existsSync(this.pidsFilePath)) {
-        existingContent = await Bun.file(this.pidsFilePath).text();
-      }
-      const line = `${JSON.stringify(entry)}
-`;
-      await Bun.write(this.pidsFilePath, existingContent + line);
-      logger?.debug("pid-registry", `Registered PID ${pid}`, { pid });
-    } catch (err) {
-      logger?.warn("pid-registry", `Failed to write PID ${pid} to registry`, {
-        error: err.message
-      });
-    }
-  }
-  async unregister(pid) {
-    const logger = getSafeLogger();
-    this.pids.delete(pid);
-    try {
-      await this.writePidsFile();
-      logger?.debug("pid-registry", `Unregistered PID ${pid}`, { pid });
-    } catch (err) {
-      logger?.warn("pid-registry", `Failed to unregister PID ${pid}`, {
-        error: err.message
-      });
-    }
-  }
-  async killAll() {
-    const logger = getSafeLogger();
-    const pids = Array.from(this.pids);
-    if (pids.length === 0) {
-      logger?.debug("pid-registry", "No PIDs to kill");
-      return;
-    }
-    logger?.info("pid-registry", `Killing ${pids.length} registered processes`, { pids });
-    const killPromises = pids.map((pid) => this.killPid(pid));
-    await Promise.allSettled(killPromises);
-    try {
-      await Bun.write(this.pidsFilePath, "");
-      this.pids.clear();
-      logger?.info("pid-registry", "All registered PIDs killed and registry cleared");
-    } catch (err) {
-      logger?.warn("pid-registry", "Failed to clear registry file", {
-        error: err.message
-      });
-    }
-  }
-  async cleanupStale() {
-    const logger = getSafeLogger();
-    if (!existsSync(this.pidsFilePath)) {
-      logger?.debug("pid-registry", "No stale PIDs file found");
-      return;
-    }
-    try {
-      const content = await Bun.file(this.pidsFilePath).text();
-      const lines = content.split(`
-`).filter((line) => line.trim()).map((line) => {
-        try {
-          return JSON.parse(line);
-        } catch {
-          return null;
-        }
-      }).filter((entry) => entry !== null);
-      if (lines.length === 0) {
-        logger?.debug("pid-registry", "No stale PIDs to cleanup");
-        await Bun.write(this.pidsFilePath, "");
-        return;
-      }
-      const stalePids = lines.map((entry) => entry.pid);
-      logger?.info("pid-registry", `Cleaning up ${stalePids.length} stale PIDs from previous run`, {
-        pids: stalePids
-      });
-      const killPromises = stalePids.map((pid) => this.killPid(pid));
-      await Promise.allSettled(killPromises);
-      await Bun.write(this.pidsFilePath, "");
-      logger?.info("pid-registry", "Stale PIDs cleanup completed");
-    } catch (err) {
-      logger?.warn("pid-registry", "Failed to cleanup stale PIDs", {
-        error: err.message
-      });
-    }
-  }
-  async killPid(pid) {
-    const logger = getSafeLogger();
-    try {
-      const checkProc = Bun.spawn(["kill", "-0", String(pid)], {
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const checkCode = await checkProc.exited;
-      if (checkCode !== 0) {
-        logger?.debug("pid-registry", `PID ${pid} not found (already exited)`, { pid });
-        return;
-      }
-      const killArgs = this.platform === "linux" ? ["kill", "-TERM", `-${pid}`] : ["kill", "-TERM", String(pid)];
-      const killProc = Bun.spawn(killArgs, {
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const killCode = await killProc.exited;
-      if (killCode === 0) {
-        logger?.debug("pid-registry", `Killed PID ${pid}`, { pid });
-      } else {
-        const stderr = await new Response(killProc.stderr).text();
-        logger?.warn("pid-registry", `Failed to kill PID ${pid}`, {
-          pid,
-          exitCode: killCode,
-          stderr: stderr.trim()
-        });
-      }
-    } catch (err) {
-      logger?.warn("pid-registry", `Error killing PID ${pid}`, {
-        pid,
-        error: err.message
-      });
-    }
-  }
-  async writePidsFile() {
-    const entries = Array.from(this.pids).map((pid) => ({
-      pid,
-      spawnedAt: new Date().toISOString(),
-      workdir: this.workdir
-    }));
-    const content = entries.map((entry) => JSON.stringify(entry)).join(`
-`);
-    await Bun.write(this.pidsFilePath, content ? `${content}
-` : "");
-  }
-  getPids() {
-    return Array.from(this.pids);
-  }
-}
-var PID_REGISTRY_FILE = ".nax-pids";
-var init_pid_registry = __esm(() => {
-  init_logger2();
-});
-
-// src/agents/claude-decompose.ts
-function buildDecomposePrompt(options) {
-  return `You are a requirements analyst. Break down the following feature specification into user stories and classify each story's complexity.
-
-CODEBASE CONTEXT:
-${options.codebaseContext}
-
-FEATURE SPECIFICATION:
-${options.specContent}
-
-Decompose this spec into user stories. For each story, provide:
-1. id: Story ID (e.g., "US-001")
-2. title: Concise story title
-3. description: What needs to be implemented
-4. acceptanceCriteria: Array of testable criteria
-5. tags: Array of routing tags (e.g., ["security", "api"])
-6. dependencies: Array of story IDs this depends on (e.g., ["US-001"])
-7. complexity: "simple" | "medium" | "complex" | "expert"
-8. contextFiles: Array of file paths to inject into agent prompt before execution
-9. reasoning: Why this complexity level
-10. estimatedLOC: Estimated lines of code to change
-11. risks: Array of implementation risks
-12. testStrategy: "three-session-tdd" | "test-after"
-
-testStrategy rules:
-- "three-session-tdd": ONLY for complex/expert tasks that are security-critical (auth, encryption, tokens, credentials) or define public API contracts consumers depend on
-- "test-after": for all other tasks including simple/medium complexity
-- A "simple" complexity task should almost never be "three-session-tdd"
-
-Complexity classification rules:
-- simple: 1-3 files, <100 LOC, straightforward implementation, existing patterns
-- medium: 3-6 files, 100-300 LOC, moderate logic, some new patterns
-- complex: 6+ files, 300-800 LOC, architectural changes, cross-cutting concerns
-- expert: Security/crypto/real-time/distributed systems, >800 LOC, new infrastructure
-
-Grouping Guidelines:
-- Combine small, related tasks (e.g., multiple utility functions, interfaces) into a single "simple" or "medium" story.
-- Do NOT create separate stories for every single file or function unless complex.
-- Aim for coherent units of value (e.g., "Implement User Authentication" vs "Create User Interface", "Create Login Service").
-- Maximum recommended stories: 10-15 per feature. Group aggressively if list grows too long.
-
-Consider:
-1. Does infrastructure exist? (e.g., "add caching" when no cache layer exists = complex)
-2. How many files will be touched?
-3. Are there cross-cutting concerns (auth, validation, error handling)?
-4. Does it require new dependencies or architectural decisions?
-
-Respond with ONLY a JSON array (no markdown code fences):
-[{
-  "id": "US-001",
-  "title": "Story title",
-  "description": "Story description",
-  "acceptanceCriteria": ["Criterion 1", "Criterion 2"],
-  "tags": ["tag1"],
-  "dependencies": [],
-  "complexity": "medium",
-  "contextFiles": ["src/path/to/file.ts"],
-  "reasoning": "Why this complexity level",
-  "estimatedLOC": 150,
-  "risks": ["Risk 1"],
-  "testStrategy": "test-after"
-}]`;
-}
-function parseDecomposeOutput(output) {
-  const jsonMatch = output.match(/```(?:json)?\s*(\[[\s\S]*?\])\s*```/);
-  let jsonText = jsonMatch ? jsonMatch[1] : output;
-  if (!jsonMatch) {
-    const arrayMatch = output.match(/\[[\s\S]*\]/);
-    if (arrayMatch) {
-      jsonText = arrayMatch[0];
-    }
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(jsonText.trim());
-  } catch (error) {
-    throw new Error(`Failed to parse decompose output as JSON: ${error.message}
-
-Output:
-${output.slice(0, 500)}`);
-  }
-  if (!Array.isArray(parsed)) {
-    throw new Error("Decompose output is not an array");
-  }
-  const stories = parsed.map((item, index) => {
-    if (typeof item !== "object" || item === null) {
-      throw new Error(`Story at index ${index} is not an object`);
-    }
-    const record = item;
-    if (!record.id || typeof record.id !== "string") {
-      throw new Error(`Story at index ${index} missing valid 'id' field`);
-    }
-    if (!record.title || typeof record.title !== "string") {
-      throw new Error(`Story ${record.id} missing valid 'title' field`);
-    }
-    return {
-      id: record.id,
-      title: record.title,
-      description: String(record.description || record.title),
-      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),
-      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"),
-      estimatedLOC: Number(record.estimatedLOC) || 0,
-      risks: Array.isArray(record.risks) ? record.risks : [],
-      testStrategy: record.testStrategy === "three-session-tdd" ? "three-session-tdd" : record.testStrategy === "test-after" ? "test-after" : undefined
-    };
-  });
-  if (stories.length === 0) {
-    throw new Error("Decompose returned empty story array");
-  }
-  return stories;
-}
-function validateComplexity(value) {
-  if (value === "simple" || value === "medium" || value === "complex" || value === "expert") {
-    return value;
-  }
-  return "medium";
-}
-
-// src/agents/claude-plan.ts
-import { mkdtempSync, rmSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-function buildPlanCommand(binary, options) {
-  const cmd = [binary, "--permission-mode", "plan"];
-  if (options.modelDef) {
-    cmd.push("--model", options.modelDef.model);
-  }
-  cmd.push("--dangerously-skip-permissions");
-  let fullPrompt = options.prompt;
-  if (options.codebaseContext) {
-    fullPrompt = `${options.codebaseContext}
-
-${options.prompt}`;
-  }
-  if (options.inputFile) {
-    try {
-      const inputContent = __require("fs").readFileSync(__require("path").resolve(options.workdir, options.inputFile), "utf-8");
-      fullPrompt = `${fullPrompt}
-
-## Input Requirements
-
-${inputContent}`;
-    } catch (error) {
-      throw new Error(`Failed to read input file ${options.inputFile}: ${error.message}`);
-    }
-  }
-  if (!options.interactive) {
-    cmd.push("-p", fullPrompt);
-  } else {
-    cmd.push("-p", fullPrompt);
-  }
-  return cmd;
-}
-async function runPlan(binary, options, pidRegistry, buildAllowedEnv) {
-  const cmd = buildPlanCommand(binary, options);
-  const envOptions = {
-    workdir: options.workdir,
-    modelDef: options.modelDef || { provider: "anthropic", model: "claude-sonnet-4-5", env: {} },
-    prompt: "",
-    modelTier: "balanced",
-    timeoutSeconds: 600
-  };
-  if (options.interactive) {
-    const proc = Bun.spawn(cmd, {
-      cwd: options.workdir,
-      stdin: "inherit",
-      stdout: "inherit",
-      stderr: "inherit",
-      env: buildAllowedEnv(envOptions)
-    });
-    await pidRegistry.register(proc.pid);
-    const exitCode = await proc.exited;
-    await pidRegistry.unregister(proc.pid);
-    if (exitCode !== 0) {
-      throw new Error(`Plan mode failed with exit code ${exitCode}`);
-    }
-    return { specContent: "", conversationLog: "" };
-  }
-  const tempDir = mkdtempSync(join(tmpdir(), "nax-plan-"));
-  const outFile = join(tempDir, "stdout.txt");
-  const errFile = join(tempDir, "stderr.txt");
-  try {
-    const proc = Bun.spawn(cmd, {
-      cwd: options.workdir,
-      stdin: "ignore",
-      stdout: Bun.file(outFile),
-      stderr: Bun.file(errFile),
-      env: buildAllowedEnv(envOptions)
-    });
-    await pidRegistry.register(proc.pid);
-    const exitCode = await proc.exited;
-    await pidRegistry.unregister(proc.pid);
-    const specContent = await Bun.file(outFile).text();
-    const conversationLog = await Bun.file(errFile).text();
-    if (exitCode !== 0) {
-      throw new Error(`Plan mode failed with exit code ${exitCode}: ${conversationLog || "unknown error"}`);
-    }
-    return { specContent, conversationLog };
-  } finally {
-    try {
-      rmSync(tempDir, { recursive: true });
-    } catch (error) {
-      const logger = getLogger();
-      logger?.debug("agent", "Failed to clean up temp directory", { error, tempDir });
-    }
-  }
-}
-var init_claude_plan = __esm(() => {
-  init_logger2();
-});
-
-// src/agents/cost.ts
-function parseTokenUsage(output) {
-  try {
-    const jsonMatch = output.match(/\{[^}]*"usage"\s*:\s*\{[^}]*"input_tokens"\s*:\s*(\d+)[^}]*"output_tokens"\s*:\s*(\d+)[^}]*\}[^}]*\}/);
-    if (jsonMatch) {
-      return {
-        inputTokens: Number.parseInt(jsonMatch[1], 10),
-        outputTokens: Number.parseInt(jsonMatch[2], 10),
-        confidence: "exact"
-      };
-    }
-    const lines = output.split(`
-`);
-    for (const line of lines) {
-      if (line.trim().startsWith("{")) {
-        try {
-          const parsed = JSON.parse(line);
-          if (parsed.usage?.input_tokens && parsed.usage?.output_tokens) {
-            return {
-              inputTokens: parsed.usage.input_tokens,
-              outputTokens: parsed.usage.output_tokens,
-              confidence: "exact"
-            };
-          }
-        } catch {}
-      }
-    }
-  } catch {}
-  const inputMatch = output.match(/\b(?:input|input_tokens)\s*:\s*(\d{2,})|(?:input)\s+(?:tokens?)\s*:\s*(\d{2,})/i);
-  const outputMatch = output.match(/\b(?:output|output_tokens)\s*:\s*(\d{2,})|(?:output)\s+(?:tokens?)\s*:\s*(\d{2,})/i);
-  if (inputMatch && outputMatch) {
-    const inputTokens = Number.parseInt(inputMatch[1] || inputMatch[2], 10);
-    const outputTokens = Number.parseInt(outputMatch[1] || outputMatch[2], 10);
-    if (inputTokens > 1e6 || outputTokens > 1e6) {
-      return null;
-    }
-    return {
-      inputTokens,
-      outputTokens,
-      confidence: "estimated"
-    };
-  }
-  return null;
-}
-function estimateCost(modelTier, inputTokens, outputTokens, customRates) {
-  const rates = customRates ?? COST_RATES[modelTier];
-  const inputCost = inputTokens / 1e6 * rates.inputPer1M;
-  const outputCost = outputTokens / 1e6 * rates.outputPer1M;
-  return inputCost + outputCost;
-}
-function estimateCostFromOutput(modelTier, output) {
-  const usage = parseTokenUsage(output);
-  if (!usage) {
-    return null;
-  }
-  const cost = estimateCost(modelTier, usage.inputTokens, usage.outputTokens);
-  return {
-    cost,
-    confidence: usage.confidence
-  };
-}
-function estimateCostByDuration(modelTier, durationMs) {
-  const costPerMinute = {
-    fast: 0.01,
-    balanced: 0.05,
-    powerful: 0.15
-  };
-  const minutes = durationMs / 60000;
-  const cost = minutes * costPerMinute[modelTier];
-  return {
-    cost,
-    confidence: "fallback"
-  };
-}
-var COST_RATES;
-var init_cost = __esm(() => {
-  COST_RATES = {
-    fast: {
-      inputPer1M: 0.8,
-      outputPer1M: 4
-    },
-    balanced: {
-      inputPer1M: 3,
-      outputPer1M: 15
-    },
-    powerful: {
-      inputPer1M: 15,
-      outputPer1M: 75
-    }
-  };
-});
-
-// src/agents/claude.ts
-class ClaudeCodeAdapter {
-  name = "claude";
-  displayName = "Claude Code";
-  binary = "claude";
-  capabilities = {
-    supportedTiers: ["fast", "balanced", "powerful"],
-    maxContextTokens: 200000,
-    features: new Set(["tdd", "review", "refactor", "batch"])
-  };
-  pidRegistries = new Map;
-  getPidRegistry(workdir) {
-    if (!this.pidRegistries.has(workdir)) {
-      this.pidRegistries.set(workdir, new PidRegistry(workdir));
-    }
-    const registry = this.pidRegistries.get(workdir);
-    if (!registry) {
-      throw new Error(`PidRegistry not found for workdir: ${workdir}`);
-    }
-    return registry;
-  }
-  async isInstalled() {
-    try {
-      const proc = Bun.spawn(["which", this.binary], { stdout: "pipe", stderr: "pipe" });
-      const code = await proc.exited;
-      return code === 0;
-    } catch (error) {
-      const logger = getLogger();
-      logger?.debug("agent", "Failed to check if agent is installed", { error });
-      return false;
-    }
-  }
-  buildCommand(options) {
-    const model = options.modelDef.model;
-    const skipPermissions = options.dangerouslySkipPermissions ?? true;
-    const permArgs = skipPermissions ? ["--dangerously-skip-permissions"] : [];
-    return [this.binary, "--model", model, ...permArgs, "-p", options.prompt];
-  }
-  async run(options) {
-    const maxRetries = 3;
-    let lastError = null;
-    for (let attempt = 1;attempt <= maxRetries; attempt++) {
-      try {
-        const result = await this.runOnce(options, attempt);
-        if (result.rateLimited && attempt < maxRetries) {
-          const backoffMs = 2 ** attempt * 1000;
-          const logger = getLogger();
-          logger.warn("agent", "Rate limited, retrying", { backoffSeconds: backoffMs / 1000, attempt, maxRetries });
-          await Bun.sleep(backoffMs);
-          continue;
-        }
-        return result;
-      } catch (error) {
-        lastError = error;
-        const isSpawnError = lastError.message.includes("spawn") || lastError.message.includes("ENOENT");
-        if (isSpawnError && attempt < maxRetries) {
-          const backoffMs = 2 ** attempt * 1000;
-          const logger = getLogger();
-          logger.warn("agent", "Agent spawn error, retrying", {
-            error: lastError.message,
-            backoffSeconds: backoffMs / 1000,
-            attempt,
-            maxRetries
-          });
-          await Bun.sleep(backoffMs);
-          continue;
-        }
-        throw lastError;
-      }
-    }
-    throw lastError || new Error("Agent execution failed after all retries");
-  }
-  buildAllowedEnv(options) {
-    const allowed = {};
-    const essentialVars = ["PATH", "HOME", "TMPDIR", "NODE_ENV", "USER", "LOGNAME"];
-    for (const varName of essentialVars) {
-      if (process.env[varName]) {
-        allowed[varName] = process.env[varName];
-      }
-    }
-    const apiKeyVars = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY"];
-    for (const varName of apiKeyVars) {
-      if (process.env[varName]) {
-        allowed[varName] = process.env[varName];
-      }
-    }
-    const allowedPrefixes = ["CLAUDE_", "NAX_", "CLAW_", "TURBO_"];
-    for (const [key, value] of Object.entries(process.env)) {
-      if (allowedPrefixes.some((prefix) => key.startsWith(prefix))) {
-        allowed[key] = value;
-      }
-    }
-    if (options.modelDef.env) {
-      Object.assign(allowed, options.modelDef.env);
-    }
-    if (options.env) {
-      Object.assign(allowed, options.env);
-    }
-    return allowed;
-  }
-  async runOnce(options, _attempt) {
-    const cmd = this.buildCommand(options);
-    const startTime = Date.now();
-    const proc = Bun.spawn(cmd, {
-      cwd: options.workdir,
-      stdout: "pipe",
-      stderr: "inherit",
-      env: this.buildAllowedEnv(options)
-    });
-    const processPid = proc.pid;
-    const pidRegistry = this.getPidRegistry(options.workdir);
-    await pidRegistry.register(processPid);
-    let timedOut = false;
-    const timeoutId = setTimeout(() => {
-      timedOut = true;
-      try {
-        _runOnceDeps.killProc(proc, "SIGTERM");
-      } catch {}
-      setTimeout(() => {
-        try {
-          _runOnceDeps.killProc(proc, "SIGKILL");
-        } catch {}
-      }, SIGKILL_GRACE_PERIOD_MS);
-    }, options.timeoutSeconds * 1000);
-    let exitCode;
-    try {
-      const hardDeadlineMs = options.timeoutSeconds * 1000 + SIGKILL_GRACE_PERIOD_MS + 3000;
-      exitCode = await Promise.race([
-        proc.exited,
-        new Promise((resolve) => setTimeout(() => resolve(-1), hardDeadlineMs))
-      ]);
-      if (exitCode === -1) {
-        try {
-          process.kill(processPid, "SIGKILL");
-        } catch {}
-        try {
-          process.kill(-processPid, "SIGKILL");
-        } catch {}
-      }
-    } finally {
-      clearTimeout(timeoutId);
-      await pidRegistry.unregister(processPid);
-    }
-    const stdout = await Promise.race([
-      new Response(proc.stdout).text(),
-      new Promise((resolve) => setTimeout(() => resolve(""), 5000))
-    ]);
-    const stderr = proc.stderr ? await new Response(proc.stderr).text() : "";
-    const durationMs = Date.now() - startTime;
-    const fullOutput = stdout + stderr;
-    const rateLimited = fullOutput.toLowerCase().includes("rate limit") || fullOutput.includes("429") || fullOutput.toLowerCase().includes("too many requests");
-    let costEstimate = estimateCostFromOutput(options.modelTier, fullOutput);
-    const logger = getLogger();
-    if (!costEstimate) {
-      const fallbackEstimate = estimateCostByDuration(options.modelTier, durationMs);
-      costEstimate = {
-        cost: fallbackEstimate.cost * 1.5,
-        confidence: "fallback"
-      };
-      logger.warn("agent", "Cost estimation fallback (duration-based)", {
-        modelTier: options.modelTier,
-        cost: costEstimate.cost
-      });
-    } else if (costEstimate.confidence === "estimated") {
-      logger.warn("agent", "Cost estimation using regex parsing (estimated confidence)", { cost: costEstimate.cost });
-    }
-    const cost = costEstimate.cost;
-    const actualExitCode = timedOut ? 124 : exitCode;
-    return {
-      success: exitCode === 0 && !timedOut,
-      exitCode: actualExitCode,
-      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS),
-      stderr: stderr.slice(-MAX_AGENT_STDERR_CHARS),
-      rateLimited,
-      durationMs,
-      estimatedCost: cost,
-      pid: processPid
-    };
-  }
-  async plan(options) {
-    const pidRegistry = this.getPidRegistry(options.workdir);
-    return runPlan(this.binary, options, pidRegistry, this.buildAllowedEnv.bind(this));
-  }
-  async decompose(options) {
-    const prompt = buildDecomposePrompt(options);
-    const cmd = [
-      this.binary,
-      "--model",
-      options.modelDef?.model || "claude-sonnet-4-5",
-      "--dangerously-skip-permissions",
-      "-p",
-      prompt
-    ];
-    const pidRegistry = this.getPidRegistry(options.workdir);
-    const proc = Bun.spawn(cmd, {
-      cwd: options.workdir,
-      stdout: "pipe",
-      stderr: "inherit",
-      env: this.buildAllowedEnv({
-        workdir: options.workdir,
-        modelDef: options.modelDef || { provider: "anthropic", model: "claude-sonnet-4-5", env: {} },
-        prompt: "",
-        modelTier: "balanced",
-        timeoutSeconds: 600
-      })
-    });
-    await pidRegistry.register(proc.pid);
-    const DECOMPOSE_TIMEOUT_MS = 300000;
-    let timedOut = false;
-    const decomposeTimerId = setTimeout(() => {
-      timedOut = true;
-      try {
-        proc.kill("SIGTERM");
-      } catch {}
-      setTimeout(() => {
-        try {
-          proc.kill("SIGKILL");
-        } catch {}
-      }, 5000);
-    }, DECOMPOSE_TIMEOUT_MS);
-    let exitCode;
-    try {
-      exitCode = await proc.exited;
-    } finally {
-      clearTimeout(decomposeTimerId);
-      await pidRegistry.unregister(proc.pid);
-    }
-    if (timedOut) {
-      throw new Error(`Decompose timed out after ${DECOMPOSE_TIMEOUT_MS / 1000}s`);
-    }
-    const stdout = await Promise.race([
-      new Response(proc.stdout).text(),
-      new Promise((resolve) => setTimeout(() => resolve(""), 5000))
-    ]);
-    const stderr = await new Response(proc.stderr).text();
-    if (exitCode !== 0) {
-      throw new Error(`Decompose failed with exit code ${exitCode}: ${stderr}`);
-    }
-    const stories = parseDecomposeOutput(stdout);
-    return { stories };
-  }
-  runInteractive(options) {
-    const model = options.modelDef.model;
-    const cmd = [this.binary, "--model", model, options.prompt];
-    const proc = Bun.spawn(cmd, {
-      cwd: options.workdir,
-      env: { ...this.buildAllowedEnv(options), TERM: "xterm-256color", FORCE_COLOR: "1" },
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "inherit"
-    });
-    const pidRegistry = this.getPidRegistry(options.workdir);
-    pidRegistry.register(proc.pid).catch(() => {});
-    (async () => {
-      try {
-        for await (const chunk of proc.stdout) {
-          options.onOutput(Buffer.from(chunk));
-        }
-      } catch (err) {
-        getLogger()?.error("agent", "runInteractive stdout error", { err });
-      }
-    })();
-    proc.exited.then((code) => {
-      pidRegistry.unregister(proc.pid).catch(() => {});
-      options.onExit(code ?? 1);
-    }).catch((err) => {
-      getLogger()?.error("agent", "runInteractive exit error", { err });
-    });
-    return {
-      write: (data) => {
-        proc.stdin.write(data);
-      },
-      resize: (_cols, _rows) => {},
-      kill: () => {
-        proc.kill();
-      },
-      pid: proc.pid
-    };
-  }
-}
-var MAX_AGENT_OUTPUT_CHARS = 5000, MAX_AGENT_STDERR_CHARS = 1000, SIGKILL_GRACE_PERIOD_MS = 5000, _runOnceDeps;
-var init_claude = __esm(() => {
-  init_pid_registry();
-  init_logger2();
-  init_claude_plan();
-  init_cost();
-  _runOnceDeps = {
-    killProc(proc, signal) {
-      proc.kill(signal);
-    }
-  };
-});
-
-// src/agents/registry.ts
-function getAgent(name) {
-  return ALL_AGENTS.find((a) => a.name === name);
-}
-async function checkAgentHealth() {
-  return Promise.all(ALL_AGENTS.map(async (agent) => ({
-    name: agent.name,
-    displayName: agent.displayName,
-    installed: await agent.isInstalled()
-  })));
-}
-var ALL_AGENTS;
-var init_registry = __esm(() => {
-  init_claude();
-  ALL_AGENTS = [
-    new ClaudeCodeAdapter
-  ];
-});
-
-// src/agents/validation.ts
-function validateAgentForTier(agent, tier) {
-  return agent.capabilities.supportedTiers.includes(tier);
-}
-
-// src/agents/index.ts
-var init_agents = __esm(() => {
-  init_claude();
-  init_registry();
-  init_cost();
-});
-
 // src/acceptance/generator.ts
 function parseAcceptanceCriteria(specContent) {
   const criteria = [];
@@ -4117,6 +3327,614 @@ var init_acceptance = __esm(() => {
   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";
+
+class PidRegistry {
+  workdir;
+  pidsFilePath;
+  pids = new Set;
+  platform;
+  constructor(workdir, platform) {
+    this.workdir = workdir;
+    this.pidsFilePath = `${workdir}/${PID_REGISTRY_FILE}`;
+    this.platform = platform ?? process.platform;
+  }
+  async register(pid) {
+    const logger = getSafeLogger();
+    this.pids.add(pid);
+    const entry = {
+      pid,
+      spawnedAt: new Date().toISOString(),
+      workdir: this.workdir
+    };
+    try {
+      let existingContent = "";
+      if (existsSync(this.pidsFilePath)) {
+        existingContent = await Bun.file(this.pidsFilePath).text();
+      }
+      const line = `${JSON.stringify(entry)}
+`;
+      await Bun.write(this.pidsFilePath, existingContent + line);
+      logger?.debug("pid-registry", `Registered PID ${pid}`, { pid });
+    } catch (err) {
+      logger?.warn("pid-registry", `Failed to write PID ${pid} to registry`, {
+        error: err.message
+      });
+    }
+  }
+  async unregister(pid) {
+    const logger = getSafeLogger();
+    this.pids.delete(pid);
+    try {
+      await this.writePidsFile();
+      logger?.debug("pid-registry", `Unregistered PID ${pid}`, { pid });
+    } catch (err) {
+      logger?.warn("pid-registry", `Failed to unregister PID ${pid}`, {
+        error: err.message
+      });
+    }
+  }
+  async killAll() {
+    const logger = getSafeLogger();
+    const pids = Array.from(this.pids);
+    if (pids.length === 0) {
+      logger?.debug("pid-registry", "No PIDs to kill");
+      return;
+    }
+    logger?.info("pid-registry", `Killing ${pids.length} registered processes`, { pids });
+    const killPromises = pids.map((pid) => this.killPid(pid));
+    await Promise.allSettled(killPromises);
+    try {
+      await Bun.write(this.pidsFilePath, "");
+      this.pids.clear();
+      logger?.info("pid-registry", "All registered PIDs killed and registry cleared");
+    } catch (err) {
+      logger?.warn("pid-registry", "Failed to clear registry file", {
+        error: err.message
+      });
+    }
+  }
+  async cleanupStale() {
+    const logger = getSafeLogger();
+    if (!existsSync(this.pidsFilePath)) {
+      logger?.debug("pid-registry", "No stale PIDs file found");
+      return;
+    }
+    try {
+      const content = await Bun.file(this.pidsFilePath).text();
+      const lines = content.split(`
+`).filter((line) => line.trim()).map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      }).filter((entry) => entry !== null);
+      if (lines.length === 0) {
+        logger?.debug("pid-registry", "No stale PIDs to cleanup");
+        await Bun.write(this.pidsFilePath, "");
+        return;
+      }
+      const stalePids = lines.map((entry) => entry.pid);
+      logger?.info("pid-registry", `Cleaning up ${stalePids.length} stale PIDs from previous run`, {
+        pids: stalePids
+      });
+      const killPromises = stalePids.map((pid) => this.killPid(pid));
+      await Promise.allSettled(killPromises);
+      await Bun.write(this.pidsFilePath, "");
+      logger?.info("pid-registry", "Stale PIDs cleanup completed");
+    } catch (err) {
+      logger?.warn("pid-registry", "Failed to cleanup stale PIDs", {
+        error: err.message
+      });
+    }
+  }
+  async killPid(pid) {
+    const logger = getSafeLogger();
+    try {
+      const checkProc = Bun.spawn(["kill", "-0", String(pid)], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const checkCode = await checkProc.exited;
+      if (checkCode !== 0) {
+        logger?.debug("pid-registry", `PID ${pid} not found (already exited)`, { pid });
+        return;
+      }
+      const killArgs = this.platform === "linux" ? ["kill", "-TERM", `-${pid}`] : ["kill", "-TERM", String(pid)];
+      const killProc = Bun.spawn(killArgs, {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const killCode = await killProc.exited;
+      if (killCode === 0) {
+        logger?.debug("pid-registry", `Killed PID ${pid}`, { pid });
+      } else {
+        const stderr = await new Response(killProc.stderr).text();
+        logger?.warn("pid-registry", `Failed to kill PID ${pid}`, {
+          pid,
+          exitCode: killCode,
+          stderr: stderr.trim()
+        });
+      }
+    } catch (err) {
+      logger?.warn("pid-registry", `Error killing PID ${pid}`, {
+        pid,
+        error: err.message
+      });
+    }
+  }
+  async writePidsFile() {
+    const entries = Array.from(this.pids).map((pid) => ({
+      pid,
+      spawnedAt: new Date().toISOString(),
+      workdir: this.workdir
+    }));
+    const content = entries.map((entry) => JSON.stringify(entry)).join(`
+`);
+    await Bun.write(this.pidsFilePath, content ? `${content}
+` : "");
+  }
+  getPids() {
+    return Array.from(this.pids);
+  }
+}
+var PID_REGISTRY_FILE = ".nax-pids";
+var init_pid_registry = __esm(() => {
+  init_logger2();
+});
+
+// src/agents/claude-decompose.ts
+function buildDecomposePrompt(options) {
+  return `You are a requirements analyst. Break down the following feature specification into user stories and classify each story's complexity.
+
+CODEBASE CONTEXT:
+${options.codebaseContext}
+
+FEATURE SPECIFICATION:
+${options.specContent}
+
+Decompose this spec into user stories. For each story, provide:
+1. id: Story ID (e.g., "US-001")
+2. title: Concise story title
+3. description: What needs to be implemented
+4. acceptanceCriteria: Array of testable criteria
+5. tags: Array of routing tags (e.g., ["security", "api"])
+6. dependencies: Array of story IDs this depends on (e.g., ["US-001"])
+7. complexity: "simple" | "medium" | "complex" | "expert"
+8. contextFiles: Array of file paths to inject into agent prompt before execution
+9. reasoning: Why this complexity level
+10. estimatedLOC: Estimated lines of code to change
+11. risks: Array of implementation risks
+12. testStrategy: "three-session-tdd" | "test-after"
+
+testStrategy rules:
+- "three-session-tdd": ONLY for complex/expert tasks that are security-critical (auth, encryption, tokens, credentials) or define public API contracts consumers depend on
+- "test-after": for all other tasks including simple/medium complexity
+- A "simple" complexity task should almost never be "three-session-tdd"
+
+Complexity classification rules:
+- simple: 1-3 files, <100 LOC, straightforward implementation, existing patterns
+- medium: 3-6 files, 100-300 LOC, moderate logic, some new patterns
+- complex: 6+ files, 300-800 LOC, architectural changes, cross-cutting concerns
+- expert: Security/crypto/real-time/distributed systems, >800 LOC, new infrastructure
+
+Grouping Guidelines:
+- Combine small, related tasks (e.g., multiple utility functions, interfaces) into a single "simple" or "medium" story.
+- Do NOT create separate stories for every single file or function unless complex.
+- Aim for coherent units of value (e.g., "Implement User Authentication" vs "Create User Interface", "Create Login Service").
+- Maximum recommended stories: 10-15 per feature. Group aggressively if list grows too long.
+
+Consider:
+1. Does infrastructure exist? (e.g., "add caching" when no cache layer exists = complex)
+2. How many files will be touched?
+3. Are there cross-cutting concerns (auth, validation, error handling)?
+4. Does it require new dependencies or architectural decisions?
+
+Respond with ONLY a JSON array (no markdown code fences):
+[{
+  "id": "US-001",
+  "title": "Story title",
+  "description": "Story description",
+  "acceptanceCriteria": ["Criterion 1", "Criterion 2"],
+  "tags": ["tag1"],
+  "dependencies": [],
+  "complexity": "medium",
+  "contextFiles": ["src/path/to/file.ts"],
+  "reasoning": "Why this complexity level",
+  "estimatedLOC": 150,
+  "risks": ["Risk 1"],
+  "testStrategy": "test-after"
+}]`;
+}
+function parseDecomposeOutput(output) {
+  const jsonMatch = output.match(/```(?:json)?\s*(\[[\s\S]*?\])\s*```/);
+  let jsonText = jsonMatch ? jsonMatch[1] : output;
+  if (!jsonMatch) {
+    const arrayMatch = output.match(/\[[\s\S]*\]/);
+    if (arrayMatch) {
+      jsonText = arrayMatch[0];
+    }
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonText.trim());
+  } catch (error) {
+    throw new Error(`Failed to parse decompose output as JSON: ${error.message}
+
+Output:
+${output.slice(0, 500)}`);
+  }
+  if (!Array.isArray(parsed)) {
+    throw new Error("Decompose output is not an array");
+  }
+  const stories = parsed.map((item, index) => {
+    if (typeof item !== "object" || item === null) {
+      throw new Error(`Story at index ${index} is not an object`);
+    }
+    const record = item;
+    if (!record.id || typeof record.id !== "string") {
+      throw new Error(`Story at index ${index} missing valid 'id' field`);
+    }
+    if (!record.title || typeof record.title !== "string") {
+      throw new Error(`Story ${record.id} missing valid 'title' field`);
+    }
+    return {
+      id: record.id,
+      title: record.title,
+      description: String(record.description || record.title),
+      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),
+      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"),
+      estimatedLOC: Number(record.estimatedLOC) || 0,
+      risks: Array.isArray(record.risks) ? record.risks : [],
+      testStrategy: record.testStrategy === "three-session-tdd" ? "three-session-tdd" : record.testStrategy === "test-after" ? "test-after" : undefined
+    };
+  });
+  if (stories.length === 0) {
+    throw new Error("Decompose returned empty story array");
+  }
+  return stories;
+}
+function validateComplexity(value) {
+  if (value === "simple" || value === "medium" || value === "complex" || value === "expert") {
+    return value;
+  }
+  return "medium";
+}
+
 // src/config/types.ts
 function resolveModel(entry) {
   if (typeof entry === "string") {
@@ -18266,179 +18084,774 @@ var init_schemas3 = __esm(() => {
   });
 });
 
-// src/config/defaults.ts
-var DEFAULT_CONFIG;
-var init_defaults = __esm(() => {
-  DEFAULT_CONFIG = {
-    version: 1,
-    models: {
-      fast: { provider: "anthropic", model: "haiku" },
-      balanced: { provider: "anthropic", model: "sonnet" },
-      powerful: { provider: "anthropic", model: "opus" }
-    },
-    autoMode: {
-      enabled: true,
-      defaultAgent: "claude",
-      fallbackOrder: ["claude", "codex", "opencode", "gemini"],
-      complexityRouting: {
-        simple: "fast",
-        medium: "balanced",
-        complex: "powerful",
-        expert: "powerful"
-      },
-      escalation: {
-        enabled: true,
-        tierOrder: [
-          { tier: "fast", attempts: 5 },
-          { tier: "balanced", attempts: 3 },
-          { tier: "powerful", attempts: 2 }
-        ],
-        escalateEntireBatch: true
+// src/config/defaults.ts
+var DEFAULT_CONFIG;
+var init_defaults = __esm(() => {
+  DEFAULT_CONFIG = {
+    version: 1,
+    models: {
+      fast: { provider: "anthropic", model: "haiku" },
+      balanced: { provider: "anthropic", model: "sonnet" },
+      powerful: { provider: "anthropic", model: "opus" }
+    },
+    autoMode: {
+      enabled: true,
+      defaultAgent: "claude",
+      fallbackOrder: ["claude", "codex", "opencode", "gemini"],
+      complexityRouting: {
+        simple: "fast",
+        medium: "balanced",
+        complex: "powerful",
+        expert: "powerful"
+      },
+      escalation: {
+        enabled: true,
+        tierOrder: [
+          { tier: "fast", attempts: 5 },
+          { tier: "balanced", attempts: 3 },
+          { tier: "powerful", attempts: 2 }
+        ],
+        escalateEntireBatch: true
+      }
+    },
+    routing: {
+      strategy: "keyword",
+      adaptive: {
+        minSamples: 10,
+        costThreshold: 0.8,
+        fallbackStrategy: "llm"
+      },
+      llm: {
+        model: "fast",
+        fallbackToKeywords: true,
+        cacheDecisions: true,
+        mode: "hybrid",
+        timeoutMs: 15000
+      }
+    },
+    execution: {
+      maxIterations: 10,
+      iterationDelayMs: 2000,
+      costLimit: 5,
+      sessionTimeoutSeconds: 600,
+      verificationTimeoutSeconds: 300,
+      maxStoriesPerFeature: 500,
+      rectification: {
+        enabled: true,
+        maxRetries: 2,
+        fullSuiteTimeoutSeconds: 120,
+        maxFailureSummaryChars: 2000,
+        abortOnIncreasingFailures: true
+      },
+      regressionGate: {
+        enabled: true,
+        timeoutSeconds: 120,
+        acceptOnTimeout: true,
+        maxRectificationAttempts: 2
+      },
+      contextProviderTokenBudget: 2000,
+      smartTestRunner: true
+    },
+    quality: {
+      requireTypecheck: true,
+      requireLint: true,
+      requireTests: true,
+      commands: {},
+      forceExit: false,
+      detectOpenHandles: true,
+      detectOpenHandlesRetries: 1,
+      gracePeriodMs: 5000,
+      dangerouslySkipPermissions: true,
+      drainTimeoutMs: 2000,
+      shell: "/bin/sh",
+      stripEnvVars: ["CLAUDECODE", "REPL_ID", "AGENT"],
+      environmentalEscalationDivisor: 2
+    },
+    tdd: {
+      maxRetries: 2,
+      autoVerifyIsolation: true,
+      autoApproveVerifier: true,
+      strategy: "auto",
+      sessionTiers: {
+        testWriter: "balanced",
+        verifier: "fast"
+      },
+      testWriterAllowedPaths: ["src/index.ts", "src/**/index.ts"],
+      rollbackOnFailure: true,
+      greenfieldDetection: true
+    },
+    constitution: {
+      enabled: true,
+      path: "constitution.md",
+      maxTokens: 2000
+    },
+    analyze: {
+      llmEnhanced: true,
+      model: "balanced",
+      fallbackToKeywords: true,
+      maxCodebaseSummaryTokens: 5000
+    },
+    review: {
+      enabled: true,
+      checks: ["typecheck", "lint"],
+      commands: {}
+    },
+    plan: {
+      model: "balanced",
+      outputPath: "spec.md"
+    },
+    acceptance: {
+      enabled: true,
+      maxRetries: 2,
+      generateTests: true,
+      testPath: "acceptance.test.ts"
+    },
+    context: {
+      fileInjection: "disabled",
+      testCoverage: {
+        enabled: true,
+        detail: "names-and-counts",
+        maxTokens: 500,
+        testPattern: "**/*.test.{ts,js,tsx,jsx}",
+        scopeToStory: true
+      },
+      autoDetect: {
+        enabled: true,
+        maxFiles: 5,
+        traceImports: false
+      }
+    },
+    interaction: {
+      plugin: "cli",
+      config: {},
+      defaults: {
+        timeout: 600000,
+        fallback: "escalate"
+      },
+      triggers: {
+        "security-review": true,
+        "cost-warning": true
+      }
+    },
+    precheck: {
+      storySizeGate: {
+        enabled: true,
+        maxAcCount: 6,
+        maxDescriptionLength: 2000,
+        maxBulletPoints: 8
+      }
+    },
+    prompts: {},
+    decompose: {
+      trigger: "auto",
+      maxAcceptanceCriteria: 6,
+      maxSubstories: 5,
+      maxSubstoryComplexity: "medium",
+      maxRetries: 2,
+      model: "balanced"
+    }
+  };
+});
+
+// src/config/schema.ts
+var init_schema = __esm(() => {
+  init_schemas3();
+  init_defaults();
+});
+
+// src/agents/model-resolution.ts
+var exports_model_resolution = {};
+__export(exports_model_resolution, {
+  resolveBalancedModelDef: () => resolveBalancedModelDef
+});
+function resolveBalancedModelDef(config2, adapterDefault) {
+  const configWithModels = config2;
+  const models = configWithModels.models;
+  const balancedEntry = models?.balanced;
+  if (balancedEntry) {
+    return resolveModel(balancedEntry);
+  }
+  if (adapterDefault) {
+    return adapterDefault;
+  }
+  throw new Error("No balanced model configured in config.models.balanced and no adapter default provided");
+}
+var init_model_resolution = __esm(() => {
+  init_schema();
+});
+
+// src/agents/claude-plan.ts
+import { mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+function buildPlanCommand(binary, options) {
+  const cmd = [binary, "--permission-mode", "plan"];
+  let modelDef = options.modelDef;
+  if (!modelDef && options.config) {
+    modelDef = resolveBalancedModelDef(options.config);
+  }
+  if (modelDef) {
+    cmd.push("--model", modelDef.model);
+  }
+  cmd.push("--dangerously-skip-permissions");
+  let fullPrompt = options.prompt;
+  if (options.codebaseContext) {
+    fullPrompt = `${options.codebaseContext}
+
+${options.prompt}`;
+  }
+  if (options.inputFile) {
+    try {
+      const inputContent = __require("fs").readFileSync(__require("path").resolve(options.workdir, options.inputFile), "utf-8");
+      fullPrompt = `${fullPrompt}
+
+## Input Requirements
+
+${inputContent}`;
+    } catch (error48) {
+      throw new Error(`Failed to read input file ${options.inputFile}: ${error48.message}`);
+    }
+  }
+  if (!options.interactive) {
+    cmd.push("-p", fullPrompt);
+  } else {
+    cmd.push("-p", fullPrompt);
+  }
+  return cmd;
+}
+async function runPlan(binary, options, pidRegistry, buildAllowedEnv) {
+  const { resolveBalancedModelDef: resolveBalancedModelDef2 } = await Promise.resolve().then(() => (init_model_resolution(), exports_model_resolution));
+  const cmd = buildPlanCommand(binary, options);
+  let modelDef = options.modelDef;
+  if (!modelDef) {
+    if (!options.config) {
+      throw new Error("runPlan() requires either modelDef or config with models.balanced configured");
+    }
+    modelDef = resolveBalancedModelDef2(options.config);
+  }
+  const envOptions = {
+    workdir: options.workdir,
+    modelDef,
+    prompt: "",
+    modelTier: options.modelTier || "balanced",
+    timeoutSeconds: 600
+  };
+  if (options.interactive) {
+    const proc = Bun.spawn(cmd, {
+      cwd: options.workdir,
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit",
+      env: buildAllowedEnv(envOptions)
+    });
+    await pidRegistry.register(proc.pid);
+    const exitCode = await proc.exited;
+    await pidRegistry.unregister(proc.pid);
+    if (exitCode !== 0) {
+      throw new Error(`Plan mode failed with exit code ${exitCode}`);
+    }
+    return { specContent: "", conversationLog: "" };
+  }
+  const tempDir = mkdtempSync(join(tmpdir(), "nax-plan-"));
+  const outFile = join(tempDir, "stdout.txt");
+  const errFile = join(tempDir, "stderr.txt");
+  try {
+    const proc = Bun.spawn(cmd, {
+      cwd: options.workdir,
+      stdin: "ignore",
+      stdout: Bun.file(outFile),
+      stderr: Bun.file(errFile),
+      env: buildAllowedEnv(envOptions)
+    });
+    await pidRegistry.register(proc.pid);
+    const exitCode = await proc.exited;
+    await pidRegistry.unregister(proc.pid);
+    const specContent = await Bun.file(outFile).text();
+    const conversationLog = await Bun.file(errFile).text();
+    if (exitCode !== 0) {
+      throw new Error(`Plan mode failed with exit code ${exitCode}: ${conversationLog || "unknown error"}`);
+    }
+    return { specContent, conversationLog };
+  } finally {
+    try {
+      rmSync(tempDir, { recursive: true });
+    } catch (error48) {
+      const logger = getLogger();
+      logger?.debug("agent", "Failed to clean up temp directory", { error: error48, tempDir });
+    }
+  }
+}
+var init_claude_plan = __esm(() => {
+  init_logger2();
+  init_model_resolution();
+});
+
+// src/agents/cost.ts
+function parseTokenUsage(output) {
+  try {
+    const jsonMatch = output.match(/\{[^}]*"usage"\s*:\s*\{[^}]*"input_tokens"\s*:\s*(\d+)[^}]*"output_tokens"\s*:\s*(\d+)[^}]*\}[^}]*\}/);
+    if (jsonMatch) {
+      return {
+        inputTokens: Number.parseInt(jsonMatch[1], 10),
+        outputTokens: Number.parseInt(jsonMatch[2], 10),
+        confidence: "exact"
+      };
+    }
+    const lines = output.split(`
+`);
+    for (const line of lines) {
+      if (line.trim().startsWith("{")) {
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed.usage?.input_tokens && parsed.usage?.output_tokens) {
+            return {
+              inputTokens: parsed.usage.input_tokens,
+              outputTokens: parsed.usage.output_tokens,
+              confidence: "exact"
+            };
+          }
+        } catch {}
+      }
+    }
+  } catch {}
+  const inputMatch = output.match(/\b(?:input|input_tokens)\s*:\s*(\d{2,})|(?:input)\s+(?:tokens?)\s*:\s*(\d{2,})/i);
+  const outputMatch = output.match(/\b(?:output|output_tokens)\s*:\s*(\d{2,})|(?:output)\s+(?:tokens?)\s*:\s*(\d{2,})/i);
+  if (inputMatch && outputMatch) {
+    const inputTokens = Number.parseInt(inputMatch[1] || inputMatch[2], 10);
+    const outputTokens = Number.parseInt(outputMatch[1] || outputMatch[2], 10);
+    if (inputTokens > 1e6 || outputTokens > 1e6) {
+      return null;
+    }
+    return {
+      inputTokens,
+      outputTokens,
+      confidence: "estimated"
+    };
+  }
+  return null;
+}
+function estimateCost(modelTier, inputTokens, outputTokens, customRates) {
+  const rates = customRates ?? COST_RATES[modelTier];
+  const inputCost = inputTokens / 1e6 * rates.inputPer1M;
+  const outputCost = outputTokens / 1e6 * rates.outputPer1M;
+  return inputCost + outputCost;
+}
+function estimateCostFromOutput(modelTier, output) {
+  const usage = parseTokenUsage(output);
+  if (!usage) {
+    return null;
+  }
+  const cost = estimateCost(modelTier, usage.inputTokens, usage.outputTokens);
+  return {
+    cost,
+    confidence: usage.confidence
+  };
+}
+function estimateCostByDuration(modelTier, durationMs) {
+  const costPerMinute = {
+    fast: 0.01,
+    balanced: 0.05,
+    powerful: 0.15
+  };
+  const minutes = durationMs / 60000;
+  const cost = minutes * costPerMinute[modelTier];
+  return {
+    cost,
+    confidence: "fallback"
+  };
+}
+var COST_RATES;
+var init_cost = __esm(() => {
+  COST_RATES = {
+    fast: {
+      inputPer1M: 0.8,
+      outputPer1M: 4
+    },
+    balanced: {
+      inputPer1M: 3,
+      outputPer1M: 15
+    },
+    powerful: {
+      inputPer1M: 15,
+      outputPer1M: 75
+    }
+  };
+});
+
+// src/agents/claude.ts
+class ClaudeCodeAdapter {
+  name = "claude";
+  displayName = "Claude Code";
+  binary = "claude";
+  capabilities = {
+    supportedTiers: ["fast", "balanced", "powerful"],
+    maxContextTokens: 200000,
+    features: new Set(["tdd", "review", "refactor", "batch"])
+  };
+  pidRegistries = new Map;
+  getPidRegistry(workdir) {
+    if (!this.pidRegistries.has(workdir)) {
+      this.pidRegistries.set(workdir, new PidRegistry(workdir));
+    }
+    const registry2 = this.pidRegistries.get(workdir);
+    if (!registry2) {
+      throw new Error(`PidRegistry not found for workdir: ${workdir}`);
+    }
+    return registry2;
+  }
+  async isInstalled() {
+    try {
+      const proc = Bun.spawn(["which", this.binary], { stdout: "pipe", stderr: "pipe" });
+      const code = await proc.exited;
+      return code === 0;
+    } catch (error48) {
+      const logger = getLogger();
+      logger?.debug("agent", "Failed to check if agent is installed", { error: error48 });
+      return false;
+    }
+  }
+  buildCommand(options) {
+    const model = options.modelDef.model;
+    const skipPermissions = options.dangerouslySkipPermissions ?? true;
+    const permArgs = skipPermissions ? ["--dangerously-skip-permissions"] : [];
+    return [this.binary, "--model", model, ...permArgs, "-p", options.prompt];
+  }
+  async run(options) {
+    const maxRetries = 3;
+    let lastError = null;
+    for (let attempt = 1;attempt <= maxRetries; attempt++) {
+      try {
+        const result = await this.runOnce(options, attempt);
+        if (result.rateLimited && attempt < maxRetries) {
+          const backoffMs = 2 ** attempt * 1000;
+          const logger = getLogger();
+          logger.warn("agent", "Rate limited, retrying", { backoffSeconds: backoffMs / 1000, attempt, maxRetries });
+          await Bun.sleep(backoffMs);
+          continue;
+        }
+        return result;
+      } catch (error48) {
+        lastError = error48;
+        const isSpawnError = lastError.message.includes("spawn") || lastError.message.includes("ENOENT");
+        if (isSpawnError && attempt < maxRetries) {
+          const backoffMs = 2 ** attempt * 1000;
+          const logger = getLogger();
+          logger.warn("agent", "Agent spawn error, retrying", {
+            error: lastError.message,
+            backoffSeconds: backoffMs / 1000,
+            attempt,
+            maxRetries
+          });
+          await Bun.sleep(backoffMs);
+          continue;
+        }
+        throw lastError;
       }
-    },
-    routing: {
-      strategy: "keyword",
-      adaptive: {
-        minSamples: 10,
-        costThreshold: 0.8,
-        fallbackStrategy: "llm"
-      },
-      llm: {
-        model: "fast",
-        fallbackToKeywords: true,
-        cacheDecisions: true,
-        mode: "hybrid",
-        timeoutMs: 15000
+    }
+    throw lastError || new Error("Agent execution failed after all retries");
+  }
+  buildAllowedEnv(options) {
+    const allowed = {};
+    const essentialVars = ["PATH", "HOME", "TMPDIR", "NODE_ENV", "USER", "LOGNAME"];
+    for (const varName of essentialVars) {
+      if (process.env[varName]) {
+        allowed[varName] = process.env[varName];
       }
-    },
-    execution: {
-      maxIterations: 10,
-      iterationDelayMs: 2000,
-      costLimit: 5,
-      sessionTimeoutSeconds: 600,
-      verificationTimeoutSeconds: 300,
-      maxStoriesPerFeature: 500,
-      rectification: {
-        enabled: true,
-        maxRetries: 2,
-        fullSuiteTimeoutSeconds: 120,
-        maxFailureSummaryChars: 2000,
-        abortOnIncreasingFailures: true
-      },
-      regressionGate: {
-        enabled: true,
-        timeoutSeconds: 120,
-        acceptOnTimeout: true,
-        maxRectificationAttempts: 2
-      },
-      contextProviderTokenBudget: 2000,
-      smartTestRunner: true
-    },
-    quality: {
-      requireTypecheck: true,
-      requireLint: true,
-      requireTests: true,
-      commands: {},
-      forceExit: false,
-      detectOpenHandles: true,
-      detectOpenHandlesRetries: 1,
-      gracePeriodMs: 5000,
-      dangerouslySkipPermissions: true,
-      drainTimeoutMs: 2000,
-      shell: "/bin/sh",
-      stripEnvVars: ["CLAUDECODE", "REPL_ID", "AGENT"],
-      environmentalEscalationDivisor: 2
-    },
-    tdd: {
-      maxRetries: 2,
-      autoVerifyIsolation: true,
-      autoApproveVerifier: true,
-      strategy: "auto",
-      sessionTiers: {
-        testWriter: "balanced",
-        verifier: "fast"
-      },
-      testWriterAllowedPaths: ["src/index.ts", "src/**/index.ts"],
-      rollbackOnFailure: true,
-      greenfieldDetection: true
-    },
-    constitution: {
-      enabled: true,
-      path: "constitution.md",
-      maxTokens: 2000
-    },
-    analyze: {
-      llmEnhanced: true,
-      model: "balanced",
-      fallbackToKeywords: true,
-      maxCodebaseSummaryTokens: 5000
-    },
-    review: {
-      enabled: true,
-      checks: ["typecheck", "lint"],
-      commands: {}
-    },
-    plan: {
-      model: "balanced",
-      outputPath: "spec.md"
-    },
-    acceptance: {
-      enabled: true,
-      maxRetries: 2,
-      generateTests: true,
-      testPath: "acceptance.test.ts"
-    },
-    context: {
-      fileInjection: "disabled",
-      testCoverage: {
-        enabled: true,
-        detail: "names-and-counts",
-        maxTokens: 500,
-        testPattern: "**/*.test.{ts,js,tsx,jsx}",
-        scopeToStory: true
-      },
-      autoDetect: {
-        enabled: true,
-        maxFiles: 5,
-        traceImports: false
+    }
+    const apiKeyVars = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY"];
+    for (const varName of apiKeyVars) {
+      if (process.env[varName]) {
+        allowed[varName] = process.env[varName];
       }
-    },
-    interaction: {
-      plugin: "cli",
-      config: {},
-      defaults: {
-        timeout: 600000,
-        fallback: "escalate"
-      },
-      triggers: {
-        "security-review": true,
-        "cost-warning": true
+    }
+    const allowedPrefixes = ["CLAUDE_", "NAX_", "CLAW_", "TURBO_"];
+    for (const [key, value] of Object.entries(process.env)) {
+      if (allowedPrefixes.some((prefix) => key.startsWith(prefix))) {
+        allowed[key] = value;
       }
-    },
-    precheck: {
-      storySizeGate: {
-        enabled: true,
-        maxAcCount: 6,
-        maxDescriptionLength: 2000,
-        maxBulletPoints: 8
+    }
+    if (options.modelDef.env) {
+      Object.assign(allowed, options.modelDef.env);
+    }
+    if (options.env) {
+      Object.assign(allowed, options.env);
+    }
+    return allowed;
+  }
+  async runOnce(options, _attempt) {
+    const cmd = this.buildCommand(options);
+    const startTime = Date.now();
+    const proc = Bun.spawn(cmd, {
+      cwd: options.workdir,
+      stdout: "pipe",
+      stderr: "inherit",
+      env: this.buildAllowedEnv(options)
+    });
+    const processPid = proc.pid;
+    const pidRegistry = this.getPidRegistry(options.workdir);
+    await pidRegistry.register(processPid);
+    let timedOut = false;
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      try {
+        _runOnceDeps.killProc(proc, "SIGTERM");
+      } catch {}
+      setTimeout(() => {
+        try {
+          _runOnceDeps.killProc(proc, "SIGKILL");
+        } catch {}
+      }, SIGKILL_GRACE_PERIOD_MS);
+    }, options.timeoutSeconds * 1000);
+    let exitCode;
+    try {
+      const hardDeadlineMs = options.timeoutSeconds * 1000 + SIGKILL_GRACE_PERIOD_MS + 3000;
+      exitCode = await Promise.race([
+        proc.exited,
+        new Promise((resolve) => setTimeout(() => resolve(-1), hardDeadlineMs))
+      ]);
+      if (exitCode === -1) {
+        try {
+          process.kill(processPid, "SIGKILL");
+        } catch {}
+        try {
+          process.kill(-processPid, "SIGKILL");
+        } catch {}
       }
-    },
-    prompts: {},
-    decompose: {
-      trigger: "auto",
-      maxAcceptanceCriteria: 6,
-      maxSubstories: 5,
-      maxSubstoryComplexity: "medium",
-      maxRetries: 2,
-      model: "balanced"
+    } finally {
+      clearTimeout(timeoutId);
+      await pidRegistry.unregister(processPid);
+    }
+    const stdout = await Promise.race([
+      new Response(proc.stdout).text(),
+      new Promise((resolve) => setTimeout(() => resolve(""), 5000))
+    ]);
+    const stderr = proc.stderr ? await new Response(proc.stderr).text() : "";
+    const durationMs = Date.now() - startTime;
+    const fullOutput = stdout + stderr;
+    const rateLimited = fullOutput.toLowerCase().includes("rate limit") || fullOutput.includes("429") || fullOutput.toLowerCase().includes("too many requests");
+    let costEstimate = estimateCostFromOutput(options.modelTier, fullOutput);
+    const logger = getLogger();
+    if (!costEstimate) {
+      const fallbackEstimate = estimateCostByDuration(options.modelTier, durationMs);
+      costEstimate = {
+        cost: fallbackEstimate.cost * 1.5,
+        confidence: "fallback"
+      };
+      logger.warn("agent", "Cost estimation fallback (duration-based)", {
+        modelTier: options.modelTier,
+        cost: costEstimate.cost
+      });
+    } else if (costEstimate.confidence === "estimated") {
+      logger.warn("agent", "Cost estimation using regex parsing (estimated confidence)", { cost: costEstimate.cost });
+    }
+    const cost = costEstimate.cost;
+    const actualExitCode = timedOut ? 124 : exitCode;
+    return {
+      success: exitCode === 0 && !timedOut,
+      exitCode: actualExitCode,
+      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS4),
+      stderr: stderr.slice(-MAX_AGENT_STDERR_CHARS),
+      rateLimited,
+      durationMs,
+      estimatedCost: cost,
+      pid: processPid
+    };
+  }
+  async complete(prompt, options) {
+    const cmd = ["claude", "-p", prompt];
+    if (options?.model) {
+      cmd.push("--model", options.model);
+    }
+    if (options?.maxTokens !== undefined) {
+      cmd.push("--max-tokens", String(options.maxTokens));
+    }
+    if (options?.jsonMode) {
+      cmd.push("--output-format", "json");
+    }
+    const proc = _completeDeps.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) {
+    const pidRegistry = this.getPidRegistry(options.workdir);
+    return runPlan(this.binary, options, pidRegistry, this.buildAllowedEnv.bind(this));
+  }
+  async decompose(options) {
+    const { resolveBalancedModelDef: resolveBalancedModelDef2 } = await Promise.resolve().then(() => (init_model_resolution(), exports_model_resolution));
+    const prompt = buildDecomposePrompt(options);
+    let modelDef = options.modelDef;
+    if (!modelDef) {
+      if (!options.config) {
+        throw new Error("decompose() requires either modelDef or config with models.balanced configured");
+      }
+      modelDef = resolveBalancedModelDef2(options.config);
+    }
+    const cmd = [this.binary, "--model", modelDef.model, "--dangerously-skip-permissions", "-p", prompt];
+    const pidRegistry = this.getPidRegistry(options.workdir);
+    const proc = _decomposeDeps.spawn(cmd, {
+      cwd: options.workdir,
+      stdout: "pipe",
+      stderr: "inherit",
+      env: this.buildAllowedEnv({
+        workdir: options.workdir,
+        modelDef,
+        prompt: "",
+        modelTier: options.modelTier || "balanced",
+        timeoutSeconds: 600
+      })
+    });
+    await pidRegistry.register(proc.pid);
+    const DECOMPOSE_TIMEOUT_MS = 300000;
+    let timedOut = false;
+    const decomposeTimerId = setTimeout(() => {
+      timedOut = true;
+      try {
+        proc.kill("SIGTERM");
+      } catch {}
+      setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {}
+      }, 5000);
+    }, DECOMPOSE_TIMEOUT_MS);
+    let exitCode;
+    try {
+      exitCode = await proc.exited;
+    } finally {
+      clearTimeout(decomposeTimerId);
+      await pidRegistry.unregister(proc.pid);
+    }
+    if (timedOut) {
+      throw new Error(`Decompose timed out after ${DECOMPOSE_TIMEOUT_MS / 1000}s`);
+    }
+    const stdout = await Promise.race([
+      new Response(proc.stdout).text(),
+      new Promise((resolve) => setTimeout(() => resolve(""), 5000))
+    ]);
+    const stderr = await new Response(proc.stderr).text();
+    if (exitCode !== 0) {
+      throw new Error(`Decompose failed with exit code ${exitCode}: ${stderr}`);
+    }
+    const stories = parseDecomposeOutput(stdout);
+    return { stories };
+  }
+  runInteractive(options) {
+    const model = options.modelDef.model;
+    const cmd = [this.binary, "--model", model, options.prompt];
+    const proc = Bun.spawn(cmd, {
+      cwd: options.workdir,
+      env: { ...this.buildAllowedEnv(options), TERM: "xterm-256color", FORCE_COLOR: "1" },
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "inherit"
+    });
+    const pidRegistry = this.getPidRegistry(options.workdir);
+    pidRegistry.register(proc.pid).catch(() => {});
+    (async () => {
+      try {
+        for await (const chunk of proc.stdout) {
+          options.onOutput(Buffer.from(chunk));
+        }
+      } catch (err) {
+        getLogger()?.error("agent", "runInteractive stdout error", { err });
+      }
+    })();
+    proc.exited.then((code) => {
+      pidRegistry.unregister(proc.pid).catch(() => {});
+      options.onExit(code ?? 1);
+    }).catch((err) => {
+      getLogger()?.error("agent", "runInteractive exit error", { err });
+    });
+    return {
+      write: (data) => {
+        proc.stdin.write(data);
+      },
+      resize: (_cols, _rows) => {},
+      kill: () => {
+        proc.kill();
+      },
+      pid: proc.pid
+    };
+  }
+}
+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_types2();
+  _completeDeps = {
+    spawn(cmd, opts) {
+      return Bun.spawn(cmd, opts);
+    }
+  };
+  _decomposeDeps = {
+    spawn(cmd, opts) {
+      return Bun.spawn(cmd, opts);
+    }
+  };
+  _runOnceDeps = {
+    killProc(proc, signal) {
+      proc.kill(signal);
     }
   };
 });
 
-// src/config/schema.ts
-var init_schema = __esm(() => {
-  init_schemas3();
-  init_defaults();
+// 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,
+    displayName: agent.displayName,
+    installed: await agent.isInstalled()
+  })));
+}
+var ALL_AGENTS;
+var init_registry = __esm(() => {
+  init_aider();
+  init_codex();
+  init_gemini();
+  init_opencode();
+  init_claude();
+  ALL_AGENTS = [
+    new ClaudeCodeAdapter,
+    new CodexAdapter,
+    new OpenCodeAdapter,
+    new GeminiAdapter,
+    new AiderAdapter
+  ];
 });
 
 // src/decompose/apply.ts
@@ -19180,17 +19593,13 @@ function evictOldest() {
     cachedDecisions.delete(firstKey);
   }
 }
-async function callLlmOnce(modelTier, prompt, config2, timeoutMs) {
+async function callLlmOnce(adapter, modelTier, prompt, config2, timeoutMs) {
   const modelEntry = config2.models[modelTier];
   if (!modelEntry) {
     throw new Error(`Model tier "${modelTier}" not found in config.models`);
   }
   const modelDef = resolveModel(modelEntry);
   const modelArg = modelDef.model;
-  const proc = _deps.spawn(["claude", "-p", prompt, "--model", modelArg], {
-    stdout: "pipe",
-    stderr: "pipe"
-  });
   let timeoutId;
   const timeoutPromise = new Promise((_, reject) => {
     timeoutId = setTimeout(() => {
@@ -19198,14 +19607,7 @@ async function callLlmOnce(modelTier, prompt, config2, timeoutMs) {
     }, timeoutMs);
   });
   timeoutPromise.catch(() => {});
-  const outputPromise = (async () => {
-    const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-      throw new Error(`claude CLI failed with exit code ${exitCode}: ${stderr}`);
-    }
-    return stdout.trim();
-  })();
+  const outputPromise = adapter.complete(prompt, { model: modelArg });
   try {
     const result = await Promise.race([outputPromise, timeoutPromise]);
     clearTimeout(timeoutId);
@@ -19213,11 +19615,10 @@ async function callLlmOnce(modelTier, prompt, config2, timeoutMs) {
   } catch (err) {
     clearTimeout(timeoutId);
     outputPromise.catch(() => {});
-    proc.kill();
     throw err;
   }
 }
-async function callLlm(modelTier, prompt, config2) {
+async function callLlm(adapter, modelTier, prompt, config2) {
   const llmConfig = config2.routing.llm;
   const timeoutMs = llmConfig?.timeoutMs ?? 30000;
   const maxRetries = llmConfig?.retries ?? 1;
@@ -19225,7 +19626,7 @@ async function callLlm(modelTier, prompt, config2) {
   let lastError;
   for (let attempt = 0;attempt <= maxRetries; attempt++) {
     try {
-      return await callLlmOnce(modelTier, prompt, config2, timeoutMs);
+      return await callLlmOnce(adapter, modelTier, prompt, config2, timeoutMs);
     } catch (err) {
       lastError = err;
       if (attempt < maxRetries) {
@@ -19245,10 +19646,14 @@ async function routeBatch(stories, context) {
   if (!llmConfig) {
     throw new Error("LLM routing config not found");
   }
+  const adapter = context.adapter ?? _deps.adapter;
+  if (!adapter) {
+    throw new Error("No agent adapter available for batch routing (AA-003)");
+  }
   const modelTier = llmConfig.model ?? "fast";
   const prompt = buildBatchPrompt(stories, config2);
   try {
-    const output = await callLlm(modelTier, prompt, config2);
+    const output = await callLlm(adapter, modelTier, prompt, config2);
     const decisions = parseBatchResponse(output, stories, config2);
     if (llmConfig.cacheDecisions) {
       for (const [storyId, decision] of decisions.entries()) {
@@ -19267,12 +19672,14 @@ var cachedDecisions, MAX_CACHE_SIZE = 100, _deps, llmStrategy;
 var init_llm = __esm(() => {
   init_config();
   init_logger2();
+  init_router();
   init_keyword();
   init_llm_prompts();
   init_llm_prompts();
   cachedDecisions = new Map;
   _deps = {
-    spawn: (cmd, opts) => Bun.spawn(cmd, opts)
+    spawn: (cmd, opts) => Bun.spawn(cmd, opts),
+    adapter: undefined
   };
   llmStrategy = {
     name: "llm",
@@ -19288,14 +19695,16 @@ var init_llm = __esm(() => {
         if (!cached2) {
           throw new Error(`Cached decision not found for story: ${story.id}`);
         }
+        const tddStrategy = config2.tdd?.strategy ?? "auto";
+        const freshTestStrategy = determineTestStrategy2(cached2.complexity, story.title, story.description, story.tags, tddStrategy);
         const logger = getLogger();
         logger.debug("routing", "LLM cache hit", {
           storyId: story.id,
           complexity: cached2.complexity,
           modelTier: cached2.modelTier,
-          testStrategy: cached2.testStrategy
+          testStrategy: freshTestStrategy
         });
-        return cached2;
+        return { ...cached2, testStrategy: freshTestStrategy };
       }
       if (mode === "one-shot") {
         const logger = getLogger();
@@ -19305,9 +19714,13 @@ var init_llm = __esm(() => {
         return keywordStrategy.route(story, context);
       }
       try {
+        const adapter = context.adapter ?? _deps.adapter;
+        if (!adapter) {
+          throw new Error("No agent adapter available for LLM routing (AA-003)");
+        }
         const modelTier = llmConfig.model ?? "fast";
         const prompt = buildRoutingPrompt(story, config2);
-        const output = await callLlm(modelTier, prompt, config2);
+        const output = await callLlm(adapter, modelTier, prompt, config2);
         const decision = parseRoutingResponse(output, story, config2);
         if (llmConfig.cacheDecisions) {
           if (cachedDecisions.size >= MAX_CACHE_SIZE) {
@@ -19503,6 +19916,8 @@ function determineTestStrategy2(complexity, title, description, tags = [], tddSt
     return "three-session-tdd";
   if (tddStrategy === "lite")
     return "three-session-tdd-lite";
+  if (tddStrategy === "simple")
+    return "tdd-simple";
   if (tddStrategy === "off")
     return "test-after";
   const text = [title, description, ...tags ?? []].join(" ").toLowerCase();
@@ -20242,7 +20657,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.34.0",
+    version: "0.36.0",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -20262,7 +20677,6 @@ var init_package = __esm(() => {
       prepublishOnly: "bun run build"
     },
     dependencies: {
-      "@anthropic-ai/sdk": "^0.74.0",
       "@types/react": "^19.2.14",
       chalk: "^5.6.2",
       commander: "^13.1.0",
@@ -20304,8 +20718,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("a679961"))
-        return "a679961";
+      if (/^[0-9a-f]{6,10}$/.test("78b52b0"))
+        return "78b52b0";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -20581,7 +20995,7 @@ var init_metrics = __esm(() => {
 
 // src/interaction/types.ts
 var TRIGGER_METADATA;
-var init_types2 = __esm(() => {
+var init_types3 = __esm(() => {
   TRIGGER_METADATA = {
     "security-review": {
       defaultFallback: "abort",
@@ -21475,7 +21889,7 @@ class AutoInteractionPlugin {
   }
   async destroy() {}
   async send(request) {}
-  async receive(requestId, timeout = 60000) {
+  async receive(_requestId, _timeout = 60000) {
     throw new Error("Auto plugin requires full request context (not just requestId)");
   }
   async decide(request) {
@@ -21483,8 +21897,20 @@ class AutoInteractionPlugin {
       return;
     }
     try {
-      const callFn = _deps2.callLlm ?? this.callLlm.bind(this);
-      const decision = await callFn(request);
+      if (_deps2.callLlm) {
+        const decision2 = await _deps2.callLlm(request);
+        if (decision2.confidence < (this.config.confidenceThreshold ?? 0.7)) {
+          return;
+        }
+        return {
+          requestId: request.id,
+          action: decision2.action,
+          value: decision2.value,
+          respondedBy: "auto-ai",
+          respondedAt: Date.now()
+        };
+      }
+      const decision = await this.callLlm(request);
       if (decision.confidence < (this.config.confidenceThreshold ?? 0.7)) {
         return;
       }
@@ -21501,26 +21927,24 @@ class AutoInteractionPlugin {
   }
   async callLlm(request) {
     const prompt = this.buildPrompt(request);
-    const modelTier = this.config.model ?? "fast";
-    if (!this.config.naxConfig) {
-      throw new Error("Auto plugin requires naxConfig in init()");
-    }
-    const modelEntry = this.config.naxConfig.models[modelTier];
-    if (!modelEntry) {
-      throw new Error(`Model tier "${modelTier}" not found in config.models`);
-    }
-    const modelDef = resolveModel(modelEntry);
-    const modelArg = modelDef.model;
-    const proc = Bun.spawn(["claude", "-p", prompt, "--model", modelArg], {
-      stdout: "pipe",
-      stderr: "pipe"
+    const adapter = _deps2.adapter;
+    if (!adapter) {
+      throw new Error("Auto plugin requires adapter to be injected via _deps.adapter");
+    }
+    let modelArg;
+    if (this.config.naxConfig) {
+      const modelTier = this.config.model ?? "fast";
+      const modelEntry = this.config.naxConfig.models[modelTier];
+      if (!modelEntry) {
+        throw new Error(`Model tier "${modelTier}" not found in config.models`);
+      }
+      const modelDef = resolveModel(modelEntry);
+      modelArg = modelDef.model;
+    }
+    const output = await adapter.complete(prompt, {
+      ...modelArg && { model: modelArg },
+      jsonMode: true
     });
-    const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-      throw new Error(`claude CLI failed with exit code ${exitCode}: ${stderr}`);
-    }
-    const output = stdout.trim();
     return this.parseResponse(output);
   }
   buildPrompt(request) {
@@ -21602,6 +22026,7 @@ var init_auto = __esm(() => {
     naxConfig: exports_external.any().optional()
   });
   _deps2 = {
+    adapter: null,
     callLlm: null
   };
 });
@@ -21726,7 +22151,7 @@ async function checkStoryOversized(context, config2, chain) {
   }
 }
 var init_triggers = __esm(() => {
-  init_types2();
+  init_types3();
 });
 
 // src/interaction/init.ts
@@ -21746,19 +22171,19 @@ function createInteractionPlugin(pluginName) {
 }
 async function initInteractionChain(config2, headless) {
   const logger = getSafeLogger();
-  if (headless) {
-    logger?.debug("interaction", "Headless mode - skipping interaction system");
-    return null;
-  }
   if (!config2.interaction) {
     logger?.debug("interaction", "No interaction config - skipping interaction system");
     return null;
   }
+  const pluginName = config2.interaction.plugin;
+  if (headless && pluginName === "cli") {
+    logger?.debug("interaction", "Headless mode with CLI plugin - skipping interaction system (stdin unavailable)");
+    return null;
+  }
   const chain = new InteractionChain({
     defaultTimeout: config2.interaction.defaults.timeout,
     defaultFallback: config2.interaction.defaults.fallback
   });
-  const pluginName = config2.interaction.plugin;
   try {
     const plugin = createInteractionPlugin(pluginName);
     chain.register(plugin, 100);
@@ -21785,7 +22210,7 @@ var init_init = __esm(() => {
 
 // src/interaction/index.ts
 var init_interaction = __esm(() => {
-  init_types2();
+  init_types3();
   init_state();
   init_cli();
   init_telegram();
@@ -23598,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));
@@ -23755,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");
@@ -24319,6 +24837,20 @@ async function runRectificationLoop(story, config2, workdir, agent, implementerT
     if (!rectifyResult.success && rectifyResult.pid) {
       await cleanupProcessTree(rectifyResult.pid);
     }
+    if (rectifyResult.success) {
+      logger.info("tdd", "Rectification agent session complete", {
+        storyId: story.id,
+        attempt: rectificationState.attempt,
+        cost: rectifyResult.estimatedCost
+      });
+    } else {
+      logger.warn("tdd", "Rectification agent session failed", {
+        storyId: story.id,
+        attempt: rectificationState.attempt,
+        exitCode: rectifyResult.exitCode
+      });
+    }
+    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", {
@@ -24344,6 +24876,11 @@ async function runRectificationLoop(story, config2, workdir, agent, implementerT
       testSummary.failed = newTestSummary.failed;
       testSummary.passed = newTestSummary.passed;
     }
+    logger.warn("tdd", "Full suite still failing after rectification attempt", {
+      storyId: story.id,
+      attempt: rectificationState.attempt,
+      remainingFailures: rectificationState.currentFailures
+    });
   }
   const finalFullSuite = await executeWithTimeout(testCmd, fullSuiteTimeout, undefined, { cwd: workdir });
   const finalSuitePassed = finalFullSuite.success && finalFullSuite.exitCode === 0;
@@ -24360,6 +24897,7 @@ async function runRectificationLoop(story, config2, workdir, agent, implementerT
 }
 var init_rectification_gate = __esm(() => {
   init_config();
+  init_git();
   init_verification();
   init_cleanup();
   init_isolation();
@@ -24698,7 +25236,22 @@ async function runTddSession(role, agent, story, config2, workdir, modelTier, be
   if (!result.success && result.pid) {
     await cleanupProcessTree(result.pid);
   }
-  await autoCommitIfDirty(workdir, role, story.id);
+  if (result.success) {
+    logger.info("tdd", `Session complete: ${role}`, {
+      role,
+      storyId: story.id,
+      durationMs: Date.now() - startTime,
+      cost: result.estimatedCost
+    });
+  } else {
+    logger.warn("tdd", `Session failed: ${role}`, {
+      role,
+      storyId: story.id,
+      durationMs: Date.now() - startTime,
+      exitCode: result.exitCode
+    });
+  }
+  await autoCommitIfDirty(workdir, "tdd", role, story.id);
   let isolation;
   if (!skipIsolation) {
     if (role === "test-writer") {
@@ -24745,42 +25298,11 @@ async function runTddSession(role, agent, story, config2, workdir, modelTier, be
     estimatedCost: result.estimatedCost
   };
 }
-async function autoCommitIfDirty(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();
 });
@@ -24836,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);
@@ -24855,13 +25466,26 @@ async function readVerdict(workdir) {
       });
       return null;
     }
-    if (!isValidVerdict(parsed)) {
-      logger.warn("tdd", "Verifier verdict file missing required fields \u2014 ignoring", {
-        path: verdictPath
-      });
-      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,
@@ -25182,6 +25806,7 @@ var init_orchestrator2 = __esm(() => {
   init_config();
   init_greenfield();
   init_logger2();
+  init_git();
   init_verification();
   init_rectification_gate();
   init_session_runner();
@@ -25227,34 +25852,6 @@ function routeTddFailure(failureCategory, isLiteMode, ctx, reviewReason) {
     reason: reviewReason || "Three-session TDD requires review"
   };
 }
-async function autoCommitIfDirty2(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();
@@ -25262,6 +25859,7 @@ var init_execution = __esm(() => {
   init_triggers();
   init_logger2();
   init_tdd();
+  init_git();
   executionStage = {
     name: "execution",
     enabled: () => true,
@@ -25336,7 +25934,7 @@ var init_execution = __esm(() => {
         dangerouslySkipPermissions: ctx.config.execution.dangerouslySkipPermissions
       });
       ctx.agentResult = result;
-      await autoCommitIfDirty2(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);
@@ -25903,10 +26501,17 @@ ${rectificationPrompt}`;
       timeoutSeconds: config2.execution.sessionTimeoutSeconds,
       dangerouslySkipPermissions: config2.execution.dangerouslySkipPermissions
     });
-    if (!agentResult.success) {
+    if (agentResult.success) {
+      logger?.info("rectification", `Agent ${label} session complete`, {
+        storyId: story.id,
+        attempt: rectificationState.attempt,
+        cost: agentResult.estimatedCost
+      });
+    } else {
       logger?.warn("rectification", `Agent ${label} session failed`, {
         storyId: story.id,
-        attempt: rectificationState.attempt
+        attempt: rectificationState.attempt,
+        exitCode: agentResult.exitCode
       });
     }
     const retryVerification = await fullSuite({
@@ -25938,6 +26543,11 @@ ${rectificationPrompt}`;
       testSummary.failed = newTestSummary.failed;
       testSummary.passed = newTestSummary.passed;
     }
+    logger?.warn("rectification", `${label} still failing after attempt`, {
+      storyId: story.id,
+      attempt: rectificationState.attempt,
+      remainingFailures: rectificationState.currentFailures
+    });
   }
   if (rectificationState.attempt >= rectificationConfig.maxRetries) {
     logger?.warn("rectification", `${label} exhausted max retries`, {
@@ -26362,6 +26972,7 @@ function reverseMapTestToSource(testFiles, workdir) {
 }
 var _smartRunnerDeps;
 var init_smart_runner = __esm(() => {
+  init_git();
   _smartRunnerDeps = {
     getChangedSourceFiles,
     mapSourceToTests,
@@ -26597,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();
@@ -26609,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;
@@ -26620,10 +27234,10 @@ 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 (ctx.story.routing?.testStrategy)
+        if (!hasContentHash && ctx.story.routing?.testStrategy)
           routing.testStrategy = ctx.story.routing.testStrategy;
         if (ctx.story.routing?.modelTier) {
           routing.modelTier = ctx.story.routing.modelTier;
@@ -26631,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 ?? {},
@@ -26720,7 +27334,8 @@ var init_routing2 = __esm(() => {
     computeStoryContentHash,
     applyDecomposition,
     runDecompose,
-    checkStoryOversized
+    checkStoryOversized,
+    getAgent
   };
 });
 
@@ -26911,6 +27526,28 @@ var init_stages = __esm(() => {
   postRunPipeline = [acceptanceStage];
 });
 
+// src/plugins/plugin-logger.ts
+function createPluginLogger(pluginName) {
+  const stage = `plugin:${pluginName}`;
+  return {
+    error(message, data) {
+      getSafeLogger()?.error(stage, message, data);
+    },
+    warn(message, data) {
+      getSafeLogger()?.warn(stage, message, data);
+    },
+    info(message, data) {
+      getSafeLogger()?.info(stage, message, data);
+    },
+    debug(message, data) {
+      getSafeLogger()?.debug(stage, message, data);
+    }
+  };
+}
+var init_plugin_logger = __esm(() => {
+  init_logger2();
+});
+
 // src/plugins/registry.ts
 class PluginRegistry {
   plugins;
@@ -27322,7 +27959,8 @@ async function loadAndValidatePlugin(initialModulePath, config2, allowedRoots =
     }
     if (validated.setup) {
       try {
-        await validated.setup(config2);
+        const pluginLogger = createPluginLogger(validated.name);
+        await validated.setup(config2, pluginLogger);
       } catch (error48) {
         const logger = getSafeLogger6();
         logger?.error("plugins", `Plugin '${validated.name}' setup failed`, { error: error48 });
@@ -27353,6 +27991,7 @@ var _pluginErrorSink = (...args) => console.error(...args);
 var init_loader5 = __esm(() => {
   init_logger2();
   init_path_security();
+  init_plugin_logger();
   init_registry2();
   init_validator();
 });
@@ -27480,26 +28119,27 @@ async function checkPRDValid(prd) {
     message: passed ? "PRD structure is valid" : errors3.join("; ")
   };
 }
-async function checkClaudeCLI() {
+async function checkAgentCLI(config2) {
+  const agent = config2.execution?.agent || "claude";
   try {
-    const proc = Bun.spawn(["claude", "--version"], {
+    const proc = _deps6.spawn([agent, "--version"], {
       stdout: "pipe",
       stderr: "pipe"
     });
     const exitCode = await proc.exited;
     const passed = exitCode === 0;
     return {
-      name: "claude-cli-available",
+      name: "agent-cli-available",
       tier: "blocker",
       passed,
-      message: passed ? "Claude CLI is available" : "Claude CLI not found. Install from https://claude.ai/download"
+      message: passed ? `${agent} CLI is available` : `${agent} CLI not found. Install the ${agent} binary.`
     };
   } catch {
     return {
-      name: "claude-cli-available",
+      name: "agent-cli-available",
       tier: "blocker",
       passed: false,
-      message: "Claude CLI not found in PATH. Install from https://claude.ai/download"
+      message: `${agent} CLI not found in PATH. Install the ${agent} binary.`
     };
   }
 }
@@ -27653,7 +28293,12 @@ async function checkGitUserConfigured(workdir) {
     message: passed ? "Git user is configured" : !hasName && !hasEmail ? "Git user.name and user.email not configured" : !hasName ? "Git user.name not configured" : "Git user.email not configured"
   };
 }
-var init_checks_blockers = () => {};
+var _deps6;
+var init_checks_blockers = __esm(() => {
+  _deps6 = {
+    spawn: Bun.spawn
+  };
+});
 
 // src/precheck/checks-warnings.ts
 import { existsSync as existsSync23 } from "fs";
@@ -27781,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
@@ -27903,7 +28593,7 @@ async function runPrecheck(config2, prd, options) {
     () => checkWorkingTreeClean(workdir),
     () => checkStaleLock(workdir),
     () => checkPRDValid(prd),
-    () => checkClaudeCLI(),
+    () => checkAgentCLI(config2),
     () => checkDependenciesInstalled(workdir),
     () => checkTestCommand(config2),
     () => checkLintCommand(config2),
@@ -27930,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();
@@ -29080,6 +29771,7 @@ var init_run_initialization = __esm(() => {
   init_errors3();
   init_logger2();
   init_prd();
+  init_git();
 });
 
 // src/execution/lifecycle/run-setup.ts
@@ -30663,6 +31355,7 @@ var init_iteration_runner = __esm(() => {
   init_logger2();
   init_runner();
   init_stages();
+  init_git();
   init_dry_run();
   init_pipeline_result_handler();
 });
@@ -31231,6 +31924,7 @@ var _regressionDeps;
 var init_run_regression = __esm(() => {
   init_logger2();
   init_prd();
+  init_git();
   init_verification();
   init_rectification_loop();
   init_runners();
@@ -62310,9 +63004,6 @@ var {
   Help
 } = import__.default;
 
-// bin/nax.ts
-init_agents();
-
 // src/cli/analyze.ts
 init_acceptance();
 init_registry();
@@ -62601,7 +63292,14 @@ async function reclassifyWithLLM(story, storySpec, workdir, codebaseContext, con
     throw new Error(`Agent "${agentName}" not found`);
   const modelTier = config2.analyze.model;
   const modelDef = resolveModel(config2.models[modelTier]);
-  const result = await adapter.decompose({ specContent: storySpec, workdir, codebaseContext, modelTier, modelDef });
+  const result = await adapter.decompose({
+    specContent: storySpec,
+    workdir,
+    codebaseContext,
+    modelTier,
+    modelDef,
+    config: config2
+  });
   if (result.stories.length === 0)
     return story;
   const ds = result.stories[0];
@@ -62702,7 +63400,7 @@ async function decomposeLLM(specContent, workdir, config2, logger) {
       throw new Error(`Agent "${agentName}" not found`);
     const modelTier = config2.analyze.model;
     const modelDef = resolveModel(config2.models[modelTier]);
-    const result = await adapter.decompose({ specContent, workdir, codebaseContext, modelTier, modelDef });
+    const result = await adapter.decompose({ specContent, workdir, codebaseContext, modelTier, modelDef, config: config2 });
     logger.info("cli", "[OK] Agent decompose complete", { storiesCount: result.stories.length });
     return result.stories.map((ds) => {
       let testStrategy;
@@ -62824,7 +63522,8 @@ async function planCommand(prompt, workdir, config2, options = {}) {
     codebaseContext,
     inputFile: options.from,
     modelTier,
-    modelDef
+    modelDef,
+    config: config2
   };
   const adapter = new ClaudeCodeAdapter;
   logger.info("cli", interactive ? "Starting interactive planning session..." : `Reading from ${options.from}...`, {
@@ -64425,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
@@ -64444,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
@@ -64487,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)) {
@@ -64542,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");
@@ -64630,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)",
@@ -64951,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)) {
@@ -65020,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);
@@ -65358,7 +66149,7 @@ import { readdir as readdir4 } from "fs/promises";
 import { homedir as homedir4 } from "os";
 import { join as join28 } from "path";
 var DEFAULT_LIMIT = 20;
-var _deps6 = {
+var _deps7 = {
   getRunsDir: () => join28(homedir4(), ".nax", "runs")
 };
 function formatDuration3(ms) {
@@ -65396,12 +66187,12 @@ 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);
 }
 async function runsCommand(options = {}) {
-  const runsDir = _deps6.getRunsDir();
+  const runsDir = _deps7.getRunsDir();
   let entries;
   try {
     entries = await readdir4(runsDir);
@@ -65455,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();
@@ -65469,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);
@@ -73547,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 {