@nathapp/nax 0.40.0 → 0.41.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({
@@ -17708,7 +17716,9 @@ var init_schemas3 = __esm(() => {
     testPath: exports_external.string().min(1, "acceptance.testPath must be non-empty"),
     model: exports_external.enum(["fast", "balanced", "powerful"]).default("fast"),
     refinement: exports_external.boolean().default(true),
-    redGate: exports_external.boolean().default(true)
+    redGate: exports_external.boolean().default(true),
+    testStrategy: exports_external.enum(["unit", "component", "cli", "e2e", "snapshot"]).optional(),
+    testFramework: exports_external.string().min(1, "acceptance.testFramework must be non-empty").optional()
   });
   TestCoverageConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
@@ -17792,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
   });
@@ -17827,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()
@@ -18362,14 +18377,16 @@ __export(exports_refinement, {
   buildRefinementPrompt: () => buildRefinementPrompt,
   _refineDeps: () => _refineDeps
 });
-function buildRefinementPrompt(criteria, codebaseContext) {
+function buildRefinementPrompt(criteria, codebaseContext, options) {
   const criteriaList = criteria.map((c, i) => `${i + 1}. ${c}`).join(`
 `);
+  const strategySection = buildStrategySection(options);
+  const refinedExample = buildRefinedExample(options?.testStrategy);
   return `You are an acceptance criteria refinement assistant. Your task is to convert raw acceptance criteria into concrete, machine-verifiable assertions.
 
 CODEBASE CONTEXT:
 ${codebaseContext}
-
+${strategySection}
 ACCEPTANCE CRITERIA TO REFINE:
 ${criteriaList}
 
@@ -18384,11 +18401,53 @@ Respond with ONLY a JSON array (no markdown code fences):
 
 Rules:
 - "original" must match the input criterion text exactly
-- "refined" must be a concrete assertion (e.g., "Function returns array of length N", "HTTP status 200 returned")
+- "refined" must be a concrete assertion (e.g., ${refinedExample})
 - "testable" is false only if the criterion cannot be automatically verified (e.g., "UX feels responsive", "design looks good")
 - "storyId" leave as empty string \u2014 it will be assigned by the caller
 - Respond with ONLY the JSON array`;
 }
+function buildStrategySection(options) {
+  if (!options?.testStrategy) {
+    return "";
+  }
+  const framework = options.testFramework ? ` Use ${options.testFramework} testing library syntax.` : "";
+  switch (options.testStrategy) {
+    case "component":
+      return `
+TEST STRATEGY: component
+Focus assertions on rendered output visible on screen \u2014 text content, visible elements, and screen state.
+Assert what the user sees rendered in the component, not what internal functions produce.${framework}
+`;
+    case "cli":
+      return `
+TEST STRATEGY: cli
+Focus assertions on stdout and stderr text output from the CLI command.
+Assert about terminal output content, exit codes, and standard output/standard error streams.${framework}
+`;
+    case "e2e":
+      return `
+TEST STRATEGY: e2e
+Focus assertions on HTTP response content \u2014 status codes, response bodies, and endpoint behavior.
+Assert about HTTP responses, status codes, and API endpoint output.${framework}
+`;
+    default:
+      return framework ? `
+TEST FRAMEWORK: ${options.testFramework}
+` : "";
+  }
+}
+function buildRefinedExample(testStrategy) {
+  switch (testStrategy) {
+    case "component":
+      return '"Text content visible on screen matches expected", "Rendered output contains expected element"';
+    case "cli":
+      return '"stdout contains expected text", "stderr is empty on success", "exit code is 0"';
+    case "e2e":
+      return '"HTTP status 200 returned", "Response body contains expected field", "Endpoint returns JSON"';
+    default:
+      return '"Array of length N returned", "HTTP status 200 returned"';
+  }
+}
 function parseRefinementResponse(response, criteria) {
   if (!response || !response.trim()) {
     return fallbackCriteria(criteria);
@@ -18412,7 +18471,7 @@ async function refineAcceptanceCriteria(criteria, context) {
   if (criteria.length === 0) {
     return [];
   }
-  const { storyId, codebaseContext, config: config2 } = context;
+  const { storyId, codebaseContext, config: config2, testStrategy, testFramework } = context;
   const logger = getLogger();
   const modelTier = config2.acceptance?.model ?? "fast";
   const modelEntry = config2.models[modelTier] ?? config2.models.fast;
@@ -18420,7 +18479,7 @@ async function refineAcceptanceCriteria(criteria, context) {
     throw new Error(`[refinement] config.models.${modelTier} not configured`);
   }
   const modelDef = resolveModel(modelEntry);
-  const prompt = buildRefinementPrompt(criteria, codebaseContext);
+  const prompt = buildRefinementPrompt(criteria, codebaseContext, { testStrategy, testFramework });
   let response;
   try {
     response = await _refineDeps.adapter.complete(prompt, {
@@ -18483,6 +18542,7 @@ async function generateFromPRD(_stories, refinedCriteria, options) {
   }
   const criteriaList = refinedCriteria.map((c, i) => `AC-${i + 1}: ${c.refined}`).join(`
 `);
+  const strategyInstructions = buildStrategyInstructions(options.testStrategy, options.testFramework);
   const prompt = `You are a test engineer. Generate acceptance tests for the "${options.featureName}" feature based on the refined acceptance criteria below.
 
 CODEBASE CONTEXT:
@@ -18491,7 +18551,7 @@ ${options.codebaseContext}
 ACCEPTANCE CRITERIA (refined):
 ${criteriaList}
 
-Generate a complete acceptance.test.ts file using bun:test framework. Each AC maps to exactly one test named "AC-N: <description>".
+${strategyInstructions}Generate a complete acceptance.test.ts file using bun:test framework. Each AC maps to exactly one test named "AC-N: <description>".
 
 Use this structure:
 
@@ -18518,6 +18578,40 @@ Respond with ONLY the TypeScript test code (no markdown code fences, no explanat
   await _generatorPRDDeps.writeFile(join2(options.workdir, "acceptance-refined.json"), refinedJsonContent);
   return { testCode, criteria };
 }
+function buildStrategyInstructions(strategy, framework) {
+  switch (strategy) {
+    case "component": {
+      const fw = framework ?? "ink-testing-library";
+      if (fw === "react") {
+        return `TEST STRATEGY: component (react)
+Import render and screen from @testing-library/react. Render the component and use screen.getByText to assert on output.
+
+`;
+      }
+      return `TEST STRATEGY: component (ink-testing-library)
+Import render from ink-testing-library. Render the component and use lastFrame() to assert on output.
+
+`;
+    }
+    case "cli":
+      return `TEST STRATEGY: cli
+Use Bun.spawn to run the binary. Read stdout and assert on the text output.
+
+`;
+    case "e2e":
+      return `TEST STRATEGY: e2e
+Use fetch() against http://localhost to call the running service. Assert on response body using response.text() or response.json().
+
+`;
+    case "snapshot":
+      return `TEST STRATEGY: snapshot
+Render the component and use toMatchSnapshot() to capture and compare snapshots.
+
+`;
+    default:
+      return "";
+  }
+}
 function parseAcceptanceCriteria(specContent) {
   const criteria = [];
   const lines = specContent.split(`
@@ -18595,29 +18689,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
@@ -18720,7 +18795,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();
@@ -18735,34 +18810,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)}`,
@@ -18829,6 +18879,679 @@ 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) {
+        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) {
+    if (options.interactive) {
+      throw new Error("[acp-adapter] plan() interactive mode is not yet supported via ACP");
+    }
+    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";
@@ -18859,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,
@@ -18893,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 = {
@@ -18937,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,
@@ -18968,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 = {
@@ -19037,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,
@@ -19068,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 = {
@@ -19149,6 +19872,7 @@ __export(exports_registry, {
   getInstalledAgents: () => getInstalledAgents,
   getAllAgentNames: () => getAllAgentNames,
   getAgent: () => getAgent,
+  createAgentRegistry: () => createAgentRegistry,
   checkAgentHealth: () => checkAgentHealth,
   ALL_AGENTS: () => ALL_AGENTS
 });
@@ -19172,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();
@@ -19335,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" };
@@ -19351,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 };
       }
@@ -19701,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;
@@ -19759,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);
@@ -21034,7 +21807,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.40.0",
+    version: "0.41.0",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -21098,8 +21871,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("5b23ab2"))
-        return "5b23ab2";
+      if (/^[0-9a-f]{6,10}$/.test("0db1c5f"))
+        return "0db1c5f";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -22846,7 +23619,9 @@ ${stderr}` };
           refinedCriteria = await _acceptanceSetupDeps.refine(allCriteria, {
             storyId: ctx.prd.userStories[0]?.id ?? "US-001",
             codebaseContext: "",
-            config: ctx.config
+            config: ctx.config,
+            testStrategy: ctx.config.acceptance.testStrategy,
+            testFramework: ctx.config.acceptance.testFramework
           });
         } else {
           refinedCriteria = allCriteria.map((c) => ({
@@ -22863,7 +23638,9 @@ ${stderr}` };
           codebaseContext: "",
           modelTier: ctx.config.acceptance.model ?? "fast",
           modelDef: resolveModel(ctx.config.models[ctx.config.acceptance.model ?? "fast"]),
-          config: ctx.config
+          config: ctx.config,
+          testStrategy: ctx.config.acceptance.testStrategy,
+          testFramework: ctx.config.acceptance.testFramework
         });
         await _acceptanceSetupDeps.writeFile(testPath, result.testCode);
       }
@@ -23375,10 +24152,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}
 `;
@@ -23462,7 +24239,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) {
@@ -23484,7 +24261,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);
@@ -23494,7 +24271,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);
@@ -24520,6 +25297,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) {
@@ -24570,6 +25356,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();
@@ -24647,14 +25453,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;
@@ -25042,13 +25848,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) {
@@ -25260,7 +26066,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;
@@ -25276,7 +26082,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)", {
@@ -25304,7 +26110,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,
@@ -25326,7 +26132,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);
@@ -25723,13 +26532,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;
@@ -25908,7 +26717,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) {
@@ -25930,7 +26739,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);
@@ -26278,6 +27090,7 @@ async function runThreeSessionTdd(options) {
     config: config2,
     workdir,
     modelTier,
+    featureName,
     contextMarkdown,
     constitution,
     dryRun = false,
@@ -26341,7 +27154,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) {
@@ -26403,7 +27216,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;
@@ -26419,10 +27232,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);
@@ -26581,7 +27394,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",
@@ -26601,6 +27414,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,
@@ -26670,7 +27484,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_PATTERNS2 = [/\?/, /\bwhich\b/i, /\bshould i\b/i, /\bunclear\b/i, /\bplease clarify\b/i];
+          return {
+            detectQuestion: async (text) => QUESTION_PATTERNS2.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);
@@ -27886,16 +28731,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);
@@ -27916,7 +28765,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;
@@ -27985,7 +28834,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) {
@@ -28000,7 +28849,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) {
@@ -29488,19 +30337,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;
@@ -29941,7 +30790,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;
@@ -30087,7 +30937,6 @@ async function runAcceptanceLoop(ctx) {
 }
 var init_acceptance_loop = __esm(() => {
   init_acceptance();
-  init_agents();
   init_schema();
   init_hooks();
   init_logger2();
@@ -30537,12 +31386,12 @@ __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], {
@@ -30567,9 +31416,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) {
@@ -30577,9 +31426,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) {
@@ -30590,7 +31439,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"], {
@@ -30980,7 +31829,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;
@@ -31057,7 +31906,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);
@@ -31106,7 +31955,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)
           });
         }
       }
