@nathapp/nax 0.70.1 → 0.70.3

package/dist/nax.js

@@ -17737,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 = {
@@ -17759,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", {
@@ -18072,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();
 });
@@ -18310,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 = {
@@ -18963,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;
@@ -19072,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) => {
@@ -19141,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) => {
@@ -39398,6 +39413,7 @@ var init__finding_to_check = __esm(() => {
 function makeAutofixImplementerStrategy(story, config2, sink, opts = {}) {
   const claimsAdversarial = opts.includeAdversarialReview === true;
   const adversarialReviewByFixTarget = opts.adversarialReviewByFixTarget;
+  const blockingThreshold = opts.promptSeverityFloor ?? config2.review?.blockingThreshold;
   return {
     name: "autofix-implementer",
     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",
@@ -39405,7 +39421,8 @@ function makeAutofixImplementerStrategy(story, config2, sink, opts = {}) {
     buildInput: (findings, _prior, _cycleCtx) => ({
       failedChecks: findingsToFailedChecks(findings),
       story,
-      findings
+      findings,
+      blockingThreshold
     }),
     extractApplied: (output) => {
       for (const decl of output.testEditDeclarations) {
@@ -39434,6 +39451,7 @@ var init_autofix_implementer_strategy = __esm(() => {
 // src/operations/autofix-test-writer-strategy.ts
 function makeAutofixTestWriterStrategy(story, config2, sink, opts = {}) {
   const includeAdversarial = opts.includeAdversarialReview !== false;
+  const blockingThreshold = opts.promptSeverityFloor ?? config2.review?.blockingThreshold;
   return {
     name: "autofix-test-writer",
     appliesTo: (f) => f.fixTarget === "test" || includeAdversarial && f.source === "adversarial-review" || sink.mockHandoffs.length > 0,
@@ -39458,7 +39476,7 @@ function makeAutofixTestWriterStrategy(story, config2, sink, opts = {}) {
           failedChecks: findingsToFailedChecks(findings),
           story,
           mode: "mock-restructure",
-          blockingThreshold: config2.review?.blockingThreshold,
+          blockingThreshold,
           handoffReason,
           handoffFiles
         };
@@ -39466,7 +39484,7 @@ function makeAutofixTestWriterStrategy(story, config2, sink, opts = {}) {
       return {
         failedChecks: findingsToFailedChecks(findings),
         story,
-        blockingThreshold: config2.review?.blockingThreshold
+        blockingThreshold
       };
     },
     maxAttempts: config2.execution.rectification.maxAttemptsPerStrategy,
@@ -45276,7 +45294,7 @@ function attachLoggingSubscriber(bus, runId) {
     offError();
   };
 }
-var init_logging2 = __esm(() => {
+var init_logging = __esm(() => {
   init_logger2();
 });
 
@@ -45794,7 +45812,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();
 });
@@ -54979,159 +54997,66 @@ var init_non_blocking_fix = __esm(() => {
   };
 });
 
-// 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;
@@ -55189,34 +55114,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;
@@ -55236,6 +55133,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;
@@ -55351,6 +55353,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;
@@ -55436,6 +55502,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);
@@ -55533,7 +55650,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;
@@ -55687,18 +55812,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,
@@ -55711,6 +55847,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 {
@@ -55723,11 +55861,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) {
@@ -55787,80 +55935,21 @@ 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,
-    runNonBlockingFix
-  };
-  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
@@ -55961,18 +56050,24 @@ async function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
     const nbSink = makeDeclarationSink();
     if (nbf.scope === "source") {
       nbStrategies.push(makeAutofixImplementerStrategy(story, config2, nbSink, {
-        includeAdversarialReview: true
+        includeAdversarialReview: true,
+        promptSeverityFloor: "info"
       }));
     } else if (nbf.scope === "triage") {
       nbStrategies.push(makeAutofixImplementerStrategy(story, config2, nbSink, {
-        adversarialReviewByFixTarget: "source"
+        adversarialReviewByFixTarget: "source",
+        promptSeverityFloor: "info"
       }), makeAutofixTestWriterStrategy(story, config2, nbSink, {
-        includeAdversarialReview: false
+        includeAdversarialReview: false,
+        promptSeverityFloor: "info"
       }));
     } else {
       nbStrategies.push(makeAutofixImplementerStrategy(story, config2, nbSink, {
-        includeAdversarialReview: false
-      }), makeAutofixTestWriterStrategy(story, config2, nbSink));
+        includeAdversarialReview: false,
+        promptSeverityFloor: "info"
+      }), makeAutofixTestWriterStrategy(story, config2, nbSink, {
+        promptSeverityFloor: "info"
+      }));
     }
     nbStrategies.push(makeFullSuiteRectifyStrategy(story, config2, nbSink));
     const nbPostValidate = async (findings, _validateCtx) => {
@@ -56247,7 +56342,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") {
@@ -56346,22 +56441,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";
@@ -56400,6 +56481,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) {
@@ -56497,7 +56601,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)) {
@@ -56716,7 +56820,7 @@ var init_post_run = __esm(() => {
   init_scratch_writer();
   init_rollback();
   init_git();
-  init_story_orchestrator();
+  init_tdd_failure_category();
   _postRunDeps = {
     detectMergeConflict,
     checkMergeConflict,
@@ -58853,17 +58957,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.");
@@ -58893,13 +59026,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;
@@ -58916,6 +59043,7 @@ var init_setup = __esm(() => {
   init_setup_fill();
   init_setup_llm();
   init_setup_verify();
+  init_setup_write();
   _setupDeps = {
     analyzeRepo,
     fillScripts,
@@ -58937,11 +59065,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}
 `);
@@ -60380,7 +60504,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) => {
@@ -60399,14 +60523,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;
@@ -60576,7 +60700,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.70.1",
+    version: "0.70.3",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -60587,7 +60711,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",
@@ -60598,6 +60722,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",
@@ -60609,6 +60735,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",
@@ -60672,8 +60800,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("c53be9bf"))
-        return "c53be9bf";
+      if (/^[0-9a-f]{6,10}$/.test("c399b5b4"))
+        return "c399b5b4";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -61551,15 +61679,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;
@@ -61575,7 +61703,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);
@@ -62280,7 +62408,7 @@ function outputRunFooter(options) {
 }
 var init_headless_formatter = __esm(() => {
   init_source();
-  init_logging();
+  init_log_format();
   init_version();
 });
 
@@ -62326,12 +62454,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 () => {
@@ -62512,12 +62640,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 {
@@ -62527,8 +62655,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));
@@ -62760,7 +62888,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";
@@ -62774,7 +62902,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);
@@ -62788,7 +62916,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)) {
@@ -62798,7 +62926,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;
@@ -62830,7 +62958,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",
@@ -62862,13 +62990,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 = "";
@@ -62895,7 +63023,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"], {
@@ -62935,9 +63063,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) {
@@ -62948,7 +63076,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"], {
@@ -63532,6 +63660,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":
@@ -63770,10 +63900,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,
@@ -63990,7 +64120,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) {
@@ -64015,7 +64145,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);
@@ -64035,7 +64165,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 {
@@ -64062,7 +64192,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,
@@ -64265,7 +64395,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) };
 }
@@ -64288,7 +64418,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
@@ -65188,7 +65318,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;
@@ -65307,7 +65437,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);
@@ -65741,7 +65871,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;
@@ -65758,7 +65888,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) {
@@ -95589,7 +95719,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);
 }
@@ -95672,7 +95802,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) {
@@ -95689,8 +95819,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) {
@@ -95700,7 +95830,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("");
@@ -95714,8 +95844,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}.`);
@@ -95731,7 +95861,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(() => "") : "";
@@ -95765,7 +95895,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);
@@ -95774,7 +95904,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);
@@ -95811,7 +95941,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.");
@@ -95822,7 +95952,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);
@@ -95863,12 +95993,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}).`);
@@ -95913,7 +96043,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);
@@ -97037,6 +97167,7 @@ async function runsShowCommand(options) {
 init_prompts2();
 init_init2();
 init_setup();
+init_setup_write();
 
 // src/cli/plugins.ts
 init_paths();
@@ -97112,7 +97243,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();
@@ -97155,7 +97286,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"));
     }
@@ -97175,8 +97306,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}`));
@@ -97282,7 +97413,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 = {
@@ -97535,7 +97666,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;
@@ -97557,7 +97688,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);
 }
 
@@ -97617,7 +97748,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
@@ -97766,15 +97897,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);
@@ -97833,7 +97964,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()) {
@@ -97852,8 +97983,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}`);
@@ -97975,7 +98106,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) => {
@@ -97984,7 +98115,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 [];
     }
@@ -98033,7 +98164,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;
@@ -98062,14 +98193,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 {
@@ -98089,7 +98220,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);
@@ -98100,7 +98231,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++;
@@ -98139,7 +98270,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();
 }
@@ -98191,7 +98322,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";
@@ -98276,7 +98407,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;
@@ -98330,13 +98461,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}`));
@@ -98349,13 +98480,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}`));
@@ -98373,19 +98504,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
 };
@@ -98399,7 +98530,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)) {
@@ -98421,14 +98552,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);
@@ -98514,7 +98645,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}` : "?/?";
@@ -98628,7 +98759,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();
@@ -98636,8 +98767,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}`);
   }
@@ -98663,7 +98794,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,
@@ -98685,9 +98816,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);
@@ -98710,7 +98841,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
@@ -98765,7 +98896,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();
@@ -98842,7 +98973,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);
@@ -98857,7 +98988,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) {
@@ -107295,7 +107426,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;
@@ -107324,11 +107455,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 },
@@ -107336,12 +107467,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.
@@ -107483,7 +107614,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
@@ -107496,8 +107627,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}".`));
@@ -107519,10 +107650,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]"));
@@ -107568,10 +107699,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";
@@ -107589,7 +107720,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;
@@ -107609,12 +107740,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);
@@ -107641,7 +107772,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]);
@@ -107702,9 +107833,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
 
@@ -107737,7 +107868,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()}
 
@@ -107763,7 +107894,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;
@@ -107778,7 +107909,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);
@@ -107814,10 +107945,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 {