@nathapp/nax 0.56.1 → 0.56.3

package/dist/nax.js

@@ -3663,7 +3663,18 @@ var init_env = __esm(() => {
   init_logger2();
   ESSENTIAL_VARS = ["PATH", "TMPDIR", "NODE_ENV", "USER", "LOGNAME"];
   API_KEY_VARS = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GEMINI_API_KEY", "GOOGLE_API_KEY", "CLAUDE_API_KEY"];
-  ALLOWED_PREFIXES = ["CLAUDE_", "NAX_", "CLAW_", "TURBO_", "ACPX_", "CODEX_", "GEMINI_", "ANTHROPIC_"];
+  ALLOWED_PREFIXES = [
+    "CLAUDE_",
+    "NAX_",
+    "CLAW_",
+    "TURBO_",
+    "ACPX_",
+    "CODEX_",
+    "GEMINI_",
+    "ANTHROPIC_",
+    "OPENCODE_",
+    "MINIMAX_"
+  ];
 });
 
 // src/agents/cost/pricing.ts
@@ -22056,7 +22067,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.56.1",
+    version: "0.56.3",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -22135,8 +22146,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("bfe07f9f"))
-        return "bfe07f9f";
+      if (/^[0-9a-f]{6,10}$/.test("52dcc35f"))
+        return "52dcc35f";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -22389,6 +22400,18 @@ var DEFAULT_FALLBACK_AGENT = "claude";
 var init_resolvers = () => {};
 
 // src/debate/session.ts