@@ -31565,12 +32414,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 () => {
@@ -31730,12 +32579,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 {
@@ -31745,8 +32594,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));
@@ -32414,6 +33263,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);
@@ -32740,7 +33591,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;
@@ -32808,7 +33659,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) {
@@ -33012,6 +33863,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) {
@@ -33038,11 +33890,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
@@ -33070,9 +33923,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);
@@ -33085,7 +33943,6 @@ async function initializeRun(ctx) {
   return { prd, storyCounts: counts };
 }
 var init_run_initialization = __esm(() => {
-  init_agents();
   init_errors3();
   init_logger2();
   init_prd();
@@ -33194,7 +34051,8 @@ async function setupRun(options) {
       config: config2,
       prdPath,
       workdir,
-      dryRun
+      dryRun,
+      agentGetFn: options.agentGetFn
     });
     prd = initResult.prd;
     const counts = initResult.storyCounts;
@@ -64124,7 +64982,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);
@@ -64146,14 +65004,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 { 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 = {};
@@ -64193,7 +65051,7 @@ async function generateFileTree(dir, maxDepth, currentDepth = 0, prefix = "") {
     });
     for (let i = 0;i < dirEntries.length; i++) {
       const entry = dirEntries[i];
-      const fullPath = join3(dir, entry);
+      const fullPath = join4(dir, entry);
       const isLast = i === dirEntries.length - 1;
       const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
       const childPrefix = isLast ? "    " : "\u2502   ";
@@ -64225,16 +65083,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");
   }
