@nathapp/nax 0.40.1 → 0.42.0

package/dist/nax.js

@@ -3241,9 +3241,6 @@ async function executeComplete(binary, prompt, options) {
   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");
   }
@@ -3469,6 +3466,17 @@ function estimateCostByDuration(modelTier, durationMs) {
     confidence: "fallback"
   };
 }
+function formatCostWithConfidence(estimate) {
+  const formattedCost = `$${estimate.cost.toFixed(2)}`;
+  switch (estimate.confidence) {
+    case "exact":
+      return formattedCost;
+    case "estimated":
+      return `~${formattedCost}`;
+    case "fallback":
+      return `~${formattedCost} (duration-based)`;
+  }
+}
 var COST_RATES;
 var init_cost = __esm(() => {
   COST_RATES = {
@@ -17525,7 +17533,7 @@ var init_zod = __esm(() => {
 });
 
 // src/config/schemas.ts
-var TokenPricingSchema, ModelDefSchema, ModelEntrySchema, ModelMapSchema, ModelTierSchema, TierConfigSchema, AutoModeConfigSchema, RectificationConfigSchema, RegressionGateConfigSchema, SmartTestRunnerConfigSchema, SMART_TEST_RUNNER_DEFAULT, smartTestRunnerFieldSchema, ExecutionConfigSchema, QualityConfigSchema, TddConfigSchema, ConstitutionConfigSchema, AnalyzeConfigSchema, ReviewConfigSchema, PlanConfigSchema, AcceptanceConfigSchema, TestCoverageConfigSchema, ContextAutoDetectConfigSchema, ContextConfigSchema, AdaptiveRoutingConfigSchema, LlmRoutingConfigSchema, RoutingConfigSchema, OptimizerConfigSchema, PluginConfigEntrySchema, HooksConfigSchema, InteractionConfigSchema, StorySizeGateConfigSchema, PrecheckConfigSchema, PromptsConfigSchema, DecomposeConfigSchema, NaxConfigSchema;
+var TokenPricingSchema, ModelDefSchema, ModelEntrySchema, ModelMapSchema, ModelTierSchema, TierConfigSchema, AutoModeConfigSchema, RectificationConfigSchema, RegressionGateConfigSchema, SmartTestRunnerConfigSchema, SMART_TEST_RUNNER_DEFAULT, smartTestRunnerFieldSchema, ExecutionConfigSchema, QualityConfigSchema, TddConfigSchema, ConstitutionConfigSchema, AnalyzeConfigSchema, ReviewConfigSchema, PlanConfigSchema, AcceptanceConfigSchema, TestCoverageConfigSchema, ContextAutoDetectConfigSchema, ContextConfigSchema, AdaptiveRoutingConfigSchema, LlmRoutingConfigSchema, RoutingConfigSchema, OptimizerConfigSchema, PluginConfigEntrySchema, HooksConfigSchema, InteractionConfigSchema, StorySizeGateConfigSchema, AgentConfigSchema, PrecheckConfigSchema, PromptsConfigSchema, DecomposeConfigSchema, NaxConfigSchema;
 var init_schemas3 = __esm(() => {
   init_zod();
   TokenPricingSchema = exports_external.object({
@@ -17794,6 +17802,10 @@ var init_schemas3 = __esm(() => {
     maxDescriptionLength: exports_external.number().int().min(100).max(1e4).default(2000),
     maxBulletPoints: exports_external.number().int().min(1).max(100).default(8)
   });
+  AgentConfigSchema = exports_external.object({
+    protocol: exports_external.enum(["acp", "cli"]).default("acp"),
+    acpPermissionMode: exports_external.string().optional()
+  });
   PrecheckConfigSchema = exports_external.object({
     storySizeGate: StorySizeGateConfigSchema
   });
@@ -17829,6 +17841,7 @@ var init_schemas3 = __esm(() => {
     disabledPlugins: exports_external.array(exports_external.string()).optional(),
     hooks: HooksConfigSchema.optional(),
     interaction: InteractionConfigSchema.optional(),
+    agent: AgentConfigSchema.optional(),
     precheck: PrecheckConfigSchema.optional(),
     prompts: PromptsConfigSchema.optional(),
     decompose: DecomposeConfigSchema.optional()
@@ -18240,7 +18253,7 @@ class ClaudeCodeAdapter {
             const backoffMs = 2 ** attempt * 1000;
             const logger = getLogger();
             logger.warn("agent", "Rate limited, retrying", { backoffSeconds: backoffMs / 1000, attempt, maxRetries });
-            await Bun.sleep(backoffMs);
+            await _claudeAdapterDeps.sleep(backoffMs);
             continue;
           }
           return result;
@@ -18256,7 +18269,7 @@ class ClaudeCodeAdapter {
               attempt,
               maxRetries
             });
-            await Bun.sleep(backoffMs);
+            await _claudeAdapterDeps.sleep(backoffMs);
             continue;
           }
           throw lastError;
@@ -18336,7 +18349,7 @@ class ClaudeCodeAdapter {
     return runInteractiveMode(this.binary, options, pidRegistry);
   }
 }
-var _decomposeDeps;
+var _decomposeDeps, _claudeAdapterDeps;
 var init_claude = __esm(() => {
   init_pid_registry();
   init_logger2();
@@ -18349,6 +18362,9 @@ var init_claude = __esm(() => {
       return Bun.spawn(cmd, opts);
     }
   };
+  _claudeAdapterDeps = {
+    sleep: (ms) => Bun.sleep(ms)
+  };
 });
 
 // src/utils/errors.ts
@@ -18676,29 +18692,10 @@ async function generateAcceptanceTests(adapter, options) {
   logger.info("acceptance", "Found acceptance criteria", { count: criteria.length });
   const prompt = buildAcceptanceTestPrompt(criteria, options.featureName, options.codebaseContext);
   try {
-    const skipPerms = options.config.quality?.dangerouslySkipPermissions ?? true;
-    const permArgs = skipPerms ? ["--dangerously-skip-permissions"] : [];
-    const cmd = [adapter.binary, "--model", options.modelDef.model, ...permArgs, "-p", prompt];
-    const proc = Bun.spawn(cmd, {
-      cwd: options.workdir,
-      stdout: "pipe",
-      stderr: "pipe",
-      env: {
-        ...process.env,
-        ...options.modelDef.env || {}
-      }
+    const output = await adapter.complete(prompt, {
+      model: options.modelDef.model
     });
-    const exitCode = await proc.exited;
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    if (exitCode !== 0) {
-      logger.warn("acceptance", "\u26A0 Agent test generation failed", { stderr });
-      return {
-        testCode: generateSkeletonTests(options.featureName, criteria),
-        criteria
-      };
-    }
-    const testCode = extractTestCode(stdout);
+    const testCode = extractTestCode(output);
     return {
       testCode,
       criteria
@@ -18801,7 +18798,7 @@ Requirements:
 Respond with ONLY the fix description (no JSON, no markdown, just the description text).`;
 }
 async function generateFixStories(adapter, options) {
-  const { failedACs, testOutput, prd, specContent, workdir, modelDef } = options;
+  const { failedACs, testOutput, prd, specContent, modelDef } = options;
   const fixStories = [];
   const acTextMap = parseACTextFromSpec(specContent);
   const logger = getLogger();
@@ -18816,34 +18813,9 @@ async function generateFixStories(adapter, options) {
     }
     const prompt = buildFixPrompt(failedAC, acText, testOutput, relatedStories, prd);
     try {
-      const skipPerms = options.config.quality?.dangerouslySkipPermissions ?? true;
-      const permArgs = skipPerms ? ["--dangerously-skip-permissions"] : [];
-      const cmd = [adapter.binary, "--model", modelDef.model, ...permArgs, "-p", prompt];
-      const proc = Bun.spawn(cmd, {
-        cwd: workdir,
-        stdout: "pipe",
-        stderr: "pipe",
-        env: {
-          ...process.env,
-          ...modelDef.env || {}
-        }
+      const fixDescription = await adapter.complete(prompt, {
+        model: modelDef.model
       });
-      const exitCode = await proc.exited;
-      const stdout = await new Response(proc.stdout).text();
-      const stderr = await new Response(proc.stderr).text();
-      if (exitCode !== 0) {
-        logger.warn("acceptance", "\u26A0 Agent fix generation failed", { failedAC, stderr });
-        fixStories.push({
-          id: `US-FIX-${String(i + 1).padStart(3, "0")}`,
-          title: `Fix: ${failedAC}`,
-          failedAC,
-          testOutput,
-          relatedStories,
-          description: `Fix the implementation to make ${failedAC} pass. Related stories: ${relatedStories.join(", ")}.`
-        });
-        continue;
-      }
-      const fixDescription = stdout.trim();
       fixStories.push({
         id: `US-FIX-${String(i + 1).padStart(3, "0")}`,
         title: `Fix: ${failedAC} \u2014 ${acText.slice(0, 50)}`,
@@ -18910,6 +18882,676 @@ var init_acceptance = __esm(() => {
   init_fix_generator();
 });
 
+// src/agents/acp/parser.ts
+function parseAcpxJsonOutput(rawOutput) {
+  const lines = rawOutput.split(`
+`).filter((l) => l.trim());
+  let text = "";
+  let tokenUsage;
+  let stopReason;
+  let error48;
+  for (const line of lines) {
+    try {
+      const event = JSON.parse(line);
+      if (event.content && typeof event.content === "string")
+        text += event.content;
+      if (event.text && typeof event.text === "string")
+        text += event.text;
+      if (event.result && typeof event.result === "string")
+        text = event.result;
+      if (event.cumulative_token_usage)
+        tokenUsage = event.cumulative_token_usage;
+      if (event.usage) {
+        tokenUsage = {
+          input_tokens: event.usage.input_tokens ?? event.usage.prompt_tokens ?? 0,
+          output_tokens: event.usage.output_tokens ?? event.usage.completion_tokens ?? 0
+        };
+      }
+      if (event.stopReason)
+        stopReason = event.stopReason;
+      if (event.stop_reason)
+        stopReason = event.stop_reason;
+      if (event.error) {
+        error48 = typeof event.error === "string" ? event.error : event.error.message ?? JSON.stringify(event.error);
+      }
+    } catch {
+      if (!text)
+        text = line;
+    }
+  }
+  return { text: text.trim(), tokenUsage, stopReason, error: error48 };
+}
+
+// src/agents/acp/spawn-client.ts
+function buildAllowedEnv2(extraEnv) {
+  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", "GEMINI_API_KEY", "GOOGLE_API_KEY", "CLAUDE_API_KEY"];
+  for (const varName of apiKeyVars) {
+    if (process.env[varName])
+      allowed[varName] = process.env[varName];
+  }
+  const allowedPrefixes = ["CLAUDE_", "NAX_", "CLAW_", "TURBO_", "ACPX_", "CODEX_", "GEMINI_"];
+  for (const [key, value] of Object.entries(process.env)) {
+    if (allowedPrefixes.some((prefix) => key.startsWith(prefix))) {
+      allowed[key] = value;
+    }
+  }
+  if (extraEnv)
+    Object.assign(allowed, extraEnv);
+  return allowed;
+}
+
+class SpawnAcpSession {
+  agentName;
+  sessionName;
+  cwd;
+  model;
+  timeoutSeconds;
+  permissionMode;
+  env;
+  constructor(opts) {
+    this.agentName = opts.agentName;
+    this.sessionName = opts.sessionName;
+    this.cwd = opts.cwd;
+    this.model = opts.model;
+    this.timeoutSeconds = opts.timeoutSeconds;
+    this.permissionMode = opts.permissionMode;
+    this.env = opts.env;
+  }
+  async prompt(text) {
+    const cmd = [
+      "acpx",
+      "--cwd",
+      this.cwd,
+      ...this.permissionMode === "approve-all" ? ["--approve-all"] : [],
+      "--format",
+      "json",
+      "--model",
+      this.model,
+      "--timeout",
+      String(this.timeoutSeconds),
+      this.agentName,
+      "prompt",
+      "-s",
+      this.sessionName,
+      "--file",
+      "-"
+    ];
+    getSafeLogger()?.debug("acp-adapter", `Sending prompt to session: ${this.sessionName}`);
+    const proc = _spawnClientDeps.spawn(cmd, {
+      cwd: this.cwd,
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+      env: this.env
+    });
+    proc.stdin.write(text);
+    proc.stdin.end();
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    if (exitCode !== 0) {
+      getSafeLogger()?.warn("acp-adapter", `Session prompt exited with code ${exitCode}`, {
+        stderr: stderr.slice(0, 200)
+      });
+      return {
+        messages: [{ role: "assistant", content: stderr || `Exit code ${exitCode}` }],
+        stopReason: "error"
+      };
+    }
+    try {
+      const parsed = parseAcpxJsonOutput(stdout);
+      return {
+        messages: [{ role: "assistant", content: parsed.text || "" }],
+        stopReason: "end_turn",
+        cumulative_token_usage: parsed.tokenUsage
+      };
+    } catch (err) {
+      getSafeLogger()?.warn("acp-adapter", "Failed to parse session prompt response", {
+        stderr: stderr.slice(0, 200)
+      });
+      throw err;
+    }
+  }
+  async close() {
+    const cmd = ["acpx", this.agentName, "sessions", "close", this.sessionName];
+    getSafeLogger()?.debug("acp-adapter", `Closing session: ${this.sessionName}`);
+    const proc = _spawnClientDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      getSafeLogger()?.warn("acp-adapter", "Failed to close session", {
+        sessionName: this.sessionName,
+        stderr: stderr.slice(0, 200)
+      });
+    }
+  }
+  async cancelActivePrompt() {
+    const cmd = ["acpx", this.agentName, "cancel"];
+    getSafeLogger()?.debug("acp-adapter", `Cancelling active prompt: ${this.sessionName}`);
+    const proc = _spawnClientDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+    await proc.exited;
+  }
+}
+
+class SpawnAcpClient {
+  agentName;
+  model;
+  cwd;
+  timeoutSeconds;
+  env;
+  constructor(cmdStr, cwd, timeoutSeconds) {
+    const parts = cmdStr.split(/\s+/);
+    const modelIdx = parts.indexOf("--model");
+    this.model = modelIdx >= 0 && parts[modelIdx + 1] ? parts[modelIdx + 1] : "default";
+    this.agentName = parts[parts.length - 1] || "claude";
+    this.cwd = cwd || process.cwd();
+    this.timeoutSeconds = timeoutSeconds || 1800;
+    this.env = buildAllowedEnv2();
+  }
+  async start() {}
+  async createSession(opts) {
+    const sessionName = opts.sessionName || `nax-${Date.now()}`;
+    const cmd = ["acpx", opts.agentName, "sessions", "ensure", "--name", sessionName];
+    getSafeLogger()?.debug("acp-adapter", `Ensuring session: ${sessionName}`);
+    const proc = _spawnClientDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      throw new Error(`[acp-adapter] Failed to create session: ${stderr || `exit code ${exitCode}`}`);
+    }
+    return new SpawnAcpSession({
+      agentName: opts.agentName,
+      sessionName,
+      cwd: this.cwd,
+      model: this.model,
+      timeoutSeconds: this.timeoutSeconds,
+      permissionMode: opts.permissionMode,
+      env: this.env
+    });
+  }
+  async loadSession(sessionName) {
+    const cmd = ["acpx", this.agentName, "sessions", "ensure", "--name", sessionName];
+    const proc = _spawnClientDeps.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      return null;
+    }
+    return new SpawnAcpSession({
+      agentName: this.agentName,
+      sessionName,
+      cwd: this.cwd,
+      model: this.model,
+      timeoutSeconds: this.timeoutSeconds,
+      permissionMode: "approve-all",
+      env: this.env
+    });
+  }
+  async close() {}
+}
+function createSpawnAcpClient(cmdStr, cwd, timeoutSeconds) {
+  return new SpawnAcpClient(cmdStr, cwd, timeoutSeconds);
+}
+var _spawnClientDeps;
+var init_spawn_client = __esm(() => {
+  init_logger2();
+  _spawnClientDeps = {
+    spawn(cmd, opts) {
+      return Bun.spawn(cmd, opts);
+    }
+  };
+});
+
+// src/agents/acp/cost.ts
+function estimateCostFromTokenUsage(usage, model) {
+  const pricing = MODEL_PRICING[model];
+  if (!pricing) {
+    const fallbackInputRate = 3 / 1e6;
+    const fallbackOutputRate = 15 / 1e6;
+    const inputCost2 = (usage.input_tokens ?? 0) * fallbackInputRate;
+    const outputCost2 = (usage.output_tokens ?? 0) * fallbackOutputRate;
+    const cacheReadCost2 = (usage.cache_read_input_tokens ?? 0) * (0.5 / 1e6);
+    const cacheCreationCost2 = (usage.cache_creation_input_tokens ?? 0) * (2 / 1e6);
+    return inputCost2 + outputCost2 + cacheReadCost2 + cacheCreationCost2;
+  }
+  const inputRate = pricing.input / 1e6;
+  const outputRate = pricing.output / 1e6;
+  const cacheReadRate = (pricing.cacheRead ?? pricing.input * 0.1) / 1e6;
+  const cacheCreationRate = (pricing.cacheCreation ?? pricing.input * 0.33) / 1e6;
+  const inputCost = (usage.input_tokens ?? 0) * inputRate;
+  const outputCost = (usage.output_tokens ?? 0) * outputRate;
+  const cacheReadCost = (usage.cache_read_input_tokens ?? 0) * cacheReadRate;
+  const cacheCreationCost = (usage.cache_creation_input_tokens ?? 0) * cacheCreationRate;
+  return inputCost + outputCost + cacheReadCost + cacheCreationCost;
+}
+var MODEL_PRICING;
+var init_cost2 = __esm(() => {
+  MODEL_PRICING = {
+    "claude-sonnet-4": { input: 3, output: 15 },
+    "claude-sonnet-4-5": { input: 3, output: 15 },
+    "claude-haiku": { input: 0.8, output: 4, cacheRead: 0.1, cacheCreation: 1 },
+    "claude-haiku-4-5": { input: 0.8, output: 4, cacheRead: 0.1, cacheCreation: 1 },
+    "claude-opus": { input: 15, output: 75 },
+    "claude-opus-4": { input: 15, output: 75 },
+    "gpt-4.1": { input: 10, output: 30 },
+    "gpt-4": { input: 30, output: 60 },
+    "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
+    "gemini-2.5-pro": { input: 0.075, output: 0.3 },
+    "gemini-2-pro": { input: 0.075, output: 0.3 },
+    codex: { input: 0.02, output: 0.06 },
+    "code-davinci-002": { input: 0.02, output: 0.06 }
+  };
+});
+
+// src/agents/acp/adapter.ts
+import { createHash } from "crypto";
+import { join as join3 } from "path";
+function resolveRegistryEntry(agentName) {
+  return AGENT_REGISTRY[agentName] ?? DEFAULT_ENTRY;
+}
+function isRateLimitError(err) {
+  if (!(err instanceof Error))
+    return false;
+  const msg = err.message.toLowerCase();
+  return msg.includes("rate limit") || msg.includes("rate_limit") || msg.includes("429");
+}
+function buildSessionName(workdir, featureName, storyId, sessionRole) {
+  const hash2 = createHash("sha256").update(workdir).digest("hex").slice(0, 8);
+  const sanitize = (s) => s.replace(/[^a-z0-9]+/gi, "-").toLowerCase().replace(/^-+|-+$/g, "");
+  const parts = ["nax", hash2];
+  if (featureName)
+    parts.push(sanitize(featureName));
+  if (storyId)
+    parts.push(sanitize(storyId));
+  if (sessionRole)
+    parts.push(sanitize(sessionRole));
+  return parts.join("-");
+}
+async function ensureAcpSession(client, sessionName, agentName, permissionMode) {
+  if (client.loadSession) {
+    try {
+      const existing = await client.loadSession(sessionName);
+      if (existing) {
+        getSafeLogger()?.debug("acp-adapter", `Resumed existing session: ${sessionName}`);
+        return existing;
+      }
+    } catch {}
+  }
+  getSafeLogger()?.debug("acp-adapter", `Creating new session: ${sessionName}`);
+  return client.createSession({ agentName, permissionMode, sessionName });
+}
+async function runSessionPrompt(session, prompt, timeoutMs) {
+  const promptPromise = session.prompt(prompt);
+  const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve("timeout"), timeoutMs));
+  const winner = await Promise.race([promptPromise, timeoutPromise]);
+  if (winner === "timeout") {
+    try {
+      await session.cancelActivePrompt();
+    } catch {
+      await session.close().catch(() => {});
+    }
+    return { response: null, timedOut: true };
+  }
+  return { response: winner, timedOut: false };
+}
+async function closeAcpSession(session) {
+  try {
+    await session.close();
+  } catch (err) {
+    getSafeLogger()?.warn("acp-adapter", "Failed to close session", { error: String(err) });
+  }
+}
+function acpSessionsPath(workdir, featureName) {
+  return join3(workdir, "nax", "features", featureName, "acp-sessions.json");
+}
+async function saveAcpSession(workdir, featureName, storyId, sessionName) {
+  try {
+    const path = acpSessionsPath(workdir, featureName);
+    let data = {};
+    try {
+      const existing = await Bun.file(path).text();
+      data = JSON.parse(existing);
+    } catch {}
+    data[storyId] = sessionName;
+    await Bun.write(path, JSON.stringify(data, null, 2));
+  } catch (err) {
+    getSafeLogger()?.warn("acp-adapter", "Failed to save session to sidecar", { error: String(err) });
+  }
+}
+async function clearAcpSession(workdir, featureName, storyId) {
+  try {
+    const path = acpSessionsPath(workdir, featureName);
+    let data = {};
+    try {
+      const existing = await Bun.file(path).text();
+      data = JSON.parse(existing);
+    } catch {
+      return;
+    }
+    delete data[storyId];
+    await Bun.write(path, JSON.stringify(data, null, 2));
+  } catch (err) {
+    getSafeLogger()?.warn("acp-adapter", "Failed to clear session from sidecar", { error: String(err) });
+  }
+}
+async function readAcpSession(workdir, featureName, storyId) {
+  try {
+    const path = acpSessionsPath(workdir, featureName);
+    const existing = await Bun.file(path).text();
+    const data = JSON.parse(existing);
+    return data[storyId] ?? null;
+  } catch {
+    return null;
+  }
+}
+function extractOutput(response) {
+  if (!response)
+    return "";
+  return response.messages.filter((m) => m.role === "assistant").map((m) => m.content).join(`
+`).trim();
+}
+function extractQuestion(output) {
+  const text = output.trim();
+  if (!text)
+    return null;
+  const sentences = text.split(/(?<=[.!?])\s+/);
+  const questionSentences = sentences.filter((s) => s.trim().endsWith("?"));
+  if (questionSentences.length > 0) {
+    const q = questionSentences[questionSentences.length - 1].trim();
+    if (q.length > 10)
+      return q;
+  }
+  const lower = text.toLowerCase();
+  const markers = [
+    "please confirm",
+    "please specify",
+    "please provide",
+    "which would you",
+    "should i ",
+    "do you want",
+    "can you clarify"
+  ];
+  for (const marker of markers) {
+    if (lower.includes(marker)) {
+      return text.slice(-200).trim();
+    }
+  }
+  return null;
+}
+
+class AcpAgentAdapter {
+  name;
+  displayName;
+  binary;
+  capabilities;
+  constructor(agentName) {
+    const entry = resolveRegistryEntry(agentName);
+    this.name = agentName;
+    this.displayName = entry.displayName;
+    this.binary = entry.binary;
+    this.capabilities = {
+      supportedTiers: entry.supportedTiers,
+      maxContextTokens: entry.maxContextTokens,
+      features: new Set(["tdd", "review", "refactor"])
+    };
+  }
+  async isInstalled() {
+    const path = _acpAdapterDeps.which(this.binary);
+    return path !== null;
+  }
+  buildCommand(_options) {
+    return ["acpx", this.name, "session"];
+  }
+  buildAllowedEnv(_options) {
+    return {};
+  }
+  async run(options) {
+    const startTime = Date.now();
+    let lastError;
+    getSafeLogger()?.debug("acp-adapter", `Starting run for ${this.name}`, {
+      model: options.modelDef.model,
+      workdir: options.workdir,
+      featureName: options.featureName,
+      storyId: options.storyId,
+      sessionRole: options.sessionRole
+    });
+    for (let attempt = 0;attempt < MAX_RATE_LIMIT_RETRIES; attempt++) {
+      try {
+        const result = await this._runWithClient(options, startTime);
+        if (!result.success) {
+          getSafeLogger()?.warn("acp-adapter", `Run failed for ${this.name}`, { exitCode: result.exitCode });
+        }
+        return result;
+      } catch (err) {
+        const error48 = err instanceof Error ? err : new Error(String(err));
+        lastError = error48;
+        const shouldRetry = isRateLimitError(error48) && attempt < MAX_RATE_LIMIT_RETRIES - 1;
+        if (!shouldRetry)
+          break;
+        const backoffMs = 2 ** (attempt + 1) * 1000;
+        getSafeLogger()?.warn("acp-adapter", "Retrying after rate limit", {
+          backoffSeconds: backoffMs / 1000,
+          attempt: attempt + 1
+        });
+        await _acpAdapterDeps.sleep(backoffMs);
+      }
+    }
+    const durationMs = Date.now() - startTime;
+    return {
+      success: false,
+      exitCode: 1,
+      output: lastError?.message ?? "Run failed",
+      rateLimited: isRateLimitError(lastError),
+      durationMs,
+      estimatedCost: 0
+    };
+  }
+  async _runWithClient(options, startTime) {
+    const cmdStr = `acpx --model ${options.modelDef.model} ${this.name}`;
+    const client = _acpAdapterDeps.createClient(cmdStr, options.workdir, options.timeoutSeconds);
+    await client.start();
+    let sessionName = options.acpSessionName;
+    if (!sessionName && options.featureName && options.storyId) {
+      sessionName = await readAcpSession(options.workdir, options.featureName, options.storyId) ?? undefined;
+    }
+    sessionName ??= buildSessionName(options.workdir, options.featureName, options.storyId, options.sessionRole);
+    const permissionMode = options.dangerouslySkipPermissions ? "approve-all" : "default";
+    const session = await ensureAcpSession(client, sessionName, this.name, permissionMode);
+    if (options.featureName && options.storyId) {
+      await saveAcpSession(options.workdir, options.featureName, options.storyId, sessionName);
+    }
+    let lastResponse = null;
+    let timedOut = false;
+    const totalTokenUsage = { input_tokens: 0, output_tokens: 0 };
+    try {
+      let currentPrompt = options.prompt;
+      let turnCount = 0;
+      const MAX_TURNS = options.interactionBridge ? 10 : 1;
+      while (turnCount < MAX_TURNS) {
+        turnCount++;
+        getSafeLogger()?.debug("acp-adapter", `Session turn ${turnCount}/${MAX_TURNS}`, { sessionName });
+        const turnResult = await runSessionPrompt(session, currentPrompt, options.timeoutSeconds * 1000);
+        if (turnResult.timedOut) {
+          timedOut = true;
+          break;
+        }
+        lastResponse = turnResult.response;
+        if (!lastResponse)
+          break;
+        if (lastResponse.cumulative_token_usage) {
+          totalTokenUsage.input_tokens += lastResponse.cumulative_token_usage.input_tokens ?? 0;
+          totalTokenUsage.output_tokens += lastResponse.cumulative_token_usage.output_tokens ?? 0;
+        }
+        const outputText = extractOutput(lastResponse);
+        const question = extractQuestion(outputText);
+        if (!question || !options.interactionBridge)
+          break;
+        getSafeLogger()?.debug("acp-adapter", "Agent asked question, routing to interactionBridge", { question });
+        try {
+          const answer = await Promise.race([
+            options.interactionBridge.onQuestionDetected(question),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("interaction timeout")), INTERACTION_TIMEOUT_MS))
+          ]);
+          currentPrompt = answer;
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          getSafeLogger()?.warn("acp-adapter", `InteractionBridge failed: ${msg}`);
+          break;
+        }
+      }
+      if (turnCount >= MAX_TURNS && options.interactionBridge) {
+        getSafeLogger()?.warn("acp-adapter", "Reached max turns limit", { sessionName, maxTurns: MAX_TURNS });
+      }
+    } finally {
+      await closeAcpSession(session);
+      await client.close().catch(() => {});
+      if (options.featureName && options.storyId) {
+        await clearAcpSession(options.workdir, options.featureName, options.storyId);
+      }
+    }
+    const durationMs = Date.now() - startTime;
+    if (timedOut) {
+      return {
+        success: false,
+        exitCode: 124,
+        output: `Session timed out after ${options.timeoutSeconds}s`,
+        rateLimited: false,
+        durationMs,
+        estimatedCost: 0
+      };
+    }
+    const success2 = lastResponse?.stopReason === "end_turn";
+    const output = extractOutput(lastResponse);
+    const estimatedCost = totalTokenUsage.input_tokens > 0 || totalTokenUsage.output_tokens > 0 ? estimateCostFromTokenUsage(totalTokenUsage, options.modelDef.model) : 0;
+    return {
+      success: success2,
+      exitCode: success2 ? 0 : 1,
+      output: output.slice(-MAX_AGENT_OUTPUT_CHARS2),
+      rateLimited: false,
+      durationMs,
+      estimatedCost
+    };
+  }
+  async complete(prompt, _options) {
+    const model = _options?.model ?? "default";
+    const cmdStr = `acpx --model ${model} ${this.name}`;
+    const client = _acpAdapterDeps.createClient(cmdStr);
+    await client.start();
+    const permissionMode = _options?.dangerouslySkipPermissions ? "approve-all" : "default";
+    let session = null;
+    try {
+      session = await client.createSession({ agentName: this.name, permissionMode });
+      const response = await session.prompt(prompt);
+      if (response.stopReason === "error") {
+        throw new CompleteError("complete() failed: stop reason is error");
+      }
+      const text = response.messages.filter((m) => m.role === "assistant").map((m) => m.content).join(`
+`).trim();
+      if (!text) {
+        throw new CompleteError("complete() returned empty output");
+      }
+      return text;
+    } finally {
+      if (session) {
+        await session.close().catch(() => {});
+      }
+      await client.close().catch(() => {});
+    }
+  }
+  async plan(options) {
+    const modelDef = options.modelDef ?? { provider: "anthropic", model: "default" };
+    const timeoutSeconds = options.timeoutSeconds ?? options.config?.execution?.sessionTimeoutSeconds ?? 600;
+    const result = await this.run({
+      prompt: options.prompt,
+      workdir: options.workdir,
+      modelTier: options.modelTier ?? "balanced",
+      modelDef,
+      timeoutSeconds,
+      dangerouslySkipPermissions: options.dangerouslySkipPermissions ?? false,
+      interactionBridge: options.interactionBridge,
+      featureName: options.featureName,
+      storyId: options.storyId,
+      sessionRole: options.sessionRole
+    });
+    if (!result.success) {
+      throw new Error(`[acp-adapter] plan() failed: ${result.output}`);
+    }
+    const specContent = result.output.trim();
+    if (!specContent) {
+      throw new Error("[acp-adapter] plan() returned empty spec content");
+    }
+    return { specContent };
+  }
+  async decompose(options) {
+    const model = options.modelDef?.model;
+    const prompt = buildDecomposePrompt(options);
+    let output;
+    try {
+      output = await this.complete(prompt, { model, jsonMode: true });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`[acp-adapter] decompose() failed: ${msg}`, { cause: err });
+    }
+    let stories;
+    try {
+      stories = parseDecomposeOutput(output);
+    } catch (err) {
+      throw new Error(`[acp-adapter] decompose() failed to parse stories: ${err.message}`, { cause: err });
+    }
+    return { stories };
+  }
+}
+var MAX_AGENT_OUTPUT_CHARS2 = 5000, MAX_RATE_LIMIT_RETRIES = 3, INTERACTION_TIMEOUT_MS, AGENT_REGISTRY, DEFAULT_ENTRY, _acpAdapterDeps;
+var init_adapter = __esm(() => {
+  init_logger2();
+  init_spawn_client();
+  init_types2();
+  init_cost2();
+  INTERACTION_TIMEOUT_MS = 5 * 60 * 1000;
+  AGENT_REGISTRY = {
+    claude: {
+      binary: "claude",
+      displayName: "Claude Code (ACP)",
+      supportedTiers: ["fast", "balanced", "powerful"],
+      maxContextTokens: 200000
+    },
+    codex: {
+      binary: "codex",
+      displayName: "OpenAI Codex (ACP)",
+      supportedTiers: ["fast", "balanced"],
+      maxContextTokens: 128000
+    },
+    gemini: {
+      binary: "gemini",
+      displayName: "Gemini CLI (ACP)",
+      supportedTiers: ["fast", "balanced", "powerful"],
+      maxContextTokens: 1e6
+    }
+  };
+  DEFAULT_ENTRY = {
+    binary: "claude",
+    displayName: "ACP Agent",
+    supportedTiers: ["balanced"],
+    maxContextTokens: 128000
+  };
+  _acpAdapterDeps = {
+    which(name) {
+      return Bun.which(name);
+    },
+    async sleep(ms) {
+      await Bun.sleep(ms);
+    },
+    createClient(cmdStr, cwd, timeoutSeconds) {
+      return createSpawnAcpClient(cmdStr, cwd, timeoutSeconds);
+    }
+  };
+});
+
 // src/agents/adapters/aider.ts
 class AiderAdapter {
   name = "aider";
@@ -18940,7 +19582,7 @@ class AiderAdapter {
     return {
       success: exitCode === 0,
       exitCode,
-      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS2),
+      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS3),
       rateLimited: false,
       durationMs,
       estimatedCost: 0,
@@ -18974,7 +19616,7 @@ class AiderAdapter {
     throw new Error("AiderAdapter.decompose() not implemented");
   }
 }
-var _aiderCompleteDeps, MAX_AGENT_OUTPUT_CHARS2 = 5000;
+var _aiderCompleteDeps, MAX_AGENT_OUTPUT_CHARS3 = 5000;
 var init_aider = __esm(() => {
   init_types2();
   _aiderCompleteDeps = {
@@ -19018,7 +19660,7 @@ class CodexAdapter {
     return {
       success: exitCode === 0,
       exitCode,
-      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS3),
+      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS4),
       rateLimited: false,
       durationMs,
       estimatedCost: 0,
@@ -19049,7 +19691,7 @@ class CodexAdapter {
     throw new Error("CodexAdapter.decompose() not implemented");
   }
 }
-var _codexRunDeps, _codexCompleteDeps, MAX_AGENT_OUTPUT_CHARS3 = 5000;
+var _codexRunDeps, _codexCompleteDeps, MAX_AGENT_OUTPUT_CHARS4 = 5000;
 var init_codex = __esm(() => {
   init_types2();
   _codexRunDeps = {
@@ -19118,7 +19760,7 @@ class GeminiAdapter {
     return {
       success: exitCode === 0,
       exitCode,
-      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS4),
+      output: stdout.slice(-MAX_AGENT_OUTPUT_CHARS5),
       rateLimited: false,
       durationMs,
       estimatedCost: 0,
@@ -19149,7 +19791,7 @@ class GeminiAdapter {
     throw new Error("GeminiAdapter.decompose() not implemented");
   }
 }
-var _geminiRunDeps, _geminiCompleteDeps, MAX_AGENT_OUTPUT_CHARS4 = 5000;
+var _geminiRunDeps, _geminiCompleteDeps, MAX_AGENT_OUTPUT_CHARS5 = 5000;
 var init_gemini = __esm(() => {
   init_types2();
   _geminiRunDeps = {
@@ -19230,6 +19872,7 @@ __export(exports_registry, {
   getInstalledAgents: () => getInstalledAgents,
   getAllAgentNames: () => getAllAgentNames,
   getAgent: () => getAgent,
+  createAgentRegistry: () => createAgentRegistry,
   checkAgentHealth: () => checkAgentHealth,
   ALL_AGENTS: () => ALL_AGENTS
 });
@@ -19253,8 +19896,57 @@ async function checkAgentHealth() {
     installed: await agent.isInstalled()
   })));
 }
+function createAgentRegistry(config2) {
+  const protocol = config2.agent?.protocol ?? "cli";
+  const logger = getLogger();
+  const acpCache = new Map;
+  logger?.info("agents", `Agent protocol: ${protocol}`, { protocol, hasConfig: !!config2.agent });
+  function getAgent2(name) {
+    if (protocol === "acp") {
+      const known = ALL_AGENTS.find((a) => a.name === name);
+      if (!known)
+        return;
+      if (!acpCache.has(name)) {
+        acpCache.set(name, new AcpAgentAdapter(name));
+        logger?.debug("agents", `Created AcpAgentAdapter for ${name}`, { name, protocol });
+      }
+      return acpCache.get(name);
+    }
+    const adapter = ALL_AGENTS.find((a) => a.name === name);
+    if (adapter) {
+      logger?.debug("agents", `Using CLI adapter for ${name}: ${adapter.constructor.name}`, { name });
+    }
+    return adapter;
+  }
+  async function getInstalledAgents2() {
+    const agents = protocol === "acp" ? ALL_AGENTS.map((a) => {
+      if (!acpCache.has(a.name)) {
+        acpCache.set(a.name, new AcpAgentAdapter(a.name));
+      }
+      return acpCache.get(a.name);
+    }) : ALL_AGENTS;
+    const results = await Promise.all(agents.map(async (agent) => ({ agent, installed: await agent.isInstalled() })));
+    return results.filter((r) => r.installed).map((r) => r.agent);
+  }
+  async function checkAgentHealth2() {
+    const agents = protocol === "acp" ? ALL_AGENTS.map((a) => {
+      if (!acpCache.has(a.name)) {
+        acpCache.set(a.name, new AcpAgentAdapter(a.name));
+      }
+      return acpCache.get(a.name);
+    }) : ALL_AGENTS;
+    return Promise.all(agents.map(async (agent) => ({
+      name: agent.name,
+      displayName: agent.displayName,
+      installed: await agent.isInstalled()
+    })));
+  }
+  return { getAgent: getAgent2, getInstalledAgents: getInstalledAgents2, checkAgentHealth: checkAgentHealth2, protocol };
+}
 var ALL_AGENTS;
 var init_registry = __esm(() => {
+  init_logger2();
+  init_adapter();
   init_aider();
   init_codex();
   init_gemini();
@@ -19416,7 +20108,7 @@ var init_chain = __esm(() => {
 });
 
 // src/utils/path-security.ts
-import { isAbsolute, join as join4, normalize, resolve } from "path";
+import { isAbsolute, join as join5, normalize, resolve } from "path";
 function validateModulePath(modulePath, allowedRoots) {
   if (!modulePath) {
     return { valid: false, error: "Module path is empty" };
@@ -19432,7 +20124,7 @@ function validateModulePath(modulePath, allowedRoots) {
     }
   } else {
     for (const root of normalizedRoots) {
-      const absoluteTarget = resolve(join4(root, modulePath));
+      const absoluteTarget = resolve(join5(root, modulePath));
       if (absoluteTarget.startsWith(`${root}/`) || absoluteTarget === root) {
         return { valid: true, absolutePath: absoluteTarget };
       }
@@ -19782,27 +20474,27 @@ var init_path_security2 = () => {};
 
 // src/config/paths.ts
 import { homedir } from "os";
-import { join as join5, resolve as resolve4 } from "path";
+import { join as join6, resolve as resolve4 } from "path";
 function globalConfigDir() {
-  return join5(homedir(), ".nax");
+  return join6(homedir(), ".nax");
 }
 var init_paths = () => {};
 
 // src/config/loader.ts
 import { existsSync as existsSync5 } from "fs";
-import { join as join6, resolve as resolve5 } from "path";
+import { join as join7, resolve as resolve5 } from "path";
 function globalConfigPath() {
-  return join6(globalConfigDir(), "config.json");
+  return join7(globalConfigDir(), "config.json");
 }
 function findProjectDir(startDir = process.cwd()) {
   let dir = resolve5(startDir);
   let depth = 0;
   while (depth < MAX_DIRECTORY_DEPTH) {
-    const candidate = join6(dir, "nax");
-    if (existsSync5(join6(candidate, "config.json"))) {
+    const candidate = join7(dir, "nax");
+    if (existsSync5(join7(candidate, "config.json"))) {
       return candidate;
     }
-    const parent = join6(dir, "..");
+    const parent = join7(dir, "..");
     if (parent === dir)
       break;
     dir = parent;
@@ -19840,7 +20532,7 @@ async function loadConfig(projectDir, cliOverrides) {
   }
   const projDir = projectDir ?? findProjectDir();
   if (projDir) {
-    const projConf = await loadJsonFile(join6(projDir, "config.json"), "config");
+    const projConf = await loadJsonFile(join7(projDir, "config.json"), "config");
     if (projConf) {
       const resolvedProjConf = applyBatchModeCompat(projConf);
       rawConfig = deepMergeConfig(rawConfig, resolvedProjConf);
@@ -21115,7 +21807,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.40.1",
+    version: "0.42.0",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -21127,11 +21819,12 @@ var init_package = __esm(() => {
       build: 'bun build bin/nax.ts --outdir dist --target bun --define "GIT_COMMIT=\\"$(git rev-parse --short HEAD)\\""',
       typecheck: "bun x tsc --noEmit",
       lint: "bun x biome check src/ bin/",
-      test: "NAX_SKIP_PRECHECK=1 bun test test/ --timeout=60000",
-      "test:watch": "bun test --watch",
-      "test:unit": "bun test ./test/unit/ --timeout=60000",
-      "test:integration": "bun test ./test/integration/ --timeout=60000",
-      "test:ui": "bun test ./test/ui/ --timeout=60000",
+      test: "CI=1 NAX_SKIP_PRECHECK=1 bun test test/ --timeout=60000",
+      "test:watch": "CI=1 bun test --watch",
+      "test:unit": "CI=1 NAX_SKIP_PRECHECK=1 bun test ./test/unit/ --timeout=60000",
+      "test:integration": "CI=1 NAX_SKIP_PRECHECK=1 bun test ./test/integration/ --timeout=60000",
+      "test:ui": "CI=1 bun test ./test/ui/ --timeout=60000",
+      "test:real": "NAX_SKIP_PRECHECK=1 bun test test/ --timeout=60000",
       "check-test-overlap": "bun run scripts/check-test-overlap.ts",
       "check-dead-tests": "bun run scripts/check-dead-tests.ts",
       "check:test-sizes": "bun run scripts/check-test-sizes.ts",
@@ -21179,8 +21872,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("ba3f634"))
-        return "ba3f634";
+      if (/^[0-9a-f]{6,10}$/.test("a59af3a"))
+        return "a59af3a";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -21198,6 +21891,23 @@ var init_version = __esm(() => {
   NAX_BUILD_INFO = NAX_COMMIT === "dev" ? `v${NAX_VERSION}` : `v${NAX_VERSION} (${NAX_COMMIT})`;
 });
 
+// src/prd/validate.ts
+function validateStoryId(id) {
+  if (!id || id.length === 0) {
+    throw new Error("Story ID cannot be empty");
+  }
+  if (id.includes("..")) {
+    throw new Error("Story ID cannot contain path traversal (..)");
+  }
+  if (id.startsWith("--")) {
+    throw new Error("Story ID cannot start with git flags (--)");
+  }
+  const validPattern = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
+  if (!validPattern.test(id)) {
+    throw new Error(`Story ID must match pattern [a-zA-Z0-9][a-zA-Z0-9._-]{0,63}. Got: ${id}`);
+  }
+}
+
 // src/errors.ts
 var NaxError, AgentNotFoundError, AgentNotInstalledError, StoryLimitExceededError, LockAcquisitionError;
 var init_errors3 = __esm(() => {
@@ -22206,7 +22916,7 @@ class WebhookInteractionPlugin {
         this.pendingResponses.delete(requestId);
         return response;
       }
-      await Bun.sleep(backoffMs);
+      await _webhookPluginDeps.sleep(backoffMs);
       backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
     }
     return {
@@ -22305,9 +23015,12 @@ class WebhookInteractionPlugin {
     }
   }
 }
-var WebhookConfigSchema, InteractionResponseSchema;
+var _webhookPluginDeps, WebhookConfigSchema, InteractionResponseSchema;
 var init_webhook = __esm(() => {
   init_zod();
+  _webhookPluginDeps = {
+    sleep: (ms) => Bun.sleep(ms)
+  };
   WebhookConfigSchema = exports_external.object({
     url: exports_external.string().url().optional(),
     callbackPort: exports_external.number().int().min(1024).max(65535).optional(),
@@ -22346,8 +23059,8 @@ class AutoInteractionPlugin {
       return;
     }
     try {
-      if (_deps2.callLlm) {
-        const decision2 = await _deps2.callLlm(request);
+      if (_deps3.callLlm) {
+        const decision2 = await _deps3.callLlm(request);
         if (decision2.confidence < (this.config.confidenceThreshold ?? 0.7)) {
           return;
         }
@@ -22376,7 +23089,7 @@ class AutoInteractionPlugin {
   }
   async callLlm(request) {
     const prompt = this.buildPrompt(request);
-    const adapter = _deps2.adapter;
+    const adapter = _deps3.adapter;
     if (!adapter) {
       throw new Error("Auto plugin requires adapter to be injected via _deps.adapter");
     }
@@ -22464,7 +23177,7 @@ Respond with ONLY this JSON (no markdown, no explanation):
     return parsed;
   }
 }
-var AutoConfigSchema, _deps2;
+var AutoConfigSchema, _deps3;
 var init_auto = __esm(() => {
   init_zod();
   init_config();
@@ -22474,7 +23187,7 @@ var init_auto = __esm(() => {
     maxCostPerDecision: exports_external.number().positive().optional(),
     naxConfig: exports_external.any().optional()
   });
-  _deps2 = {
+  _deps3 = {
     adapter: null,
     callLlm: null
   };
@@ -23155,7 +23868,7 @@ async function runReview(config2, workdir, executionConfig) {
   const logger = getSafeLogger();
   const checks3 = [];
   let firstFailure;
-  const allUncommittedFiles = await _deps3.getUncommittedFiles(workdir);
+  const allUncommittedFiles = await _deps4.getUncommittedFiles(workdir);
   const NAX_RUNTIME_FILES = new Set(["nax/status.json", ".nax-verifier-verdict.json"]);
   const uncommittedFiles = allUncommittedFiles.filter((f) => !NAX_RUNTIME_FILES.has(f) && !f.match(/^nax\/features\/.+\/prd\.json$/));
   if (uncommittedFiles.length > 0) {
@@ -23195,11 +23908,11 @@ Stage and commit these files before running review.`
     failureReason: firstFailure
   };
 }
-var _reviewRunnerDeps, REVIEW_CHECK_TIMEOUT_MS = 120000, SIGKILL_GRACE_PERIOD_MS2 = 5000, _deps3;
+var _reviewRunnerDeps, REVIEW_CHECK_TIMEOUT_MS = 120000, SIGKILL_GRACE_PERIOD_MS2 = 5000, _deps4;
 var init_runner2 = __esm(() => {
   init_logger2();
   _reviewRunnerDeps = { spawn, file: Bun.file };
-  _deps3 = {
+  _deps4 = {
     getUncommittedFiles: getUncommittedFilesImpl
   };
 });
@@ -23460,10 +24173,10 @@ var init_autofix = __esm(() => {
 
 // src/execution/progress.ts
 import { mkdirSync as mkdirSync2 } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 async function appendProgress(featureDir, storyId, status, message) {
   mkdirSync2(featureDir, { recursive: true });
-  const progressPath = join14(featureDir, "progress.txt");
+  const progressPath = join15(featureDir, "progress.txt");
   const timestamp = new Date().toISOString();
   const entry = `[${timestamp}] ${storyId} \u2014 ${status.toUpperCase()} \u2014 ${message}
 `;
@@ -23547,7 +24260,7 @@ function estimateTokens(text) {
 
 // src/constitution/loader.ts
 import { existsSync as existsSync13 } from "fs";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 function truncateToTokens(text, maxTokens) {
   const maxChars = maxTokens * 3;
   if (text.length <= maxChars) {
@@ -23569,7 +24282,7 @@ async function loadConstitution(projectDir, config2) {
   }
   let combinedContent = "";
   if (!config2.skipGlobal) {
-    const globalPath = join15(globalConfigDir(), config2.path);
+    const globalPath = join16(globalConfigDir(), config2.path);
     if (existsSync13(globalPath)) {
       const validatedPath = validateFilePath(globalPath, globalConfigDir());
       const globalFile = Bun.file(validatedPath);
@@ -23579,7 +24292,7 @@ async function loadConstitution(projectDir, config2) {
       }
     }
   }
-  const projectPath = join15(projectDir, config2.path);
+  const projectPath = join16(projectDir, config2.path);
   if (existsSync13(projectPath)) {
     const validatedPath = validateFilePath(projectPath, projectDir);
     const projectFile = Bun.file(validatedPath);
@@ -24304,7 +25017,7 @@ async function addFileElements(elements, storyContext, story) {
   if (contextFiles.length === 0 && storyContext.config?.context?.autoDetect?.enabled !== false && storyContext.workdir) {
     const autoDetectConfig = storyContext.config?.context?.autoDetect;
     try {
-      const detected = await _deps4.autoDetectContextFiles({
+      const detected = await _deps5.autoDetectContextFiles({
         workdir: storyContext.workdir,
         storyTitle: story.title,
         maxFiles: autoDetectConfig?.maxFiles ?? 5,
@@ -24362,7 +25075,7 @@ ${content}
     }
   }
 }
-var _deps4;
+var _deps5;
 var init_builder3 = __esm(() => {
   init_logger2();
   init_prd();
@@ -24370,7 +25083,7 @@ var init_builder3 = __esm(() => {
   init_elements();
   init_test_scanner();
   init_elements();
-  _deps4 = {
+  _deps5 = {
     autoDetectContextFiles
   };
 });
@@ -24605,6 +25318,15 @@ ${pluginMarkdown}` : pluginMarkdown;
 function validateAgentForTier(agent, tier) {
   return agent.capabilities.supportedTiers.includes(tier);
 }
+function validateAgentFeature(agent, feature) {
+  return agent.capabilities.features.has(feature);
+}
+function describeAgentCapabilities(agent) {
+  const tiers = agent.capabilities.supportedTiers.join(",");
+  const features = Array.from(agent.capabilities.features).join(",");
+  const maxTokens = agent.capabilities.maxContextTokens;
+  return `${agent.name}: tiers=[${tiers}], maxTokens=${maxTokens}, features=[${features}]`;
+}
 
 // src/agents/version-detection.ts
 async function getAgentVersion(binaryName) {
@@ -24655,6 +25377,26 @@ var init_version_detection = __esm(() => {
 });
 
 // src/agents/index.ts
+var exports_agents = {};
+__export(exports_agents, {
+  validateAgentForTier: () => validateAgentForTier,
+  validateAgentFeature: () => validateAgentFeature,
+  parseTokenUsage: () => parseTokenUsage,
+  getInstalledAgents: () => getInstalledAgents,
+  getAllAgentNames: () => getAllAgentNames,
+  getAgentVersions: () => getAgentVersions,
+  getAgentVersion: () => getAgentVersion,
+  getAgent: () => getAgent,
+  formatCostWithConfidence: () => formatCostWithConfidence,
+  estimateCostFromOutput: () => estimateCostFromOutput,
+  estimateCostByDuration: () => estimateCostByDuration,
+  estimateCost: () => estimateCost,
+  describeAgentCapabilities: () => describeAgentCapabilities,
+  checkAgentHealth: () => checkAgentHealth,
+  CompleteError: () => CompleteError,
+  ClaudeCodeAdapter: () => ClaudeCodeAdapter,
+  COST_RATES: () => COST_RATES
+});
 var init_agents = __esm(() => {
   init_types2();
   init_claude();
@@ -24732,14 +25474,14 @@ var init_isolation = __esm(() => {
 
 // src/context/greenfield.ts
 import { readdir } from "fs/promises";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 async function scanForTestFiles(dir, testPattern, isRootCall = true) {
   const results = [];
   const ignoreDirs = new Set(["node_modules", "dist", "build", ".next", ".git"]);
   try {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join16(dir, entry.name);
+      const fullPath = join17(dir, entry.name);
       if (entry.isDirectory()) {
         if (ignoreDirs.has(entry.name))
           continue;
@@ -24823,6 +25565,30 @@ function detectMergeConflict(output) {
 async function autoCommitIfDirty(workdir, stage, role, storyId) {
   const logger = getSafeLogger();
   try {
+    const topLevelProc = _gitDeps.spawn(["git", "rev-parse", "--show-toplevel"], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const gitRoot = (await new Response(topLevelProc.stdout).text()).trim();
+    await topLevelProc.exited;
+    const { realpathSync: realpathSync3 } = await import("fs");
+    const realWorkdir = (() => {
+      try {
+        return realpathSync3(workdir);
+      } catch {
+        return workdir;
+      }
+    })();
+    const realGitRoot = (() => {
+      try {
+        return realpathSync3(gitRoot);
+      } catch {
+        return gitRoot;
+      }
+    })();
+    if (realWorkdir !== realGitRoot)
+      return;
     const statusProc = _gitDeps.spawn(["git", "status", "--porcelain"], {
       cwd: workdir,
       stdout: "pipe",
@@ -25127,13 +25893,13 @@ function parseTestOutput(output, exitCode) {
 
 // src/verification/runners.ts
 import { existsSync as existsSync14 } from "fs";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 async function verifyAssets(workingDirectory, expectedFiles) {
   if (!expectedFiles || expectedFiles.length === 0)
     return { success: true, missingFiles: [] };
   const missingFiles = [];
   for (const file2 of expectedFiles) {
-    if (!existsSync14(join17(workingDirectory, file2)))
+    if (!existsSync14(join18(workingDirectory, file2)))
       missingFiles.push(file2);
   }
   if (missingFiles.length > 0) {
@@ -25208,11 +25974,15 @@ async function fullSuite(options) {
   return runVerificationCore(options);
 }
 async function regression(options) {
-  await Bun.sleep(2000);
+  await _regressionRunnerDeps.sleep(2000);
   return runVerificationCore({ ...options, expectedFiles: undefined });
 }
+var _regressionRunnerDeps;
 var init_runners = __esm(() => {
   init_executor();
+  _regressionRunnerDeps = {
+    sleep: (ms) => Bun.sleep(ms)
+  };
 });
 
 // src/verification/rectification.ts
@@ -25345,7 +26115,7 @@ var init_prompts = __esm(() => {
 });
 
 // src/tdd/rectification-gate.ts
-async function runFullSuiteGate(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger) {
+async function runFullSuiteGate(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger, featureName) {
   const rectificationEnabled = config2.execution.rectification?.enabled ?? false;
   if (!rectificationEnabled)
     return false;
@@ -25361,7 +26131,7 @@ async function runFullSuiteGate(story, config2, workdir, agent, implementerTier,
   if (!fullSuitePassed && fullSuiteResult.output) {
     const testSummary = parseBunTestOutput(fullSuiteResult.output);
     if (testSummary.failed > 0) {
-      return await runRectificationLoop(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger, testSummary, rectificationConfig, testCmd, fullSuiteTimeout);
+      return await runRectificationLoop(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger, testSummary, rectificationConfig, testCmd, fullSuiteTimeout, featureName);
     }
     if (testSummary.passed > 0) {
       logger.info("tdd", "Full suite gate passed (non-zero exit, 0 failures, tests detected)", {
@@ -25389,7 +26159,7 @@ async function runFullSuiteGate(story, config2, workdir, agent, implementerTier,
   });
   return false;
 }
-async function runRectificationLoop(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger, testSummary, rectificationConfig, testCmd, fullSuiteTimeout) {
+async function runRectificationLoop(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger, testSummary, rectificationConfig, testCmd, fullSuiteTimeout, featureName) {
   const rectificationState = {
     attempt: 0,
     initialFailures: testSummary.failed,
@@ -25411,7 +26181,10 @@ async function runRectificationLoop(story, config2, workdir, agent, implementerT
       modelTier: implementerTier,
       modelDef: resolveModel(config2.models[implementerTier]),
       timeoutSeconds: config2.execution.sessionTimeoutSeconds,
-      dangerouslySkipPermissions: config2.execution.dangerouslySkipPermissions
+      dangerouslySkipPermissions: config2.execution.dangerouslySkipPermissions,
+      featureName,
+      storyId: story.id,
+      sessionRole: "implementer"
     });
     if (!rectifyResult.success && rectifyResult.pid) {
       await cleanupProcessTree(rectifyResult.pid);
@@ -25808,13 +26581,13 @@ var exports_loader = {};
 __export(exports_loader, {
   loadOverride: () => loadOverride
 });
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 async function loadOverride(role, workdir, config2) {
   const overridePath = config2.prompts?.overrides?.[role];
   if (!overridePath) {
     return null;
   }
-  const absolutePath = join18(workdir, overridePath);
+  const absolutePath = join19(workdir, overridePath);
   const file2 = Bun.file(absolutePath);
   if (!await file2.exists()) {
     return null;
@@ -25993,7 +26766,7 @@ async function rollbackToRef(workdir, ref) {
   }
   logger.info("tdd", "Successfully rolled back git changes", { ref });
 }
-async function runTddSession(role, agent, story, config2, workdir, modelTier, beforeRef, contextMarkdown, lite = false, skipIsolation = false, constitution) {
+async function runTddSession(role, agent, story, config2, workdir, modelTier, beforeRef, contextMarkdown, lite = false, skipIsolation = false, constitution, featureName) {
   const startTime = Date.now();
   let prompt;
   switch (role) {
@@ -26015,7 +26788,10 @@ async function runTddSession(role, agent, story, config2, workdir, modelTier, be
     modelTier,
     modelDef: resolveModel(config2.models[modelTier]),
     timeoutSeconds: config2.execution.sessionTimeoutSeconds,
-    dangerouslySkipPermissions: config2.execution.dangerouslySkipPermissions
+    dangerouslySkipPermissions: config2.execution.dangerouslySkipPermissions,
+    featureName,
+    storyId: story.id,
+    sessionRole: role
   });
   if (!result.success && result.pid) {
     await cleanupProcessTree(result.pid);
@@ -26035,7 +26811,7 @@ async function runTddSession(role, agent, story, config2, workdir, modelTier, be
       exitCode: result.exitCode
     });
   }
-  await autoCommitIfDirty(workdir, "tdd", role, story.id);
+  await _sessionRunnerDeps.autoCommitIfDirty(workdir, "tdd", role, story.id);
   let isolation;
   if (!skipIsolation) {
     if (role === "test-writer") {
@@ -26082,6 +26858,7 @@ async function runTddSession(role, agent, story, config2, workdir, modelTier, be
     estimatedCost: result.estimatedCost
   };
 }
+var _sessionRunnerDeps;
 var init_session_runner = __esm(() => {
   init_config();
   init_logger2();
@@ -26089,6 +26866,9 @@ var init_session_runner = __esm(() => {
   init_git();
   init_cleanup();
   init_isolation();
+  _sessionRunnerDeps = {
+    autoCommitIfDirty
+  };
 });
 
 // src/tdd/verdict-reader.ts
@@ -26363,6 +27143,7 @@ async function runThreeSessionTdd(options) {
     config: config2,
     workdir,
     modelTier,
+    featureName,
     contextMarkdown,
     constitution,
     dryRun = false,
@@ -26426,7 +27207,7 @@ async function runThreeSessionTdd(options) {
   let session1;
   if (!isRetry) {
     const testWriterTier = config2.tdd.sessionTiers?.testWriter ?? "balanced";
-    session1 = await runTddSession("test-writer", agent, story, config2, workdir, testWriterTier, session1Ref, contextMarkdown, lite, lite, constitution);
+    session1 = await runTddSession("test-writer", agent, story, config2, workdir, testWriterTier, session1Ref, contextMarkdown, lite, lite, constitution, featureName);
     sessions.push(session1);
   }
   if (session1 && !session1.success) {
@@ -26488,7 +27269,7 @@ async function runThreeSessionTdd(options) {
   });
   const session2Ref = await captureGitRef(workdir) ?? "HEAD";
   const implementerTier = config2.tdd.sessionTiers?.implementer ?? modelTier;
-  const session2 = await runTddSession("implementer", agent, story, config2, workdir, implementerTier, session2Ref, contextMarkdown, lite, lite, constitution);
+  const session2 = await runTddSession("implementer", agent, story, config2, workdir, implementerTier, session2Ref, contextMarkdown, lite, lite, constitution, featureName);
   sessions.push(session2);
   if (!session2.success) {
     needsHumanReview = true;
@@ -26504,10 +27285,10 @@ async function runThreeSessionTdd(options) {
       lite
     };
   }
-  const fullSuiteGatePassed = await runFullSuiteGate(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger);
+  const fullSuiteGatePassed = await runFullSuiteGate(story, config2, workdir, agent, implementerTier, contextMarkdown, lite, logger, featureName);
   const session3Ref = await captureGitRef(workdir) ?? "HEAD";
   const verifierTier = config2.tdd.sessionTiers?.verifier ?? "fast";
-  const session3 = await runTddSession("verifier", agent, story, config2, workdir, verifierTier, session3Ref, undefined, false, false, constitution);
+  const session3 = await runTddSession("verifier", agent, story, config2, workdir, verifierTier, session3Ref, undefined, false, false, constitution, featureName);
   sessions.push(session3);
   const verdict = await readVerdict(workdir);
   await cleanupVerdict(workdir);
@@ -26666,7 +27447,7 @@ var init_execution = __esm(() => {
     enabled: () => true,
     async execute(ctx) {
       const logger = getLogger();
-      const agent = _executionDeps.getAgent(ctx.config.autoMode.defaultAgent);
+      const agent = (ctx.agentGetFn ?? _executionDeps.getAgent)(ctx.config.autoMode.defaultAgent);
       if (!agent) {
         return {
           action: "fail",
@@ -26686,6 +27467,7 @@ var init_execution = __esm(() => {
           config: ctx.config,
           workdir: ctx.workdir,
           modelTier: ctx.routing.modelTier,
+          featureName: ctx.prd.feature,
           contextMarkdown: ctx.contextMarkdown,
           constitution: ctx.constitution?.content,
           dryRun: false,
@@ -26755,7 +27537,38 @@ Category: ${tddResult.failureCategory ?? "unknown"}`,
         modelTier: ctx.routing.modelTier,
         modelDef: resolveModel(ctx.config.models[ctx.routing.modelTier]),
         timeoutSeconds: ctx.config.execution.sessionTimeoutSeconds,
-        dangerouslySkipPermissions: ctx.config.execution.dangerouslySkipPermissions
+        dangerouslySkipPermissions: ctx.config.execution.dangerouslySkipPermissions,
+        pidRegistry: ctx.pidRegistry,
+        featureName: ctx.prd.feature,
+        storyId: ctx.story.id,
+        interactionBridge: (() => {
+          const plugin = ctx.interaction?.getPrimary();
+          if (!plugin)
+            return;
+          const QUESTION_PATTERNS = [/\?/, /\bwhich\b/i, /\bshould i\b/i, /\bunclear\b/i, /\bplease clarify\b/i];
+          return {
+            detectQuestion: async (text) => QUESTION_PATTERNS.some((p) => p.test(text)),
+            onQuestionDetected: async (text) => {
+              const requestId = `ix-acp-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+              await plugin.send({
+                id: requestId,
+                type: "input",
+                featureName: ctx.prd.feature,
+                storyId: ctx.story.id,
+                stage: "execution",
+                summary: text,
+                fallback: "continue",
+                createdAt: Date.now()
+              });
+              try {
+                const response = await plugin.receive(requestId, 120000);
+                return response.value ?? "continue";
+              } catch {
+                return "continue";
+              }
+            }
+          };
+        })()
       });
       ctx.agentResult = result;
       await autoCommitIfDirty(ctx.workdir, "execution", "single-session", ctx.story.id);
@@ -27971,16 +28784,20 @@ var init_regression2 = __esm(() => {
 });
 
 // src/pipeline/stages/routing.ts
-async function runDecompose(story, prd, config2, _workdir) {
+async function runDecompose(story, prd, config2, _workdir, agentGetFn) {
   const naxDecompose = config2.decompose;
   const builderConfig = {
     maxSubStories: naxDecompose?.maxSubstories ?? 5,
     maxComplexity: naxDecompose?.maxSubstoryComplexity ?? "medium",
     maxRetries: naxDecompose?.maxRetries ?? 2
   };
+  const agent = (agentGetFn ?? getAgent)(config2.autoMode.defaultAgent);
+  if (!agent) {
+    throw new Error(`[decompose] Agent "${config2.autoMode.defaultAgent}" not found \u2014 cannot decompose`);
+  }
   const adapter = {
-    async decompose(_prompt) {
-      throw new Error("[decompose] No LLM adapter configured for story decomposition");
+    async decompose(prompt) {
+      return agent.complete(prompt, { jsonMode: true });
     }
   };
   return DecomposeBuilder.for(story).prd(prd).config(builderConfig).decompose(adapter);
@@ -28001,7 +28818,7 @@ var init_routing2 = __esm(() => {
     async execute(ctx) {
       const logger = getLogger();
       const agentName = ctx.config.execution?.agent ?? "claude";
-      const adapter = _routingDeps.getAgent(agentName);
+      const adapter = (ctx.agentGetFn ?? _routingDeps.getAgent)(agentName);
       const hasExistingRouting = ctx.story.routing !== undefined;
       const hasContentHash = ctx.story.routing?.contentHash !== undefined;
       let currentHash;
@@ -28070,7 +28887,7 @@ var init_routing2 = __esm(() => {
           if (decomposeConfig.trigger === "disabled") {
             logger.warn("routing", `Story ${ctx.story.id} is oversized (${acCount} ACs) but decompose is disabled \u2014 continuing with original`);
           } else if (decomposeConfig.trigger === "auto") {
-            const result = await _routingDeps.runDecompose(ctx.story, ctx.prd, ctx.config, ctx.workdir);
+            const result = await _routingDeps.runDecompose(ctx.story, ctx.prd, ctx.config, ctx.workdir, ctx.agentGetFn);
             if (result.validation.valid) {
               _routingDeps.applyDecomposition(ctx.prd, result);
               if (ctx.prdPath) {
@@ -28085,7 +28902,7 @@ var init_routing2 = __esm(() => {
           } else if (decomposeConfig.trigger === "confirm") {
             const action = await _routingDeps.checkStoryOversized({ featureName: ctx.prd.feature, storyId: ctx.story.id, criteriaCount: acCount }, ctx.config, ctx.interaction);
             if (action === "decompose") {
-              const result = await _routingDeps.runDecompose(ctx.story, ctx.prd, ctx.config, ctx.workdir);
+              const result = await _routingDeps.runDecompose(ctx.story, ctx.prd, ctx.config, ctx.workdir, ctx.agentGetFn);
               if (result.validation.valid) {
                 _routingDeps.applyDecomposition(ctx.prd, result);
                 if (ctx.prdPath) {
@@ -28987,7 +29804,7 @@ var init_checks_config = () => {};
 async function checkAgentCLI(config2) {
   const agent = config2.execution?.agent || "claude";
   try {
-    const proc = _deps6.spawn([agent, "--version"], {
+    const proc = _deps7.spawn([agent, "--version"], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -29008,9 +29825,9 @@ async function checkAgentCLI(config2) {
     };
   }
 }
-var _deps6;
+var _deps7;
 var init_checks_cli = __esm(() => {
-  _deps6 = {
+  _deps7 = {
     spawn: Bun.spawn
   };
 });
@@ -29573,19 +30390,19 @@ var init_precheck = __esm(() => {
 });
 
 // src/hooks/runner.ts
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 async function loadHooksConfig(projectDir, globalDir) {
   let globalHooks = { hooks: {} };
   let projectHooks = { hooks: {} };
   let skipGlobal = false;
-  const projectPath = join36(projectDir, "hooks.json");
+  const projectPath = join37(projectDir, "hooks.json");
   const projectData = await loadJsonFile(projectPath, "hooks");
   if (projectData) {
     projectHooks = projectData;
     skipGlobal = projectData.skipGlobal ?? false;
   }
   if (!skipGlobal && globalDir) {
-    const globalPath = join36(globalDir, "hooks.json");
+    const globalPath = join37(globalDir, "hooks.json");
     const globalData = await loadJsonFile(globalPath, "hooks");
     if (globalData) {
       globalHooks = globalData;
@@ -30026,7 +30843,8 @@ function buildResult(success2, prd, totalCost, iterations, storiesCompleted, prd
 }
 async function generateAndAddFixStories(ctx, failures, prd) {
   const logger = getSafeLogger();
-  const agent = getAgent(ctx.config.autoMode.defaultAgent);
+  const { getAgent: getAgent2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
+  const agent = (ctx.agentGetFn ?? getAgent2)(ctx.config.autoMode.defaultAgent);
   if (!agent) {
     logger?.error("acceptance", "Agent not found, cannot generate fix stories");
     return null;
@@ -30172,7 +30990,6 @@ async function runAcceptanceLoop(ctx) {
 }
 var init_acceptance_loop = __esm(() => {
   init_acceptance();
-  init_agents();
   init_schema();
   init_hooks();
   init_logger2();
@@ -30599,35 +31416,18 @@ var init_headless_formatter = __esm(() => {
   init_version();
 });
 
-// src/prd/validate.ts
-function validateStoryId(id) {
-  if (!id || id.length === 0) {
-    throw new Error("Story ID cannot be empty");
-  }
-  if (id.includes("..")) {
-    throw new Error("Story ID cannot contain path traversal (..)");
-  }
-  if (id.startsWith("--")) {
-    throw new Error("Story ID cannot start with git flags (--)");
-  }
-  const validPattern = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
-  if (!validPattern.test(id)) {
-    throw new Error(`Story ID must match pattern [a-zA-Z0-9][a-zA-Z0-9._-]{0,63}. Got: ${id}`);
-  }
-}
-
 // src/worktree/manager.ts
 var exports_manager = {};
 __export(exports_manager, {
   WorktreeManager: () => WorktreeManager
 });
 import { existsSync as existsSync30, symlinkSync } from "fs";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 
 class WorktreeManager {
   async create(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join37(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join38(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const proc = Bun.spawn(["git", "worktree", "add", worktreePath, "-b", branchName], {
@@ -30652,9 +31452,9 @@ class WorktreeManager {
       }
       throw new Error(`Failed to create worktree: ${String(error48)}`);
     }
-    const nodeModulesSource = join37(projectRoot, "node_modules");
+    const nodeModulesSource = join38(projectRoot, "node_modules");
     if (existsSync30(nodeModulesSource)) {
-      const nodeModulesTarget = join37(worktreePath, "node_modules");
+      const nodeModulesTarget = join38(worktreePath, "node_modules");
       try {
         symlinkSync(nodeModulesSource, nodeModulesTarget, "dir");
       } catch (error48) {
@@ -30662,9 +31462,9 @@ class WorktreeManager {
         throw new Error(`Failed to symlink node_modules: ${errorMessage(error48)}`);
       }
     }
-    const envSource = join37(projectRoot, ".env");
+    const envSource = join38(projectRoot, ".env");
     if (existsSync30(envSource)) {
-      const envTarget = join37(worktreePath, ".env");
+      const envTarget = join38(worktreePath, ".env");
       try {
         symlinkSync(envSource, envTarget, "file");
       } catch (error48) {
@@ -30675,7 +31475,7 @@ class WorktreeManager {
   }
   async remove(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join37(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join38(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const proc = Bun.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
@@ -31065,7 +31865,7 @@ var init_parallel_worker = __esm(() => {
 
 // src/execution/parallel-coordinator.ts
 import os3 from "os";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 function groupStoriesByDependencies(stories) {
   const batches = [];
   const processed = new Set;
@@ -31142,7 +31942,7 @@ async function executeParallel(stories, prdPath, projectRoot, config2, hooks, pl
     };
     const worktreePaths = new Map;
     for (const story of batch) {
-      const worktreePath = join38(projectRoot, ".nax-wt", story.id);
+      const worktreePath = join39(projectRoot, ".nax-wt", story.id);
       try {
         await worktreeManager.create(projectRoot, story.id);
         worktreePaths.set(story.id, worktreePath);
@@ -31191,7 +31991,7 @@ async function executeParallel(stories, prdPath, projectRoot, config2, hooks, pl
           });
           logger?.warn("parallel", "Worktree preserved for manual conflict resolution", {
             storyId: mergeResult.storyId,
-            worktreePath: join38(projectRoot, ".nax-wt", mergeResult.storyId)
+            worktreePath: join39(projectRoot, ".nax-wt", mergeResult.storyId)
           });
         }
       }
@@ -31650,12 +32450,12 @@ var init_parallel_executor = __esm(() => {
 // src/pipeline/subscribers/events-writer.ts
 import { appendFile as appendFile2, mkdir } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { basename as basename3, join as join39 } from "path";
+import { basename as basename3, join as join40 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename3(workdir);
-  const eventsDir = join39(homedir5(), ".nax", "events", project);
-  const eventsFile = join39(eventsDir, "events.jsonl");
+  const eventsDir = join40(homedir5(), ".nax", "events", project);
+  const eventsFile = join40(eventsDir, "events.jsonl");
   let dirReady = false;
   const write = (line) => {
     (async () => {
@@ -31815,12 +32615,12 @@ var init_interaction2 = __esm(() => {
 // src/pipeline/subscribers/registry.ts
 import { mkdir as mkdir2, writeFile } from "fs/promises";
 import { homedir as homedir6 } from "os";
-import { basename as basename4, join as join40 } from "path";
+import { basename as basename4, join as join41 } from "path";
 function wireRegistry(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename4(workdir);
-  const runDir = join40(homedir6(), ".nax", "runs", `${project}-${feature}-${runId}`);
-  const metaFile = join40(runDir, "meta.json");
+  const runDir = join41(homedir6(), ".nax", "runs", `${project}-${feature}-${runId}`);
+  const metaFile = join41(runDir, "meta.json");
   const unsub = bus.on("run:started", (_ev) => {
     (async () => {
       try {
@@ -31830,8 +32630,8 @@ function wireRegistry(bus, feature, runId, workdir) {
           project,
           feature,
           workdir,
-          statusPath: join40(workdir, "nax", "features", feature, "status.json"),
-          eventsDir: join40(workdir, "nax", "features", feature, "runs"),
+          statusPath: join41(workdir, "nax", "features", feature, "status.json"),
+          eventsDir: join41(workdir, "nax", "features", feature, "runs"),
           registeredAt: new Date().toISOString()
         };
         await writeFile(metaFile, JSON.stringify(meta3, null, 2));
@@ -32499,6 +33299,8 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
     storyStartTime: new Date().toISOString(),
     storyGitRef: storyGitRef ?? undefined,
     interaction: ctx.interactionChain ?? undefined,
+    agentGetFn: ctx.agentGetFn,
+    pidRegistry: ctx.pidRegistry,
     accumulatedAttemptCost: accumulatedAttemptCost > 0 ? accumulatedAttemptCost : undefined
   };
   ctx.statusWriter.setPrd(prd);
@@ -32825,7 +33627,7 @@ async function writeStatusFile(filePath, status) {
 var init_status_file = () => {};
 
 // src/execution/status-writer.ts
-import { join as join41 } from "path";
+import { join as join42 } from "path";
 
 class StatusWriter {
   statusFile;
@@ -32893,7 +33695,7 @@ class StatusWriter {
     if (!this._prd)
       return;
     const safeLogger = getSafeLogger();
-    const featureStatusPath = join41(featureDir, "status.json");
+    const featureStatusPath = join42(featureDir, "status.json");
     try {
       const base = this.getSnapshot(totalCost, iterations);
       if (!base) {
@@ -33097,6 +33899,7 @@ var init_precheck_runner = __esm(() => {
 // src/execution/lifecycle/run-initialization.ts
 var exports_run_initialization = {};
 __export(exports_run_initialization, {
+  logActiveProtocol: () => logActiveProtocol,
   initializeRun: () => initializeRun
 });
 async function reconcileState(prd, prdPath, workdir) {
@@ -33123,11 +33926,12 @@ async function reconcileState(prd, prdPath, workdir) {
   }
   return prd;
 }
-async function checkAgentInstalled(config2, dryRun) {
+async function checkAgentInstalled(config2, dryRun, agentGetFn) {
   if (dryRun)
     return;
   const logger = getSafeLogger();
-  const agent = getAgent(config2.autoMode.defaultAgent);
+  const { getAgent: getAgent2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
+  const agent = (agentGetFn ?? getAgent2)(config2.autoMode.defaultAgent);
   if (!agent) {
     logger?.error("execution", "Agent not found", {
       agent: config2.autoMode.defaultAgent
@@ -33155,9 +33959,14 @@ function validateStoryCount(counts, config2) {
     throw new StoryLimitExceededError(counts.total, config2.execution.maxStoriesPerFeature);
   }
 }
+function logActiveProtocol(config2) {
+  const logger = getSafeLogger();
+  const protocol = config2.agent?.protocol ?? "cli";
+  logger?.info("run-initialization", `Agent protocol: ${protocol}`, { protocol });
+}
 async function initializeRun(ctx) {
   const logger = getSafeLogger();
-  await checkAgentInstalled(ctx.config, ctx.dryRun);
+  await checkAgentInstalled(ctx.config, ctx.dryRun, ctx.agentGetFn);
   let prd = await loadPRD(ctx.prdPath);
   prd = await reconcileState(prd, ctx.prdPath, ctx.workdir);
   const counts = countStories(prd);
@@ -33170,7 +33979,6 @@ async function initializeRun(ctx) {
   return { prd, storyCounts: counts };
 }
 var init_run_initialization = __esm(() => {
-  init_agents();
   init_errors3();
   init_logger2();
   init_prd();
@@ -33279,7 +34087,8 @@ async function setupRun(options) {
       config: config2,
       prdPath,
       workdir,
-      dryRun
+      dryRun,
+      agentGetFn: options.agentGetFn
     });
     prd = initResult.prd;
     const counts = initResult.storyCounts;
@@ -64209,7 +65018,7 @@ var require_jsx_dev_runtime = __commonJS((exports, module) => {
 init_source();
 import { existsSync as existsSync32, mkdirSync as mkdirSync6 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -64231,14 +65040,14 @@ var {
 init_acceptance();
 init_registry();
 import { existsSync as existsSync8 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/analyze/scanner.ts
-import { existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync2, readdirSync } from "fs";
+import { join as join4 } from "path";
 async function scanCodebase(workdir) {
-  const srcPath = join3(workdir, "src");
-  const packageJsonPath = join3(workdir, "package.json");
+  const srcPath = join4(workdir, "src");
+  const packageJsonPath = join4(workdir, "package.json");
   const fileTree = existsSync2(srcPath) ? await generateFileTree(srcPath, 3) : "No src/ directory";
   let dependencies = {};
   let devDependencies = {};
@@ -64263,30 +65072,23 @@ async function generateFileTree(dir, maxDepth, currentDepth = 0, prefix = "") {
   }
   const entries = [];
   try {
-    const dirEntries = Array.from(new Bun.Glob("*").scanSync({
-      cwd: dir,
-      onlyFiles: false
-    }));
+    const dirEntries = readdirSync(dir, { withFileTypes: true });
     dirEntries.sort((a, b) => {
-      const aIsDir = !a.includes(".");
-      const bIsDir = !b.includes(".");
-      if (aIsDir && !bIsDir)
+      if (a.isDirectory() && !b.isDirectory())
         return -1;
-      if (!aIsDir && bIsDir)
+      if (!a.isDirectory() && b.isDirectory())
         return 1;
-      return a.localeCompare(b);
+      return a.name.localeCompare(b.name);
     });
     for (let i = 0;i < dirEntries.length; i++) {
-      const entry = dirEntries[i];
-      const fullPath = join3(dir, entry);
+      const dirent = dirEntries[i];
       const isLast = i === dirEntries.length - 1;
       const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
       const childPrefix = isLast ? "    " : "\u2502   ";
-      const stat = await Bun.file(fullPath).stat();
-      const isDir = stat.isDirectory();
-      entries.push(`${prefix}${connector}${entry}${isDir ? "/" : ""}`);
+      const isDir = dirent.isDirectory();
+      entries.push(`${prefix}${connector}${dirent.name}${isDir ? "/" : ""}`);
       if (isDir) {
-        const subtree = await generateFileTree(fullPath, maxDepth, currentDepth + 1, prefix + childPrefix);
+        const subtree = await generateFileTree(join4(dir, dirent.name), maxDepth, currentDepth + 1, prefix + childPrefix);
         if (subtree) {
           entries.push(subtree);
         }
@@ -64310,16 +65112,16 @@ function detectTestPatterns(workdir, dependencies, devDependencies) {
   } else {
     patterns.push("Test framework: likely bun:test (no framework dependency)");
   }
-  if (existsSync2(join3(workdir, "test"))) {
+  if (existsSync2(join4(workdir, "test"))) {
     patterns.push("Test directory: test/");
   }
-  if (existsSync2(join3(workdir, "__tests__"))) {
+  if (existsSync2(join4(workdir, "__tests__"))) {
     patterns.push("Test directory: __tests__/");
   }
-  if (existsSync2(join3(workdir, "tests"))) {
+  if (existsSync2(join4(workdir, "tests"))) {
     patterns.push("Test directory: tests/");
   }
-  const hasTestFiles = existsSync2(join3(workdir, "test")) || existsSync2(join3(workdir, "src"));
+  const hasTestFiles = existsSync2(join4(workdir, "test")) || existsSync2(join4(workdir, "src"));
   if (hasTestFiles) {
     patterns.push("Test files: *.test.ts, *.spec.ts");
   }
@@ -64337,7 +65139,7 @@ init_version();
 // src/cli/analyze-parser.ts
 init_registry();
 import { existsSync as existsSync7 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 init_schema();
 init_logger2();
 init_prd();
@@ -64467,7 +65269,7 @@ function estimateLOCFromComplexity(complexity) {
   }
 }
 async function reclassifyExistingPRD(featureDir, featureName, branchName, workdir, config2) {
-  const prdPath = join7(featureDir, "prd.json");
+  const prdPath = join8(featureDir, "prd.json");
   if (!existsSync7(prdPath)) {
     throw new Error(`prd.json not found at ${prdPath}. Run analyze without --reclassify first.`);
   }
@@ -64568,11 +65370,11 @@ function reclassifyWithKeywords(story, config2) {
 // src/cli/analyze.ts
 async function analyzeFeature(options) {
   const { featureDir, featureName, branchName, config: config2, specPath: explicitSpecPath, reclassify = false } = options;
-  const workdir = join8(featureDir, "../..");
+  const workdir = join9(featureDir, "../..");
   if (reclassify) {
     return await reclassifyExistingPRD(featureDir, featureName, branchName, workdir, config2);
   }
-  const specPath = explicitSpecPath || join8(featureDir, "spec.md");
+  const specPath = explicitSpecPath || join9(featureDir, "spec.md");
   if (!existsSync8(specPath))
     throw new Error(`spec.md not found at ${specPath}`);
   const specContent = await Bun.file(specPath).text();
@@ -64689,7 +65491,7 @@ async function generateAcceptanceTestsForFeature(specContent, featureName, featu
       modelDef,
       config: config2
     });
-    const acceptanceTestPath = join8(featureDir, config2.acceptance.testPath);
+    const acceptanceTestPath = join9(featureDir, config2.acceptance.testPath);
     await Bun.write(acceptanceTestPath, result.testCode);
     logger.info("cli", "[OK] Acceptance tests generated", {
       criteriaCount: result.criteria.length,
@@ -64700,77 +65502,243 @@ async function generateAcceptanceTestsForFeature(specContent, featureName, featu
   }
 }
 // src/cli/plan.ts
-init_claude();
+init_registry();
 import { existsSync as existsSync9 } from "fs";
-import { join as join9 } from "path";
-init_schema();
+import { join as join10 } from "path";
 init_logger2();
-var SPEC_TEMPLATE = `# Feature: [title]
-
-## Problem
-Why this is needed.
-
-## Requirements
-- REQ-1: ...
-- REQ-2: ...
-
-## Acceptance Criteria
-- AC-1: ...
 
-## Technical Notes
-Architecture hints, constraints, dependencies.
+// src/prd/schema.ts
+var VALID_COMPLEXITY = ["simple", "medium", "complex", "expert"];
+var VALID_TEST_STRATEGIES = [
+  "test-after",
+  "tdd-simple",
+  "three-session-tdd",
+  "three-session-tdd-lite"
+];
+var STORY_ID_NO_SEPARATOR = /^([A-Za-z]+)(\d+)$/;
+function extractJsonFromMarkdown(text) {
+  const match = text.match(/```(?:json)?\s*\n([\s\S]*?)\n?\s*```/);
+  if (match) {
+    return match[1] ?? text;
+  }
+  return text;
+}
+function stripTrailingCommas(text) {
+  return text.replace(/,\s*([}\]])/g, "$1");
+}
+function normalizeStoryId(id) {
+  const match = id.match(STORY_ID_NO_SEPARATOR);
+  if (match) {
+    return `${match[1]}-${match[2]}`;
+  }
+  return id;
+}
+function normalizeComplexity2(raw) {
+  const lower = raw.toLowerCase();
+  if (VALID_COMPLEXITY.includes(lower)) {
+    return lower;
+  }
+  return null;
+}
+function validateStory(raw, index, allIds) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error(`[schema] story[${index}] must be an object`);
+  }
+  const s = raw;
+  const rawId = s.id;
+  if (rawId === undefined || rawId === null || rawId === "") {
+    throw new Error(`[schema] story[${index}].id is required and must be non-empty`);
+  }
+  if (typeof rawId !== "string") {
+    throw new Error(`[schema] story[${index}].id must be a string`);
+  }
+  const id = normalizeStoryId(rawId);
+  validateStoryId(id);
+  const title = s.title;
+  if (!title || typeof title !== "string" || title.trim() === "") {
+    throw new Error(`[schema] story[${index}].title is required and must be non-empty`);
+  }
+  const description = s.description;
+  if (!description || typeof description !== "string" || description.trim() === "") {
+    throw new Error(`[schema] story[${index}].description is required and must be non-empty`);
+  }
+  const ac = s.acceptanceCriteria;
+  if (!Array.isArray(ac) || ac.length === 0) {
+    throw new Error(`[schema] story[${index}].acceptanceCriteria is required and must be a non-empty array`);
+  }
+  for (let i = 0;i < ac.length; i++) {
+    if (typeof ac[i] !== "string") {
+      throw new Error(`[schema] story[${index}].acceptanceCriteria[${i}] must be a string`);
+    }
+  }
+  const routing = typeof s.routing === "object" && s.routing !== null ? s.routing : {};
+  const rawComplexity = routing.complexity ?? s.complexity;
+  if (rawComplexity === undefined || rawComplexity === null) {
+    throw new Error(`[schema] story[${index}] missing complexity. Set routing.complexity to one of: ${VALID_COMPLEXITY.join(", ")}`);
+  }
+  if (typeof rawComplexity !== "string") {
+    throw new Error(`[schema] story[${index}].routing.complexity must be a string`);
+  }
+  const complexity = normalizeComplexity2(rawComplexity);
+  if (complexity === null) {
+    throw new Error(`[schema] story[${index}].routing.complexity "${rawComplexity}" is invalid. Valid values: ${VALID_COMPLEXITY.join(", ")}`);
+  }
+  const rawTestStrategy = routing.testStrategy ?? s.testStrategy;
+  const testStrategy = rawTestStrategy !== undefined && VALID_TEST_STRATEGIES.includes(rawTestStrategy) ? rawTestStrategy : "tdd-simple";
+  const rawDeps = s.dependencies;
+  const dependencies = Array.isArray(rawDeps) ? rawDeps : [];
+  for (const dep of dependencies) {
+    if (!allIds.has(dep)) {
+      throw new Error(`[schema] story[${index}].dependencies references unknown story ID "${dep}"`);
+    }
+  }
+  const rawTags = s.tags;
+  const tags = Array.isArray(rawTags) ? rawTags : [];
+  return {
+    id,
+    title: title.trim(),
+    description: description.trim(),
+    acceptanceCriteria: ac,
+    tags,
+    dependencies,
+    status: "pending",
+    passes: false,
+    attempts: 0,
+    escalations: [],
+    routing: {
+      complexity,
+      testStrategy,
+      reasoning: "validated from LLM output"
+    }
+  };
+}
+function parseRawString(text) {
+  const extracted = extractJsonFromMarkdown(text);
+  const cleaned = stripTrailingCommas(extracted);
+  try {
+    return JSON.parse(cleaned);
+  } catch (err) {
+    const parseErr = err;
+    throw new Error(`[schema] Failed to parse JSON: ${parseErr.message}`, { cause: parseErr });
+  }
+}
+function validatePlanOutput(raw, feature, branch) {
+  const parsed = typeof raw === "string" ? parseRawString(raw) : raw;
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("[schema] PRD output must be a JSON object");
+  }
+  const obj = parsed;
+  const rawStories = obj.userStories;
+  if (!Array.isArray(rawStories) || rawStories.length === 0) {
+    throw new Error("[schema] userStories is required and must be a non-empty array");
+  }
+  const allIds = new Set;
+  for (const story of rawStories) {
+    if (typeof story === "object" && story !== null && !Array.isArray(story)) {
+      const s = story;
+      const rawId = s.id;
+      if (typeof rawId === "string" && rawId !== "") {
+        allIds.add(normalizeStoryId(rawId));
+      }
+    }
+  }
+  const userStories = rawStories.map((story, index) => validateStory(story, index, allIds));
+  const now = new Date().toISOString();
+  return {
+    project: typeof obj.project === "string" && obj.project !== "" ? obj.project : feature,
+    feature,
+    branchName: branch,
+    createdAt: typeof obj.createdAt === "string" ? obj.createdAt : now,
+    updatedAt: now,
+    userStories
+  };
+}
 
-## Out of Scope
-What this does NOT include.
-`;
-async function planCommand(prompt, workdir, config2, options = {}) {
-  const interactive = options.interactive !== false;
-  const ngentDir = join9(workdir, "nax");
-  const outputPath = join9(ngentDir, config2.plan.outputPath);
-  if (!existsSync9(ngentDir)) {
+// src/cli/plan.ts
+var _deps2 = {
+  readFile: (path) => Bun.file(path).text(),
+  writeFile: (path, content) => Bun.write(path, content).then(() => {}),
+  scanCodebase: (workdir) => scanCodebase(workdir),
+  getAgent: (name) => getAgent(name),
+  readPackageJson: (workdir) => Bun.file(join10(workdir, "package.json")).json().catch(() => null),
+  spawnSync: (cmd, opts) => {
+    const result = Bun.spawnSync(cmd, opts ? { cwd: opts.cwd } : {});
+    return { stdout: result.stdout, exitCode: result.exitCode };
+  },
+  mkdirp: (path) => Bun.spawn(["mkdir", "-p", path]).exited.then(() => {})
+};
+async function planCommand(workdir, config2, options) {
+  const naxDir = join10(workdir, "nax");
+  if (!existsSync9(naxDir)) {
     throw new Error(`nax directory not found. Run 'nax init' first in ${workdir}`);
   }
   const logger = getLogger();
-  logger.info("cli", "Scanning codebase...");
-  const scan = await scanCodebase(workdir);
+  logger?.info("plan", "Reading spec", { from: options.from });
+  const specContent = await _deps2.readFile(options.from);
+  logger?.info("plan", "Scanning codebase...");
+  const scan = await _deps2.scanCodebase(workdir);
   const codebaseContext = buildCodebaseContext2(scan);
-  const modelTier = config2.plan.model;
-  const modelEntry = config2.models[modelTier];
-  const modelDef = resolveModel(modelEntry);
-  const fullPrompt = buildPlanPrompt(prompt, SPEC_TEMPLATE);
-  const planOptions = {
-    prompt: fullPrompt,
-    workdir,
-    interactive,
-    codebaseContext,
-    inputFile: options.from,
-    modelTier,
-    modelDef,
-    config: config2
-  };
-  const adapter = new ClaudeCodeAdapter;
-  logger.info("cli", interactive ? "Starting interactive planning session..." : `Reading from ${options.from}...`, {
-    interactive,
-    from: options.from
-  });
-  const result = await adapter.plan(planOptions);
-  if (interactive) {
-    if (result.specContent) {
-      await Bun.write(outputPath, result.specContent);
-    } else {
-      if (!existsSync9(outputPath)) {
-        throw new Error(`Interactive planning completed but spec not found at ${outputPath}`);
-      }
-    }
+  const pkg = await _deps2.readPackageJson(workdir);
+  const projectName = detectProjectName(workdir, pkg);
+  const branchName = options.branch ?? `feat/${options.feature}`;
+  const prompt = buildPlanningPrompt(specContent, codebaseContext);
+  const agentName = config2?.autoMode?.defaultAgent ?? "claude";
+  const adapter = _deps2.getAgent(agentName);
+  if (!adapter) {
+    throw new Error(`[plan] No agent adapter found for '${agentName}'`);
+  }
+  const timeoutSeconds = config2?.execution?.sessionTimeoutSeconds ?? 600;
+  let rawResponse;
+  if (options.auto) {
+    rawResponse = await adapter.complete(prompt, { jsonMode: true });
   } else {
-    if (!result.specContent) {
-      throw new Error("Agent did not produce specification content");
+    const interactionBridge = createCliInteractionBridge();
+    logger?.info("plan", "Starting interactive planning session...", { agent: agentName });
+    try {
+      const result = await adapter.plan({
+        prompt,
+        workdir,
+        interactive: true,
+        timeoutSeconds,
+        interactionBridge
+      });
+      rawResponse = result.specContent;
+    } finally {
+      logger?.info("plan", "Interactive session ended");
     }
-    await Bun.write(outputPath, result.specContent);
   }
-  logger.info("cli", "\u2713 Specification written to output", { outputPath });
+  const finalPrd = validatePlanOutput(rawResponse, options.feature, branchName);
+  finalPrd.project = projectName;
+  const outputDir = join10(naxDir, "features", options.feature);
+  const outputPath = join10(outputDir, "prd.json");
+  await _deps2.mkdirp(outputDir);
+  await _deps2.writeFile(outputPath, JSON.stringify(finalPrd, null, 2));
+  logger?.info("plan", "[OK] PRD written", { outputPath });
   return outputPath;
 }
+function createCliInteractionBridge() {
+  return {
+    async detectQuestion(text) {
+      return text.includes("?");
+    },
+    async onQuestionDetected(text) {
+      return text;
+    }
+  };
+}
+function detectProjectName(workdir, pkg) {
+  if (pkg?.name && typeof pkg.name === "string") {
+    return pkg.name;
+  }
+  const result = _deps2.spawnSync(["git", "remote", "get-url", "origin"], { cwd: workdir });
+  if (result.exitCode === 0) {
+    const url2 = result.stdout.toString().trim();
+    const match = url2.match(/\/([^/]+?)(?:\.git)?$/);
+    if (match?.[1])
+      return match[1];
+  }
+  return "unknown";
+}
 function buildCodebaseContext2(scan) {
   const sections = [];
   sections.push(`## Codebase Structure
@@ -64797,24 +65765,62 @@ function buildCodebaseContext2(scan) {
   return sections.join(`
 `);
 }
-function buildPlanPrompt(userPrompt, template) {
-  return `You are helping plan a new feature for this codebase.
+function buildPlanningPrompt(specContent, codebaseContext) {
+  return `You are a senior software architect generating a product requirements document (PRD) as JSON.
+
+## Spec
+
+${specContent}
+
+## Codebase Context
+
+${codebaseContext}
+
+## Output Schema
+
+Generate a JSON object with this exact structure (no markdown, no explanation \u2014 JSON only):
+
+{
+  "project": "string \u2014 project name",
+  "feature": "string \u2014 feature name",
+  "branchName": "string \u2014 git branch (e.g. feat/my-feature)",
+  "createdAt": "ISO 8601 timestamp",
+  "updatedAt": "ISO 8601 timestamp",
+  "userStories": [
+    {
+      "id": "string \u2014 e.g. US-001",
+      "title": "string \u2014 concise story title",
+      "description": "string \u2014 detailed description of the story",
+      "acceptanceCriteria": ["string \u2014 each AC line"],
+      "tags": ["string \u2014 routing tags, e.g. feature, security, api"],
+      "dependencies": ["string \u2014 story IDs this story depends on"],
+      "status": "pending",
+      "passes": false,
+      "routing": {
+        "complexity": "simple | medium | complex | expert",
+        "testStrategy": "test-after | tdd-lite | three-session-tdd",
+        "reasoning": "string \u2014 brief classification rationale"
+      },
+      "escalations": [],
+      "attempts": 0
+    }
+  ]
+}
 
-Task: ${userPrompt}
+## Complexity Classification Guide
 
-Please gather requirements and produce a structured specification following this template:
+- simple: \u226450 LOC, single-file change, purely additive, no new dependencies \u2192 test-after
+- medium: 50\u2013200 LOC, 2\u20135 files, standard patterns, clear requirements \u2192 tdd-lite
+- complex: 200\u2013500 LOC, multiple modules, new abstractions or integrations \u2192 three-session-tdd
+- expert: 500+ LOC, architectural changes, cross-cutting concerns, high risk \u2192 three-session-tdd
 
-${template}
+## Test Strategy Guide
 
-Ask clarifying questions as needed to ensure the spec is complete and unambiguous.
-Focus on understanding:
-- The problem being solved
-- Specific requirements and constraints
-- Acceptance criteria for success
-- Technical approach and architecture
-- What is explicitly out of scope
+- test-after: Simple changes with well-understood behavior. Write tests after implementation.
+- tdd-lite: Medium complexity. Write key tests first, implement, then fill coverage.
+- three-session-tdd: Complex/expert. Full TDD cycle with separate sessions for tests and implementation.
 
-When done, output the complete specification in markdown format.`;
+Output ONLY the JSON object. Do not wrap in markdown code blocks.`;
 }
 // src/cli/accept.ts
 init_config();
@@ -64963,14 +65969,14 @@ async function displayModelEfficiency(workdir) {
 }
 // src/cli/status-features.ts
 init_source();
-import { existsSync as existsSync11, readdirSync as readdirSync2 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync3 } from "fs";
+import { join as join13 } from "path";
 
 // src/commands/common.ts
 init_path_security2();
 init_errors3();
-import { existsSync as existsSync10, readdirSync, realpathSync as realpathSync2 } from "fs";
-import { join as join10, resolve as resolve6 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync2, realpathSync as realpathSync2 } from "fs";
+import { join as join11, resolve as resolve6 } from "path";
 function resolveProject(options = {}) {
   const { dir, feature } = options;
   let projectRoot;
@@ -64978,12 +65984,12 @@ function resolveProject(options = {}) {
   let configPath;
   if (dir) {
     projectRoot = realpathSync2(resolve6(dir));
-    naxDir = join10(projectRoot, "nax");
+    naxDir = join11(projectRoot, "nax");
     if (!existsSync10(naxDir)) {
       throw new NaxError(`Directory does not contain a nax project: ${projectRoot}
 Expected to find: ${naxDir}`, "NAX_DIR_NOT_FOUND", { projectRoot, naxDir });
     }
-    configPath = join10(naxDir, "config.json");
+    configPath = join11(naxDir, "config.json");
     if (!existsSync10(configPath)) {
       throw new NaxError(`nax directory found but config.json is missing: ${naxDir}
 Expected to find: ${configPath}`, "CONFIG_NOT_FOUND", { naxDir, configPath });
@@ -64991,24 +65997,24 @@ Expected to find: ${configPath}`, "CONFIG_NOT_FOUND", { naxDir, configPath });
   } else {
     const found = findProjectRoot(process.cwd());
     if (!found) {
-      const cwdNaxDir = join10(process.cwd(), "nax");
+      const cwdNaxDir = join11(process.cwd(), "nax");
       if (existsSync10(cwdNaxDir)) {
-        const cwdConfigPath = join10(cwdNaxDir, "config.json");
+        const cwdConfigPath = join11(cwdNaxDir, "config.json");
         throw new NaxError(`nax directory found but config.json is missing: ${cwdNaxDir}
 Expected to find: ${cwdConfigPath}`, "CONFIG_NOT_FOUND", { naxDir: cwdNaxDir, configPath: cwdConfigPath });
       }
       throw new NaxError("No nax project found. Run this command from within a nax project directory, or use -d flag to specify the project path.", "PROJECT_NOT_FOUND", { cwd: process.cwd() });
     }
     projectRoot = found;
-    naxDir = join10(projectRoot, "nax");
-    configPath = join10(naxDir, "config.json");
+    naxDir = join11(projectRoot, "nax");
+    configPath = join11(naxDir, "config.json");
   }
   let featureDir;
   if (feature) {
-    const featuresDir = join10(naxDir, "features");
-    featureDir = join10(featuresDir, feature);
+    const featuresDir = join11(naxDir, "features");
+    featureDir = join11(featuresDir, feature);
     if (!existsSync10(featureDir)) {
-      const availableFeatures = existsSync10(featuresDir) ? readdirSync(featuresDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name) : [];
+      const availableFeatures = existsSync10(featuresDir) ? readdirSync2(featuresDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name) : [];
       const availableMsg = availableFeatures.length > 0 ? `
 
 Available features:
@@ -65033,12 +66039,12 @@ function findProjectRoot(startDir) {
   let current = resolve6(startDir);
   let depth = 0;
   while (depth < MAX_DIRECTORY_DEPTH) {
-    const naxDir = join10(current, "nax");
-    const configPath = join10(naxDir, "config.json");
+    const naxDir = join11(current, "nax");
+    const configPath = join11(naxDir, "config.json");
     if (existsSync10(configPath)) {
       return realpathSync2(current);
     }
-    const parent = join10(current, "..");
+    const parent = join11(current, "..");
     if (parent === current) {
       break;
     }
@@ -65060,7 +66066,7 @@ function isPidAlive(pid) {
   }
 }
 async function loadStatusFile(featureDir) {
-  const statusPath = join12(featureDir, "status.json");
+  const statusPath = join13(featureDir, "status.json");
   if (!existsSync11(statusPath)) {
     return null;
   }
@@ -65072,7 +66078,7 @@ async function loadStatusFile(featureDir) {
   }
 }
 async function loadProjectStatusFile(projectDir) {
-  const statusPath = join12(projectDir, "nax", "status.json");
+  const statusPath = join13(projectDir, "nax", "status.json");
   if (!existsSync11(statusPath)) {
     return null;
   }
@@ -65084,7 +66090,7 @@ async function loadProjectStatusFile(projectDir) {
   }
 }
 async function getFeatureSummary(featureName, featureDir) {
-  const prdPath = join12(featureDir, "prd.json");
+  const prdPath = join13(featureDir, "prd.json");
   const prd = await loadPRD(prdPath);
   const counts = countStories(prd);
   const summary = {
@@ -65118,9 +66124,9 @@ async function getFeatureSummary(featureName, featureDir) {
       };
     }
   }
-  const runsDir = join12(featureDir, "runs");
+  const runsDir = join13(featureDir, "runs");
   if (existsSync11(runsDir)) {
-    const runs = readdirSync2(runsDir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".jsonl") && e.name !== "latest.jsonl").map((e) => e.name).sort().reverse();
+    const runs = readdirSync3(runsDir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".jsonl") && e.name !== "latest.jsonl").map((e) => e.name).sort().reverse();
     if (runs.length > 0) {
       const latestRun = runs[0].replace(".jsonl", "");
       summary.lastRun = latestRun;
@@ -65129,12 +66135,12 @@ async function getFeatureSummary(featureName, featureDir) {
   return summary;
 }
 async function displayAllFeatures(projectDir) {
-  const featuresDir = join12(projectDir, "nax", "features");
+  const featuresDir = join13(projectDir, "nax", "features");
   if (!existsSync11(featuresDir)) {
     console.log(source_default.dim("No features found."));
     return;
   }
-  const features = readdirSync2(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  const features = readdirSync3(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
   if (features.length === 0) {
     console.log(source_default.dim("No features found."));
     return;
@@ -65170,7 +66176,7 @@ async function displayAllFeatures(projectDir) {
       console.log();
     }
   }
-  const summaries = await Promise.all(features.map((name) => getFeatureSummary(name, join12(featuresDir, name))));
+  const summaries = await Promise.all(features.map((name) => getFeatureSummary(name, join13(featuresDir, name))));
   console.log(source_default.bold(`\uD83D\uDCCA Features
 `));
   const header = `  ${"Feature".padEnd(25)} ${"Done".padEnd(6)} ${"Failed".padEnd(8)} ${"Pending".padEnd(9)} ${"Last Run".padEnd(22)} ${"Cost".padEnd(10)} Status`;
@@ -65196,7 +66202,7 @@ async function displayAllFeatures(projectDir) {
   console.log();
 }
 async function displayFeatureDetails(featureName, featureDir) {
-  const prdPath = join12(featureDir, "prd.json");
+  const prdPath = join13(featureDir, "prd.json");
   const prd = await loadPRD(prdPath);
   const counts = countStories(prd);
   const status = await loadStatusFile(featureDir);
@@ -65310,8 +66316,8 @@ async function displayFeatureStatus(options = {}) {
 // src/cli/runs.ts
 init_errors3();
 init_logger2();
-import { existsSync as existsSync12, readdirSync as readdirSync3 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync4 } from "fs";
+import { join as join14 } from "path";
 async function parseRunLog(logPath) {
   const logger = getLogger();
   try {
@@ -65327,19 +66333,19 @@ async function parseRunLog(logPath) {
 async function runsListCommand(options) {
   const logger = getLogger();
   const { feature, workdir } = options;
-  const runsDir = join13(workdir, "nax", "features", feature, "runs");
+  const runsDir = join14(workdir, "nax", "features", feature, "runs");
   if (!existsSync12(runsDir)) {
     logger.info("cli", "No runs found for feature", { feature, hint: `Directory not found: ${runsDir}` });
     return;
   }
-  const files = readdirSync3(runsDir).filter((f) => f.endsWith(".jsonl"));
+  const files = readdirSync4(runsDir).filter((f) => f.endsWith(".jsonl"));
   if (files.length === 0) {
     logger.info("cli", "No runs found for feature", { feature });
     return;
   }
   logger.info("cli", `Runs for ${feature}`, { count: files.length });
   for (const file2 of files.sort().reverse()) {
-    const logPath = join13(runsDir, file2);
+    const logPath = join14(runsDir, file2);
     const entries = await parseRunLog(logPath);
     const startEvent = entries.find((e) => e.message === "run.start");
     const completeEvent = entries.find((e) => e.message === "run.complete");
@@ -65365,7 +66371,7 @@ async function runsListCommand(options) {
 async function runsShowCommand(options) {
   const logger = getLogger();
   const { runId, feature, workdir } = options;
-  const logPath = join13(workdir, "nax", "features", feature, "runs", `${runId}.jsonl`);
+  const logPath = join14(workdir, "nax", "features", feature, "runs", `${runId}.jsonl`);
   if (!existsSync12(logPath)) {
     logger.error("cli", "Run not found", { runId, feature, logPath });
     throw new NaxError("Run not found", "RUN_NOT_FOUND", { runId, feature, logPath });
@@ -65404,7 +66410,7 @@ async function runsShowCommand(options) {
 // src/cli/prompts-main.ts
 init_logger2();
 import { existsSync as existsSync15, mkdirSync as mkdirSync3 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 
 // src/pipeline/index.ts
 init_runner();
@@ -65440,7 +66446,7 @@ init_prd();
 
 // src/cli/prompts-tdd.ts
 init_prompts2();
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 async function handleThreeSessionTddPrompts(story, ctx, outputDir, logger) {
   const [testWriterPrompt, implementerPrompt, verifierPrompt] = await Promise.all([
     PromptBuilder.for("test-writer", { isolation: "strict" }).withLoader(ctx.workdir, ctx.config).story(story).context(ctx.contextMarkdown).constitution(ctx.constitution?.content).testCommand(ctx.config.quality?.commands?.test).build(),
@@ -65459,7 +66465,7 @@ ${frontmatter}---
 
 ${session.prompt}`;
     if (outputDir) {
-      const promptFile = join19(outputDir, `${story.id}.${session.role}.md`);
+      const promptFile = join20(outputDir, `${story.id}.${session.role}.md`);
       await Bun.write(promptFile, fullOutput);
       logger.info("cli", "Written TDD prompt file", {
         storyId: story.id,
@@ -65475,7 +66481,7 @@ ${"=".repeat(80)}`);
     }
   }
   if (outputDir && ctx.contextMarkdown) {
-    const contextFile = join19(outputDir, `${story.id}.context.md`);
+    const contextFile = join20(outputDir, `${story.id}.context.md`);
     const frontmatter = buildFrontmatter(story, ctx);
     const contextOutput = `---
 ${frontmatter}---
@@ -65489,12 +66495,12 @@ ${ctx.contextMarkdown}`;
 async function promptsCommand(options) {
   const logger = getLogger();
   const { feature, workdir, config: config2, storyId, outputDir } = options;
-  const naxDir = join20(workdir, "nax");
+  const naxDir = join21(workdir, "nax");
   if (!existsSync15(naxDir)) {
     throw new Error(`nax directory not found. Run 'nax init' first in ${workdir}`);
   }
-  const featureDir = join20(naxDir, "features", feature);
-  const prdPath = join20(featureDir, "prd.json");
+  const featureDir = join21(naxDir, "features", feature);
+  const prdPath = join21(featureDir, "prd.json");
   if (!existsSync15(prdPath)) {
     throw new Error(`Feature "${feature}" not found or missing prd.json`);
   }
@@ -65554,10 +66560,10 @@ ${frontmatter}---
 
 ${ctx.prompt}`;
     if (outputDir) {
-      const promptFile = join20(outputDir, `${story.id}.prompt.md`);
+      const promptFile = join21(outputDir, `${story.id}.prompt.md`);
       await Bun.write(promptFile, fullOutput);
       if (ctx.contextMarkdown) {
-        const contextFile = join20(outputDir, `${story.id}.context.md`);
+        const contextFile = join21(outputDir, `${story.id}.context.md`);
         const contextOutput = `---
 ${frontmatter}---
 
@@ -65621,7 +66627,7 @@ function buildFrontmatter(story, ctx, role) {
 }
 // src/cli/prompts-init.ts
 import { existsSync as existsSync16, mkdirSync as mkdirSync4 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 var TEMPLATE_ROLES = [
   { file: "test-writer.md", role: "test-writer" },
   { file: "implementer.md", role: "implementer", variant: "standard" },
@@ -65645,9 +66651,9 @@ var TEMPLATE_HEADER = `<!--
 `;
 async function promptsInitCommand(options) {
   const { workdir, force = false, autoWireConfig = true } = options;
-  const templatesDir = join21(workdir, "nax", "templates");
+  const templatesDir = join22(workdir, "nax", "templates");
   mkdirSync4(templatesDir, { recursive: true });
-  const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync16(join21(templatesDir, f)));
+  const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync16(join22(templatesDir, f)));
   if (existingFiles.length > 0 && !force) {
     console.warn(`[WARN] nax/templates/ already contains files: ${existingFiles.join(", ")}. No files overwritten.
        Pass --force to overwrite existing templates.`);
@@ -65655,7 +66661,7 @@ async function promptsInitCommand(options) {
   }
   const written = [];
   for (const template of TEMPLATE_ROLES) {
-    const filePath = join21(templatesDir, template.file);
+    const filePath = join22(templatesDir, template.file);
     const roleBody = template.role === "implementer" ? buildRoleTaskSection(template.role, template.variant) : buildRoleTaskSection(template.role);
     const content = TEMPLATE_HEADER + roleBody;
     await Bun.write(filePath, content);
@@ -65671,7 +66677,7 @@ async function promptsInitCommand(options) {
   return written;
 }
 async function autoWirePromptsConfig(workdir) {
-  const configPath = join21(workdir, "nax.config.json");
+  const configPath = join22(workdir, "nax.config.json");
   if (!existsSync16(configPath)) {
     const exampleConfig = JSON.stringify({
       prompts: {
@@ -65837,8 +66843,8 @@ function pad(str, width) {
 init_config();
 init_logger2();
 init_prd();
-import { existsSync as existsSync17, readdirSync as readdirSync4 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync17, readdirSync as readdirSync5 } from "fs";
+import { join as join25 } from "path";
 
 // src/cli/diagnose-analysis.ts
 function detectFailurePattern(story, prd, status) {
@@ -66037,7 +67043,7 @@ function isProcessAlive2(pid) {
   }
 }
 async function loadStatusFile2(workdir) {
-  const statusPath = join24(workdir, "nax", "status.json");
+  const statusPath = join25(workdir, "nax", "status.json");
   if (!existsSync17(statusPath))
     return null;
   try {
@@ -66065,7 +67071,7 @@ async function countCommitsSince(workdir, since) {
   }
 }
 async function checkLock(workdir) {
-  const lockFile = Bun.file(join24(workdir, "nax.lock"));
+  const lockFile = Bun.file(join25(workdir, "nax.lock"));
   if (!await lockFile.exists())
     return { lockPresent: false };
   try {
@@ -66083,8 +67089,8 @@ async function diagnoseCommand(options = {}) {
   const logger = getLogger();
   const workdir = options.workdir ?? process.cwd();
   const naxSubdir = findProjectDir(workdir);
-  let projectDir = naxSubdir ? join24(naxSubdir, "..") : null;
-  if (!projectDir && existsSync17(join24(workdir, "nax"))) {
+  let projectDir = naxSubdir ? join25(naxSubdir, "..") : null;
+  if (!projectDir && existsSync17(join25(workdir, "nax"))) {
     projectDir = workdir;
   }
   if (!projectDir)
@@ -66095,18 +67101,18 @@ async function diagnoseCommand(options = {}) {
     if (status2) {
       feature = status2.run.feature;
     } else {
-      const featuresDir = join24(projectDir, "nax", "features");
+      const featuresDir = join25(projectDir, "nax", "features");
       if (!existsSync17(featuresDir))
         throw new Error("No features found in project");
-      const features = readdirSync4(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+      const features = readdirSync5(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
       if (features.length === 0)
         throw new Error("No features found");
       feature = features[0];
       logger.info("diagnose", "No feature specified, using first found", { feature });
     }
   }
-  const featureDir = join24(projectDir, "nax", "features", feature);
-  const prdPath = join24(featureDir, "prd.json");
+  const featureDir = join25(projectDir, "nax", "features", feature);
+  const prdPath = join25(featureDir, "prd.json");
   if (!existsSync17(prdPath))
     throw new Error(`Feature not found: ${feature}`);
   const prd = await loadPRD(prdPath);
@@ -66149,16 +67155,16 @@ init_interaction();
 init_source();
 init_loader2();
 import { existsSync as existsSync20 } from "fs";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 
 // src/context/generator.ts
 init_path_security2();
 import { existsSync as existsSync19 } from "fs";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 
 // src/context/injector.ts
 import { existsSync as existsSync18 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 var NOTABLE_NODE_DEPS = [
   "@nestjs",
   "express",
@@ -66188,7 +67194,7 @@ var NOTABLE_NODE_DEPS = [
   "ioredis"
 ];
 async function detectNode(workdir) {
-  const pkgPath = join25(workdir, "package.json");
+  const pkgPath = join26(workdir, "package.json");
   if (!existsSync18(pkgPath))
     return null;
   try {
@@ -66205,7 +67211,7 @@ async function detectNode(workdir) {
   }
 }
 async function detectGo(workdir) {
-  const goMod = join25(workdir, "go.mod");
+  const goMod = join26(workdir, "go.mod");
   if (!existsSync18(goMod))
     return null;
   try {
@@ -66229,7 +67235,7 @@ async function detectGo(workdir) {
   }
 }
 async function detectRust(workdir) {
-  const cargoPath = join25(workdir, "Cargo.toml");
+  const cargoPath = join26(workdir, "Cargo.toml");
   if (!existsSync18(cargoPath))
     return null;
   try {
@@ -66245,8 +67251,8 @@ async function detectRust(workdir) {
   }
 }
 async function detectPython(workdir) {
-  const pyproject = join25(workdir, "pyproject.toml");
-  const requirements = join25(workdir, "requirements.txt");
+  const pyproject = join26(workdir, "pyproject.toml");
+  const requirements = join26(workdir, "requirements.txt");
   if (!existsSync18(pyproject) && !existsSync18(requirements))
     return null;
   try {
@@ -66265,7 +67271,7 @@ async function detectPython(workdir) {
   }
 }
 async function detectPhp(workdir) {
-  const composerPath = join25(workdir, "composer.json");
+  const composerPath = join26(workdir, "composer.json");
   if (!existsSync18(composerPath))
     return null;
   try {
@@ -66278,7 +67284,7 @@ async function detectPhp(workdir) {
   }
 }
 async function detectRuby(workdir) {
-  const gemfile = join25(workdir, "Gemfile");
+  const gemfile = join26(workdir, "Gemfile");
   if (!existsSync18(gemfile))
     return null;
   try {
@@ -66290,9 +67296,9 @@ async function detectRuby(workdir) {
   }
 }
 async function detectJvm(workdir) {
-  const pom = join25(workdir, "pom.xml");
-  const gradle = join25(workdir, "build.gradle");
-  const gradleKts = join25(workdir, "build.gradle.kts");
+  const pom = join26(workdir, "pom.xml");
+  const gradle = join26(workdir, "build.gradle");
+  const gradleKts = join26(workdir, "build.gradle.kts");
   if (!existsSync18(pom) && !existsSync18(gradle) && !existsSync18(gradleKts))
     return null;
   try {
@@ -66300,7 +67306,7 @@ async function detectJvm(workdir) {
       const content2 = await Bun.file(pom).text();
       const nameMatch = content2.match(/<artifactId>([^<]+)<\/artifactId>/);
       const deps2 = [...content2.matchAll(/<artifactId>([^<]+)<\/artifactId>/g)].map((m) => m[1]).filter((d) => d !== nameMatch?.[1]).slice(0, 10);
-      const lang2 = existsSync18(join25(workdir, "src/main/kotlin")) ? "Kotlin" : "Java";
+      const lang2 = existsSync18(join26(workdir, "src/main/kotlin")) ? "Kotlin" : "Java";
       return { name: nameMatch?.[1], lang: lang2, dependencies: deps2 };
     }
     const gradleFile = existsSync18(gradleKts) ? gradleKts : gradle;
@@ -66521,7 +67527,7 @@ async function generateFor(agent, options, config2) {
   try {
     const context = await loadContextContent(options, config2);
     const content = generator.generate(context);
-    const outputPath = join26(options.outputDir, generator.outputFile);
+    const outputPath = join27(options.outputDir, generator.outputFile);
     validateFilePath(outputPath, options.outputDir);
     if (!options.dryRun) {
       await Bun.write(outputPath, content);
@@ -66538,7 +67544,7 @@ async function generateAll(options, config2) {
   for (const [agentKey, generator] of Object.entries(GENERATORS)) {
     try {
       const content = generator.generate(context);
-      const outputPath = join26(options.outputDir, generator.outputFile);
+      const outputPath = join27(options.outputDir, generator.outputFile);
       validateFilePath(outputPath, options.outputDir);
       if (!options.dryRun) {
         await Bun.write(outputPath, content);
@@ -66556,8 +67562,8 @@ async function generateAll(options, config2) {
 var VALID_AGENTS = ["claude", "codex", "opencode", "cursor", "windsurf", "aider", "gemini"];
 async function generateCommand(options) {
   const workdir = process.cwd();
-  const contextPath = options.context ? join27(workdir, options.context) : join27(workdir, "nax/context.md");
-  const outputDir = options.output ? join27(workdir, options.output) : workdir;
+  const contextPath = options.context ? join28(workdir, options.context) : join28(workdir, "nax/context.md");
+  const outputDir = options.output ? join28(workdir, options.output) : workdir;
   const autoInject = !options.noAutoInject;
   const dryRun = options.dryRun ?? false;
   if (!existsSync20(contextPath)) {
@@ -66633,7 +67639,7 @@ async function generateCommand(options) {
 // src/cli/config-display.ts
 init_loader2();
 import { existsSync as existsSync22 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 
 // src/cli/config-descriptions.ts
 var FIELD_DESCRIPTIONS = {
@@ -66839,7 +67845,7 @@ function deepEqual(a, b) {
 init_defaults();
 init_loader2();
 import { existsSync as existsSync21 } from "fs";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 async function loadConfigFile(path14) {
   if (!existsSync21(path14))
     return null;
@@ -66861,7 +67867,7 @@ async function loadProjectConfig() {
   const projectDir = findProjectDir();
   if (!projectDir)
     return null;
-  const projectPath = join28(projectDir, "config.json");
+  const projectPath = join29(projectDir, "config.json");
   return await loadConfigFile(projectPath);
 }
 
@@ -66921,7 +67927,7 @@ async function configCommand(config2, options = {}) {
 function determineConfigSources() {
   const globalPath = globalConfigPath();
   const projectDir = findProjectDir();
-  const projectPath = projectDir ? join29(projectDir, "config.json") : null;
+  const projectPath = projectDir ? join30(projectDir, "config.json") : null;
   return {
     global: fileExists(globalPath) ? globalPath : null,
     project: projectPath && fileExists(projectPath) ? projectPath : null
@@ -67101,24 +68107,24 @@ async function diagnose(options) {
 
 // src/commands/logs.ts
 import { existsSync as existsSync24 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 
 // src/commands/logs-formatter.ts
 init_source();
 init_formatter();
-import { readdirSync as readdirSync6 } from "fs";
-import { join as join31 } from "path";
+import { readdirSync as readdirSync7 } from "fs";
+import { join as join32 } from "path";
 
 // src/commands/logs-reader.ts
-import { existsSync as existsSync23, readdirSync as readdirSync5 } from "fs";
+import { existsSync as existsSync23, readdirSync as readdirSync6 } from "fs";
 import { readdir as readdir3 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { join as join30 } from "path";
-var _deps5 = {
-  getRunsDir: () => process.env.NAX_RUNS_DIR ?? join30(homedir3(), ".nax", "runs")
+import { join as join31 } from "path";
+var _deps6 = {
+  getRunsDir: () => process.env.NAX_RUNS_DIR ?? join31(homedir3(), ".nax", "runs")
 };
 async function resolveRunFileFromRegistry(runId) {
-  const runsDir = _deps5.getRunsDir();
+  const runsDir = _deps6.getRunsDir();
   let entries;
   try {
     entries = await readdir3(runsDir);
@@ -67127,7 +68133,7 @@ async function resolveRunFileFromRegistry(runId) {
   }
   let matched = null;
   for (const entry of entries) {
-    const metaPath = join30(runsDir, entry, "meta.json");
+    const metaPath = join31(runsDir, entry, "meta.json");
     try {
       const meta3 = await Bun.file(metaPath).json();
       if (meta3.runId === runId || meta3.runId.startsWith(runId)) {
@@ -67143,20 +68149,20 @@ async function resolveRunFileFromRegistry(runId) {
     console.log(`Log directory unavailable for run: ${runId}`);
     return null;
   }
-  const files = readdirSync5(matched.eventsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
+  const files = readdirSync6(matched.eventsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
   if (files.length === 0) {
     console.log(`No log files found for run: ${runId}`);
     return null;
   }
   const specificFile = files.find((f) => f === `${matched.runId}.jsonl`);
-  return join30(matched.eventsDir, specificFile ?? files[0]);
+  return join31(matched.eventsDir, specificFile ?? files[0]);
 }
 async function selectRunFile(runsDir) {
-  const files = readdirSync5(runsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
+  const files = readdirSync6(runsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
   if (files.length === 0) {
     return null;
   }
-  return join30(runsDir, files[0]);
+  return join31(runsDir, files[0]);
 }
 async function extractRunSummary(filePath) {
   const file2 = Bun.file(filePath);
@@ -67230,7 +68236,7 @@ var LOG_LEVEL_PRIORITY2 = {
   error: 3
 };
 async function displayRunsList(runsDir) {
-  const files = readdirSync6(runsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
+  const files = readdirSync7(runsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
   if (files.length === 0) {
     console.log(source_default.dim("No runs found"));
     return;
@@ -67241,7 +68247,7 @@ Runs:
   console.log(source_default.gray("  Timestamp            Stories  Duration  Cost      Status"));
   console.log(source_default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   for (const file2 of files) {
-    const filePath = join31(runsDir, file2);
+    const filePath = join32(runsDir, file2);
     const summary = await extractRunSummary(filePath);
     const timestamp = file2.replace(".jsonl", "");
     const stories = summary ? `${summary.passed}/${summary.total}` : "?/?";
@@ -67366,7 +68372,7 @@ async function logsCommand(options) {
     return;
   }
   const resolved = resolveProject({ dir: options.dir });
-  const naxDir = join32(resolved.projectDir, "nax");
+  const naxDir = join33(resolved.projectDir, "nax");
   const configPath = resolved.configPath;
   const configFile = Bun.file(configPath);
   const config2 = await configFile.json();
@@ -67374,8 +68380,8 @@ async function logsCommand(options) {
   if (!featureName) {
     throw new Error("No feature specified in config.json");
   }
-  const featureDir = join32(naxDir, "features", featureName);
-  const runsDir = join32(featureDir, "runs");
+  const featureDir = join33(naxDir, "features", featureName);
+  const runsDir = join33(featureDir, "runs");
   if (!existsSync24(runsDir)) {
     throw new Error(`No runs directory found for feature: ${featureName}`);
   }
@@ -67400,7 +68406,7 @@ init_config();
 init_prd();
 init_precheck();
 import { existsSync as existsSync29 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 async function precheckCommand(options) {
   const resolved = resolveProject({
     dir: options.dir,
@@ -67416,16 +68422,16 @@ async function precheckCommand(options) {
       process.exit(1);
     }
   }
-  const naxDir = join33(resolved.projectDir, "nax");
-  const featureDir = join33(naxDir, "features", featureName);
-  const prdPath = join33(featureDir, "prd.json");
+  const naxDir = join34(resolved.projectDir, "nax");
+  const featureDir = join34(naxDir, "features", featureName);
+  const prdPath = join34(featureDir, "prd.json");
   if (!existsSync29(featureDir)) {
     console.error(source_default.red(`Feature not found: ${featureName}`));
     process.exit(1);
   }
   if (!existsSync29(prdPath)) {
     console.error(source_default.red(`Missing prd.json for feature: ${featureName}`));
-    console.error(source_default.dim(`Run: nax analyze -f ${featureName}`));
+    console.error(source_default.dim(`Run: nax plan -f ${featureName} --from spec.md --auto`));
     process.exit(EXIT_CODES.INVALID_PRD);
   }
   const config2 = await loadConfig(resolved.projectDir);
@@ -67442,10 +68448,10 @@ async function precheckCommand(options) {
 init_source();
 import { readdir as readdir4 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 var DEFAULT_LIMIT = 20;
-var _deps7 = {
-  getRunsDir: () => join34(homedir4(), ".nax", "runs")
+var _deps8 = {
+  getRunsDir: () => join35(homedir4(), ".nax", "runs")
 };
 function formatDuration3(ms) {
   if (ms <= 0)
@@ -67487,7 +68493,7 @@ function pad3(str, width) {
   return str + " ".repeat(padding);
 }
 async function runsCommand(options = {}) {
-  const runsDir = _deps7.getRunsDir();
+  const runsDir = _deps8.getRunsDir();
   let entries;
   try {
     entries = await readdir4(runsDir);
@@ -67497,7 +68503,7 @@ async function runsCommand(options = {}) {
   }
   const rows = [];
   for (const entry of entries) {
-    const metaPath = join34(runsDir, entry, "meta.json");
+    const metaPath = join35(runsDir, entry, "meta.json");
     let meta3;
     try {
       meta3 = await Bun.file(metaPath).json();
@@ -67574,7 +68580,7 @@ async function runsCommand(options = {}) {
 
 // src/commands/unlock.ts
 init_source();
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -67589,7 +68595,7 @@ function formatLockAge(ageMs) {
 }
 async function unlockCommand(options) {
   const workdir = options.dir ?? process.cwd();
-  const lockPath = join35(workdir, "nax.lock");
+  const lockPath = join36(workdir, "nax.lock");
   const lockFile = Bun.file(lockPath);
   const exists = await lockFile.exists();
   if (!exists) {
@@ -67628,6 +68634,7 @@ async function unlockCommand(options) {
 init_config();
 
 // src/execution/runner.ts
+init_registry();
 init_hooks();
 init_logger2();
 init_prd();
@@ -67637,6 +68644,7 @@ init_crash_recovery();
 init_hooks();
 init_logger2();
 init_prd();
+init_git();
 init_crash_recovery();
 init_story_context();
 async function runCompletionPhase(options) {
@@ -67646,7 +68654,7 @@ async function runCompletionPhase(options) {
     const acceptanceResult = await runAcceptanceLoop2({
       config: options.config,
       prd: options.prd,
-      prdPath: "",
+      prdPath: options.prdPath,
       workdir: options.workdir,
       featureDir: options.featureDir,
       hooks: options.hooks,
@@ -67657,7 +68665,8 @@ async function runCompletionPhase(options) {
       allStoryMetrics: options.allStoryMetrics,
       pluginRegistry: options.pluginRegistry,
       eventEmitter: options.eventEmitter,
-      statusWriter: options.statusWriter
+      statusWriter: options.statusWriter,
+      agentGetFn: options.agentGetFn
     });
     Object.assign(options, {
       prd: acceptanceResult.prd,
@@ -67708,6 +68717,7 @@ async function runCompletionPhase(options) {
   }
   stopHeartbeat();
   await writeExitSummary(options.logFilePath, options.totalCost, options.iterations, options.storiesCompleted, durationMs);
+  await autoCommitIfDirty(options.workdir, "run.complete", "run-summary", options.feature);
   return {
     durationMs,
     runCompletedAt
@@ -67858,7 +68868,9 @@ async function runExecutionPhase(options, prd, pluginRegistry) {
     logFilePath: options.logFilePath,
     runId: options.runId,
     startTime: options.startTime,
-    batchPlan
+    batchPlan,
+    agentGetFn: options.agentGetFn,
+    pidRegistry: options.pidRegistry
   }, prd);
   prd = sequentialResult.prd;
   iterations = sequentialResult.iterations;
@@ -67896,7 +68908,8 @@ async function runSetupPhase(options) {
     getTotalCost: options.getTotalCost,
     getIterations: options.getIterations,
     getStoriesCompleted: options.getStoriesCompleted,
-    getTotalStories: options.getTotalStories
+    getTotalStories: options.getTotalStories,
+    agentGetFn: options.agentGetFn
   });
   return setupResult;
 }
@@ -67934,6 +68947,8 @@ async function run(options) {
   let totalCost = 0;
   const allStoryMetrics = [];
   const logger = getSafeLogger();
+  const registry2 = createAgentRegistry(config2);
+  const agentGetFn = registry2.getAgent.bind(registry2);
   let prd;
   const setupResult = await runSetupPhase({
     prdPath,
@@ -67951,6 +68966,7 @@ async function run(options) {
     skipPrecheck,
     headless,
     formatterMode,
+    agentGetFn,
     getTotalCost: () => totalCost,
     getIterations: () => iterations,
     getStoriesCompleted: () => storiesCompleted,
@@ -67978,7 +68994,9 @@ async function run(options) {
       formatterMode,
       headless,
       parallel,
-      runParallelExecution: _runnerDeps.runParallelExecution ?? undefined
+      runParallelExecution: _runnerDeps.runParallelExecution ?? undefined,
+      agentGetFn,
+      pidRegistry
     }, prd, pluginRegistry);
     prd = executionResult.prd;
     iterations = executionResult.iterations;
@@ -67999,6 +69017,7 @@ async function run(options) {
       hooks,
       feature,
       workdir,
+      prdPath,
       statusFile,
       logFilePath,
       runId,
@@ -68014,7 +69033,8 @@ async function run(options) {
       iterations,
       statusWriter,
       pluginRegistry,
-      eventEmitter
+      eventEmitter,
+      agentGetFn
     });
     const { durationMs } = completionResult;
     return {
@@ -75349,6 +76369,31 @@ function renderTui(props) {
 init_version();
 var program2 = new Command;
 program2.name("nax").description("AI Coding Agent Orchestrator \u2014 loops until done").version(NAX_VERSION);
+async function promptForConfirmation(question) {
+  if (!process.stdin.isTTY) {
+    return true;
+  }
+  return new Promise((resolve9) => {
+    process.stdout.write(source_default.bold(`${question} [Y/n] `));
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    const handler = (char) => {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdin.removeListener("data", handler);
+      const answer = char.toLowerCase();
+      process.stdout.write(`
+`);
+      if (answer === "n") {
+        resolve9(false);
+      } else {
+        resolve9(true);
+      }
+    };
+    process.stdin.on("data", handler);
+  });
+}
 program2.command("init").description("Initialize nax in the current project").option("-d, --dir <path>", "Project directory", process.cwd()).option("-f, --force", "Force overwrite existing files", false).action(async (options) => {
   let workdir;
   try {
@@ -75357,15 +76402,15 @@ program2.command("init").description("Initialize nax in the current project").op
     console.error(source_default.red(`Invalid directory: ${err.message}`));
     process.exit(1);
   }
-  const naxDir = join42(workdir, "nax");
+  const naxDir = join43(workdir, "nax");
   if (existsSync32(naxDir) && !options.force) {
     console.log(source_default.yellow("nax already initialized. Use --force to overwrite."));
     return;
   }
-  mkdirSync6(join42(naxDir, "features"), { recursive: true });
-  mkdirSync6(join42(naxDir, "hooks"), { recursive: true });
-  await Bun.write(join42(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
-  await Bun.write(join42(naxDir, "hooks.json"), JSON.stringify({
+  mkdirSync6(join43(naxDir, "features"), { recursive: true });
+  mkdirSync6(join43(naxDir, "hooks"), { recursive: true });
+  await Bun.write(join43(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
+  await Bun.write(join43(naxDir, "hooks.json"), JSON.stringify({
     hooks: {
       "on-start": { command: 'echo "nax started: $NAX_FEATURE"', enabled: false },
       "on-complete": { command: 'echo "nax complete: $NAX_FEATURE"', enabled: false },
@@ -75373,12 +76418,12 @@ program2.command("init").description("Initialize nax in the current project").op
       "on-error": { command: 'echo "nax error: $NAX_REASON"', enabled: false }
     }
   }, null, 2));
-  await Bun.write(join42(naxDir, ".gitignore"), `# nax temp files
+  await Bun.write(join43(naxDir, ".gitignore"), `# nax temp files
 *.tmp
 .paused.json
 .nax-verifier-verdict.json
 `);
-  await Bun.write(join42(naxDir, "context.md"), `# Project Context
+  await Bun.write(join43(naxDir, "context.md"), `# Project Context
 
 This document defines coding standards, architectural decisions, and forbidden patterns for this project.
 Run \`nax generate\` to regenerate agent config files (CLAUDE.md, AGENTS.md, .cursorrules, etc.) from this file.
@@ -75463,7 +76508,7 @@ Run \`nax generate\` to regenerate agent config files (CLAUDE.md, AGENTS.md, .cu
   console.log(source_default.dim(`
 Next: nax features create <name>`));
 });
-program2.command("run").description("Run the orchestration loop for a feature").requiredOption("-f, --feature <name>", "Feature name").option("-a, --agent <name>", "Force a specific agent").option("-m, --max-iterations <n>", "Max iterations", "20").option("--dry-run", "Show plan without executing", false).option("--no-context", "Disable context builder (skip file context in prompts)").option("--no-batch", "Disable story batching (execute all stories individually)").option("--parallel <n>", "Max parallel sessions (0=auto, omit=sequential)").option("--headless", "Force headless mode (disable TUI, use pipe mode)", false).option("--verbose", "Enable verbose logging (debug level)", false).option("--quiet", "Quiet mode (warnings and errors only)", false).option("--silent", "Silent mode (errors only)", false).option("--json", "JSON mode (raw JSONL output to stdout)", false).option("-d, --dir <path>", "Working directory", process.cwd()).option("--skip-precheck", "Skip precheck validations (advanced users only)", false).action(async (options) => {
+program2.command("run").description("Run the orchestration loop for a feature").requiredOption("-f, --feature <name>", "Feature name").option("-a, --agent <name>", "Force a specific agent").option("-m, --max-iterations <n>", "Max iterations", "20").option("--dry-run", "Show plan without executing", false).option("--no-context", "Disable context builder (skip file context in prompts)").option("--no-batch", "Disable story batching (execute all stories individually)").option("--parallel <n>", "Max parallel sessions (0=auto, omit=sequential)").option("--plan", "Run plan phase first before execution", false).option("--from <spec-path>", "Path to spec file (required when --plan is used)").option("--headless", "Force headless mode (disable TUI, use pipe mode)", false).option("--verbose", "Enable verbose logging (debug level)", false).option("--quiet", "Quiet mode (warnings and errors only)", false).option("--silent", "Silent mode (errors only)", false).option("--json", "JSON mode (raw JSONL output to stdout)", false).option("-d, --dir <path>", "Working directory", process.cwd()).option("--skip-precheck", "Skip precheck validations (advanced users only)", false).action(async (options) => {
   let workdir;
   try {
     workdir = validateDirectory(options.dir);
@@ -75471,6 +76516,14 @@ program2.command("run").description("Run the orchestration loop for a feature").
     console.error(source_default.red(`Invalid directory: ${err.message}`));
     process.exit(1);
   }
+  if (options.plan && !options.from) {
+    console.error(source_default.red("Error: --plan requires --from <spec-path>"));
+    process.exit(1);
+  }
+  if (options.from && !existsSync32(options.from)) {
+    console.error(source_default.red(`Error: File not found: ${options.from} (required with --plan)`));
+    process.exit(1);
+  }
   let logLevel = "info";
   const envLevel = process.env.NAX_LOG_LEVEL?.toLowerCase();
   if (envLevel && ["error", "warn", "info", "debug"].includes(envLevel)) {
@@ -75496,16 +76549,48 @@ program2.command("run").description("Run the orchestration loop for a feature").
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join42(naxDir, "features", options.feature);
-  const prdPath = join42(featureDir, "prd.json");
+  const featureDir = join43(naxDir, "features", options.feature);
+  const prdPath = join43(featureDir, "prd.json");
+  if (options.plan && options.from) {
+    try {
+      console.log(source_default.dim("   [Planning phase: generating PRD from spec]"));
+      const generatedPrdPath = await planCommand(workdir, config2, {
+        from: options.from,
+        feature: options.feature,
+        auto: true,
+        branch: undefined
+      });
+      const generatedPrd = await loadPRD(generatedPrdPath);
+      console.log(source_default.bold(`
+\u2500\u2500 Planning Summary \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`));
+      console.log(source_default.dim(`Feature: ${generatedPrd.feature}`));
+      console.log(source_default.dim(`Stories: ${generatedPrd.userStories.length}`));
+      console.log();
+      for (const story of generatedPrd.userStories) {
+        const complexity = story.routing?.complexity || "unknown";
+        console.log(source_default.dim(`  ${story.id}: ${story.title} [${complexity}]`));
+      }
+      console.log();
+      if (!options.headless) {
+        const confirmationResult = await promptForConfirmation("Proceed with execution?");
+        if (!confirmationResult) {
+          console.log(source_default.yellow("Execution cancelled."));
+          process.exit(0);
+        }
+      }
+    } catch (err) {
+      console.error(source_default.red(`Error during planning: ${err.message}`));
+      process.exit(1);
+    }
+  }
   if (!existsSync32(prdPath)) {
     console.error(source_default.red(`Feature "${options.feature}" not found or missing prd.json`));
     process.exit(1);
   }
-  const runsDir = join42(featureDir, "runs");
+  const runsDir = join43(featureDir, "runs");
   mkdirSync6(runsDir, { recursive: true });
   const runId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const logFilePath = join42(runsDir, `${runId}.jsonl`);
+  const logFilePath = join43(runsDir, `${runId}.jsonl`);
   const isTTY = process.stdout.isTTY ?? false;
   const headlessFlag = options.headless ?? false;
   const headlessEnv = process.env.NAX_HEADLESS === "1";
@@ -75521,7 +76606,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     config2.autoMode.defaultAgent = options.agent;
   }
   config2.execution.maxIterations = Number.parseInt(options.maxIterations, 10);
-  const globalNaxDir = join42(homedir8(), ".nax");
+  const globalNaxDir = join43(homedir8(), ".nax");
   const hooks = await loadHooksConfig(naxDir, globalNaxDir);
   const eventEmitter = new PipelineEventEmitter;
   let tuiInstance;
@@ -75544,7 +76629,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
   } else {
     console.log(source_default.dim("   [Headless mode \u2014 pipe output]"));
   }
-  const statusFilePath = join42(workdir, "nax", "status.json");
+  const statusFilePath = join43(workdir, "nax", "status.json");
   let parallel;
   if (options.parallel !== undefined) {
     parallel = Number.parseInt(options.parallel, 10);
@@ -75570,7 +76655,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     headless: useHeadless,
     skipPrecheck: options.skipPrecheck ?? false
   });
-  const latestSymlink = join42(runsDir, "latest.jsonl");
+  const latestSymlink = join43(runsDir, "latest.jsonl");
   try {
     if (existsSync32(latestSymlink)) {
       Bun.spawnSync(["rm", latestSymlink]);
@@ -75608,9 +76693,9 @@ features.command("create <name>").description("Create a new feature").option("-d
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join42(naxDir, "features", name);
+  const featureDir = join43(naxDir, "features", name);
   mkdirSync6(featureDir, { recursive: true });
-  await Bun.write(join42(featureDir, "spec.md"), `# Feature: ${name}
+  await Bun.write(join43(featureDir, "spec.md"), `# Feature: ${name}
 
 ## Overview
 
@@ -75618,7 +76703,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 
 ## Acceptance Criteria
 `);
-  await Bun.write(join42(featureDir, "plan.md"), `# Plan: ${name}
+  await Bun.write(join43(featureDir, "plan.md"), `# Plan: ${name}
 
 ## Architecture
 
@@ -75626,7 +76711,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 
 ## Dependencies
 `);
-  await Bun.write(join42(featureDir, "tasks.md"), `# Tasks: ${name}
+  await Bun.write(join43(featureDir, "tasks.md"), `# Tasks: ${name}
 
 ## US-001: [Title]
 
@@ -75635,7 +76720,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 ### Acceptance Criteria
 - [ ] Criterion 1
 `);
-  await Bun.write(join42(featureDir, "progress.txt"), `# Progress: ${name}
+  await Bun.write(join43(featureDir, "progress.txt"), `# Progress: ${name}
 
 Created: ${new Date().toISOString()}
 
@@ -75648,7 +76733,7 @@ Created: ${new Date().toISOString()}
   console.log(source_default.dim("   \u251C\u2500\u2500 tasks.md"));
   console.log(source_default.dim("   \u2514\u2500\u2500 progress.txt"));
   console.log(source_default.dim(`
-Next: Edit spec.md and tasks.md, then: nax analyze --feature ${name}`));
+Next: Edit spec.md and tasks.md, then: nax plan -f ${name} --from spec.md --auto`));
 });
 features.command("list").description("List all features").option("-d, --dir <path>", "Project directory", process.cwd()).action(async (options) => {
   let workdir;
@@ -75663,13 +76748,13 @@ features.command("list").description("List all features").option("-d, --dir <pat
     console.error(source_default.red("nax not initialized."));
     process.exit(1);
   }
-  const featuresDir = join42(naxDir, "features");
+  const featuresDir = join43(naxDir, "features");
   if (!existsSync32(featuresDir)) {
     console.log(source_default.dim("No features yet."));
     return;
   }
-  const { readdirSync: readdirSync7 } = await import("fs");
-  const entries = readdirSync7(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  const { readdirSync: readdirSync8 } = await import("fs");
+  const entries = readdirSync8(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   if (entries.length === 0) {
     console.log(source_default.dim("No features yet."));
     return;
@@ -75678,7 +76763,7 @@ features.command("list").description("List all features").option("-d, --dir <pat
 Features:
 `));
   for (const name of entries) {
-    const prdPath = join42(featuresDir, name, "prd.json");
+    const prdPath = join43(featuresDir, name, "prd.json");
     if (existsSync32(prdPath)) {
       const prd = await loadPRD(prdPath);
       const c = countStories(prd);
@@ -75689,7 +76774,13 @@ Features:
   }
   console.log();
 });
-program2.command("plan <description>").description("Interactive planning via agent plan mode").option("--from <file>", "Non-interactive mode: read from input file").option("-d, --dir <path>", "Project directory", process.cwd()).action(async (description, options) => {
+program2.command("plan [description]").description("Generate prd.json from a spec file via LLM one-shot call (replaces deprecated 'nax analyze')").requiredOption("--from <spec-path>", "Path to spec file (required)").requiredOption("-f, --feature <name>", "Feature name (required)").option("--auto", "Run in auto (one-shot LLM) mode", false).option("-b, --branch <branch>", "Override default branch name").option("-d, --dir <path>", "Project directory", process.cwd()).action(async (description, options) => {
+  if (description) {
+    console.error(source_default.red(`Error: Positional args removed in plan v2.
+
+Use: nax plan -f <feature> --from <spec>`));
+    process.exit(1);
+  }
   let workdir;
   try {
     workdir = validateDirectory(options.dir);
@@ -75704,21 +76795,26 @@ program2.command("plan <description>").description("Interactive planning via age
   }
   const config2 = await loadConfig(workdir);
   try {
-    const specPath = await planCommand(description, workdir, config2, {
-      interactive: !options.from,
-      from: options.from
+    const prdPath = await planCommand(workdir, config2, {
+      from: options.from,
+      feature: options.feature,
+      auto: options.auto,
+      branch: options.branch
     });
     console.log(source_default.green(`
-\u2705 Planning complete`));
-    console.log(source_default.dim(`   Spec: ${specPath}`));
+[OK] PRD generated`));
+    console.log(source_default.dim(`   PRD: ${prdPath}`));
     console.log(source_default.dim(`
-Next: nax analyze -f <feature-name>`));
+Next: nax run -f ${options.feature}`));
   } catch (err) {
     console.error(source_default.red(`Error: ${err.message}`));
     process.exit(1);
   }
 });
-program2.command("analyze").description("Parse spec.md into prd.json via agent decompose").requiredOption("-f, --feature <name>", "Feature name").option("-b, --branch <name>", "Branch name", "feat/<feature>").option("--from <path>", "Explicit spec path (overrides default spec.md)").option("--reclassify", "Re-classify existing prd.json without decompose", false).option("-d, --dir <path>", "Project directory", process.cwd()).action(async (options) => {
+program2.command("analyze").description("(deprecated) Parse spec.md into prd.json via agent decompose \u2014 use 'nax plan' instead").requiredOption("-f, --feature <name>", "Feature name").option("-b, --branch <name>", "Branch name", "feat/<feature>").option("--from <path>", "Explicit spec path (overrides default spec.md)").option("--reclassify", "Re-classify existing prd.json without decompose", false).option("-d, --dir <path>", "Project directory", process.cwd()).action(async (options) => {
+  const deprecationMsg = "\u26A0\uFE0F  'nax analyze' is deprecated. Use 'nax plan -f <feature> --from <spec> --auto' instead.";
+  process.stderr.write(`${source_default.yellow(deprecationMsg)}
+`);
   let workdir;
   try {
     workdir = validateDirectory(options.dir);
@@ -75731,7 +76827,7 @@ program2.command("analyze").description("Parse spec.md into prd.json via agent d
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join42(naxDir, "features", options.feature);
+  const featureDir = join43(naxDir, "features", options.feature);
   if (!existsSync32(featureDir)) {
     console.error(source_default.red(`Feature "${options.feature}" not found.`));
     process.exit(1);
@@ -75747,7 +76843,7 @@ program2.command("analyze").description("Parse spec.md into prd.json via agent d
       specPath: options.from,
       reclassify: options.reclassify
     });
-    const prdPath = join42(featureDir, "prd.json");
+    const prdPath = join43(featureDir, "prd.json");
     await Bun.write(prdPath, JSON.stringify(prd, null, 2));
     const c = countStories(prd);
     console.log(source_default.green(`