+function resolveDebaterModel(debater, config2) {
+  const tier = debater.model ?? "fast";
+  if (!config2?.models)
+    return debater.model;
+  try {
+    const defaultAgent = config2.autoMode?.defaultAgent ?? debater.agent;
+    const modelDef = resolveModelForAgent(config2.models, debater.agent, tier, defaultAgent);
+    return modelDef.model;
+  } catch {
+    return debater.model;
+  }
+}
 function buildFailedResult(storyId, stage, stageConfig, totalCostUsd = 0) {
   return {
     storyId,
@@ -22411,10 +22434,12 @@ class DebateSession {
   storyId;
   stage;
   stageConfig;
+  config;
   constructor(opts) {
     this.storyId = opts.storyId;
     this.stage = opts.stage;
     this.stageConfig = opts.stageConfig;
+    this.config = opts.config;
   }
   async run(prompt) {
     const sessionMode = this.stageConfig.sessionMode ?? "one-shot";
@@ -22437,11 +22462,17 @@ class DebateSession {
       }
       resolved.push({ debater, adapter });
     }
+    logger?.info("debate", "debate:start", {
+      storyId: this.storyId,
+      stage: this.stage,
+      debaters: resolved.map((r) => r.debater.agent)
+    });
     const sessions = [];
     try {
       for (let i = 0;i < resolved.length; i++) {
         const { debater, adapter } = resolved[i];
-        const cmdStr = `acpx --model ${debater.model} ${debater.agent}`;
+        const resolvedModel = resolveDebaterModel(debater, this.config);
+        const cmdStr = resolvedModel ? `acpx --model ${resolvedModel} ${debater.agent}` : `acpx ${debater.agent}`;
         const client = _debateSessionDeps.createSpawnAcpClient(cmdStr);
         const sessionName = `nax-debate-${this.storyId}-${i}`;
         try {
@@ -22457,9 +22488,19 @@ class DebateSession {
       }
       if (sessions.length < 2) {
         if (sessions.length === 1) {
+          logger?.warn("debate", "debate:fallback", {
+            storyId: this.storyId,
+            stage: this.stage,
+            reason: "only 1 session created"
+          });
           const solo = sessions[0];
           const response = await solo.session.prompt(prompt);
           const output = extractSessionOutput(response);
+          logger?.info("debate", "debate:result", {
+            storyId: this.storyId,
+            stage: this.stage,
+            outcome: "passed"
+          });
           return {
             storyId: this.storyId,
             stage: this.stage,
@@ -22471,6 +22512,11 @@ class DebateSession {
             totalCostUsd
           };
         }
+        logger?.warn("debate", "debate:fallback", {
+          storyId: this.storyId,
+          stage: this.stage,
+          reason: "no sessions created"
+        });
         return buildFailedResult(this.storyId, this.stage, config2, totalCostUsd);
       }
       const proposalSettled = await Promise.allSettled(sessions.map(({ session }) => session.prompt(prompt)));
@@ -22486,8 +22532,22 @@ class DebateSession {
         }
       }
       if (successfulSessions.length < 2) {
+        logger?.warn("debate", "debate:fallback", {
+          storyId: this.storyId,
+          stage: this.stage,
+          reason: "fewer than 2 proposal rounds succeeded"
+        });
         return buildFailedResult(this.storyId, this.stage, config2, totalCostUsd);
       }
+      for (let i = 0;i < successfulSessions.length; i++) {
+        const s = successfulSessions[i];
+        logger?.info("debate", "debate:proposal", {
+          storyId: this.storyId,
+          stage: this.stage,
+          debaterIndex: i,
+          agent: s.entry.debater.agent
+        });
+      }
       let critiqueOutputs = [];
       if (config2.rounds > 1) {
         const proposalOutputs2 = successfulSessions.map((s) => s.output);
@@ -22506,6 +22566,11 @@ class DebateSession {
         debater: s.entry.debater,
         output: s.output
       }));
+      logger?.info("debate", "debate:result", {
+        storyId: this.storyId,
+        stage: this.stage,
+        outcome
+      });
       return {
         storyId: this.storyId,
         stage: this.stage,
@@ -22534,16 +22599,40 @@ class DebateSession {
       }
       resolved.push({ debater, adapter });
     }
-    const proposalSettled = await Promise.allSettled(resolved.map(({ debater, adapter }) => adapter.complete(prompt, { model: debater.model }).then((output) => ({ debater, adapter, output, cost: 0 }))));
+    logger?.info("debate", "debate:start", {
+      storyId: this.storyId,
+      stage: this.stage,
+      debaters: resolved.map((r) => r.debater.agent)
+    });
+    const proposalSettled = await Promise.allSettled(resolved.map(({ debater, adapter }) => adapter.complete(prompt, { model: resolveDebaterModel(debater, this.config) }).then((output) => ({ debater, adapter, output, cost: 0 }))));
     const successful = proposalSettled.filter((r) => r.status === "fulfilled").map((r) => r.value);
     for (const r of proposalSettled) {
       if (r.status === "fulfilled") {
         totalCostUsd += r.value.cost;
       }
     }
+    for (let i = 0;i < successful.length; i++) {
+      logger?.info("debate", "debate:proposal", {
+        storyId: this.storyId,
+        stage: this.stage,
+        debaterIndex: i,
+        agent: successful[i].debater.agent,
+        model: resolveDebaterModel(successful[i].debater, this.config)
+      });
+    }
     if (successful.length < 2) {
       if (successful.length === 1) {
+        logger?.warn("debate", "debate:fallback", {
+          storyId: this.storyId,
+          stage: this.stage,
+          reason: "only 1 debater succeeded"
+        });
         const solo = successful[0];
+        logger?.info("debate", "debate:result", {
+          storyId: this.storyId,
+          stage: this.stage,
+          outcome: "passed"
+        });
         return {
           storyId: this.storyId,
           stage: this.stage,
@@ -22557,8 +22646,20 @@ class DebateSession {
       }
       if (resolved.length > 0) {
         const { adapter: fallbackAdapter, debater: fallbackDebater } = resolved[0];
+        logger?.warn("debate", "debate:fallback", {
+          storyId: this.storyId,
+          stage: this.stage,
+          reason: "all debaters failed \u2014 retrying with first adapter"
+        });
         try {
-          const fallbackOutput = await fallbackAdapter.complete(prompt, { model: fallbackDebater.model });
+          const fallbackOutput = await fallbackAdapter.complete(prompt, {
+            model: resolveDebaterModel(fallbackDebater, this.config)
+          });
+          logger?.info("debate", "debate:result", {
+            storyId: this.storyId,
+            stage: this.stage,
+            outcome: "passed"
+          });
           return {
             storyId: this.storyId,
             stage: this.stage,
@@ -22577,7 +22678,7 @@ class DebateSession {
     if (config2.rounds > 1) {
       const proposalOutputs2 = successful.map((p) => p.output);
       const critiqueSettled = await Promise.allSettled(successful.map(({ debater, adapter }, i) => adapter.complete(buildCritiquePrompt(prompt, proposalOutputs2, i), {
-        model: debater.model
+        model: resolveDebaterModel(debater, this.config)
       })));
       for (const r of critiqueSettled) {
         if (r.status === "fulfilled") {
@@ -22593,6 +22694,11 @@ class DebateSession {
       debater: p.debater,
       output: p.output
     }));
+    logger?.info("debate", "debate:result", {
+      storyId: this.storyId,
+      stage: this.stage,
+      outcome
+    });
     return {
       storyId: this.storyId,
       stage: this.stage,
@@ -22604,7 +22710,7 @@ class DebateSession {
       totalCostUsd
     };
   }
-  async resolve(proposalOutputs, critiqueOutputs, successful) {
+  async resolve(proposalOutputs, critiqueOutputs, _successful) {
     const resolverConfig = this.stageConfig.resolver;
     if (resolverConfig.type === "majority-fail-closed" || resolverConfig.type === "majority-fail-open") {
       return majorityResolver(proposalOutputs, resolverConfig.type === "majority-fail-open");
@@ -22631,6 +22737,7 @@ var RESOLVER_FALLBACK_AGENT = "synthesis", _debateSessionDeps;
 var init_session = __esm(() => {
   init_spawn_client();
   init_registry();
+  init_config();
   init_logger2();
   init_resolvers();
   _debateSessionDeps = {
@@ -26276,7 +26383,8 @@ async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, mo
     const debateSession = _semanticDeps.createDebateSession({
       storyId: story.id,
       stage: "review",
-      stageConfig: reviewStageConfig
+      stageConfig: reviewStageConfig,
+      config: naxConfig
     });
     const debateResult = await debateSession.run(prompt);
     let passCount = 0;
@@ -27030,17 +27138,15 @@ var init_autofix = __esm(() => {
 });
 
 // src/execution/progress.ts
-import { mkdirSync as mkdirSync2 } from "fs";
+import { appendFile as appendFile2, mkdir } from "fs/promises";
 import { join as join18 } from "path";
 async function appendProgress(featureDir, storyId, status, message) {
-  mkdirSync2(featureDir, { recursive: true });
+  await mkdir(featureDir, { recursive: true });
   const progressPath = join18(featureDir, "progress.txt");
   const timestamp = new Date().toISOString();
   const entry = `[${timestamp}] ${storyId} \u2014 ${status.toUpperCase()} \u2014 ${message}
 `;
-  const file3 = Bun.file(progressPath);
-  const existing = await file3.exists() ? await file3.text() : "";
-  await Bun.write(progressPath, existing + entry);
+  await appendFile2(progressPath, entry);
 }
 var init_progress = () => {};
 
@@ -32384,7 +32490,7 @@ __export(exports_init_context, {
   _initContextDeps: () => _initContextDeps
 });
 import { existsSync as existsSync24 } from "fs";
-import { mkdir } from "fs/promises";
+import { mkdir as mkdir2 } from "fs/promises";
 import { basename as basename3, join as join30 } from "path";
 async function findFiles(dir, maxFiles = 200) {
   try {
@@ -32628,7 +32734,7 @@ async function initPackage(repoRoot, packagePath, force = false) {
     return;
   }
   if (!existsSync24(naxDir)) {
-    await mkdir(naxDir, { recursive: true });
+    await mkdir2(naxDir, { recursive: true });
   }
   const content = generatePackageContextTemplate(packagePath);
   await Bun.write(contextPath, content);
@@ -32643,7 +32749,7 @@ async function initContext(projectRoot, options = {}) {
     return;
   }
   if (!existsSync24(naxDir)) {
-    await mkdir(naxDir, { recursive: true });
+    await mkdir2(naxDir, { recursive: true });
   }
   const scan = await scanProject(projectRoot);
   let content;
@@ -34346,7 +34452,7 @@ var init_headless_formatter = __esm(() => {
 });
 
 // src/pipeline/subscribers/events-writer.ts
-import { appendFile as appendFile2, mkdir as mkdir2 } from "fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir3 } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import { basename as basename6, join as join47 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
@@ -34359,10 +34465,10 @@ function wireEventsWriter(bus, feature, runId, workdir) {
     return (async () => {
       try {
         if (!dirReady) {
-          await mkdir2(eventsDir, { recursive: true });
+          await mkdir3(eventsDir, { recursive: true });
           dirReady = true;
         }
-        await appendFile2(eventsFile, `${JSON.stringify(line)}
+        await appendFile3(eventsFile, `${JSON.stringify(line)}
 `);
       } catch (err) {
         logger?.warn("events-writer", "Failed to write event line (non-fatal)", {
@@ -34532,7 +34638,7 @@ var init_interaction2 = __esm(() => {
 });
 
 // src/pipeline/subscribers/registry.ts
-import { mkdir as mkdir3, writeFile } from "fs/promises";
+import { mkdir as mkdir4, writeFile } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import { basename as basename7, join as join48 } from "path";
 function wireRegistry(bus, feature, runId, workdir) {
@@ -34543,7 +34649,7 @@ function wireRegistry(bus, feature, runId, workdir) {
   const unsub = bus.on("run:started", (_ev) => {
     return (async () => {
       try {
-        await mkdir3(runDir, { recursive: true });
+        await mkdir4(runDir, { recursive: true });
         const meta3 = {
           runId,
           project,
@@ -35495,7 +35601,7 @@ __export(exports_manager, {
   WorktreeManager: () => WorktreeManager
 });
 import { existsSync as existsSync32, symlinkSync } from "fs";
-import { mkdir as mkdir4 } from "fs/promises";
+import { mkdir as mkdir5 } from "fs/promises";
 import { join as join50 } from "path";
 
 class WorktreeManager {
@@ -35504,7 +35610,7 @@ class WorktreeManager {
     const infoDir = join50(projectRoot, ".git", "info");
     const excludePath = join50(infoDir, "exclude");
     try {
-      await mkdir4(infoDir, { recursive: true });
+      await mkdir5(infoDir, { recursive: true });
       let existing = "";
       if (existsSync32(excludePath)) {
         existing = await Bun.file(excludePath).text();
@@ -36685,6 +36791,7 @@ class StatusWriter {
   _prd = null;
   _currentStory = null;
   _consecutiveWriteFailures = 0;
+  _mutex = Promise.resolve();
   constructor(statusFile, config2, ctx) {
     this.statusFile = statusFile;
     this.costLimit = config2.execution.costLimit === Number.POSITIVE_INFINITY ? null : config2.execution.costLimit;
@@ -36720,6 +36827,11 @@ class StatusWriter {
   async update(totalCost, iterations, overrides = {}) {
     if (!this._prd)
       return;
+    const write = this._doUpdate(totalCost, iterations, overrides);
+    this._mutex = this._mutex.then(() => write).catch(() => write);
+    return this._mutex;
+  }
+  async _doUpdate(totalCost, iterations, overrides) {
     const safeLogger = getSafeLogger();
     try {
       const base = this.getSnapshot(totalCost, iterations);
@@ -36744,20 +36856,23 @@ class StatusWriter {
       return;
     const safeLogger = getSafeLogger();
     const featureStatusPath = join52(featureDir, "status.json");
-    try {
-      const base = this.getSnapshot(totalCost, iterations);
-      if (!base) {
-        throw new Error("Failed to get snapshot");
+    const write = async () => {
+      try {
+        const base = this.getSnapshot(totalCost, iterations);
+        if (!base)
+          throw new Error("Failed to get snapshot");
+        const state = { ...base, ...overrides };
+        await writeStatusFile(featureStatusPath, buildStatusSnapshot(state));
+        safeLogger?.debug("status-file", "Feature status written", { path: featureStatusPath });
+      } catch (err) {
+        safeLogger?.warn("status-file", "Failed to write feature status file (non-fatal)", {
+          path: featureStatusPath,
+          error: err.message
+        });
       }
-      const state = { ...base, ...overrides };
-      await writeStatusFile(featureStatusPath, buildStatusSnapshot(state));
-      safeLogger?.debug("status-file", "Feature status written", { path: featureStatusPath });
-    } catch (err) {
-      safeLogger?.warn("status-file", "Failed to write feature status file (non-fatal)", {
-        path: featureStatusPath,
-        error: err.message
-      });
-    }
+    };
+    this._mutex = this._mutex.then(write).catch(() => write());
+    return this._mutex;
   }
 }
 var init_status_writer = __esm(() => {
@@ -36856,7 +36971,7 @@ var exports_precheck_runner = {};
 __export(exports_precheck_runner, {
   runPrecheckValidation: () => runPrecheckValidation
 });
-import { mkdirSync as mkdirSync5 } from "fs";
+import { mkdirSync as mkdirSync4 } from "fs";
 import path17 from "path";
 async function runPrecheckValidation(ctx) {
   const logger = getSafeLogger();
@@ -36871,7 +36986,7 @@ async function runPrecheckValidation(ctx) {
     format: "human"
   });
   if (ctx.logFilePath) {
-    mkdirSync5(path17.dirname(ctx.logFilePath), { recursive: true });
+    mkdirSync4(path17.dirname(ctx.logFilePath), { recursive: true });
     const precheckLog = {
       type: "precheck",
       timestamp: new Date().toISOString(),
@@ -68177,7 +68292,7 @@ var require_jsx_dev_runtime = __commonJS((exports, module) => {
 
 // bin/nax.ts
 init_source();
-import { existsSync as existsSync34, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync5 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join55 } from "path";
 
@@ -69453,78 +69568,75 @@ async function planCommand(workdir, config2, options) {
         autoModel = resolveModelForAgent2(config2.models, defaultAgent, planTier, defaultAgent).model;
       }
     } catch {}
-    if (isAcp) {
-      logger?.info("plan", "Starting ACP auto planning session", {
-        agent: agentName,
-        model: autoModel ?? config2?.plan?.model ?? "balanced",
-        workdir,
-        feature: options.feature,
-        timeoutSeconds
-      });
-      const pidRegistry = new PidRegistry(workdir);
-      try {
-        await adapter.plan({
-          prompt,
+    const runSingleAgentPlan = async () => {
+      if (isAcp) {
+        logger?.info("plan", "Starting ACP auto planning session", {
+          agent: agentName,
+          model: autoModel ?? config2?.plan?.model ?? "balanced",
           workdir,
-          interactive: false,
-          timeoutSeconds,
-          config: config2,
-          modelTier: config2?.plan?.model ?? "balanced",
-          dangerouslySkipPermissions: resolvePermissions(config2, "plan").skipPermissions,
-          maxInteractionTurns: config2?.agent?.maxInteractionTurns,
-          featureName: options.feature,
-          pidRegistry,
-          sessionRole: "plan"
-        });
-      } finally {
-        await pidRegistry.killAll().catch(() => {});
-      }
-      if (!_planDeps.existsSync(outputPath)) {
-        throw new Error(`[plan] ACP agent did not write PRD to ${outputPath}. Check agent logs for errors.`);
-      }
-      rawResponse = await _planDeps.readFile(outputPath);
-    } else {
-      const debateEnabled = config2?.debate?.enabled && config2?.debate?.stages?.plan?.enabled;
-      if (debateEnabled) {
-        const planStageConfig = config2.debate?.stages.plan;
-        const debateSession = _planDeps.createDebateSession({
-          storyId: options.feature,
-          stage: "plan",
-          stageConfig: planStageConfig
+          feature: options.feature,
+          timeoutSeconds
         });
-        const debateResult = await debateSession.run(prompt);
-        if (debateResult.outcome !== "failed" && debateResult.output) {
-          rawResponse = debateResult.output;
-        } else {
-          logger?.warn("debate", "All debaters failed \u2014 falling back to single agent", {
-            stage: "debate",
-            event: "fallback"
-          });
-          rawResponse = await adapter.complete(prompt, {
-            model: autoModel,
-            jsonMode: true,
+        const pidRegistry = new PidRegistry(workdir);
+        try {
+          await adapter.plan({
+            prompt,
             workdir,
+            interactive: false,
+            timeoutSeconds,
             config: config2,
+            modelTier: config2?.plan?.model ?? "balanced",
+            dangerouslySkipPermissions: resolvePermissions(config2, "plan").skipPermissions,
+            maxInteractionTurns: config2?.agent?.maxInteractionTurns,
             featureName: options.feature,
+            pidRegistry,
             sessionRole: "plan"
           });
+        } finally {
+          await pidRegistry.killAll().catch(() => {});
         }
-      } else {
-        rawResponse = await adapter.complete(prompt, {
-          model: autoModel,
-          jsonMode: true,
-          workdir,
-          config: config2,
-          featureName: options.feature,
-          sessionRole: "plan"
-        });
+        if (!_planDeps.existsSync(outputPath)) {
+          throw new Error(`[plan] ACP agent did not write PRD to ${outputPath}. Check agent logs for errors.`);
+        }
+        return await _planDeps.readFile(outputPath);
       }
+      let result = await adapter.complete(prompt, {
+        model: autoModel,
+        jsonMode: true,
+        workdir,
+        config: config2,
+        featureName: options.feature,
+        sessionRole: "plan"
+      });
       try {
-        const envelope = JSON.parse(rawResponse);
+        const envelope = JSON.parse(result);
         if (envelope?.type === "result" && typeof envelope?.result === "string") {
-          rawResponse = envelope.result;
+          result = envelope.result;
         }
       } catch {}
+      return result;
+    };
+    const debateEnabled = config2?.debate?.enabled && config2?.debate?.stages?.plan?.enabled;
+    if (debateEnabled) {
+      const planStageConfig = config2?.debate?.stages.plan;
+      const debateSession = _planDeps.createDebateSession({
+        storyId: options.feature,
+        stage: "plan",
+        stageConfig: planStageConfig,
+        config: config2
+      });
+      const debateResult = await debateSession.run(prompt);
+      if (debateResult.outcome !== "failed" && debateResult.output) {
+        rawResponse = debateResult.output;
+      } else {
+        logger?.warn("debate", "All debaters failed \u2014 falling back to single agent", {
+          stage: "debate",
+          event: "fallback"
+        });
+        rawResponse = await runSingleAgentPlan();
+      }
+    } else {
+      rawResponse = await runSingleAgentPlan();
     }
   } else {
     const prompt = buildPlanningPrompt(specContent, codebaseContext, outputPath, relativePackages, packageDetails, config2?.project);
@@ -70589,7 +70701,7 @@ async function runsShowCommand(options) {
 }
 // src/cli/prompts-main.ts
 init_logger2();
-import { existsSync as existsSync22, mkdirSync as mkdirSync3 } from "fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync2 } from "fs";
 import { join as join28 } from "path";
 
 // src/pipeline/index.ts
@@ -70729,7 +70841,7 @@ async function promptsCommand(options) {
     throw new Error(storyId ? `Story "${storyId}" not found in feature "${feature}"` : `No stories found in feature "${feature}"`);
   }
   if (outputDir) {
-    mkdirSync3(outputDir, { recursive: true });
+    mkdirSync2(outputDir, { recursive: true });
   }
   logger.info("cli", "Assembling prompts", {
     feature,
@@ -70809,7 +70921,7 @@ ${"=".repeat(80)}`);
   return processedStories;
 }
 // src/cli/prompts-init.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync4 } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync3 } from "fs";
 import { join as join29 } from "path";
 var TEMPLATE_ROLES = [
   { file: "test-writer.md", role: "test-writer" },
@@ -70835,7 +70947,7 @@ var TEMPLATE_HEADER = `<!--
 async function promptsInitCommand(options) {
   const { workdir, force = false, autoWireConfig = true } = options;
   const templatesDir = join29(workdir, ".nax", "templates");
-  mkdirSync4(templatesDir, { recursive: true });
+  mkdirSync3(templatesDir, { recursive: true });
   const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync23(join29(templatesDir, f)));
   if (existingFiles.length > 0 && !force) {
     console.warn(`[WARN] nax/templates/ already contains files: ${existingFiles.join(", ")}. No files overwritten.
@@ -80304,8 +80416,8 @@ Next: nax generate --package ${options.package}`));
     console.log(source_default.yellow("nax already initialized. Use --force to overwrite."));
     return;
   }
-  mkdirSync6(join55(naxDir, "features"), { recursive: true });
-  mkdirSync6(join55(naxDir, "hooks"), { recursive: true });
+  mkdirSync5(join55(naxDir, "features"), { recursive: true });
+  mkdirSync5(join55(naxDir, "hooks"), { recursive: true });
   await Bun.write(join55(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
   await Bun.write(join55(naxDir, "hooks.json"), JSON.stringify({
     hooks: {
@@ -80470,7 +80582,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     }
     try {
       const planLogDir = join55(featureDir, "plan");
-      mkdirSync6(planLogDir, { recursive: true });
+      mkdirSync5(planLogDir, { recursive: true });
       const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
       const planLogPath = join55(planLogDir, `${planLogId}.jsonl`);
       initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
@@ -80517,7 +80629,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
   }
   resetLogger();
   const runsDir = join55(featureDir, "runs");
-  mkdirSync6(runsDir, { recursive: true });
+  mkdirSync5(runsDir, { recursive: true });
   const runId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
   const logFilePath = join55(runsDir, `${runId}.jsonl`);
   const isTTY = process.stdout.isTTY ?? false;
@@ -80623,7 +80735,7 @@ features.command("create <name>").description("Create a new feature").option("-d
     process.exit(1);
   }
   const featureDir = join55(naxDir, "features", name);
-  mkdirSync6(featureDir, { recursive: true });
+  mkdirSync5(featureDir, { recursive: true });
   await Bun.write(join55(featureDir, "spec.md"), `# Feature: ${name}
 
 ## Overview
@@ -80730,7 +80842,7 @@ Use: nax plan -f <feature> --from <spec>`));
   }
   const config2 = await loadConfig(workdir);
   const featureLogDir = join55(naxDir, "features", options.feature, "plan");
-  mkdirSync6(featureLogDir, { recursive: true });
+  mkdirSync5(featureLogDir, { recursive: true });
   const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
   const planLogPath = join55(featureLogDir, `${planLogId}.jsonl`);
   initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nathapp/nax",
-  "version": "0.56.1",
+  "version": "0.56.3",
   "description": "AI Coding Agent Orchestrator — loops until done",
   "type": "module",
   "bin": {