@@ -64252,7 +65110,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();
@@ -64382,7 +65240,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.`);
   }
@@ -64483,11 +65341,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();
@@ -64604,7 +65462,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,
@@ -64617,9 +65475,25 @@ async function generateAcceptanceTestsForFeature(specContent, featureName, featu
 // src/cli/plan.ts
 init_claude();
 import { existsSync as existsSync9 } from "fs";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
+import { createInterface } from "readline";
 init_schema();
 init_logger2();
+var QUESTION_PATTERNS = [/\?[\s]*$/, /\bwhich\b/i, /\bshould i\b/i, /\bdo you want\b/i, /\bwould you like\b/i];
+async function detectQuestion(text) {
+  return QUESTION_PATTERNS.some((p) => p.test(text.trim()));
+}
+async function askHuman(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve6) => {
+    rl.question(`
+[Agent asks]: ${question}
+Your answer: `, (answer) => {
+      rl.close();
+      resolve6(answer.trim());
+    });
+  });
+}
 var SPEC_TEMPLATE = `# Feature: [title]
 
 ## Problem
@@ -64640,8 +65514,8 @@ 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);
+  const ngentDir = join10(workdir, "nax");
+  const outputPath = join10(ngentDir, config2.plan.outputPath);
   if (!existsSync9(ngentDir)) {
     throw new Error(`nax directory not found. Run 'nax init' first in ${workdir}`);
   }
