@nathapp/nax 0.70.0 → 0.70.2

package/dist/nax.js

@@ -17277,9 +17277,13 @@ var init_schemas_review = __esm(() => {
     }).optional(),
     nonBlockingFix: exports_external.object({
       enabled: exports_external.boolean().default(false),
-      scope: exports_external.enum(["source", "both"]).default("both"),
+      scope: exports_external.enum(["source", "both", "triage"]).default("both"),
       regressionAttempts: exports_external.number().int().min(0).default(1),
-      verifierGuard: exports_external.boolean().default(true)
+      verifierGuard: exports_external.boolean().default(true),
+      sourceDiffCap: exports_external.object({
+        maxFiles: exports_external.number().int().min(0).default(10),
+        maxLines: exports_external.number().int().min(0).default(500)
+      }).optional().default({ maxFiles: 10, maxLines: 500 })
     }).optional()
   });
   ReviewConfigSchema = exports_external.object({
@@ -17733,7 +17737,7 @@ var init_schema = __esm(() => {
   init_defaults();
 });
 
-// src/logging/types.ts
+// src/log-format/types.ts
 var EMOJI;
 var init_types2 = __esm(() => {
   EMOJI = {
@@ -17755,7 +17759,7 @@ var init_types2 = __esm(() => {
   };
 });
 
-// src/logging/formatter.ts
+// src/log-format/formatter.ts
 function formatTimestamp(isoTimestamp) {
   const date5 = new Date(isoTimestamp);
   return date5.toLocaleTimeString("en-US", {
@@ -18068,8 +18072,8 @@ var init_formatter = __esm(() => {
   ];
 });
 
-// src/logging/index.ts
-var init_logging = __esm(() => {
+// src/log-format/index.ts
+var init_log_format = __esm(() => {
   init_formatter();
   init_types2();
 });
@@ -18306,7 +18310,7 @@ function resetLogger() {
 }
 var LOG_LEVEL_PRIORITY, instance = null, noopLogger;
 var init_logger = __esm(() => {
-  init_logging();
+  init_log_format();
   init_formatters();
   init_redact();
   LOG_LEVEL_PRIORITY = {
@@ -18959,6 +18963,19 @@ function rejectLegacyRectificationKeys(conf) {
 `);
   throw new NaxError(message, "CONFIG_LEGACY_RECTIFICATION_KEYS", { stage: "config", legacyKeys });
 }
+function rejectUnimplementedScopedProfile(conf) {
+  const execution = conf.execution;
+  if (execution?.permissionProfile !== "scoped")
+    return;
+  const message = [
+    'Invalid configuration \u2014 execution.permissionProfile: "scoped" is not yet implemented.',
+    "The scoped (per-stage tool allowlist) profile is tracked by GitHub #374 and would",
+    'otherwise silently run as "safe", giving you weaker permissions than intended.',
+    'Use "unrestricted" or "safe" for now.'
+  ].join(`
+`);
+  throw new NaxError(message, "CONFIG_SCOPED_PROFILE_UNIMPLEMENTED", { stage: "config" });
+}
 function applyBatchModeCompat(conf) {
   const routing = conf.routing;
   const llm = routing?.llm;
@@ -19068,6 +19085,7 @@ async function loadConfig(startDir, cliOverrides) {
   }
   rejectLegacyAgentKeys(rawConfig);
   rejectLegacyRectificationKeys(rawConfig);
+  rejectUnimplementedScopedProfile(rawConfig);
   const result = NaxConfigSchema.safeParse(rawConfig);
   if (!result.success) {
     const errors3 = result.error.issues.map((err) => {
@@ -19137,6 +19155,7 @@ async function loadConfigForWorkdir(rootConfigPath, packageDir, cliOverrides) {
     rawMerged.profileChain = packageChain;
     rejectLegacyAgentKeys(rawMerged);
     rejectLegacyRectificationKeys(rawMerged);
+    rejectUnimplementedScopedProfile(rawMerged);
     const result = NaxConfigSchema.safeParse(rawMerged);
     if (!result.success) {
       const errors3 = result.error.issues.map((err) => {
@@ -32581,6 +32600,14 @@ var init_ac_structural_counterfactual = __esm(() => {
   BLOCKING_CATEGORIES = new Set(["input", "error-path", "abandonment", "assumption"]);
 });
 
+// src/review/category-fix-target.ts
+function categoryToFixTarget(category) {
+  return category != null && BLOCKING_CATEGORIES.has(category) ? "source" : "test";
+}
+var init_category_fix_target = __esm(() => {
+  init_ac_structural_counterfactual();
+});
+
 // src/review/severity.ts
 function isBlockingSeverity(sev, threshold = "error") {
   return (SEVERITY_RANK[sev] ?? 0) >= SEVERITY_RANK[threshold];
@@ -32637,12 +32664,13 @@ function toAdversarialReviewFindings(findings) {
       line: f.line,
       message: f.issue,
       suggestion: f.suggestion,
-      fixTarget: f.category === "test-gap" ? "test" : undefined,
+      fixTarget: categoryToFixTarget(f.category),
       meta: Object.keys(metaExtras).length > 0 ? metaExtras : undefined
     };
   });
 }
 var init_adversarial_helpers = __esm(() => {
+  init_category_fix_target();
   init_severity();
 });
 
@@ -33448,9 +33476,16 @@ function buildMeta(f, originalSeverity) {
 function findingCategory(f) {
   return "category" in f && f.category ? f.category : undefined;
 }
+function deriveFixTargetForReviewFinding(category, source) {
+  if (source === "semantic-review" || source === "semantic-debate-review") {
+    return "source";
+  }
+  return categoryToFixTarget(category);
+}
 function llmFindingToReviewFinding(f, opts = {}) {
   const category = findingCategory(f);
   const narrowed = narrowSeverity(f.severity);
+  const source = opts.source;
   const result = {
     ruleId: deriveRuleId(category, f.issue),
     severity: narrowed,
@@ -33460,8 +33495,9 @@ function llmFindingToReviewFinding(f, opts = {}) {
   };
   if (category)
     result.category = category;
-  if (opts.source)
-    result.source = opts.source;
+  if (source)
+    result.source = source;
+  result.fixTarget = deriveFixTargetForReviewFinding(category, source);
   const meta3 = buildMeta(f, f.severity !== narrowed ? f.severity : undefined);
   if (meta3)
     result.meta = meta3;
@@ -33472,6 +33508,7 @@ function llmFindingsToReviewFindings(findings, opts = {}) {
 }
 var SEVERITY_MAP, RULE_ID_SLUG_TOKENS = 6;
 var init_finding_projection = __esm(() => {
+  init_category_fix_target();
   SEVERITY_MAP = {
     critical: "critical",
     error: "error",
@@ -39375,9 +39412,10 @@ var init__finding_to_check = __esm(() => {
 // src/operations/autofix-implementer-strategy.ts
 function makeAutofixImplementerStrategy(story, config2, sink, opts = {}) {
   const claimsAdversarial = opts.includeAdversarialReview === true;
+  const adversarialReviewByFixTarget = opts.adversarialReviewByFixTarget;
   return {
     name: "autofix-implementer",
-    appliesTo: (f) => (f.fixTarget === "source" || f.fixTarget == null) && IMPLEMENTER_SOURCES.has(f.source) || claimsAdversarial && f.source === "adversarial-review",
+    appliesTo: (f) => (f.fixTarget === "source" || f.fixTarget == null) && IMPLEMENTER_SOURCES.has(f.source) || adversarialReviewByFixTarget !== undefined && f.source === "adversarial-review" && f.fixTarget === adversarialReviewByFixTarget || adversarialReviewByFixTarget === undefined && claimsAdversarial && f.source === "adversarial-review",
     fixOp: implementerRectifyOp,
     buildInput: (findings, _prior, _cycleCtx) => ({
       failedChecks: findingsToFailedChecks(findings),
@@ -39409,10 +39447,11 @@ var init_autofix_implementer_strategy = __esm(() => {
 });
 
 // src/operations/autofix-test-writer-strategy.ts
-function makeAutofixTestWriterStrategy(story, config2, sink) {
+function makeAutofixTestWriterStrategy(story, config2, sink, opts = {}) {
+  const includeAdversarial = opts.includeAdversarialReview !== false;
   return {
     name: "autofix-test-writer",
-    appliesTo: (f) => f.fixTarget === "test" || f.source === "adversarial-review" || sink.mockHandoffs.length > 0,
+    appliesTo: (f) => f.fixTarget === "test" || includeAdversarial && f.source === "adversarial-review" || sink.mockHandoffs.length > 0,
     fixOp: testWriterRectifyOp,
     buildInput: (findings, _prior, _cycleCtx) => {
       if (sink.mockHandoffs.length > 0) {
@@ -42307,6 +42346,7 @@ var init_runner2 = __esm(() => {
 // src/review/index.ts
 var init_review = __esm(() => {
   init_semantic_helpers();
+  init_category_fix_target();
   init_ac_quote_validator();
   init_ac_structural_counterfactual();
   init_adversarial();
@@ -45251,7 +45291,7 @@ function attachLoggingSubscriber(bus, runId) {
     offError();
   };
 }
-var init_logging2 = __esm(() => {
+var init_logging = __esm(() => {
   init_logger2();
 });
 
@@ -45769,7 +45809,7 @@ var init_idle_watchdog = __esm(() => {
 // src/runtime/middleware/index.ts
 var init_middleware = __esm(() => {
   init_cancellation();
-  init_logging2();
+  init_logging();
   init_agent_stream_logging();
   init_idle_watchdog();
 });
@@ -54815,6 +54855,26 @@ var init_rollback = __esm(() => {
   };
 });
 
+// src/utils/paths.ts
+import { join as join47, relative as relative13, sep as sep4 } from "path";
+function packageDirRelative(projectDir, workdir) {
+  if (!projectDir || !workdir || workdir === projectDir)
+    return;
+  const rel = relative13(projectDir, workdir);
+  if (rel === ".." || rel.startsWith(`..${sep4}`))
+    return;
+  return rel && rel !== "." ? rel : undefined;
+}
+function getRunsDir() {
+  return process.env.NAX_RUNS_DIR ?? join47(globalConfigDir(), "runs");
+}
+function getEventsRootDir() {
+  return join47(globalConfigDir(), "events");
+}
+var init_paths3 = __esm(() => {
+  init_paths();
+});
+
 // src/execution/non-blocking-fix.ts
 function shouldRunNonBlockingFix(cfg, advisoryCount) {
   return cfg?.enabled === true && advisoryCount > 0;
@@ -54823,9 +54883,42 @@ function nonBlockingExcludePhases() {
   return REVIEW_PHASE_KINDS;
 }
 function nonBlockingExtraPhases(cfg) {
-  return cfg.scope === "both" && cfg.verifierGuard ? ["verifier"] : [];
+  return (cfg.scope === "both" || cfg.scope === "triage") && cfg.verifierGuard ? ["verifier"] : [];
+}
+function createMeasureSourceDiff(args) {
+  const packageDirRel = packageDirRelative(args.projectDir, args.packageDir);
+  return async (workdir, fromRef) => {
+    const resolved = await _nonBlockingFixDeps.resolveTestFilePatterns(args.config, args.projectDir, packageDirRel);
+    const isTestFile3 = createTestFileClassifier(resolved);
+    const proc = _nonBlockingFixDeps.spawn(["git", "diff", "--numstat", fromRef], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const stdout = await Bun.readableStreamToText(proc.stdout);
+    const stderr = await Bun.readableStreamToText(proc.stderr);
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      const detail = stderr.trim() || `exit ${exitCode}`;
+      throw new Error(`[non-blocking-fix] git diff --numstat failed: ${detail}`);
+    }
+    let fileCount = 0;
+    let sourceLineCount = 0;
+    for (const line of stdout.trim().split(`
+`).filter(Boolean)) {
+      const [addedStr, _deletedStr, filePath] = line.split("\t");
+      if (!filePath || isTestFile3(filePath))
+        continue;
+      fileCount += 1;
+      const added = Number.parseInt(addedStr ?? "", 10);
+      if (Number.isFinite(added))
+        sourceLineCount += added;
+    }
+    return { fileCount, sourceLineCount };
+  };
 }
-async function runNonBlockingFix(args, _deps = DEFAULT_DEPS) {
+async function runNonBlockingFix(args, overrides = {}) {
+  const _deps = { ...DEFAULT_DEPS, ...overrides };
   const logger = getSafeLogger();
   if (!shouldRunNonBlockingFix(args.cfg, args.advisoryFindings.length)) {
     return { ran: false, kept: false, restored: false };
@@ -54845,9 +54938,34 @@ async function runNonBlockingFix(args, _deps = DEFAULT_DEPS) {
     exhausted = true;
   }
   if (!exhausted) {
+    const cap = args.cfg.sourceDiffCap;
+    if (cap) {
+      let metrics;
+      try {
+        metrics = await _deps.measureSourceDiff(args.workdir, restoreRef);
+      } catch (err) {
+        logger?.warn("non-blocking-fix", "source-diff measurement threw \u2014 restoring", {
+          storyId: args.storyId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        return restoreToSnapshot(args, _deps, restoreRef, phaseOutputsSnapshot, logger);
+      }
+      if (metrics.fileCount > cap.maxFiles || metrics.sourceLineCount > cap.maxLines) {
+        logger?.info("non-blocking-fix", "source diff exceeded cap \u2014 restoring", {
+          storyId: args.storyId,
+          fileCount: metrics.fileCount,
+          sourceLineCount: metrics.sourceLineCount,
+          cap
+        });
+        return restoreToSnapshot(args, _deps, restoreRef, phaseOutputsSnapshot, logger);
+      }
+    }
     logger?.info("non-blocking-fix", "best-effort fix kept", { storyId: args.storyId });
     return { ran: true, kept: true, restored: false };
   }
+  return restoreToSnapshot(args, _deps, restoreRef, phaseOutputsSnapshot, logger);
+}
+async function restoreToSnapshot(args, _deps, restoreRef, phaseOutputsSnapshot, logger) {
   await _deps.rollbackToRef(args.workdir, restoreRef);
   for (const key of Object.keys(args.phaseOutputs))
     delete args.phaseOutputs[key];
@@ -54857,167 +54975,85 @@ async function runNonBlockingFix(args, _deps = DEFAULT_DEPS) {
   });
   return { ran: true, kept: false, restored: true };
 }
-var REVIEW_PHASE_KINDS, DEFAULT_DEPS;
+var REVIEW_PHASE_KINDS, _nonBlockingFixDeps, DEFAULT_DEPS;
 var init_non_blocking_fix = __esm(() => {
   init_logger2();
   init_rollback();
+  init_test_runners();
+  init_bun_deps();
+  init_paths3();
   REVIEW_PHASE_KINDS = ["semantic-review", "adversarial-review"];
-  DEFAULT_DEPS = { captureSnapshotRef, rollbackToRef };
+  _nonBlockingFixDeps = {
+    spawn: typedSpawn,
+    resolveTestFilePatterns
+  };
+  DEFAULT_DEPS = {
+    captureSnapshotRef,
+    rollbackToRef,
+    measureSourceDiff: async () => ({ fileCount: 0, sourceLineCount: 0 })
+  };
 });
 
-// src/execution/story-orchestrator-logging.ts
-function formatPhaseResultMessage(opName, success2, stage, status) {
-  if (opName === "greenfield-gate") {
-    return success2 ? "Greenfield-gate: pre-existing tests detected (not greenfield) \u2014 proceeding with normal TDD" : "Greenfield-gate: no pre-existing tests \u2014 greenfield run, pausing TDD test-writer";
-  }
-  if (status === "skipped") {
-    return `Phase skipped: ${opName}`;
-  }
-  if (stage === "rectification") {
-    return `Rectification strategy completed: ${opName}`;
-  }
-  return success2 ? `Phase passed: ${opName}` : `Phase failed: ${opName}`;
-}
-function buildPhaseOutcomeLogData(storyId, opName, output, durationMs) {
-  if (output === null || output === undefined || typeof output !== "object")
-    return null;
-  const r = output;
-  const success2 = r.success === true || r.passed === true;
-  const findingsCount = Array.isArray(r.normalizedFindings) ? r.normalizedFindings.length : Array.isArray(r.findings) ? r.findings.length : undefined;
-  const status = typeof r.status === "string" ? r.status : undefined;
-  const data = { storyId, phase: opName, durationMs };
-  if (findingsCount !== undefined)
-    data.findingsCount = findingsCount;
-  if (status !== undefined)
-    data.status = status;
-  if (typeof r.failureCategory === "string")
-    data.failureCategory = r.failureCategory;
-  if (typeof r.reviewReason === "string")
-    data.reviewReason = r.reviewReason;
-  return { success: success2, data };
-}
-function logDeterministicPhaseOutcome(storyId, opName, output, durationMs, isTddPhase, stage, progressData = {}) {
-  if (isTddPhase)
-    return;
-  if (opName === "semantic-review" || opName === "adversarial-review")
-    return;
-  const built = buildPhaseOutcomeLogData(storyId, opName, output, durationMs);
-  if (!built)
-    return;
-  const { success: success2 } = built;
-  const data = { ...built.data, ...progressData };
-  const status = typeof built.data.status === "string" ? built.data.status : undefined;
-  const logger = getSafeLogger();
-  const message = formatPhaseResultMessage(opName, success2, stage, status);
-  if (stage === "rectification") {
-    logger?.info("story-orchestrator", message, data);
-    return;
-  }
-  if (success2) {
-    logger?.info("story-orchestrator", message, data);
-  } else {
-    logger?.warn("story-orchestrator", message, data);
-  }
-}
-var init_story_orchestrator_logging = __esm(() => {
-  init_logger2();
+// src/execution/story-orchestrator/types.ts
+var EXHAUSTED_EXIT_REASONS, TDD_OP_NAMES, CANONICAL_ORDER, PHASE_KIND_TO_STATE_KEY, STRATEGY_TO_REVALIDATION_PHASES, STRICT_VERDICT_PHASE_NAMES;
+var init_types9 = __esm(() => {
+  EXHAUSTED_EXIT_REASONS = new Set([
+    "max-attempts-total",
+    "max-attempts-per-strategy",
+    "bail-when",
+    "no-strategy",
+    "agent-gave-up",
+    "validate-short-circuit"
+  ]);
+  TDD_OP_NAMES = new Set(["test-writer", "implementer", "verifier"]);
+  CANONICAL_ORDER = [
+    "test-writer",
+    "greenfield-gate",
+    "implementer",
+    "full-suite-gate",
+    "verifier",
+    "verify-scoped",
+    "lint-check",
+    "typecheck-check",
+    "semantic-review",
+    "adversarial-review"
+  ];
+  PHASE_KIND_TO_STATE_KEY = {
+    "test-writer": "testWriter",
+    "greenfield-gate": "greenfieldGate",
+    implementer: "implementer",
+    "full-suite-gate": "fullSuiteGate",
+    verifier: "verifier",
+    "verify-scoped": "verifyScoped",
+    "lint-check": "lintCheck",
+    "typecheck-check": "typecheckCheck",
+    "semantic-review": "semanticReview",
+    "adversarial-review": "adversarialReview"
+  };
+  STRATEGY_TO_REVALIDATION_PHASES = {
+    "mechanical-lintfix": ["lint-check"],
+    "mechanical-formatfix": ["lint-check"],
+    "autofix-implementer": ["lint-check", "typecheck-check", "full-suite-gate", "semantic-review", "adversarial-review"],
+    "autofix-test-writer": ["lint-check", "typecheck-check", "full-suite-gate", "adversarial-review"],
+    "full-suite-rectify": [
+      "lint-check",
+      "typecheck-check",
+      "full-suite-gate",
+      "verifier",
+      "verify-scoped",
+      "semantic-review"
+    ]
+  };
+  STRICT_VERDICT_PHASE_NAMES = new Set([
+    "full-suite-gate",
+    "verify-scoped",
+    "lint-check",
+    "typecheck-check",
+    "verifier"
+  ]);
 });
 
-// src/execution/story-orchestrator.ts
-async function refreshReviewInputForDispatch(opName, input) {
-  if (opName !== "semantic-review" && opName !== "adversarial-review")
-    return input;
-  const i = input;
-  const { _refresh } = i;
-  if (!_refresh || !i.workdir)
-    return input;
-  try {
-    if (opName === "semantic-review") {
-      const { _refresh: _, ...semInput } = input;
-      const fresh2 = await _storyOrchestratorDeps.prepareSemanticReviewInput({
-        workdir: semInput.workdir,
-        projectDir: _refresh.projectDir,
-        storyId: _refresh.storyId,
-        storyGitRef: _refresh.storyGitRef,
-        config: _refresh.config,
-        naxIgnoreIndex: _refresh.naxIgnoreIndex,
-        resolvedTestPatterns: _refresh.resolvedTestPatterns,
-        semanticConfig: semInput.semanticConfig
-      });
-      return {
-        ...semInput,
-        stat: fresh2.stat,
-        diff: fresh2.diff,
-        excludePatterns: fresh2.excludePatterns,
-        storyGitRef: fresh2.effectiveRef ?? semInput.storyGitRef
-      };
-    }
-    const { _refresh: __, ...advInput } = input;
-    const fresh = await _storyOrchestratorDeps.prepareAdversarialReviewInput({
-      workdir: advInput.workdir,
-      projectDir: _refresh.projectDir,
-      storyId: _refresh.storyId,
-      storyGitRef: _refresh.storyGitRef,
-      config: _refresh.config,
-      naxIgnoreIndex: _refresh.naxIgnoreIndex,
-      resolvedTestPatterns: _refresh.resolvedTestPatterns,
-      adversarialConfig: advInput.adversarialConfig
-    });
-    return {
-      ...advInput,
-      stat: fresh.stat,
-      diff: fresh.diff,
-      testInventory: fresh.testInventory,
-      excludePatterns: fresh.excludePatterns,
-      testGlobs: fresh.testGlobs,
-      refExcludePatterns: fresh.refExcludePatterns,
-      storyGitRef: fresh.effectiveRef ?? advInput.storyGitRef
-    };
-  } catch (err) {
-    getSafeLogger()?.warn("story-orchestrator", "review input refresh failed \u2014 dispatching with stale input", {
-      storyId: _refresh.storyId,
-      phase: opName,
-      error: errorMessage(err)
-    });
-    const { _refresh: _stripped, ...fallback } = input;
-    return fallback;
-  }
-}
-function isSlot(value) {
-  return value !== null && typeof value === "object" && "op" in value && "input" in value && typeof value.op?.kind === "string";
-}
-function setPhase(state, kind, slot) {
-  const key = PHASE_KIND_TO_STATE_KEY[kind];
-  if (state[key] !== undefined) {
-    throw new NaxError(`StoryOrchestratorBuilder: addX was called twice for phase "${kind}"`, "ORCHESTRATOR_PHASE_DUPLICATE", { stage: "execution", kind });
-  }
-  state[key] = { kind, slot };
-}
-function collectOrderedPhases(state) {
-  return CANONICAL_ORDER.flatMap((kind) => {
-    if (kind === "test-writer" && state.testWriter)
-      return [state.testWriter];
-    if (kind === "greenfield-gate" && state.greenfieldGate)
-      return [state.greenfieldGate];
-    if (kind === "implementer" && state.implementer)
-      return [state.implementer];
-    if (kind === "full-suite-gate" && state.fullSuiteGate)
-      return [state.fullSuiteGate];
-    if (kind === "verifier" && state.verifier)
-      return [state.verifier];
-    if (kind === "verify-scoped" && state.verifyScoped)
-      return [state.verifyScoped];
-    if (kind === "lint-check" && state.lintCheck)
-      return [state.lintCheck];
-    if (kind === "typecheck-check" && state.typecheckCheck)
-      return [state.typecheckCheck];
-    if (kind === "semantic-review" && state.semanticReview)
-      return [state.semanticReview];
-    if (kind === "adversarial-review" && state.adversarialReview)
-      return [state.adversarialReview];
-    return [];
-  });
-}
+// src/execution/story-orchestrator/phase-eval.ts
 function phaseExplicitlyPassed(output) {
   if (output === null || output === undefined || typeof output !== "object")
     return false;
@@ -55075,34 +55111,6 @@ function gateFailureKeys(gateOutput) {
   }
   return keys;
 }
-function shouldSkipPhaseForRectification(phase, state, phaseOutputs) {
-  if (phase.kind !== "full-suite-gate")
-    return false;
-  const verifierName = state.verifier?.slot.op.name;
-  if (!verifierName)
-    return false;
-  return phaseExplicitlyPassed(phaseOutputs[verifierName]);
-}
-function gatherRectificationFindings(phaseOutputs, phases, state) {
-  const findings = [];
-  for (const phase of phases) {
-    if (shouldSkipPhaseForRectification(phase, state, phaseOutputs))
-      continue;
-    findings.push(...extractPhaseFindings(phaseOutputs[phase.slot.op.name]));
-  }
-  return findings;
-}
-function collectRectificationPhases(state) {
-  return [
-    state.fullSuiteGate,
-    state.verifier,
-    state.verifyScoped,
-    state.lintCheck,
-    state.typecheckCheck,
-    state.semanticReview,
-    state.adversarialReview
-  ].filter((phase) => phase !== undefined);
-}
 function phasesToRevalidate(strategiesRun, allPhases) {
   if (!strategiesRun || strategiesRun.length === 0)
     return allPhases;
@@ -55122,6 +55130,111 @@ function orderGateLast(phases) {
   const gates = phases.filter((p) => p.kind === "full-suite-gate");
   return [...rest, ...gates];
 }
+var init_phase_eval = __esm(() => {
+  init_logger2();
+  init_types9();
+});
+
+// src/execution/story-orchestrator/phase-state.ts
+function isSlot(value) {
+  return value !== null && typeof value === "object" && "op" in value && "input" in value && typeof value.op?.kind === "string";
+}
+function setPhase(state, kind, slot) {
+  const key = PHASE_KIND_TO_STATE_KEY[kind];
+  if (state[key] !== undefined) {
+    throw new NaxError(`StoryOrchestratorBuilder: addX was called twice for phase "${kind}"`, "ORCHESTRATOR_PHASE_DUPLICATE", { stage: "execution", kind });
+  }
+  state[key] = { kind, slot };
+}
+function collectOrderedPhases(state) {
+  return CANONICAL_ORDER.flatMap((kind) => {
+    if (kind === "test-writer" && state.testWriter)
+      return [state.testWriter];
+    if (kind === "greenfield-gate" && state.greenfieldGate)
+      return [state.greenfieldGate];
+    if (kind === "implementer" && state.implementer)
+      return [state.implementer];
+    if (kind === "full-suite-gate" && state.fullSuiteGate)
+      return [state.fullSuiteGate];
+    if (kind === "verifier" && state.verifier)
+      return [state.verifier];
+    if (kind === "verify-scoped" && state.verifyScoped)
+      return [state.verifyScoped];
+    if (kind === "lint-check" && state.lintCheck)
+      return [state.lintCheck];
+    if (kind === "typecheck-check" && state.typecheckCheck)
+      return [state.typecheckCheck];
+    if (kind === "semantic-review" && state.semanticReview)
+      return [state.semanticReview];
+    if (kind === "adversarial-review" && state.adversarialReview)
+      return [state.adversarialReview];
+    return [];
+  });
+}
+var init_phase_state = __esm(() => {
+  init_errors();
+  init_types9();
+});
+
+// src/execution/story-orchestrator-logging.ts
+function formatPhaseResultMessage(opName, success2, stage, status) {
+  if (opName === "greenfield-gate") {
+    return success2 ? "Greenfield-gate: pre-existing tests detected (not greenfield) \u2014 proceeding with normal TDD" : "Greenfield-gate: no pre-existing tests \u2014 greenfield run, pausing TDD test-writer";
+  }
+  if (status === "skipped") {
+    return `Phase skipped: ${opName}`;
+  }
+  if (stage === "rectification") {
+    return `Rectification strategy completed: ${opName}`;
+  }
+  return success2 ? `Phase passed: ${opName}` : `Phase failed: ${opName}`;
+}
+function buildPhaseOutcomeLogData(storyId, opName, output, durationMs) {
+  if (output === null || output === undefined || typeof output !== "object")
+    return null;
+  const r = output;
+  const success2 = r.success === true || r.passed === true;
+  const findingsCount = Array.isArray(r.normalizedFindings) ? r.normalizedFindings.length : Array.isArray(r.findings) ? r.findings.length : undefined;
+  const status = typeof r.status === "string" ? r.status : undefined;
+  const data = { storyId, phase: opName, durationMs };
+  if (findingsCount !== undefined)
+    data.findingsCount = findingsCount;
+  if (status !== undefined)
+    data.status = status;
+  if (typeof r.failureCategory === "string")
+    data.failureCategory = r.failureCategory;
+  if (typeof r.reviewReason === "string")
+    data.reviewReason = r.reviewReason;
+  return { success: success2, data };
+}
+function logDeterministicPhaseOutcome(storyId, opName, output, durationMs, isTddPhase, stage, progressData = {}) {
+  if (isTddPhase)
+    return;
+  if (opName === "semantic-review" || opName === "adversarial-review")
+    return;
+  const built = buildPhaseOutcomeLogData(storyId, opName, output, durationMs);
+  if (!built)
+    return;
+  const { success: success2 } = built;
+  const data = { ...built.data, ...progressData };
+  const status = typeof built.data.status === "string" ? built.data.status : undefined;
+  const logger = getSafeLogger();
+  const message = formatPhaseResultMessage(opName, success2, stage, status);
+  if (stage === "rectification") {
+    logger?.info("story-orchestrator", message, data);
+    return;
+  }
+  if (success2) {
+    logger?.info("story-orchestrator", message, data);
+  } else {
+    logger?.warn("story-orchestrator", message, data);
+  }
+}
+var init_story_orchestrator_logging = __esm(() => {
+  init_logger2();
+});
+
+// src/execution/story-orchestrator/review-decision.ts
 function toReviewDecisionPayload(opName, output) {
   if (output === null || output === undefined || typeof output !== "object")
     return null;
@@ -55237,6 +55350,70 @@ function logUnifiedReviewPhaseResult(storyId, opName, output) {
     truncated: findingsCount > findingsSummary.length
   });
 }
+var init_review_decision = __esm(() => {
+  init_logger2();
+});
+
+// src/execution/story-orchestrator/run-phase.ts
+async function refreshReviewInputForDispatch(opName, input) {
+  if (opName !== "semantic-review" && opName !== "adversarial-review")
+    return input;
+  const i = input;
+  const { _refresh } = i;
+  if (!_refresh || !i.workdir)
+    return input;
+  try {
+    if (opName === "semantic-review") {
+      const { _refresh: _, ...semInput } = input;
+      const fresh2 = await _storyOrchestratorDeps.prepareSemanticReviewInput({
+        workdir: semInput.workdir,
+        projectDir: _refresh.projectDir,
+        storyId: _refresh.storyId,
+        storyGitRef: _refresh.storyGitRef,
+        config: _refresh.config,
+        naxIgnoreIndex: _refresh.naxIgnoreIndex,
+        resolvedTestPatterns: _refresh.resolvedTestPatterns,
+        semanticConfig: semInput.semanticConfig
+      });
+      return {
+        ...semInput,
+        stat: fresh2.stat,
+        diff: fresh2.diff,
+        excludePatterns: fresh2.excludePatterns,
+        storyGitRef: fresh2.effectiveRef ?? semInput.storyGitRef
+      };
+    }
+    const { _refresh: __, ...advInput } = input;
+    const fresh = await _storyOrchestratorDeps.prepareAdversarialReviewInput({
+      workdir: advInput.workdir,
+      projectDir: _refresh.projectDir,
+      storyId: _refresh.storyId,
+      storyGitRef: _refresh.storyGitRef,
+      config: _refresh.config,
+      naxIgnoreIndex: _refresh.naxIgnoreIndex,
+      resolvedTestPatterns: _refresh.resolvedTestPatterns,
+      adversarialConfig: advInput.adversarialConfig
+    });
+    return {
+      ...advInput,
+      stat: fresh.stat,
+      diff: fresh.diff,
+      testInventory: fresh.testInventory,
+      excludePatterns: fresh.excludePatterns,
+      testGlobs: fresh.testGlobs,
+      refExcludePatterns: fresh.refExcludePatterns,
+      storyGitRef: fresh.effectiveRef ?? advInput.storyGitRef
+    };
+  } catch (err) {
+    getSafeLogger()?.warn("story-orchestrator", "review input refresh failed \u2014 dispatching with stale input", {
+      storyId: _refresh.storyId,
+      phase: opName,
+      error: errorMessage(err)
+    });
+    const { _refresh: _stripped, ...fallback } = input;
+    return fallback;
+  }
+}
 async function runPhase(ctx, slot, phaseCosts, phaseOutputs, isThreeSession = false, progress) {
   const logger = getSafeLogger();
   const opName = slot.op.name;
@@ -55322,6 +55499,57 @@ function withIncreasingFailuresBail(strategies, enabled, consecutiveIncreases) {
     }
   }));
 }
+var _storyOrchestratorDeps;
+var init_run_phase = __esm(() => {
+  init_findings();
+  init_logger2();
+  init_operations();
+  init_pipeline();
+  init_review();
+  init_git();
+  init_non_blocking_fix();
+  init_story_orchestrator_logging();
+  init_review_decision();
+  init_types9();
+  _storyOrchestratorDeps = {
+    callOp,
+    runFixCycle,
+    captureGitRef,
+    prepareSemanticReviewInput,
+    prepareAdversarialReviewInput,
+    runNonBlockingFix
+  };
+});
+
+// src/execution/story-orchestrator/rectification.ts
+function shouldSkipPhaseForRectification(phase, state, phaseOutputs) {
+  if (phase.kind !== "full-suite-gate")
+    return false;
+  const verifierName = state.verifier?.slot.op.name;
+  if (!verifierName)
+    return false;
+  return phaseExplicitlyPassed(phaseOutputs[verifierName]);
+}
+function gatherRectificationFindings(phaseOutputs, phases, state) {
+  const findings = [];
+  for (const phase of phases) {
+    if (shouldSkipPhaseForRectification(phase, state, phaseOutputs))
+      continue;
+    findings.push(...extractPhaseFindings(phaseOutputs[phase.slot.op.name]));
+  }
+  return findings;
+}
+function collectRectificationPhases(state) {
+  return [
+    state.fullSuiteGate,
+    state.verifier,
+    state.verifyScoped,
+    state.lintCheck,
+    state.typecheckCheck,
+    state.semanticReview,
+    state.adversarialReview
+  ].filter((phase) => phase !== undefined);
+}
 async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides) {
   const rectification = state.rectification;
   const baseValidationPhases = collectRectificationPhases(state);
@@ -55419,7 +55647,15 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
   }
   return {};
 }
+var init_rectification = __esm(() => {
+  init_logger2();
+  init_phase_eval();
+  init_phase_eval();
+  init_run_phase();
+  init_types9();
+});
 
+// src/execution/story-orchestrator/execution-plan.ts
 class ExecutionPlan {
   ctx;
   state;
@@ -55542,7 +55778,7 @@ class ExecutionPlan {
     const advisoryOut = phaseOutputs["adversarial-review"];
     const advisoryFindings = advisoryOut?.advisoryFindings ?? [];
     if (advCfg && this.state.rectification && this.ctx.storyId && shouldRunNonBlockingFix(advCfg, advisoryFindings.length)) {
-      await runNonBlockingFix({
+      await _storyOrchestratorDeps.runNonBlockingFix({
         workdir: this.ctx.packageDir,
         storyId: this.ctx.storyId,
         advisoryFindings,
@@ -55556,6 +55792,12 @@ class ExecutionPlan {
           maxAttempts,
           postValidate: this.state.nonBlockingFixPostValidate
         })
+      }, {
+        measureSourceDiff: createMeasureSourceDiff({
+          config: this.ctx.runtime.configLoader.current(),
+          projectDir: this.ctx.runtime.projectDir,
+          packageDir: this.ctx.packageDir
+        })
       });
     }
     const verifierName = this.state.verifier?.slot.op.name;
@@ -55567,18 +55809,29 @@ class ExecutionPlan {
     } else if (verifierPassedSsot && gateName !== undefined && !phasePassed(gateName, phaseOutputs[gateName], this.ctx.storyId)) {
       logger?.warn("story-orchestrator", "Full-suite gate failed but verifier judged story OK \u2014 treating gate failures as unrelated regressions", { storyId: this.ctx.storyId, packageDir: this.ctx.packageDir });
     }
-    const success2 = Object.entries(phaseOutputs).every(([name, output]) => {
+    const requiredReviewPhaseNames = [
+      this.state.semanticReview?.slot.op.name,
+      this.state.adversarialReview?.slot.op.name
+    ].filter((name) => name !== undefined);
+    const missingRequiredReviewPhases = requiredReviewPhaseNames.filter((name) => !(name in phaseOutputs));
+    if (missingRequiredReviewPhases.length > 0) {
+      logger?.warn("story-orchestrator", "Configured review phase(s) never ran \u2014 story cannot pass without review judgment, failing for escalation", { storyId: this.ctx.storyId, packageDir: this.ctx.packageDir, missingRequiredReviewPhases });
+    }
+    const success2 = missingRequiredReviewPhases.length === 0 && Object.entries(phaseOutputs).every(([name, output]) => {
       if (verifierPassedSsot && name === gateName)
         return true;
       return phasePassed(name, output, this.ctx.storyId);
     });
     const totalCostUsd = Object.values(phaseCosts).reduce((sum, cost) => sum + cost, 0);
     const durationMs = Date.now() - startedAt;
-    const failedPhases = Object.entries(phaseOutputs).filter(([name, output]) => {
-      if (verifierPassedSsot && name === gateName)
-        return false;
-      return !phasePassed(name, output, this.ctx.storyId);
-    }).map(([name]) => name);
+    const failedPhases = [
+      ...Object.entries(phaseOutputs).filter(([name, output]) => {
+        if (verifierPassedSsot && name === gateName)
+          return false;
+        return !phasePassed(name, output, this.ctx.storyId);
+      }).map(([name]) => name),
+      ...missingRequiredReviewPhases.map((name) => `${name} (never ran)`)
+    ];
     const summary = {
       storyId: this.ctx.storyId,
       success: success2,
@@ -55591,6 +55844,8 @@ class ExecutionPlan {
       summary.rectificationExhausted = true;
     if (rectResult.unfixedFindings)
       summary.unfixedFindingsCount = rectResult.unfixedFindings.length;
+    if (missingRequiredReviewPhases.length > 0)
+      summary.missingRequiredReviewPhases = missingRequiredReviewPhases;
     if (success2) {
       logger?.info("story-orchestrator", "Story orchestration complete", summary);
     } else {
@@ -55603,11 +55858,21 @@ class ExecutionPlan {
       durationMs,
       phaseOutputs,
       ...rectResult,
-      gateRegressedDuringRect
+      gateRegressedDuringRect,
+      missingRequiredReviewPhases: missingRequiredReviewPhases.length > 0 ? missingRequiredReviewPhases : undefined
     };
   }
 }
+var init_execution_plan = __esm(() => {
+  init_logger2();
+  init_non_blocking_fix();
+  init_phase_eval();
+  init_phase_state();
+  init_rectification();
+  init_run_phase();
+});
 
+// src/execution/story-orchestrator/builder.ts
 class StoryOrchestratorBuilder {
   state = {};
   addImplementer(value) {
@@ -55667,83 +55932,25 @@ class StoryOrchestratorBuilder {
     return new ExecutionPlan(ctx, { ...this.state }, opts.isThreeSession ?? false);
   }
 }
-var _storyOrchestratorDeps, EXHAUSTED_EXIT_REASONS, TDD_OP_NAMES, STRICT_VERDICT_PHASE_NAMES, CANONICAL_ORDER, PHASE_KIND_TO_STATE_KEY, STRATEGY_TO_REVALIDATION_PHASES;
-var init_story_orchestrator = __esm(() => {
+var init_builder2 = __esm(() => {
   init_errors();
-  init_findings();
-  init_logger2();
   init_operations();
-  init_call();
-  init_event_bus();
-  init_prepare_inputs();
-  init_git();
-  init_non_blocking_fix();
-  init_story_orchestrator_logging();
-  _storyOrchestratorDeps = {
-    callOp,
-    runFixCycle,
-    captureGitRef,
-    prepareSemanticReviewInput,
-    prepareAdversarialReviewInput
-  };
-  EXHAUSTED_EXIT_REASONS = new Set([
-    "max-attempts-total",
-    "max-attempts-per-strategy",
-    "bail-when",
-    "no-strategy",
-    "agent-gave-up",
-    "validate-short-circuit"
-  ]);
-  TDD_OP_NAMES = new Set(["test-writer", "implementer", "verifier"]);
-  STRICT_VERDICT_PHASE_NAMES = new Set([
-    fullSuiteGateOp.name,
-    verifyScopedOp.name,
-    lintCheckOp.name,
-    typecheckCheckOp.name,
-    verifierOp.name
-  ]);
-  CANONICAL_ORDER = [
-    "test-writer",
-    "greenfield-gate",
-    "implementer",
-    "full-suite-gate",
-    "verifier",
-    "verify-scoped",
-    "lint-check",
-    "typecheck-check",
-    "semantic-review",
-    "adversarial-review"
-  ];
-  PHASE_KIND_TO_STATE_KEY = {
-    "test-writer": "testWriter",
-    "greenfield-gate": "greenfieldGate",
-    implementer: "implementer",
-    "full-suite-gate": "fullSuiteGate",
-    verifier: "verifier",
-    "verify-scoped": "verifyScoped",
-    "lint-check": "lintCheck",
-    "typecheck-check": "typecheckCheck",
-    "semantic-review": "semanticReview",
-    "adversarial-review": "adversarialReview"
-  };
-  STRATEGY_TO_REVALIDATION_PHASES = {
-    "mechanical-lintfix": ["lint-check"],
-    "mechanical-formatfix": ["lint-check"],
-    "autofix-implementer": ["lint-check", "typecheck-check", "full-suite-gate", "semantic-review", "adversarial-review"],
-    "autofix-test-writer": ["lint-check", "typecheck-check", "full-suite-gate", "adversarial-review"],
-    "full-suite-rectify": [
-      "lint-check",
-      "typecheck-check",
-      "full-suite-gate",
-      "verifier",
-      "verify-scoped",
-      "semantic-review"
-    ]
-  };
+  init_execution_plan();
+  init_phase_state();
+});
+
+// src/execution/story-orchestrator/index.ts
+var init_story_orchestrator = __esm(() => {
+  init_builder2();
+  init_execution_plan();
+  init_phase_eval();
+  init_rectification();
+  init_run_phase();
+  init_types9();
 });
 
 // src/execution/build-plan-for-strategy.ts
-import { join as join47 } from "path";
+import { join as join48 } from "path";
 function requiresInitialRefCapture(strategy) {
   return isThreeSessionStrategy(strategy);
 }
@@ -55787,7 +55994,7 @@ async function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
   if (inputs.adversarialReview) {
     builder.addAdversarialReview(inputs.adversarialReview);
   }
-  const packageDir = join47(ctx.packageDir, story.workdir ?? "");
+  const packageDir = join48(ctx.packageDir, story.workdir ?? "");
   const resolvedTestPatterns = await resolveTestFilePatterns(config2, ctx.packageDir, story.workdir);
   if (shouldRunRectification(config2) && inputs.rectification) {
     const sink = makeDeclarationSink();
@@ -55842,6 +56049,12 @@ async function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
       nbStrategies.push(makeAutofixImplementerStrategy(story, config2, nbSink, {
         includeAdversarialReview: true
       }));
+    } else if (nbf.scope === "triage") {
+      nbStrategies.push(makeAutofixImplementerStrategy(story, config2, nbSink, {
+        adversarialReviewByFixTarget: "source"
+      }), makeAutofixTestWriterStrategy(story, config2, nbSink, {
+        includeAdversarialReview: false
+      }));
     } else {
       nbStrategies.push(makeAutofixImplementerStrategy(story, config2, nbSink, {
         includeAdversarialReview: false
@@ -55876,26 +56089,6 @@ var init_build_plan_for_strategy = __esm(() => {
   init_story_orchestrator();
 });
 
-// src/utils/paths.ts
-import { join as join48, relative as relative13, sep as sep4 } from "path";
-function packageDirRelative(projectDir, workdir) {
-  if (!projectDir || !workdir || workdir === projectDir)
-    return;
-  const rel = relative13(projectDir, workdir);
-  if (rel === ".." || rel.startsWith(`..${sep4}`))
-    return;
-  return rel && rel !== "." ? rel : undefined;
-}
-function getRunsDir() {
-  return process.env.NAX_RUNS_DIR ?? join48(globalConfigDir(), "runs");
-}
-function getEventsRootDir() {
-  return join48(globalConfigDir(), "events");
-}
-var init_paths3 = __esm(() => {
-  init_paths();
-});
-
 // src/execution/plan-inputs.ts
 function validatePlanInputs(story, config2) {
   if (!story.id || story.id.trim() === "") {
@@ -56140,7 +56333,7 @@ function routeTddFailure(failureCategory, isLiteMode, ctx, reviewReason, failure
     }
     return { action: "escalate", reason: buildReason("isolation-violation") };
   }
-  if (failureCategory === "session-failure" || failureCategory === "tests-failing" || failureCategory === "full-suite-gate-exhausted" || failureCategory === "verifier-rejected" || failureCategory === "runtime-crash") {
+  if (failureCategory === "session-failure" || failureCategory === "tests-failing" || failureCategory === "full-suite-gate-exhausted" || failureCategory === "verifier-rejected" || failureCategory === "runtime-crash" || failureCategory === "review-incomplete") {
     return { action: "escalate", reason: buildReason(failureCategory) };
   }
   if (failureCategory === "greenfield-no-tests") {
@@ -56239,22 +56432,8 @@ async function closeAllRunSessions(sessionManager, agentGetFn, opts) {
   return totalClosed;
 }
 
-// src/execution/post-run.ts
-function shouldRollbackTddFailure(tddMode, failureCategory) {
-  return tddMode?.rollbackEnabled === true && failureCategory === "isolation-violation";
-}
-function extractPauseReason(phaseOutputs) {
-  for (const output of Object.values(phaseOutputs)) {
-    if (output !== null && typeof output === "object") {
-      const record2 = output;
-      if (typeof record2.pauseReason === "string" && record2.pauseReason) {
-        return record2.pauseReason;
-      }
-    }
-  }
-  return;
-}
-function deriveTddFailureCategory(phaseOutputs, unfixedFindings, gateRegressedDuringRect) {
+// src/execution/tdd-failure-category.ts
+function deriveTddFailureCategory(phaseOutputs, unfixedFindings, gateRegressedDuringRect, missingRequiredReviewPhases) {
   const testWriterOutput = phaseOutputs[testWriterOp.name];
   if (testWriterOutput?.success === false) {
     return "session-failure";
@@ -56293,6 +56472,29 @@ function deriveTddFailureCategory(phaseOutputs, unfixedFindings, gateRegressedDu
   if (implOutput?.success === false) {
     return "session-failure";
   }
+  if (missingRequiredReviewPhases && missingRequiredReviewPhases.length > 0) {
+    return "review-incomplete";
+  }
+  return;
+}
+var init_tdd_failure_category = __esm(() => {
+  init_operations();
+  init_story_orchestrator();
+});
+
+// src/execution/post-run.ts
+function shouldRollbackTddFailure(tddMode, failureCategory) {
+  return tddMode?.rollbackEnabled === true && failureCategory === "isolation-violation";
+}
+function extractPauseReason(phaseOutputs) {
+  for (const output of Object.values(phaseOutputs)) {
+    if (output !== null && typeof output === "object") {
+      const record2 = output;
+      if (typeof record2.pauseReason === "string" && record2.pauseReason) {
+        return record2.pauseReason;
+      }
+    }
+  }
   return;
 }
 async function cleanupSessionOnFailure(ctx) {
@@ -56390,7 +56592,7 @@ async function applyPostRunInspection(ctx, planResult, opts) {
     }
   }
   const pauseReason = extractPauseReason(planResult.phaseOutputs);
-  const failureCategory = isTdd && !planResult.success ? deriveTddFailureCategory(planResult.phaseOutputs, planResult.unfixedFindings, planResult.gateRegressedDuringRect) : undefined;
+  const failureCategory = isTdd && !planResult.success ? deriveTddFailureCategory(planResult.phaseOutputs, planResult.unfixedFindings, planResult.gateRegressedDuringRect, planResult.missingRequiredReviewPhases) : undefined;
   if (isTdd && !planResult.success && !failureCategory) {
     const phaseSignals = {};
     for (const [name, output] of Object.entries(planResult.phaseOutputs)) {
@@ -56609,7 +56811,7 @@ var init_post_run = __esm(() => {
   init_scratch_writer();
   init_rollback();
   init_git();
-  init_story_orchestrator();
+  init_tdd_failure_category();
   _postRunDeps = {
     detectMergeConflict,
     checkMergeConflict,
@@ -58746,17 +58948,46 @@ var init_setup_verify = __esm(() => {
   };
 });
 
+// src/cli/setup-write.ts
+import { join as join57 } from "path";
+async function writeSetupConfig(workdir, config2, monoConfigs, _opts, deps = _writeSetupDeps) {
+  const naxDir = join57(workdir, ".nax");
+  const naxConfigPath = join57(naxDir, "config.json");
+  const written = [];
+  await deps.mkdir(naxDir);
+  await deps.writeFile(naxConfigPath, JSON.stringify(config2, null, 2));
+  written.push(naxConfigPath);
+  for (const mc of monoConfigs) {
+    const monoDir = join57(naxDir, "mono", mc.relativeDir);
+    const monoConfigPath = join57(monoDir, "config.json");
+    await deps.mkdir(monoDir);
+    await deps.writeFile(monoConfigPath, JSON.stringify(mc.config, null, 2));
+    written.push(monoConfigPath);
+  }
+  return { written };
+}
+var _writeSetupDeps;
+var init_setup_write = __esm(() => {
+  _writeSetupDeps = {
+    writeFile: (path14, content) => Bun.write(path14, content).then(() => {}),
+    mkdir: async (path14) => {
+      const proc = Bun.spawn(["mkdir", "-p", path14]);
+      await proc.exited;
+    }
+  };
+});
+
 // src/cli/setup.ts
 var exports_setup = {};
 __export(exports_setup, {
   setupCommand: () => setupCommand,
   _setupDeps: () => _setupDeps
 });
-import { join as join57 } from "path";
+import { join as join58 } from "path";
 async function setupCommand(options = {}) {
   const workdir = options.dir ?? process.cwd();
-  const naxDir = join57(workdir, ".nax");
-  const naxConfigPath = join57(naxDir, "config.json");
+  const naxDir = join58(workdir, ".nax");
+  const naxConfigPath = join58(naxDir, "config.json");
   const exists = await _setupDeps.fileExists(naxConfigPath);
   if (exists && !options.force) {
     _setupDeps.stderr("[setup] .nax/config.json already exists. Use --force to overwrite.");
@@ -58786,13 +59017,7 @@ ${JSON.stringify(plan.config, null, 2)}`);
     if (options.fillScripts) {
       await _setupDeps.fillScripts(workdir, analysis);
     }
-    await _setupDeps.mkdir(naxDir);
-    await _setupDeps.writeFile(naxConfigPath, JSON.stringify(plan.config, null, 2));
-    for (const mc of plan.monoConfigs) {
-      const monoDir = join57(naxDir, "mono", mc.relativeDir);
-      await _setupDeps.mkdir(monoDir);
-      await _setupDeps.writeFile(join57(monoDir, "config.json"), JSON.stringify(mc.config, null, 2));
-    }
+    await _setupDeps.writeSetupConfig(workdir, plan.config, plan.monoConfigs, { force: options.force });
     const gateResult = await _setupDeps.runGate(workdir, plan.config);
     if (gateResult !== 0) {
       return gateResult;
@@ -58809,6 +59034,7 @@ var init_setup = __esm(() => {
   init_setup_fill();
   init_setup_llm();
   init_setup_verify();
+  init_setup_write();
   _setupDeps = {
     analyzeRepo,
     fillScripts,
@@ -58830,11 +59056,7 @@ var init_setup = __esm(() => {
     generateSetupPlan: (ctx, analysis) => generateSetupPlan(ctx, analysis),
     runGate: (workdir, config2) => runSetupGate(workdir, config2),
     fileExists: (path14) => Bun.file(path14).exists(),
-    writeFile: (path14, content) => Bun.write(path14, content).then(() => {}),
-    mkdir: async (path14) => {
-      const proc = Bun.spawn(["mkdir", "-p", path14]);
-      await proc.exited;
-    },
+    writeSetupConfig: (workdir, config2, monoConfigs, opts) => writeSetupConfig(workdir, config2, monoConfigs, opts),
     stdout: (msg) => {
       process.stdout.write(`${msg}
 `);
@@ -60273,7 +60495,7 @@ var init_command_argv = __esm(() => {
 });
 
 // src/hooks/runner.ts
-import { join as join74 } from "path";
+import { join as join75 } from "path";
 function createDrainDeadline2(deadlineMs) {
   let timeoutId;
   const promise2 = new Promise((resolve16) => {
@@ -60292,14 +60514,14 @@ async function loadHooksConfig(projectDir, globalDir) {
   let globalHooks = { hooks: {} };
   let projectHooks = { hooks: {} };
   let skipGlobal = false;
-  const projectPath = join74(projectDir, "hooks.json");
+  const projectPath = join75(projectDir, "hooks.json");
   const projectData = await loadJsonFile(projectPath, "hooks");
   if (projectData) {
     projectHooks = projectData;
     skipGlobal = projectData.skipGlobal ?? false;
   }
   if (!skipGlobal && globalDir) {
-    const globalPath = join74(globalDir, "hooks.json");
+    const globalPath = join75(globalDir, "hooks.json");
     const globalData = await loadJsonFile(globalPath, "hooks");
     if (globalData) {
       globalHooks = globalData;
@@ -60469,7 +60691,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.70.0",
+    version: "0.70.2",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -60480,7 +60702,7 @@ var init_package = __esm(() => {
       dev: "bun run bin/nax.ts",
       build: 'bun build bin/nax.ts --outdir dist --target bun --define "GIT_COMMIT=\\"$(git rev-parse --short HEAD)\\""',
       typecheck: "bun x tsc --noEmit && bun x tsc --noEmit -p tsconfig.contracts.json",
-      lint: "bun x biome check src/ bin/ && bun run check:no-real-global-nax && bun run check:alias-internals && bun run check:deep-relatives && bun run check:nax-error && bun run check:logger-storyid",
+      lint: "bun x biome check src/ bin/ && bun run check:no-real-global-nax && bun run check:alias-internals && bun run check:deep-relatives && bun run check:nax-error && bun run check:logger-storyid && bun run check:file-sizes",
       "lint:json": "bun x biome check src/ bin/ --reporter json && bun run check:nax-error 1>&2 && bun run check:logger-storyid 1>&2",
       "lint:fix": "bun x biome check --write src/ bin/",
       "check:no-real-global-nax": "bun run scripts/check-no-real-global-nax.ts",
@@ -60491,6 +60713,8 @@ var init_package = __esm(() => {
       "check:nax-error:update": "bun run scripts/check-nax-error.ts --update-baseline",
       "check:logger-storyid": "bun run scripts/check-logger-storyid.ts",
       "check:logger-storyid:update": "bun run scripts/check-logger-storyid.ts --update-baseline",
+      "check:file-sizes": "bun run scripts/check-file-sizes.ts",
+      "check:file-sizes:update": "bun run scripts/check-file-sizes.ts --update-baseline",
       release: "bun scripts/release.ts",
       test: "AGENT=1 bun run scripts/run-tests.ts",
       "test:verbose": "bun run scripts/run-tests.ts",
@@ -60502,6 +60726,8 @@ var init_package = __esm(() => {
       "test:integration": "bun test ./test/integration/ --timeout=60000",
       "test:ui": "bun test ./test/ui/ --timeout=60000",
       "test:e2e": "timeout -k 5s 180s bun test test/e2e/ --timeout=60000",
+      "test:coverage": "bun run scripts/check-coverage.ts",
+      "test:coverage:report": "bun run scripts/check-coverage.ts --report",
       "check-test-overlap": "bun run scripts/check-test-overlap.ts",
       "check-dead-tests": "bun run scripts/check-dead-tests.ts",
       "check:test-sizes": "bun run scripts/check-test-sizes.ts",
@@ -60565,8 +60791,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("0be1d11a"))
-        return "0be1d11a";
+      if (/^[0-9a-f]{6,10}$/.test("0e202cfa"))
+        return "0e202cfa";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -61444,15 +61670,15 @@ var init_acceptance_loop = __esm(() => {
 
 // src/session/scratch-purge.ts
 import { mkdir as mkdir12, rename, rm } from "fs/promises";
-import { dirname as dirname12, join as join75 } from "path";
+import { dirname as dirname12, join as join76 } from "path";
 async function purgeStaleScratch(projectDir, featureName, retentionDays, archiveInsteadOfDelete = false) {
-  const sessionsDir = join75(projectDir, ".nax", "features", featureName, "sessions");
+  const sessionsDir = join76(projectDir, ".nax", "features", featureName, "sessions");
   const sessionIds = await _scratchPurgeDeps.listSessionDirs(sessionsDir);
   const cutoffMs = _scratchPurgeDeps.now() - retentionDays * 86400000;
   let purged = 0;
   for (const sessionId of sessionIds) {
-    const sessionDir = join75(sessionsDir, sessionId);
-    const descriptorPath = join75(sessionDir, "descriptor.json");
+    const sessionDir = join76(sessionsDir, sessionId);
+    const descriptorPath = join76(sessionDir, "descriptor.json");
     if (!await _scratchPurgeDeps.fileExists(descriptorPath))
       continue;
     let lastActivityAt;
@@ -61468,7 +61694,7 @@ async function purgeStaleScratch(projectDir, featureName, retentionDays, archive
     if (new Date(lastActivityAt).getTime() >= cutoffMs)
       continue;
     if (archiveInsteadOfDelete) {
-      const archiveDest = join75(projectDir, ".nax", "features", featureName, "_archive", "sessions", sessionId);
+      const archiveDest = join76(projectDir, ".nax", "features", featureName, "_archive", "sessions", sessionId);
       await _scratchPurgeDeps.move(sessionDir, archiveDest);
     } else {
       await _scratchPurgeDeps.remove(sessionDir);
@@ -62173,7 +62399,7 @@ function outputRunFooter(options) {
 }
 var init_headless_formatter = __esm(() => {
   init_source();
-  init_logging();
+  init_log_format();
   init_version();
 });
 
@@ -62219,12 +62445,12 @@ var DEFAULT_MAX_BATCH_SIZE = 4;
 
 // src/pipeline/subscribers/events-writer.ts
 import { appendFile as appendFile4, mkdir as mkdir13 } from "fs/promises";
-import { basename as basename13, join as join76 } from "path";
+import { basename as basename13, join as join77 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename13(workdir);
-  const eventsDir = join76(getEventsRootDir(), project);
-  const eventsFile = join76(eventsDir, "events.jsonl");
+  const eventsDir = join77(getEventsRootDir(), project);
+  const eventsFile = join77(eventsDir, "events.jsonl");
   let dirReady = false;
   const write = (line) => {
     return (async () => {
@@ -62405,12 +62631,12 @@ var init_interaction2 = __esm(() => {
 
 // src/pipeline/subscribers/registry.ts
 import { mkdir as mkdir14, writeFile as writeFile2 } from "fs/promises";
-import { basename as basename14, join as join77 } from "path";
+import { basename as basename14, join as join78 } from "path";
 function wireRegistry(bus, feature, runId, workdir, outputDir) {
   const logger = getSafeLogger();
   const project = basename14(workdir);
-  const runDir = join77(getRunsDir(), `${project}-${feature}-${runId}`);
-  const metaFile = join77(runDir, "meta.json");
+  const runDir = join78(getRunsDir(), `${project}-${feature}-${runId}`);
+  const metaFile = join78(runDir, "meta.json");
   const unsub = bus.on("run:started", (_ev) => {
     return (async () => {
       try {
@@ -62420,8 +62646,8 @@ function wireRegistry(bus, feature, runId, workdir, outputDir) {
           project,
           feature,
           workdir,
-          statusPath: join77(outputDir, "features", feature, "status.json"),
-          eventsDir: join77(outputDir, "features", feature, "runs"),
+          statusPath: join78(outputDir, "features", feature, "status.json"),
+          eventsDir: join78(outputDir, "features", feature, "runs"),
           registeredAt: new Date().toISOString()
         };
         await writeFile2(metaFile, JSON.stringify(meta3, null, 2));
@@ -62653,7 +62879,7 @@ function buildPreviewRouting(story, config2) {
 
 // src/worktree/types.ts
 var WorktreeDependencyPreparationError;
-var init_types9 = __esm(() => {
+var init_types10 = __esm(() => {
   WorktreeDependencyPreparationError = class WorktreeDependencyPreparationError extends Error {
     mode;
     failureCategory = "dependency-prep";
@@ -62667,7 +62893,7 @@ var init_types9 = __esm(() => {
 
 // src/worktree/dependencies.ts
 import { existsSync as existsSync30 } from "fs";
-import { join as join78 } from "path";
+import { join as join79 } from "path";
 async function prepareWorktreeDependencies(options) {
   const mode = options.config.execution.worktreeDependencies.mode;
   const resolvedCwd = resolveDependencyCwd(options);
@@ -62681,7 +62907,7 @@ async function prepareWorktreeDependencies(options) {
   }
 }
 function resolveDependencyCwd(options) {
-  return options.storyWorkdir ? join78(options.worktreeRoot, options.storyWorkdir) : options.worktreeRoot;
+  return options.storyWorkdir ? join79(options.worktreeRoot, options.storyWorkdir) : options.worktreeRoot;
 }
 function resolveInheritedDependencies(options, resolvedCwd) {
   if (hasDependencyManifests(options.worktreeRoot, resolvedCwd)) {
@@ -62691,7 +62917,7 @@ function resolveInheritedDependencies(options, resolvedCwd) {
 }
 function hasDependencyManifests(worktreeRoot, resolvedCwd) {
   const directories = resolvedCwd === worktreeRoot ? [worktreeRoot] : [worktreeRoot, resolvedCwd];
-  return directories.some((directory) => PHASE_ONE_INHERIT_UNSUPPORTED_FILES.some((filename) => _worktreeDependencyDeps.existsSync(join78(directory, filename))));
+  return directories.some((directory) => PHASE_ONE_INHERIT_UNSUPPORTED_FILES.some((filename) => _worktreeDependencyDeps.existsSync(join79(directory, filename))));
 }
 async function provisionDependencies(config2, worktreeRoot, resolvedCwd) {
   const setupCommand2 = config2.execution.worktreeDependencies.setupCommand;
@@ -62723,7 +62949,7 @@ var PHASE_ONE_INHERIT_UNSUPPORTED_FILES, _worktreeDependencyDeps;
 var init_dependencies = __esm(() => {
   init_bun_deps();
   init_command_argv();
-  init_types9();
+  init_types10();
   PHASE_ONE_INHERIT_UNSUPPORTED_FILES = [
     "package.json",
     "bun.lock",
@@ -62755,13 +62981,13 @@ __export(exports_manager, {
 });
 import { existsSync as existsSync31, symlinkSync } from "fs";
 import { mkdir as mkdir15 } from "fs/promises";
-import { join as join79 } from "path";
+import { join as join80 } from "path";
 
 class WorktreeManager {
   async ensureGitExcludes(projectRoot) {
     const logger = getSafeLogger();
-    const infoDir = join79(projectRoot, ".git", "info");
-    const excludePath = join79(infoDir, "exclude");
+    const infoDir = join80(projectRoot, ".git", "info");
+    const excludePath = join80(infoDir, "exclude");
     try {
       await mkdir15(infoDir, { recursive: true });
       let existing = "";
@@ -62788,7 +63014,7 @@ ${missing.join(`
   }
   async create(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join79(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join80(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const pruneProc = _managerDeps.spawn(["git", "worktree", "prune"], {
@@ -62828,9 +63054,9 @@ ${missing.join(`
       }
       throw new Error(`Failed to create worktree: ${String(error48)}`);
     }
-    const envSource = join79(projectRoot, ".env");
+    const envSource = join80(projectRoot, ".env");
     if (existsSync31(envSource)) {
-      const envTarget = join79(worktreePath, ".env");
+      const envTarget = join80(worktreePath, ".env");
       try {
         symlinkSync(envSource, envTarget, "file");
       } catch (error48) {
@@ -62841,7 +63067,7 @@ ${missing.join(`
   }
   async remove(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join79(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join80(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const proc = _managerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
@@ -63425,6 +63651,8 @@ function resolveMaxAttemptsOutcome(failureCategory) {
       return "pause";
     case "runtime-crash":
       return "pause";
+    case "review-incomplete":
+      return "pause";
     case "session-failure":
     case "tests-failing":
     case "full-suite-gate-exhausted":
@@ -63663,10 +63891,10 @@ var init_merge_conflict_rectify = __esm(() => {
 });
 
 // src/execution/pipeline-result-handler.ts
-import { join as join80 } from "path";
+import { join as join81 } from "path";
 async function removeWorktreeDirectory(projectRoot, storyId) {
   const logger = getSafeLogger();
-  const worktreePath = join80(projectRoot, ".nax-wt", storyId);
+  const worktreePath = join81(projectRoot, ".nax-wt", storyId);
   try {
     const proc = _resultHandlerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
       cwd: projectRoot,
@@ -63883,7 +64111,7 @@ var init_pipeline_result_handler = __esm(() => {
 
 // src/execution/iteration-runner.ts
 import { existsSync as existsSync32 } from "fs";
-import { join as join81 } from "path";
+import { join as join82 } from "path";
 async function runIteration(ctx, prd, selection, iterations, totalCost, allStoryMetrics) {
   const { story, storiesToExecute, routing, isBatchExecution } = selection;
   if (ctx.dryRun) {
@@ -63908,7 +64136,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
   const storyStartTime = Date.now();
   let effectiveWorkdir = ctx.workdir;
   if (ctx.config.execution.storyIsolation === "worktree") {
-    const worktreePath = join81(ctx.workdir, ".nax-wt", story.id);
+    const worktreePath = join82(ctx.workdir, ".nax-wt", story.id);
     const worktreeExists = _iterationRunnerDeps.existsSync(worktreePath);
     if (!worktreeExists) {
       await _iterationRunnerDeps.worktreeManager.ensureGitExcludes(ctx.workdir);
@@ -63928,7 +64156,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
   }
   const accumulatedAttemptCost = (story.priorFailures || []).reduce((sum, f) => sum + (f.cost || 0), 0);
   const profileOverride = profileOverrideFromConfig(ctx.config);
-  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join81(ctx.workdir, ".nax", "config.json"), story.workdir, profileOverride) : ctx.config;
+  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join82(ctx.workdir, ".nax", "config.json"), story.workdir, profileOverride) : ctx.config;
   let dependencyContext;
   if (ctx.config.execution.storyIsolation === "worktree") {
     try {
@@ -63955,7 +64183,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
       };
     }
   }
-  const resolvedWorkdir = dependencyContext?.cwd ? dependencyContext.cwd : ctx.config.execution.storyIsolation === "worktree" ? story.workdir ? join81(effectiveWorkdir, story.workdir) : effectiveWorkdir : story.workdir ? join81(ctx.workdir, story.workdir) : ctx.workdir;
+  const resolvedWorkdir = dependencyContext?.cwd ? dependencyContext.cwd : ctx.config.execution.storyIsolation === "worktree" ? story.workdir ? join82(effectiveWorkdir, story.workdir) : effectiveWorkdir : story.workdir ? join82(ctx.workdir, story.workdir) : ctx.workdir;
   const pipelineContext = {
     config: effectiveConfig,
     rootConfig: ctx.config,
@@ -64158,7 +64386,7 @@ __export(exports_parallel_worker, {
   buildWorktreePipelineContext: () => buildWorktreePipelineContext,
   _parallelWorkerDeps: () => _parallelWorkerDeps
 });
-import { join as join82 } from "path";
+import { join as join83 } from "path";
 function buildWorktreePipelineContext(base, _story) {
   return { ...base, prd: structuredClone(base.prd) };
 }
@@ -64181,7 +64409,7 @@ async function executeStoryInWorktree(story, worktreePath, dependencyContext, co
       story,
       stories: [story],
       projectDir: context.projectDir,
-      workdir: dependencyContext.cwd ?? (story.workdir ? join82(worktreePath, story.workdir) : worktreePath),
+      workdir: dependencyContext.cwd ?? (story.workdir ? join83(worktreePath, story.workdir) : worktreePath),
       worktreeDependencyContext: dependencyContext,
       routing,
       storyGitRef: storyGitRef ?? undefined
@@ -65081,7 +65309,7 @@ async function writeStatusFile(filePath, status) {
 var init_status_file = () => {};
 
 // src/execution/status-writer.ts
-import { join as join83 } from "path";
+import { join as join84 } from "path";
 
 class StatusWriter {
   statusFile;
@@ -65200,7 +65428,7 @@ class StatusWriter {
     if (!this._prd)
       return;
     const safeLogger = getSafeLogger();
-    const featureStatusPath = join83(featureDir, "status.json");
+    const featureStatusPath = join84(featureDir, "status.json");
     const write = async () => {
       try {
         const base = this.getSnapshot(totalCost, iterations);
@@ -65634,7 +65862,7 @@ __export(exports_run_initialization, {
   initializeRun: () => initializeRun,
   _reconcileDeps: () => _reconcileDeps
 });
-import { join as join84 } from "path";
+import { join as join85 } from "path";
 async function reconcileState(prd, prdPath, workdir, config2) {
   const logger = getSafeLogger();
   let reconciledCount = 0;
@@ -65651,7 +65879,7 @@ async function reconcileState(prd, prdPath, workdir, config2) {
       });
       continue;
     }
-    const effectiveWorkdir = story.workdir ? join84(workdir, story.workdir) : workdir;
+    const effectiveWorkdir = story.workdir ? join85(workdir, story.workdir) : workdir;
     try {
       const reviewResult = await _reconcileDeps.runReview(config2.review, effectiveWorkdir, config2.execution);
       if (!reviewResult.success) {
@@ -95482,7 +95710,7 @@ __export(exports_curator, {
 });
 import { readdirSync as readdirSync8 } from "fs";
 import { unlink as unlink4 } from "fs/promises";
-import { basename as basename15, join as join86 } from "path";
+import { basename as basename15, join as join87 } from "path";
 function getProjectKey(config2, projectDir) {
   return config2.name?.trim() || basename15(projectDir);
 }
@@ -95565,7 +95793,7 @@ async function curatorStatus(options) {
   const config2 = await _curatorCmdDeps.loadConfig(resolved.projectDir);
   const projectKey = getProjectKey(config2, resolved.projectDir);
   const outputDir = _curatorCmdDeps.projectOutputDir(projectKey, config2.outputDir);
-  const runsDir = join86(outputDir, "runs");
+  const runsDir = join87(outputDir, "runs");
   const runIds = listRunIds(runsDir);
   let runId;
   if (options.run) {
@@ -95582,8 +95810,8 @@ async function curatorStatus(options) {
     runId = runIds[runIds.length - 1];
   }
   console.log(`Run: ${runId}`);
-  const runDir = join86(runsDir, runId);
-  const observationsPath = join86(runDir, "observations.jsonl");
+  const runDir = join87(runsDir, runId);
+  const observationsPath = join87(runDir, "observations.jsonl");
   const observations = await parseObservations(observationsPath);
   const counts = new Map;
   for (const obs of observations) {
@@ -95593,7 +95821,7 @@ async function curatorStatus(options) {
   for (const [kind, count] of counts.entries()) {
     console.log(`  ${kind}: ${count}`);
   }
-  const proposalsPath = join86(runDir, "curator-proposals.md");
+  const proposalsPath = join87(runDir, "curator-proposals.md");
   const proposalText = await _curatorCmdDeps.readFile(proposalsPath).catch(() => null);
   if (proposalText !== null) {
     console.log("");
@@ -95607,8 +95835,8 @@ async function curatorCommit(options) {
   const config2 = await _curatorCmdDeps.loadConfig(resolved.projectDir);
   const projectKey = getProjectKey(config2, resolved.projectDir);
   const outputDir = _curatorCmdDeps.projectOutputDir(projectKey, config2.outputDir);
-  const runDir = join86(outputDir, "runs", options.runId);
-  const proposalsPath = join86(runDir, "curator-proposals.md");
+  const runDir = join87(outputDir, "runs", options.runId);
+  const proposalsPath = join87(runDir, "curator-proposals.md");
   const proposalText = await _curatorCmdDeps.readFile(proposalsPath).catch(() => null);
   if (proposalText === null) {
     console.log(`curator-proposals.md not found for run ${options.runId}.`);
@@ -95624,7 +95852,7 @@ async function curatorCommit(options) {
   const dropFileState = new Map;
   const skippedDrops = new Set;
   for (const drop2 of drops) {
-    const targetPath = join86(resolved.projectDir, drop2.canonicalFile);
+    const targetPath = join87(resolved.projectDir, drop2.canonicalFile);
     if (!dropFileState.has(targetPath)) {
       const fileExists2 = await Bun.file(targetPath).exists();
       const existing = fileExists2 ? await _curatorCmdDeps.readFile(targetPath).catch(() => "") : "";
@@ -95658,7 +95886,7 @@ async function curatorCommit(options) {
     if (skippedDrops.has(drop2)) {
       continue;
     }
-    const targetPath = join86(resolved.projectDir, drop2.canonicalFile);
+    const targetPath = join87(resolved.projectDir, drop2.canonicalFile);
     const existing = await _curatorCmdDeps.readFile(targetPath).catch(() => "");
     const filtered = filterDropContent(existing, drop2.description);
     await _curatorCmdDeps.writeFile(targetPath, filtered);
@@ -95667,7 +95895,7 @@ async function curatorCommit(options) {
   }
   const adds = proposals.filter((p) => p.action === "add" || p.action === "advisory");
   for (const add2 of adds) {
-    const targetPath = join86(resolved.projectDir, add2.canonicalFile);
+    const targetPath = join87(resolved.projectDir, add2.canonicalFile);
     const content = buildAddContent(add2);
     await _curatorCmdDeps.appendFile(targetPath, content);
     modifiedFiles.add(targetPath);
@@ -95704,7 +95932,7 @@ async function curatorDryrun(options) {
   const config2 = await _curatorCmdDeps.loadConfig(resolved.projectDir);
   const projectKey = getProjectKey(config2, resolved.projectDir);
   const outputDir = _curatorCmdDeps.projectOutputDir(projectKey, config2.outputDir);
-  const runsDir = join86(outputDir, "runs");
+  const runsDir = join87(outputDir, "runs");
   const runIds = listRunIds(runsDir);
   if (runIds.length === 0) {
     console.log("No runs found.");
@@ -95715,7 +95943,7 @@ async function curatorDryrun(options) {
     console.log(`Run ${options.run} not found in ${runsDir}.`);
     return;
   }
-  const observationsPath = join86(runsDir, runId, "observations.jsonl");
+  const observationsPath = join87(runsDir, runId, "observations.jsonl");
   const observations = await parseObservations(observationsPath);
   const thresholds = getThresholds(config2);
   const proposals = runHeuristics(observations, thresholds);
@@ -95756,12 +95984,12 @@ async function curatorGc(options) {
   await _curatorCmdDeps.writeFile(rollupPath, newContent);
   const projectKey = getProjectKey(config2, resolved.projectDir);
   const outputDir = _curatorCmdDeps.projectOutputDir(projectKey, config2.outputDir);
-  const perRunsDir = join86(outputDir, "runs");
+  const perRunsDir = join87(outputDir, "runs");
   for (const runId of uniqueRunIds) {
     if (!keepSet.has(runId)) {
-      const runDir = join86(perRunsDir, runId);
-      await _curatorCmdDeps.removeFile(join86(runDir, "observations.jsonl"));
-      await _curatorCmdDeps.removeFile(join86(runDir, "curator-proposals.md"));
+      const runDir = join87(perRunsDir, runId);
+      await _curatorCmdDeps.removeFile(join87(runDir, "observations.jsonl"));
+      await _curatorCmdDeps.removeFile(join87(runDir, "curator-proposals.md"));
     }
   }
   console.log(`[gc] Pruned rollup to ${keep} most recent runs (was ${uniqueRunIds.length}).`);
@@ -95806,7 +96034,7 @@ var init_curator2 = __esm(() => {
 init_source();
 import { existsSync as existsSync35, mkdirSync as mkdirSync7 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename as basename16, join as join87 } from "path";
+import { basename as basename16, join as join88 } from "path";
 
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -96930,6 +97158,7 @@ async function runsShowCommand(options) {
 init_prompts2();
 init_init2();
 init_setup();
+init_setup_write();
 
 // src/cli/plugins.ts
 init_paths();
@@ -97005,7 +97234,7 @@ init_source();
 init_loader();
 init_generator2();
 import { existsSync as existsSync24 } from "fs";
-import { join as join62 } from "path";
+import { join as join63 } from "path";
 var VALID_AGENTS = ["claude", "codex", "opencode", "cursor", "windsurf", "aider", "gemini"];
 async function generateCommand(options) {
   const workdir = options.dir ?? process.cwd();
@@ -97048,7 +97277,7 @@ async function generateCommand(options) {
     return;
   }
   if (options.package) {
-    const packageDir = join62(workdir, options.package);
+    const packageDir = join63(workdir, options.package);
     if (dryRun) {
       console.log(source_default.yellow("\u26A0 Dry run \u2014 no files will be written"));
     }
@@ -97068,8 +97297,8 @@ async function generateCommand(options) {
       process.exit(1);
     return;
   }
-  const contextPath = options.context ? join62(workdir, options.context) : join62(workdir, ".nax/context.md");
-  const outputDir = options.output ? join62(workdir, options.output) : workdir;
+  const contextPath = options.context ? join63(workdir, options.context) : join63(workdir, ".nax/context.md");
+  const outputDir = options.output ? join63(workdir, options.output) : workdir;
   const autoInject = !options.noAutoInject;
   if (!existsSync24(contextPath)) {
     console.error(source_default.red(`\u2717 Context file not found: ${contextPath}`));
@@ -97175,7 +97404,7 @@ async function generateCommand(options) {
 // src/cli/config-display.ts
 init_loader();
 import { existsSync as existsSync26 } from "fs";
-import { join as join64 } from "path";
+import { join as join65 } from "path";
 
 // src/cli/config-descriptions.ts
 var FIELD_DESCRIPTIONS = {
@@ -97428,7 +97657,7 @@ function deepEqual(a, b) {
 init_defaults();
 init_loader();
 import { existsSync as existsSync25 } from "fs";
-import { join as join63 } from "path";
+import { join as join64 } from "path";
 async function loadConfigFile(path19) {
   if (!existsSync25(path19))
     return null;
@@ -97450,7 +97679,7 @@ async function loadProjectConfig() {
   const projectDir = findProjectDir();
   if (!projectDir)
     return null;
-  const projectPath = join63(projectDir, "config.json");
+  const projectPath = join64(projectDir, "config.json");
   return await loadConfigFile(projectPath);
 }
 
@@ -97510,7 +97739,7 @@ async function configCommand(config2, options = {}) {
 function determineConfigSources() {
   const globalPath = globalConfigPath();
   const projectDir = findProjectDir();
-  const projectPath = projectDir ? join64(projectDir, "config.json") : null;
+  const projectPath = projectDir ? join65(projectDir, "config.json") : null;
   return {
     global: fileExists(globalPath) ? globalPath : null,
     project: projectPath && fileExists(projectPath) ? projectPath : null
@@ -97659,15 +97888,15 @@ init_paths();
 init_profile();
 import { mkdirSync as mkdirSync5 } from "fs";
 import { readdirSync as readdirSync5 } from "fs";
-import { join as join65 } from "path";
+import { join as join66 } from "path";
 var _profileCLIDeps = {
   env: process.env
 };
 var SENSITIVE_KEY_PATTERN = /key|token|secret|password|credential/i;
 var VAR_PATTERN = /\$[A-Za-z_][A-Za-z0-9_]*/;
 async function profileListCommand(startDir) {
-  const globalProfilesDir = join65(globalConfigDir(), "profiles");
-  const projectProfilesDir = join65(projectConfigDir(startDir), "profiles");
+  const globalProfilesDir = join66(globalConfigDir(), "profiles");
+  const projectProfilesDir = join66(projectConfigDir(startDir), "profiles");
   const globalProfiles = scanProfileDir(globalProfilesDir);
   const projectProfiles = scanProfileDir(projectProfilesDir);
   const activeProfile = await resolveProfileName({}, _profileCLIDeps.env, startDir);
@@ -97726,7 +97955,7 @@ function maskProfileValues(obj) {
   return result;
 }
 async function profileUseCommand(profileName, startDir) {
-  const configPath = join65(projectConfigDir(startDir), "config.json");
+  const configPath = join66(projectConfigDir(startDir), "config.json");
   const configFile = Bun.file(configPath);
   let existing = {};
   if (await configFile.exists()) {
@@ -97745,8 +97974,8 @@ async function profileCurrentCommand(startDir) {
   return resolveProfileName({}, _profileCLIDeps.env, startDir);
 }
 async function profileCreateCommand(profileName, startDir) {
-  const profilesDir = join65(projectConfigDir(startDir), "profiles");
-  const profilePath = join65(profilesDir, `${profileName}.json`);
+  const profilesDir = join66(projectConfigDir(startDir), "profiles");
+  const profilePath = join66(profilesDir, `${profileName}.json`);
   const profileFile = Bun.file(profilePath);
   if (await profileFile.exists()) {
     throw new Error(`Profile "${profileName}" already exists at ${profilePath}`);
@@ -97868,7 +98097,7 @@ async function contextInspectCommand(options) {
 init_canonical_loader();
 init_errors();
 import { mkdir as mkdir11 } from "fs/promises";
-import { basename as basename12, join as join66 } from "path";
+import { basename as basename12, join as join67 } from "path";
 var _rulesCLIDeps = {
   readFile: async (path19) => Bun.file(path19).text(),
   writeFile: async (path19, content) => {
@@ -97877,7 +98106,7 @@ var _rulesCLIDeps = {
   fileExists: async (path19) => Bun.file(path19).exists(),
   globInDir: (dir) => {
     try {
-      return [...new Bun.Glob("*.md").scanSync({ cwd: dir })].sort().map((f) => join66(dir, f));
+      return [...new Bun.Glob("*.md").scanSync({ cwd: dir })].sort().map((f) => join67(dir, f));
     } catch {
       return [];
     }
@@ -97926,7 +98155,7 @@ ${r.content}`).join(`
 `);
   const shimContent = `${header + body}
 `;
-  const shimPath = join66(workdir, shimFileName);
+  const shimPath = join67(workdir, shimFileName);
   if (options.dryRun) {
     console.log(`[dry-run] Would write ${shimPath} (${shimContent.length} bytes)`);
     return;
@@ -97955,14 +98184,14 @@ function neutralizeContent(content) {
 }
 async function collectMigrationSources(workdir) {
   const sources = [];
-  const claudeMdPath = join66(workdir, "CLAUDE.md");
+  const claudeMdPath = join67(workdir, "CLAUDE.md");
   if (await _rulesCLIDeps.fileExists(claudeMdPath)) {
     const content = await _rulesCLIDeps.readFile(claudeMdPath);
     if (content.trim()) {
       sources.push({ sourcePath: claudeMdPath, targetFileName: "project-conventions.md", content });
     }
   }
-  const rulesDir = join66(workdir, ".claude", "rules");
+  const rulesDir = join67(workdir, ".claude", "rules");
   const ruleFiles = _rulesCLIDeps.globInDir(rulesDir);
   for (const filePath of ruleFiles) {
     try {
@@ -97982,7 +98211,7 @@ async function rulesMigrateCommand(options) {
     console.log("[WARN] No source files found (checked CLAUDE.md and .claude/rules/*.md). Nothing to migrate.");
     return;
   }
-  const targetDir = join66(workdir, CANONICAL_RULES_DIR);
+  const targetDir = join67(workdir, CANONICAL_RULES_DIR);
   if (!options.dryRun) {
     try {
       await _rulesCLIDeps.mkdir(targetDir);
@@ -97993,7 +98222,7 @@ async function rulesMigrateCommand(options) {
   let written = 0;
   let skipped = 0;
   for (const { sourcePath, targetFileName, content } of sources) {
-    const targetPath = join66(targetDir, targetFileName);
+    const targetPath = join67(targetDir, targetFileName);
     if (!force && !options.dryRun && await _rulesCLIDeps.fileExists(targetPath)) {
       console.log(`[skip] ${targetFileName} already exists (use --force to overwrite)`);
       skipped++;
@@ -98032,7 +98261,7 @@ function collectCanonicalRuleRoots(workdir) {
     const packageRel = normalized.slice(0, idx);
     if (!packageRel)
       continue;
-    roots.add(join66(workdir, packageRel));
+    roots.add(join67(workdir, packageRel));
   }
   return [...roots].sort();
 }
@@ -98084,7 +98313,7 @@ init_logger2();
 init_detect2();
 init_workspace();
 init_common();
-import { join as join67 } from "path";
+import { join as join68 } from "path";
 function resolveEffective(detected, configPatterns) {
   if (configPatterns !== undefined)
     return "config";
@@ -98169,7 +98398,7 @@ async function detectCommand(options) {
   const rootDetected = detectionMap[""] ?? { patterns: [], confidence: "empty", sources: [] };
   const pkgEntries = await Promise.all(packageDirs.map(async (dir) => {
     const det = detectionMap[dir] ?? { patterns: [], confidence: "empty", sources: [] };
-    const pkgConfigPath = join67(workdir, ".nax", "mono", dir, "config.json");
+    const pkgConfigPath = join68(workdir, ".nax", "mono", dir, "config.json");
     const pkgRaw = await loadRawConfig(pkgConfigPath);
     const pkgPatterns = deepGet(pkgRaw, TEST_PATTERNS_KEY);
     const effective = Array.isArray(pkgPatterns) ? pkgPatterns : undefined;
@@ -98223,13 +98452,13 @@ async function detectCommand(options) {
     if (rootDetected.confidence === "empty") {
       console.log(source_default.yellow("  root: skipped (empty detection)"));
     } else {
-      const rootConfigPath = join67(workdir, ".nax", "config.json");
+      const rootConfigPath = join68(workdir, ".nax", "config.json");
       try {
         const status = await applyToConfig(rootConfigPath, rootDetected.patterns, options.force ?? false);
         if (status === "skipped") {
           console.log(source_default.dim("  root: skipped (testFilePatterns already set; use --force to overwrite)"));
         } else {
-          console.log(source_default.green(`  root: ${status} \u2192 ${join67(".nax", "config.json")}`));
+          console.log(source_default.green(`  root: ${status} \u2192 ${join68(".nax", "config.json")}`));
         }
       } catch (err) {
         console.error(source_default.red(`  root: write failed \u2014 ${err.message}`));
@@ -98242,13 +98471,13 @@ async function detectCommand(options) {
         console.log(source_default.dim(`  ${dir}: skipped (empty detection)`));
         continue;
       }
-      const pkgConfigPath = join67(workdir, ".nax", "mono", dir, "config.json");
+      const pkgConfigPath = join68(workdir, ".nax", "mono", dir, "config.json");
       try {
         const status = await applyToConfig(pkgConfigPath, det.patterns, options.force ?? false);
         if (status === "skipped") {
           console.log(source_default.dim(`  ${dir}: skipped (already set)`));
         } else {
-          console.log(source_default.green(`  ${dir}: ${status} \u2192 ${join67(".nax", "mono", dir, "config.json")}`));
+          console.log(source_default.green(`  ${dir}: ${status} \u2192 ${join68(".nax", "mono", dir, "config.json")}`));
         }
       } catch (err) {
         console.error(source_default.red(`  ${dir}: write failed \u2014 ${err.message}`));
@@ -98266,19 +98495,19 @@ async function detectCommand(options) {
 // src/commands/logs.ts
 init_common();
 import { existsSync as existsSync28 } from "fs";
-import { join as join70 } from "path";
+import { join as join71 } from "path";
 
 // src/commands/logs-formatter.ts
 init_source();
 init_formatter();
 import { readdirSync as readdirSync7 } from "fs";
-import { join as join69 } from "path";
+import { join as join70 } from "path";
 
 // src/commands/logs-reader.ts
 init_paths3();
 import { existsSync as existsSync27, readdirSync as readdirSync6 } from "fs";
 import { readdir as readdir3 } from "fs/promises";
-import { join as join68 } from "path";
+import { join as join69 } from "path";
 var _logsReaderDeps = {
   getRunsDir
 };
@@ -98292,7 +98521,7 @@ async function resolveRunFileFromRegistry(runId) {
   }
   let matched = null;
   for (const entry of entries) {
-    const metaPath = join68(runsDir, entry, "meta.json");
+    const metaPath = join69(runsDir, entry, "meta.json");
     try {
       const meta3 = await Bun.file(metaPath).json();
       if (meta3.runId === runId || meta3.runId.startsWith(runId)) {
@@ -98314,14 +98543,14 @@ async function resolveRunFileFromRegistry(runId) {
     return null;
   }
   const specificFile = files.find((f) => f === `${matched.runId}.jsonl`);
-  return join68(matched.eventsDir, specificFile ?? files[0]);
+  return join69(matched.eventsDir, specificFile ?? files[0]);
 }
 async function selectRunFile(runsDir) {
   const files = readdirSync6(runsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
   if (files.length === 0) {
     return null;
   }
-  return join68(runsDir, files[0]);
+  return join69(runsDir, files[0]);
 }
 async function extractRunSummary(filePath) {
   const file3 = Bun.file(filePath);
@@ -98407,7 +98636,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 file3 of files) {
-    const filePath = join69(runsDir, file3);
+    const filePath = join70(runsDir, file3);
     const summary = await extractRunSummary(filePath);
     const timestamp = file3.replace(".jsonl", "");
     const stories = summary ? `${summary.passed}/${summary.total}` : "?/?";
@@ -98521,7 +98750,7 @@ async function logsCommand(options) {
     return;
   }
   const resolved = resolveProject({ dir: options.dir });
-  const naxDir = join70(resolved.projectDir, ".nax");
+  const naxDir = join71(resolved.projectDir, ".nax");
   const configPath = resolved.configPath;
   const configFile = Bun.file(configPath);
   const config2 = await configFile.json();
@@ -98529,8 +98758,8 @@ async function logsCommand(options) {
   if (!featureName) {
     throw new Error("No feature specified in config.json");
   }
-  const featureDir = join70(naxDir, "features", featureName);
-  const runsDir = join70(featureDir, "runs");
+  const featureDir = join71(naxDir, "features", featureName);
+  const runsDir = join71(featureDir, "runs");
   if (!existsSync28(runsDir)) {
     throw new Error(`No runs directory found for feature: ${featureName}`);
   }
@@ -98556,7 +98785,7 @@ init_prd();
 init_precheck();
 init_common();
 import { existsSync as existsSync29 } from "fs";
-import { join as join71 } from "path";
+import { join as join72 } from "path";
 async function precheckCommand(options) {
   const resolved = resolveProject({
     dir: options.dir,
@@ -98578,9 +98807,9 @@ async function precheckCommand(options) {
       process.exit(1);
     }
   }
-  const naxDir = join71(resolved.projectDir, ".nax");
-  const featureDir = join71(naxDir, "features", featureName);
-  const prdPath = join71(featureDir, "prd.json");
+  const naxDir = join72(resolved.projectDir, ".nax");
+  const featureDir = join72(naxDir, "features", featureName);
+  const prdPath = join72(featureDir, "prd.json");
   if (!existsSync29(featureDir)) {
     console.error(source_default.red(`Feature not found: ${featureName}`));
     process.exit(1);
@@ -98603,7 +98832,7 @@ async function precheckCommand(options) {
 init_source();
 init_paths3();
 import { readdir as readdir4 } from "fs/promises";
-import { join as join72 } from "path";
+import { join as join73 } from "path";
 var DEFAULT_LIMIT = 20;
 var _runsCmdDeps = {
   getRunsDir
@@ -98658,7 +98887,7 @@ async function runsCommand(options = {}) {
   }
   const rows = [];
   for (const entry of entries) {
-    const metaPath = join72(runsDir, entry, "meta.json");
+    const metaPath = join73(runsDir, entry, "meta.json");
     let meta3;
     try {
       meta3 = await Bun.file(metaPath).json();
@@ -98735,7 +98964,7 @@ async function runsCommand(options = {}) {
 
 // src/commands/unlock.ts
 init_source();
-import { join as join73 } from "path";
+import { join as join74 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -98750,7 +98979,7 @@ function formatLockAge(ageMs) {
 }
 async function unlockCommand(options) {
   const workdir = options.dir ?? process.cwd();
-  const lockPath = join73(workdir, "nax.lock");
+  const lockPath = join74(workdir, "nax.lock");
   const lockFile = Bun.file(lockPath);
   const exists = await lockFile.exists();
   if (!exists) {
@@ -107188,7 +107417,7 @@ Next: nax generate --package ${options.package}`));
     }
     return;
   }
-  const naxDir = join87(workdir, ".nax");
+  const naxDir = join88(workdir, ".nax");
   if (existsSync35(naxDir) && !options.force) {
     console.log(source_default.yellow("nax already initialized. Use --force to overwrite."));
     return;
@@ -107217,11 +107446,11 @@ Next: nax generate --package ${options.package}`));
       }
     }
   }
-  mkdirSync7(join87(naxDir, "features"), { recursive: true });
-  mkdirSync7(join87(naxDir, "hooks"), { recursive: true });
+  mkdirSync7(join88(naxDir, "features"), { recursive: true });
+  mkdirSync7(join88(naxDir, "hooks"), { recursive: true });
   const initConfig = options.name ? { ...DEFAULT_CONFIG, name: options.name } : DEFAULT_CONFIG;
-  await Bun.write(join87(naxDir, "config.json"), JSON.stringify(initConfig, null, 2));
-  await Bun.write(join87(naxDir, "hooks.json"), JSON.stringify({
+  await Bun.write(join88(naxDir, "config.json"), JSON.stringify(initConfig, null, 2));
+  await Bun.write(join88(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 },
@@ -107229,12 +107458,12 @@ Next: nax generate --package ${options.package}`));
       "on-error": { command: 'echo "nax error: $NAX_REASON"', enabled: false }
     }
   }, null, 2));
-  await Bun.write(join87(naxDir, ".gitignore"), `# nax temp files
+  await Bun.write(join88(naxDir, ".gitignore"), `# nax temp files
 *.tmp
 .paused.json
 .nax-verifier-verdict.json
 `);
-  await Bun.write(join87(naxDir, "context.md"), `# Project Context
+  await Bun.write(join88(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.
@@ -107376,7 +107605,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
   const cliOverrides = {};
   const cliProfiles = options.profile ?? [];
   const profileOverride = naxDir ? await resolveRunProfileOverride({
-    prdPath: join87(naxDir, "features", options.feature, "prd.json"),
+    prdPath: join88(naxDir, "features", options.feature, "prd.json"),
     projectRoot: workdir,
     cliProfile: cliProfiles,
     envProfile: process.env.NAX_PROFILE
@@ -107389,8 +107618,8 @@ 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 = join87(naxDir, "features", options.feature);
-  const prdPath = join87(featureDir, "prd.json");
+  const featureDir = join88(naxDir, "features", options.feature);
+  const prdPath = join88(featureDir, "prd.json");
   if (options.plan && options.from) {
     if (existsSync35(prdPath) && !options.force) {
       console.error(source_default.red(`Error: prd.json already exists for feature "${options.feature}".`));
@@ -107412,10 +107641,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
       }
     }
     try {
-      const planLogDir = join87(featureDir, "plan");
+      const planLogDir = join88(featureDir, "plan");
       mkdirSync7(planLogDir, { recursive: true });
       const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-      const planLogPath = join87(planLogDir, `${planLogId}.jsonl`);
+      const planLogPath = join88(planLogDir, `${planLogId}.jsonl`);
       initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
       console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
       console.log(source_default.dim("   [Planning phase: generating PRD from spec]"));
@@ -107461,10 +107690,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
   resetLogger();
   const projectKey = config2.name?.trim() || basename16(workdir);
   const outputDir = projectOutputDir(projectKey, config2.outputDir);
-  const runsDir = join87(outputDir, "features", options.feature, "runs");
+  const runsDir = join88(outputDir, "features", options.feature, "runs");
   mkdirSync7(runsDir, { recursive: true });
   const runId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const logFilePath = join87(runsDir, `${runId}.jsonl`);
+  const logFilePath = join88(runsDir, `${runId}.jsonl`);
   const isTTY = process.stdout.isTTY ?? false;
   const headlessFlag = options.headless ?? false;
   const headlessEnv = process.env.NAX_HEADLESS === "1";
@@ -107482,7 +107711,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     config2.agent.default = options.agent;
   }
   config2.execution.maxIterations = Number.parseInt(options.maxIterations, 10);
-  const globalNaxDir = join87(homedir3(), ".nax");
+  const globalNaxDir = join88(homedir3(), ".nax");
   const hooks = await loadHooksConfig(naxDir, globalNaxDir);
   const eventEmitter = new PipelineEventEmitter;
   const agentStreamEvents = useHeadless ? undefined : new AgentStreamEventBus;
@@ -107502,12 +107731,12 @@ program2.command("run").description("Run the orchestration loop for a feature").
       events: eventEmitter,
       ptyOptions: null,
       agentStreamEvents,
-      queueFilePath: join87(workdir, ".queue.txt")
+      queueFilePath: join88(workdir, ".queue.txt")
     });
   } else {
     console.log(source_default.dim("   [Headless mode \u2014 pipe output]"));
   }
-  const statusFilePath = join87(outputDir, "status.json");
+  const statusFilePath = join88(outputDir, "status.json");
   let parallel;
   if (options.parallel !== undefined) {
     parallel = Number.parseInt(options.parallel, 10);
@@ -107534,7 +107763,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     skipPrecheck: options.skipPrecheck ?? false,
     agentStreamEvents
   });
-  const latestSymlink = join87(runsDir, "latest.jsonl");
+  const latestSymlink = join88(runsDir, "latest.jsonl");
   try {
     if (existsSync35(latestSymlink)) {
       Bun.spawnSync(["rm", latestSymlink]);
@@ -107595,9 +107824,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 = join87(naxDir, "features", name);
+  const featureDir = join88(naxDir, "features", name);
   mkdirSync7(featureDir, { recursive: true });
-  await Bun.write(join87(featureDir, "spec.md"), `# Feature: ${name}
+  await Bun.write(join88(featureDir, "spec.md"), `# Feature: ${name}
 
 ## Overview
 
@@ -107630,7 +107859,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 
 <!-- What this feature explicitly does NOT cover. -->
 `);
-  await Bun.write(join87(featureDir, "progress.txt"), `# Progress: ${name}
+  await Bun.write(join88(featureDir, "progress.txt"), `# Progress: ${name}
 
 Created: ${new Date().toISOString()}
 
@@ -107656,7 +107885,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 = join87(naxDir, "features");
+  const featuresDir = join88(naxDir, "features");
   if (!existsSync35(featuresDir)) {
     console.log(source_default.dim("No features yet."));
     return;
@@ -107671,7 +107900,7 @@ features.command("list").description("List all features").option("-d, --dir <pat
 Features:
 `));
   for (const name of entries) {
-    const prdPath = join87(featuresDir, name, "prd.json");
+    const prdPath = join88(featuresDir, name, "prd.json");
     if (existsSync35(prdPath)) {
       const prd = await loadPRD(prdPath);
       const c = countStories(prd);
@@ -107707,10 +107936,10 @@ Use: nax plan -f <feature> --from <spec>`));
     cliOverrides.profile = cliProfiles;
   }
   const config2 = await loadConfig(workdir, cliOverrides);
-  const featureLogDir = join87(naxDir, "features", options.feature, "plan");
+  const featureLogDir = join88(naxDir, "features", options.feature, "plan");
   mkdirSync7(featureLogDir, { recursive: true });
   const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const planLogPath = join87(featureLogDir, `${planLogId}.jsonl`);
+  const planLogPath = join88(featureLogDir, `${planLogId}.jsonl`);
   initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
   console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
   try {