@@ -64661,7 +65535,8 @@ async function planCommand(prompt, workdir, config2, options = {}) {
     inputFile: options.from,
     modelTier,
     modelDef,
-    config: config2
+    config: config2,
+    interactionBridge: interactive ? { detectQuestion, onQuestionDetected: askHuman } : undefined
   };
   const adapter = new ClaudeCodeAdapter;
   logger.info("cli", interactive ? "Starting interactive planning session..." : `Reading from ${options.from}...`, {
@@ -64879,13 +65754,13 @@ 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 { 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 { join as join11, resolve as resolve6 } from "path";
 function resolveProject(options = {}) {
   const { dir, feature } = options;
   let projectRoot;
@@ -64893,12 +65768,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 });
@@ -64906,22 +65781,22 @@ 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 availableMsg = availableFeatures.length > 0 ? `
@@ -64948,12 +65823,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;
     }
@@ -64975,7 +65850,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;
   }
@@ -64987,7 +65862,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;
   }
@@ -64999,7 +65874,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 = {
@@ -65033,7 +65908,7 @@ 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();
     if (runs.length > 0) {
@@ -65044,7 +65919,7 @@ 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;
@@ -65085,7 +65960,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`;
@@ -65111,7 +65986,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);
@@ -65226,7 +66101,7 @@ async function displayFeatureStatus(options = {}) {
 init_errors3();
 init_logger2();
 import { existsSync as existsSync12, readdirSync as readdirSync3 } from "fs";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 async function parseRunLog(logPath) {
   const logger = getLogger();
   try {
@@ -65242,7 +66117,7 @@ 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;
@@ -65254,7 +66129,7 @@ async function runsListCommand(options) {
   }
   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");
@@ -65280,7 +66155,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 });
@@ -65319,7 +66194,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();
@@ -65355,7 +66230,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(),
@@ -65374,7 +66249,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,
@@ -65390,7 +66265,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}---
@@ -65404,12 +66279,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`);
   }
@@ -65469,10 +66344,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}---
 
@@ -65536,7 +66411,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" },
@@ -65560,9 +66435,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.`);
@@ -65570,7 +66445,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);
@@ -65586,7 +66461,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: {
@@ -65753,7 +66628,7 @@ init_config();
 init_logger2();
 init_prd();
 import { existsSync as existsSync17, readdirSync as readdirSync4 } from "fs";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 
 // src/cli/diagnose-analysis.ts
 function detectFailurePattern(story, prd, status) {
@@ -65952,7 +66827,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 {
@@ -65980,7 +66855,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 {
@@ -65998,8 +66873,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)
@@ -66010,7 +66885,7 @@ 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);
@@ -66020,8 +66895,8 @@ async function diagnoseCommand(options = {}) {
       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);
@@ -66064,16 +66939,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",
@@ -66103,7 +66978,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 {
@@ -66120,7 +66995,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 {
@@ -66144,7 +67019,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 {
@@ -66160,8 +67035,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 {
@@ -66180,7 +67055,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 {
@@ -66193,7 +67068,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 {
@@ -66205,9 +67080,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 {
@@ -66215,7 +67090,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;
@@ -66436,7 +67311,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);
@@ -66453,7 +67328,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);
@@ -66471,8 +67346,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)) {
@@ -66548,7 +67423,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 = {
@@ -66754,7 +67629,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;
@@ -66776,7 +67651,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);
 }
 
@@ -66836,7 +67711,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
@@ -67016,21 +67891,21 @@ 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 { join as join32 } from "path";
 
 // src/commands/logs-reader.ts
 import { existsSync as existsSync23, readdirSync as readdirSync5 } from "fs";
 import { readdir as readdir3 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 var _deps5 = {
-  getRunsDir: () => process.env.NAX_RUNS_DIR ?? join30(homedir3(), ".nax", "runs")
+  getRunsDir: () => process.env.NAX_RUNS_DIR ?? join31(homedir3(), ".nax", "runs")
 };
 async function resolveRunFileFromRegistry(runId) {
   const runsDir = _deps5.getRunsDir();
@@ -67042,7 +67917,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)) {
@@ -67064,14 +67939,14 @@ async function resolveRunFileFromRegistry(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();
   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);
@@ -67156,7 +68031,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}` : "?/?";
@@ -67281,7 +68156,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();
@@ -67289,8 +68164,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}`);
   }
@@ -67315,7 +68190,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,
@@ -67331,9 +68206,9 @@ 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);
@@ -67357,10 +68232,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")
+  getRunsDir: () => join35(homedir4(), ".nax", "runs")
 };
 function formatDuration3(ms) {
   if (ms <= 0)
@@ -67412,7 +68287,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();
@@ -67489,7 +68364,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);
@@ -67504,7 +68379,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) {
@@ -67543,6 +68418,7 @@ async function unlockCommand(options) {
 init_config();
 
 // src/execution/runner.ts
+init_registry();
 init_hooks();
 init_logger2();
 init_prd();
@@ -67552,6 +68428,7 @@ init_crash_recovery();
 init_hooks();
 init_logger2();
 init_prd();
+init_git();
 init_crash_recovery();
 init_story_context();
 async function runCompletionPhase(options) {
@@ -67561,7 +68438,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,
@@ -67572,7 +68449,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,
@@ -67623,6 +68501,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
@@ -67773,7 +68652,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;
@@ -67811,7 +68692,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;
 }
@@ -67849,6 +68731,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,
@@ -67866,6 +68750,7 @@ async function run(options) {
     skipPrecheck,
     headless,
     formatterMode,
+    agentGetFn,
     getTotalCost: () => totalCost,
     getIterations: () => iterations,
     getStoriesCompleted: () => storiesCompleted,
@@ -67893,7 +68778,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;
@@ -67914,6 +68801,7 @@ async function run(options) {
       hooks,
       feature,
       workdir,
+      prdPath,
       statusFile,
       logFilePath,
       runId,
@@ -67929,7 +68817,8 @@ async function run(options) {
       iterations,
       statusWriter,
       pluginRegistry,
-      eventEmitter
+      eventEmitter,
+      agentGetFn
     });
     const { durationMs } = completionResult;
     return {
@@ -75272,15 +76161,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 },
@@ -75288,12 +76177,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.
@@ -75411,16 +76300,16 @@ 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 (!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";
@@ -75436,7 +76325,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;
@@ -75459,7 +76348,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);
@@ -75485,7 +76374,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]);
@@ -75523,9 +76412,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
 
@@ -75533,7 +76422,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
 
@@ -75541,7 +76430,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]
 
@@ -75550,7 +76439,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()}
 
@@ -75578,7 +76467,7 @@ 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;
@@ -75593,7 +76482,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);
@@ -75646,7 +76535,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);
@@ -75662,7 +76551,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(`