@nathapp/nax 0.67.10 → 0.67.12

package/dist/nax.js

@@ -16833,7 +16833,8 @@ var init_schemas_execution = __esm(() => {
   });
   RectificationConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
-    maxRetries: exports_external.number().int().min(0).max(10).default(2),
+    maxAttemptsTotal: exports_external.number().int().min(1).max(50).default(12),
+    maxAttemptsPerStrategy: exports_external.number().int().min(1).max(20).default(3),
     fullSuiteTimeoutSeconds: exports_external.number().int().min(10).max(600).default(120),
     maxFailureSummaryChars: exports_external.number().int().min(500).max(1e4).default(2000),
     abortOnIncreasingFailures: exports_external.boolean().default(true),
@@ -16845,8 +16846,7 @@ var init_schemas_execution = __esm(() => {
     enabled: exports_external.boolean().default(true),
     timeoutSeconds: exports_external.number().int().min(10).max(600).default(120),
     acceptOnTimeout: exports_external.boolean().default(true),
-    mode: exports_external.enum(["deferred", "per-story", "disabled"]).default("deferred"),
-    maxRectificationAttempts: exports_external.number().int().min(1).default(2)
+    mode: exports_external.enum(["deferred", "per-story", "disabled"]).default("deferred")
   });
   SmartTestRunnerConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
@@ -16928,16 +16928,10 @@ var init_schemas_execution = __esm(() => {
     autofix: exports_external.object({
       enabled: exports_external.boolean().default(true),
       maxAttempts: exports_external.number().int().min(1).default(3),
-      maxTotalAttempts: exports_external.number().int().min(1).default(12),
-      rethinkAtAttempt: exports_external.number().int().min(1).default(2),
-      urgencyAtAttempt: exports_external.number().int().min(1).default(3),
       enforceTestWriterIsolation: exports_external.boolean().default(true)
     }).default({
       enabled: true,
       maxAttempts: 3,
-      maxTotalAttempts: 12,
-      rethinkAtAttempt: 2,
-      urgencyAtAttempt: 3,
       enforceTestWriterIsolation: true
     }),
     forceExit: exports_external.boolean().default(false),
@@ -17225,6 +17219,7 @@ var init_schemas_review = __esm(() => {
     excludePatterns: exports_external.array(exports_external.string()).optional(),
     parallel: exports_external.boolean().default(false),
     maxConcurrentSessions: exports_external.number().int().min(1).max(4).default(2),
+    acRegroundOnDrop: exports_external.boolean().default(true),
     substantiation: exports_external.object({
       requote: exports_external.boolean().default(true),
       maxRequotes: exports_external.number().int().min(0).default(5)
@@ -17324,7 +17319,8 @@ var init_schemas3 = __esm(() => {
       maxStoriesPerFeature: 500,
       rectification: {
         enabled: true,
-        maxRetries: 2,
+        maxAttemptsTotal: 12,
+        maxAttemptsPerStrategy: 3,
         fullSuiteTimeoutSeconds: 300,
         maxFailureSummaryChars: 2000,
         abortOnIncreasingFailures: true,
@@ -17336,8 +17332,7 @@ var init_schemas3 = __esm(() => {
         enabled: true,
         timeoutSeconds: 300,
         acceptOnTimeout: true,
-        mode: "deferred",
-        maxRectificationAttempts: 3
+        mode: "deferred"
       },
       contextProviderTokenBudget: 2000,
       permissionProfile: "unrestricted",
@@ -17363,9 +17358,6 @@ var init_schemas3 = __esm(() => {
       autofix: {
         enabled: true,
         maxAttempts: 3,
-        maxTotalAttempts: 12,
-        rethinkAtAttempt: 2,
-        urgencyAtAttempt: 3,
         enforceTestWriterIsolation: true
       },
       forceExit: false,
@@ -17462,6 +17454,7 @@ var init_schemas3 = __esm(() => {
         timeoutMs: 600000,
         parallel: false,
         maxConcurrentSessions: 2,
+        acRegroundOnDrop: true,
         substantiation: {
           requote: true,
           maxRequotes: 5
@@ -18678,6 +18671,47 @@ function rejectLegacyAgentKeys(conf) {
 `);
   throw new NaxError(message, "CONFIG_LEGACY_AGENT_KEYS", { stage: "config", legacyKeys });
 }
+function rejectLegacyRectificationKeys(conf) {
+  const legacyKeys = [];
+  const migrationHints = [];
+  const quality = conf.quality;
+  const autofix = quality?.autofix;
+  if (autofix && typeof autofix === "object") {
+    if ("maxTotalAttempts" in autofix) {
+      legacyKeys.push("quality.autofix.maxTotalAttempts");
+      migrationHints.push("- Move `quality.autofix.maxTotalAttempts` \u2192 `execution.rectification.maxAttemptsTotal`");
+    }
+    if ("rethinkAtAttempt" in autofix) {
+      legacyKeys.push("quality.autofix.rethinkAtAttempt");
+      migrationHints.push("- Move `quality.autofix.rethinkAtAttempt` \u2192 `execution.rectification.rethinkAtAttempt`");
+    }
+    if ("urgencyAtAttempt" in autofix) {
+      legacyKeys.push("quality.autofix.urgencyAtAttempt");
+      migrationHints.push("- Move `quality.autofix.urgencyAtAttempt` \u2192 `execution.rectification.urgencyAtAttempt`");
+    }
+  }
+  const execution = conf.execution;
+  const rectification = execution?.rectification;
+  if (rectification && typeof rectification === "object" && "maxRetries" in rectification) {
+    legacyKeys.push("execution.rectification.maxRetries");
+    migrationHints.push("- Rename `execution.rectification.maxRetries` \u2192 `execution.rectification.maxAttemptsTotal` (default changed from 2 to 12)");
+  }
+  const regressionGate = execution?.regressionGate;
+  if (regressionGate && typeof regressionGate === "object" && "maxRectificationAttempts" in regressionGate) {
+    legacyKeys.push("execution.regressionGate.maxRectificationAttempts");
+    migrationHints.push("- Remove `execution.regressionGate.maxRectificationAttempts` \u2014 the regression cycle now shares `execution.rectification.maxAttemptsTotal`");
+  }
+  if (legacyKeys.length === 0)
+    return;
+  const message = [
+    `Invalid configuration \u2014 legacy rectification-cap keys detected: ${legacyKeys.join(", ")}.`,
+    "These were consolidated under `execution.rectification.*` so one config controls the unified",
+    "fix cycle (semantic + adversarial + mechanical + regression). Migrate as follows:",
+    ...migrationHints
+  ].join(`
+`);
+  throw new NaxError(message, "CONFIG_LEGACY_RECTIFICATION_KEYS", { stage: "config", legacyKeys });
+}
 function applyBatchModeCompat(conf) {
   const routing = conf.routing;
   const llm = routing?.llm;
@@ -18784,6 +18818,7 @@ async function loadConfig(startDir, cliOverrides) {
     return structuredClone(DEFAULT_CONFIG);
   }
   rejectLegacyAgentKeys(rawConfig);
+  rejectLegacyRectificationKeys(rawConfig);
   const result = NaxConfigSchema.safeParse(rawConfig);
   if (!result.success) {
     const errors3 = result.error.issues.map((err) => {
@@ -18836,6 +18871,7 @@ async function loadConfigForWorkdir(rootConfigPath, packageDir, cliOverrides) {
     const rawMerged = deepMergeConfig(merged, profileData);
     rawMerged.profile = packageProfile;
     rejectLegacyAgentKeys(rawMerged);
+    rejectLegacyRectificationKeys(rawMerged);
     const result = NaxConfigSchema.safeParse(rawMerged);
     if (result.success) {
       merged = result.data;
@@ -21059,6 +21095,7 @@ class DispatchEventBus {
   _completedListeners = new Set;
   _errorListeners = new Set;
   _reviewDecisionListeners = new Set;
+  _reviewRepromptListeners = new Set;
   onDispatch(l) {
     this._dispatchListeners.add(l);
     return () => this._dispatchListeners.delete(l);
@@ -21075,6 +21112,10 @@ class DispatchEventBus {
     this._reviewDecisionListeners.add(l);
     return () => this._reviewDecisionListeners.delete(l);
   }
+  onReviewReprompt(l) {
+    this._reviewRepromptListeners.add(l);
+    return () => this._reviewRepromptListeners.delete(l);
+  }
   emitDispatch(event) {
     for (const l of this._dispatchListeners) {
       try {
@@ -21111,6 +21152,15 @@ class DispatchEventBus {
       }
     }
   }
+  emitReviewReprompt(event) {
+    for (const l of this._reviewRepromptListeners) {
+      try {
+        l(event);
+      } catch (err) {
+        getSafeLogger()?.warn("dispatch-bus", "review-reprompt-listener threw", { error: errorMessage(err) });
+      }
+    }
+  }
 }
 var init_dispatch_events = __esm(() => {
   init_logger2();
@@ -30342,78 +30392,6 @@ function truncate(s, max) {
 var MAX_BLOCK_CHARS = 6000;
 
 // src/prompts/builders/review-builder.ts
-class ReviewPromptBuilder {
-  buildSemanticReviewPrompt(story, semanticConfig, options) {
-    const acList = story.acceptanceCriteria.map((ac, i) => `${i + 1}. ${ac}`).join(`
-`);
-    const customRulesBlock = semanticConfig.rules.length > 0 ? `
-## Additional Review Rules
-${semanticConfig.rules.map((r, i) => `${i + 1}. ${r}`).join(`
-`)}
-` : "";
-    const priorIterationsBlock = buildPriorIterationsBlock(options.priorSemanticIterations ?? []);
-    let diffSection;
-    if (options.mode === "ref") {
-      diffSection = buildRefDiffSection(options.storyGitRef ?? "", options.stat ?? "", options.excludePatterns ?? []);
-    } else {
-      diffSection = buildEmbeddedDiffSection(options.diff ?? "");
-    }
-    const core2 = `${SEMANTIC_ROLE}
-
-## Story: ${story.title}
-
-### Description
-${story.description}
-
-### Acceptance Criteria
-${acList}
-${customRulesBlock}${priorIterationsBlock}
-${SEMANTIC_INSTRUCTIONS}
-${SEMANTIC_OUTPUT_SCHEMA}
-
-${diffSection}`;
-    return wrapJsonPrompt(core2);
-  }
-  static jsonRetry() {
-    return `Your previous response could not be parsed as valid JSON.
-` + `Output ONLY the JSON object from your review \u2014 no markdown fences, no explanation.
-` + "The object must start with { and end with }.";
-  }
-  static jsonRetryCondensed(opts) {
-    const threshold = opts?.blockingThreshold ?? "error";
-    const advisoryCap = opts?.advisoryCap ?? 3;
-    const blockingList = threshold === "error" ? '"error"' : threshold === "warning" ? '"error" and "warning"' : '"error", "warning", and "info"';
-    const blockingClause = threshold === "info" ? "Include ALL findings \u2014 do not drop any by severity." : `Include ALL findings with severity ${blockingList} (these are blocking \u2014 do not drop them).`;
-    const advisoryClause = threshold === "info" ? "If your response would still exceed limits, prioritize the highest-severity findings first." : `Below that, include at most ${advisoryCap} additional findings (highest severity first).`;
-    return `Your previous response was truncated and could not be parsed as valid JSON.
-Respond with a condensed summary:
-- ${blockingClause}
-- ${advisoryClause}
-- Keep \`verifiedBy\` for every finding. If \`verifiedBy.observed\` is long, abbreviate it to one line \u2014 never drop the field.
-Output ONLY a complete, valid JSON object. It must start with { and end with }.
-Schema: {"passed": boolean, "findings": [{"severity": string, "category": string, "file": string, "line": number, "issue": string, "suggestion": string, "verifiedBy": {"command": string, "file": string, "line": number, "observed": string}}]}`;
-  }
-  static requoteVerbatim(opts) {
-    const file3 = opts.finding.verifiedBy?.file ?? opts.finding.file;
-    const line = opts.finding.verifiedBy?.line ?? opts.finding.line;
-    return `Your previous verifiedBy.observed value did not match the referenced file on disk.
-
-You MUST use your file-reading tool to open ${file3} and copy the actual bytes around line ${line}. Do NOT quote from memory or from the prior conversation \u2014 the previous quote was wrong precisely because it was not read from disk. If you reply without a file-read tool call, the quote will be rejected.
-
-Return ONLY this JSON object:
-{"file":"${file3}","line":${line},"observed":"exact 1-3 line quote"}
-
-Finding issue: ${opts.finding.issue}
-Referenced file: ${file3}
-Referenced line: ${line}
-
-Rules:
-- Read ${file3} with your file tool first. Then copy observed verbatim from the read result.
-- observed must be a 1-3 line excerpt that proves the claim, taken from at or near line ${line}.
-- If after reading the file you cannot find anything that proves the claim, set observed to "".
-- Do not return a full review. Do not include markdown fences or explanation.`;
-  }
-}
 function buildEmbeddedDiffSection(diff) {
   return `## Git Diff (production code only \u2014 test files excluded)
 
@@ -30493,9 +30471,114 @@ Notes:
 - \`acIndex\` is required when severity is "error" (1-based, into the Acceptance Criteria list above).
 - \`acQuote\` is optional advisory metadata for human auditors \u2014 not validated.
 - Omit both for "warning", "info", "unverifiable".
-If all ACs are correctly implemented, respond with { "passed": true, "findings": [] }.`;
+If all ACs are correctly implemented, respond with { "passed": true, "findings": [] }.`, ReviewPromptBuilder;
 var init_review_builder = __esm(() => {
   SEMANTIC_ROLE = "You are a semantic code reviewer with access to the repository files. " + "Your job is to walk each acceptance criterion (AC) and judge whether the production code fulfills it \u2014 fully, partially, or not at all. " + "Test coverage gaps and convention/lint issues are out of scope \u2014 adversarial review and lint/typecheck handle those.";
+  ReviewPromptBuilder = class ReviewPromptBuilder {
+    buildSemanticReviewPrompt(story, semanticConfig, options) {
+      const acList = story.acceptanceCriteria.map((ac, i) => `${i + 1}. ${ac}`).join(`
+`);
+      const customRulesBlock = semanticConfig.rules.length > 0 ? `
+## Additional Review Rules
+${semanticConfig.rules.map((r, i) => `${i + 1}. ${r}`).join(`
+`)}
+` : "";
+      const priorIterationsBlock = buildPriorIterationsBlock(options.priorSemanticIterations ?? []);
+      let diffSection;
+      if (options.mode === "ref") {
+        diffSection = buildRefDiffSection(options.storyGitRef ?? "", options.stat ?? "", options.excludePatterns ?? []);
+      } else {
+        diffSection = buildEmbeddedDiffSection(options.diff ?? "");
+      }
+      const core2 = `${SEMANTIC_ROLE}
+
+## Story: ${story.title}
+
+### Description
+${story.description}
+
+### Acceptance Criteria
+${acList}
+${customRulesBlock}${priorIterationsBlock}
+${SEMANTIC_INSTRUCTIONS}
+${SEMANTIC_OUTPUT_SCHEMA}
+
+${diffSection}`;
+      return wrapJsonPrompt(core2);
+    }
+    static jsonRetry() {
+      return `Your previous response could not be parsed as valid JSON.
+` + `Output ONLY the JSON object from your review \u2014 no markdown fences, no explanation.
+` + "The object must start with { and end with }.";
+    }
+    static jsonRetryCondensed(opts) {
+      const threshold = opts?.blockingThreshold ?? "error";
+      const advisoryCap = opts?.advisoryCap ?? 3;
+      const blockingList = threshold === "error" ? '"error"' : threshold === "warning" ? '"error" and "warning"' : '"error", "warning", and "info"';
+      const blockingClause = threshold === "info" ? "Include ALL findings \u2014 do not drop any by severity." : `Include ALL findings with severity ${blockingList} (these are blocking \u2014 do not drop them).`;
+      const advisoryClause = threshold === "info" ? "If your response would still exceed limits, prioritize the highest-severity findings first." : `Below that, include at most ${advisoryCap} additional findings (highest severity first).`;
+      return `Your previous response was truncated and could not be parsed as valid JSON.
+Respond with a condensed summary:
+- ${blockingClause}
+- ${advisoryClause}
+- Keep \`verifiedBy\` for every finding. If \`verifiedBy.observed\` is long, abbreviate it to one line \u2014 never drop the field.
+Output ONLY a complete, valid JSON object. It must start with { and end with }.
+Schema: {"passed": boolean, "findings": [{"severity": string, "category": string, "file": string, "line": number, "issue": string, "suggestion": string, "verifiedBy": {"command": string, "file": string, "line": number, "observed": string}}]}`;
+    }
+    static requoteVerbatim(opts) {
+      const file3 = opts.finding.verifiedBy?.file ?? opts.finding.file;
+      const line = opts.finding.verifiedBy?.line ?? opts.finding.line;
+      return `Your previous verifiedBy.observed value did not match the referenced file on disk.
+
+You MUST use your file-reading tool to open ${file3} and copy the actual bytes around line ${line}. Do NOT quote from memory or from the prior conversation \u2014 the previous quote was wrong precisely because it was not read from disk. If you reply without a file-read tool call, the quote will be rejected.
+
+Return ONLY this JSON object:
+{"file":"${file3}","line":${line},"observed":"exact 1-3 line quote"}
+
+Finding issue: ${opts.finding.issue}
+Referenced file: ${file3}
+Referenced line: ${line}
+
+Rules:
+- Read ${file3} with your file tool first. Then copy observed verbatim from the read result.
+- observed must be a 1-3 line excerpt that proves the claim, taken from at or near line ${line}.
+- If after reading the file you cannot find anything that proves the claim, set observed to "".
+- Do not return a full review. Do not include markdown fences or explanation.`;
+    }
+    static DROP_CODE_MESSAGES_MINIMAL = {
+      missing_ac_index: "no `acIndex` field was provided \u2014 every blocking finding must cite an AC by 1-based index",
+      ac_index_out_of_range: "`acIndex` is 0 or larger than the AC list \u2014 ACs are 1-indexed; the lowest valid value is 1"
+    };
+    static regroundDroppedFindings(opts) {
+      const { drops, acceptanceCriteria } = opts;
+      if (drops.length === 0)
+        return "";
+      const firstDrop = drops[0];
+      const codeMessage = ReviewPromptBuilder.DROP_CODE_MESSAGES_MINIMAL[firstDrop.code];
+      const acList = acceptanceCriteria.map((ac, i) => `${i + 1}. ${ac}`).join(`
+`);
+      return `Your previous review produced ${drops.length} finding${drops.length > 1 ? "s" : ""} that ${drops.length > 1 ? "were" : "was"} dropped because:
+
+${codeMessage}
+
+The dropped finding${drops.length > 1 ? "s" : ""} ${drops.length > 1 ? "are" : "is"}:
+${drops.map((d, i) => `${i + 1}. [${d.finding.severity}] ${d.finding.issue}`).join(`
+`)}
+
+Please re-review the code and re-issue any valid findings. For each finding you re-issue:
+- You MUST include a valid \`acIndex\` (1-based index into the AC list below)
+- You MUST include a \`verifiedBy\` field with verified evidence
+
+## Acceptance Criteria
+${acList}
+
+## Rules
+- If a finding's locus (file / symbol) is not named in any AC bullet, downgrade it to \`"info"\` or \`"warning"\`
+- Only re-issue findings that are genuinely substantiated by the code and constrained by an AC
+- Return ONLY a JSON object with the same shape as before:
+{"passed":true|false,"findings":[...]}`;
+    }
+  };
 });
 
 // src/prompts/builders/adversarial-review-builder.ts
@@ -30578,92 +30661,6 @@ ${diff}\`\`\`
 
 `;
 }
-
-class AdversarialReviewPromptBuilder {
-  buildAdversarialReviewPrompt(story, config2, options) {
-    const {
-      mode,
-      diff,
-      storyGitRef,
-      stat,
-      testInventory,
-      excludePatterns,
-      testGlobs,
-      refExcludePatterns,
-      priorAdversarialIterations,
-      blockingThreshold
-    } = options;
-    const priorFindingsBlock = buildPriorIterationsBlock(priorAdversarialIterations ?? []);
-    const storyBlock = `## Story Under Review
-
-**ID:** ${story.id}
-**Title:** ${story.title}
-**Description:** ${story.description || "(none)"}
-
-**Acceptance Criteria:**
-${story.acceptanceCriteria.map((ac, i) => `${i + 1}. ${ac}`).join(`
-`)}
-
-`;
-    const customRulesBlock = config2.rules.length > 0 ? `## Project-Specific Adversarial Rules
-
-${config2.rules.map((r) => `- ${r}`).join(`
-`)}
-
-` : "";
-    let diffBlock;
-    if (mode === "ref" && storyGitRef) {
-      diffBlock = buildAdversarialRefDiffSection(storyGitRef, stat, excludePatterns ?? [], testGlobs ?? [], refExcludePatterns ?? []);
-    } else if (mode === "embedded" && diff) {
-      diffBlock = buildAdversarialEmbeddedDiffSection(diff, testInventory);
-    } else {
-      diffBlock = `## Diff
-
-(No diff available \u2014 review based on story context only)
-
-`;
-    }
-    return [
-      ADVERSARIAL_ROLE,
-      `
-
-`,
-      priorFindingsBlock,
-      storyBlock,
-      ADVERSARIAL_INSTRUCTIONS,
-      `
-
-`,
-      customRulesBlock,
-      buildBlockingThresholdBlock(blockingThreshold ?? "error"),
-      OUTPUT_SCHEMA,
-      `
-
-`,
-      diffBlock
-    ].join("");
-  }
-  static requoteVerbatim(opts) {
-    const file3 = opts.finding.verifiedBy?.file ?? opts.finding.file;
-    const line = opts.finding.verifiedBy?.line ?? opts.finding.line;
-    return `Your previous verifiedBy.observed value did not match the referenced file on disk.
-
-You MUST use your file-reading tool to open ${file3} and copy the actual bytes around line ${line}. Do NOT quote from memory or from the prior conversation \u2014 the previous quote was wrong precisely because it was not read from disk. If you reply without a file-read tool call, the quote will be rejected.
-
-Return ONLY this JSON object:
-{"file":"${file3}","line":${line},"observed":"exact 1-3 line quote"}
-
-Finding issue: ${opts.finding.issue}
-Referenced file: ${file3}
-Referenced line: ${line}
-
-Rules:
-- Read ${file3} with your file tool first. Then copy observed verbatim from the read result.
-- observed must be a 1-3 line excerpt that proves the claim, taken from at or near line ${line}.
-- If after reading the file you cannot find anything that proves the claim, set observed to "".
-- Do not return a full review. Do not include markdown fences or explanation.`;
-  }
-}
 var ADVERSARIAL_ROLE = `You are an adversarial code reviewer with full access to the repository.
 
 Your job is NOT to re-verify that the code satisfies the acceptance criteria \u2014 semantic review owns that question. Don't re-litigate AC correctness.
@@ -30772,8 +30769,130 @@ Worked example:
 **Scope constraints are not Acceptance Criteria:**
 The story description may contain a "Scope" section with "In:" and "Out:" bullets. These are implementation guidelines, not ACs. A finding about code changed outside the stated scope (e.g., a file listed under "Out:") cannot cite a scope constraint as its \`acQuote\`/\`acIndex\` because scope text is not in the numbered AC list. Emit scope-violation findings as \`"warning"\` \u2014 never \`"error"\`. Never use \`acIndex: 0\`; \`acIndex\` is 1-based (first AC bullet = 1).
 
-If you cannot find an AC that names the **specific symbol** in your finding, downgrade to \`"info"\` or \`"warning"\`. A finding dropped by the validator is worse than one correctly classified as advisory.`;
-var init_adversarial_review_builder = () => {};
+If you cannot find an AC that names the **specific symbol** in your finding, downgrade to \`"info"\` or \`"warning"\`. A finding dropped by the validator is worse than one correctly classified as advisory.`, AdversarialReviewPromptBuilder;
+var init_adversarial_review_builder = __esm(() => {
+  AdversarialReviewPromptBuilder = class AdversarialReviewPromptBuilder {
+    buildAdversarialReviewPrompt(story, config2, options) {
+      const {
+        mode,
+        diff,
+        storyGitRef,
+        stat,
+        testInventory,
+        excludePatterns,
+        testGlobs,
+        refExcludePatterns,
+        priorAdversarialIterations,
+        blockingThreshold
+      } = options;
+      const priorFindingsBlock = buildPriorIterationsBlock(priorAdversarialIterations ?? []);
+      const storyBlock = `## Story Under Review
+
+**ID:** ${story.id}
+**Title:** ${story.title}
+**Description:** ${story.description || "(none)"}
+
+**Acceptance Criteria:**
+${story.acceptanceCriteria.map((ac, i) => `${i + 1}. ${ac}`).join(`
+`)}
+
+`;
+      const customRulesBlock = config2.rules.length > 0 ? `## Project-Specific Adversarial Rules
+
+${config2.rules.map((r) => `- ${r}`).join(`
+`)}
+
+` : "";
+      let diffBlock;
+      if (mode === "ref" && storyGitRef) {
+        diffBlock = buildAdversarialRefDiffSection(storyGitRef, stat, excludePatterns ?? [], testGlobs ?? [], refExcludePatterns ?? []);
+      } else if (mode === "embedded" && diff) {
+        diffBlock = buildAdversarialEmbeddedDiffSection(diff, testInventory);
+      } else {
+        diffBlock = `## Diff
+
+(No diff available \u2014 review based on story context only)
+
+`;
+      }
+      return [
+        ADVERSARIAL_ROLE,
+        `
+
+`,
+        priorFindingsBlock,
+        storyBlock,
+        ADVERSARIAL_INSTRUCTIONS,
+        `
+
+`,
+        customRulesBlock,
+        buildBlockingThresholdBlock(blockingThreshold ?? "error"),
+        OUTPUT_SCHEMA,
+        `
+
+`,
+        diffBlock
+      ].join("");
+    }
+    static requoteVerbatim(opts) {
+      const file3 = opts.finding.verifiedBy?.file ?? opts.finding.file;
+      const line = opts.finding.verifiedBy?.line ?? opts.finding.line;
+      return `Your previous verifiedBy.observed value did not match the referenced file on disk.
+
+You MUST use your file-reading tool to open ${file3} and copy the actual bytes around line ${line}. Do NOT quote from memory or from the prior conversation \u2014 the previous quote was wrong precisely because it was not read from disk. If you reply without a file-read tool call, the quote will be rejected.
+
+Return ONLY this JSON object:
+{"file":"${file3}","line":${line},"observed":"exact 1-3 line quote"}
+
+Finding issue: ${opts.finding.issue}
+Referenced file: ${file3}
+Referenced line: ${line}
+
+Rules:
+- Read ${file3} with your file tool first. Then copy observed verbatim from the read result.
+- observed must be a 1-3 line excerpt that proves the claim, taken from at or near line ${line}.
+- If after reading the file you cannot find anything that proves the claim, set observed to "".
+- Do not return a full review. Do not include markdown fences or explanation.`;
+    }
+    static DROP_CODE_MESSAGES_QUOTE = {
+      missing_ac_quote: "no `acQuote` field was provided \u2014 every blocking finding must cite an AC",
+      ac_index_out_of_range: "`acIndex` is 0 or larger than the AC list \u2014 ACs are 1-indexed; the lowest valid value is 1",
+      ac_quote_not_substring: "`acQuote` text does not appear verbatim in any AC bullet \u2014 copy the AC text character-for-character",
+      ac_quote_does_not_constrain_locus: "the cited AC mentions the file but not the specific symbol your finding flags \u2014 pick a different AC, or downgrade to `info` / `warning`"
+    };
+    static regroundDroppedFindings(opts) {
+      const { drops, acceptanceCriteria } = opts;
+      if (drops.length === 0)
+        return "";
+      const firstDrop = drops[0];
+      const codeMessage = AdversarialReviewPromptBuilder.DROP_CODE_MESSAGES_QUOTE[firstDrop.code] ?? `rejection code: ${firstDrop.code}`;
+      const acList = acceptanceCriteria.map((ac, i) => `${i + 1}. ${ac}`).join(`
+`);
+      return `Your previous review produced ${drops.length} finding${drops.length > 1 ? "s" : ""} that ${drops.length > 1 ? "were" : "was"} dropped because:
+
+${codeMessage}
+
+The dropped finding${drops.length > 1 ? "s" : ""} ${drops.length > 1 ? "are" : "is"}:
+${drops.map((d, i) => `${i + 1}. [${d.finding.severity}] ${d.finding.issue}`).join(`
+`)}
+
+Please re-review the code and re-issue any valid findings. For each finding you re-issue:
+- You MUST include a valid \`acQuote\` that appears verbatim in one of the AC bullets below
+- You MUST include a valid \`acIndex\` (1-based index into the AC list)
+- The \`acQuote\` must cite the specific symbol you are flagging, not just the file
+
+## Acceptance Criteria
+${acList}
+
+## Rules
+- If a finding's locus (file / symbol) is not named in any AC bullet, downgrade it to \`"info"\` or \`"warning"\`
+- Only re-issue findings that are genuinely substantiated by the code and constrained by an AC
+- Return ONLY a JSON object with the same shape as before:
+{"passed":true|false,"findings":[...]}`;
+    }
+  };
+});
 
 // src/prompts/builders/acceptance-builder-helpers.ts
 function formatTestOutputForFix(rawOutput) {
@@ -31546,6 +31665,28 @@ function isRecord(value) {
 var init_requote_response = () => {};
 
 // src/operations/adversarial-review.ts
+function withRepromptMarker(output, info) {
+  const parsed = tryParseLLMJson(output);
+  if (!parsed || typeof parsed !== "object")
+    return output;
+  return JSON.stringify({ ...parsed, _repromptInfo: info });
+}
+function extractRepromptInfo(raw) {
+  if (!raw || typeof raw !== "object")
+    return;
+  const info = raw._repromptInfo;
+  if (!info || typeof info !== "object")
+    return;
+  const i = info;
+  if (typeof i.dropCount !== "number" || typeof i.costUsd !== "number" || typeof i.outcome !== "string") {
+    return;
+  }
+  return {
+    dropCount: i.dropCount,
+    costUsd: i.costUsd,
+    outcome: i.outcome
+  };
+}
 async function requoteBlockingAdversarialFindings(findings, ctx) {
   const threshold = ctx.input.blockingThreshold ?? "error";
   const maxRequotes = ctx.input.adversarialConfig.substantiation?.maxRequotes ?? DEFAULT_MAX_REQUOTES;
@@ -31614,6 +31755,69 @@ async function requoteBlockingAdversarialFindings(findings, ctx) {
   }
   return { findings: next, changed, extraCostUsd };
 }
+function evaluateRepromptTrigger(shape, input) {
+  if (input.adversarialConfig.acRegroundOnDrop === false)
+    return { shouldReprompt: false };
+  if (shape.passed)
+    return { shouldReprompt: false };
+  const { accepted, dropped } = filterByAcQuote(shape.findings, input.story.acceptanceCriteria);
+  const threshold = input.blockingThreshold ?? "error";
+  const blockingAccepted = accepted.filter((f) => isBlockingSeverity(f.severity, threshold));
+  if (blockingAccepted.length > 0)
+    return { shouldReprompt: false };
+  if (dropped.length === 0)
+    return { shouldReprompt: false };
+  return { shouldReprompt: true, acDropped: dropped };
+}
+async function performAdversarialReground(turn, firstParsed, drops, ctx) {
+  const threshold = ctx.input.blockingThreshold ?? "error";
+  const acceptanceCriteria = ctx.input.story.acceptanceCriteria;
+  const { accepted: firstAccepted } = filterByAcQuote(firstParsed.findings, acceptanceCriteria);
+  const firstAdvisory = firstAccepted.filter((f) => !isBlockingSeverity(f.severity, threshold));
+  const repromptPrompt = AdversarialReviewPromptBuilder.regroundDroppedFindings({
+    drops,
+    acceptanceCriteria
+  });
+  const secondTurn = await ctx.send(repromptPrompt);
+  const secondParsed = validateAdversarialShape(tryParseLLMJson(secondTurn.output));
+  const costUsd = (turn.estimatedCostUsd ?? 0) + (secondTurn.estimatedCostUsd ?? 0);
+  const dropCount = drops.length;
+  if (!secondParsed) {
+    return {
+      ...turn,
+      output: withRepromptMarker(turn.output, { dropCount, outcome: "parse-failed", costUsd })
+    };
+  }
+  const { accepted: secondAccepted } = filterByAcQuote(secondParsed.findings, acceptanceCriteria);
+  const secondBlocking = secondAccepted.filter((f) => isBlockingSeverity(f.severity, threshold));
+  if (secondBlocking.length > 0) {
+    return {
+      ...turn,
+      output: JSON.stringify({
+        passed: false,
+        findings: secondParsed.findings,
+        _repromptInfo: { dropCount, outcome: "recovered-blocking", costUsd }
+      }),
+      estimatedCostUsd: costUsd
+    };
+  }
+  if (secondParsed.passed) {
+    const secondAdvisory = secondAccepted.filter((f) => !isBlockingSeverity(f.severity, threshold));
+    return {
+      ...turn,
+      output: JSON.stringify({
+        passed: true,
+        findings: [...firstAdvisory, ...secondAdvisory],
+        _repromptInfo: { dropCount, outcome: "recovered-advisory-only", costUsd }
+      }),
+      estimatedCostUsd: costUsd
+    };
+  }
+  return {
+    ...turn,
+    output: withRepromptMarker(turn.output, { dropCount, outcome: "still-dropped", costUsd })
+  };
+}
 var FAIL_OPEN, ADVERSARIAL_REQUOTE_RECOVERED_EVENT = "review.adversarial.finding.requote_recovered", ADVERSARIAL_REQUOTE_FAILED_EVENT = "review.adversarial.finding.requote_failed", DEFAULT_MAX_REQUOTES = 5, adversarialParseRetry = (input) => makeParseRetryStrategy({
   validate: (parsed) => validateAdversarialShape(parsed) !== null,
   reviewerKind: "adversarial",
@@ -31654,15 +31858,30 @@ var init_adversarial_review = __esm(() => {
       const parsed = validateAdversarialShape(tryParseLLMJson(turn.output));
       if (!parsed)
         return turn;
-      const requoted = await requoteBlockingAdversarialFindings(parsed.findings, ctx);
-      if (!requoted.changed)
+      if (ctx.input.mode !== "ref")
         return turn;
-      const passed = !requoted.findings.some((finding) => isBlockingSeverity(finding.severity, ctx.input.blockingThreshold ?? "error"));
-      return {
-        ...turn,
-        output: JSON.stringify({ passed, findings: requoted.findings }),
-        estimatedCostUsd: (turn.estimatedCostUsd ?? 0) + requoted.extraCostUsd
-      };
+      const regroundEnabled = ctx.input.adversarialConfig.acRegroundOnDrop !== false;
+      if (regroundEnabled) {
+        const firstShape = { passed: parsed.passed, findings: parsed.findings };
+        const trigger = evaluateRepromptTrigger(firstShape, ctx.input);
+        if (trigger.shouldReprompt) {
+          return await performAdversarialReground(turn, parsed, trigger.acDropped, ctx);
+        }
+      }
+      const requoteEnabled = ctx.input.adversarialConfig.substantiation?.requote ?? true;
+      const maxRequotes = ctx.input.adversarialConfig.substantiation?.maxRequotes ?? DEFAULT_MAX_REQUOTES;
+      if (!requoteEnabled || maxRequotes <= 0)
+        return turn;
+      const requoted = await requoteBlockingAdversarialFindings(parsed.findings, ctx);
+      if (requoted.changed) {
+        const passed = !requoted.findings.some((finding) => isBlockingSeverity(finding.severity, ctx.input.blockingThreshold ?? "error"));
+        return {
+          ...turn,
+          output: JSON.stringify({ passed, findings: requoted.findings }),
+          estimatedCostUsd: (turn.estimatedCostUsd ?? 0) + requoted.extraCostUsd
+        };
+      }
+      return turn;
     },
     build(input, _ctx) {
       const base = new AdversarialReviewPromptBuilder().buildAdversarialReviewPrompt(input.story, input.adversarialConfig, {
@@ -31686,16 +31905,25 @@ var init_adversarial_review = __esm(() => {
     parse(output, _input, _ctx) {
       const raw = tryParseLLMJson(output);
       const parsed = validateAdversarialShape(raw);
+      const repromptEvent = extractRepromptInfo(raw);
       if (parsed) {
         return {
           passed: parsed.passed,
           findings: parsed.findings,
           normalizedFindings: [],
-          acDropped: []
+          acDropped: [],
+          repromptEvent
         };
       }
       if (/"passed"\s*:\s*false/.test(output) && !/"findings"\s*:\s*\[\s*\{/.test(output)) {
-        return { passed: false, findings: [], normalizedFindings: [], acDropped: [], looksLikeFail: true };
+        return {
+          passed: false,
+          findings: [],
+          normalizedFindings: [],
+          acDropped: [],
+          looksLikeFail: true,
+          repromptEvent
+        };
       }
       throw new ParseValidationError("[adversarial-review] parse failed: invalid JSON shape");
     },
@@ -32198,7 +32426,7 @@ async function runAdversarialReview(opts) {
   } = opts;
   const startTime = Date.now();
   const logger = getSafeLogger();
-  const effectiveRef = await resolveEffectiveRef(workdir, storyGitRef, story.id);
+  const effectiveRef = await _adversarialDeps.resolveEffectiveRef(workdir, storyGitRef, story.id);
   if (!effectiveRef) {
     return {
       check: "adversarial",
@@ -32217,7 +32445,7 @@ async function runAdversarialReview(opts) {
   });
   const repoRoot = projectDir ?? workdir;
   const packageDir = workdir !== repoRoot ? workdir : undefined;
-  const stat = await collectDiffStat(workdir, effectiveRef, { naxIgnoreIndex, packageDir });
+  const stat = await _adversarialDeps.collectDiffStat(workdir, effectiveRef, { naxIgnoreIndex, packageDir });
   if (!stat) {
     return {
       check: "adversarial",
@@ -32399,6 +32627,16 @@ async function runAdversarialReview(opts) {
       durationMs: Date.now() - startTime
     };
   }
+  if (opResult.repromptEvent) {
+    runtime.dispatchEvents.emitReviewReprompt({
+      kind: "review-reprompt-on-drop",
+      storyId: story.id,
+      reviewer: "adversarial",
+      dropCount: opResult.repromptEvent.dropCount,
+      repromptOutcome: opResult.repromptEvent.outcome,
+      costUsd: opResult.repromptEvent.costUsd
+    });
+  }
   const threshold = blockingThreshold ?? "error";
   const allFindings = opResult.findings;
   const blockingFindings = allFindings.filter((f) => isBlockingSeverity(f.severity, threshold));
@@ -32410,7 +32648,7 @@ async function runAdversarialReview(opts) {
     diffFiles = extractDiffFiles(diff);
     diffAvailable = true;
   } else {
-    const list = await collectDiffFileList(workdir, effectiveRef, { naxIgnoreIndex, packageDir });
+    const list = await _adversarialDeps.collectDiffFileList(workdir, effectiveRef, { naxIgnoreIndex, packageDir });
     if (list === undefined) {
       diffFiles = new Set;
       diffAvailable = false;
@@ -32586,7 +32824,10 @@ var init_adversarial = __esm(() => {
   init_review_audit();
   _adversarialDeps = {
     writeReviewAudit,
-    callOp
+    callOp,
+    resolveEffectiveRef,
+    collectDiffStat,
+    collectDiffFileList
   };
 });
 
@@ -33289,6 +33530,13 @@ class ScopedStrategy {
     const durationMs = Date.now() - start;
     if (result.success) {
       const parsed2 = result.output ? parseTestOutput(result.output) : { passed: 0, failed: 0, failures: [] };
+      logger.info("verify[scoped]", "Scoped tests passed", {
+        storyId: ctx.storyId,
+        passCount: parsed2.passed,
+        durationMs,
+        scopeTestFallback: scopeTestFallback ?? false,
+        isFullSuite
+      });
       return makePassResult(ctx.storyId, "scoped", {
         rawOutput: result.output,
         passCount: parsed2.passed,
@@ -33297,6 +33545,12 @@ class ScopedStrategy {
       });
     }
     if (result.status === "TIMEOUT") {
+      logger.warn("verify[scoped]", "Scoped tests timed out", {
+        storyId: ctx.storyId,
+        durationMs,
+        scopeTestFallback: scopeTestFallback ?? false,
+        isFullSuite
+      });
       return makeFailResult(ctx.storyId, "scoped", "TIMEOUT", {
         rawOutput: result.output,
         durationMs,
@@ -33305,6 +33559,14 @@ class ScopedStrategy {
       });
     }
     const parsed = result.output ? parseTestOutput(result.output) : { passed: 0, failed: 0, failures: [] };
+    logger.warn("verify[scoped]", "Scoped tests failed", {
+      storyId: ctx.storyId,
+      passCount: parsed.passed,
+      failCount: parsed.failed,
+      durationMs,
+      scopeTestFallback: scopeTestFallback ?? false,
+      isFullSuite
+    });
     return makeFailResult(ctx.storyId, "scoped", "TEST_FAILURE", {
       rawOutput: result.output,
       passCount: parsed.passed,
@@ -35168,6 +35430,91 @@ var init_acceptance_fix = __esm(() => {
 });
 
 // src/operations/semantic-review.ts
+function withRepromptMarker2(output, info) {
+  const parsed = tryParseLLMJson(output);
+  if (!parsed || typeof parsed !== "object")
+    return output;
+  return JSON.stringify({ ...parsed, _repromptInfo: info });
+}
+function extractRepromptInfo2(raw) {
+  if (!raw || typeof raw !== "object")
+    return;
+  const info = raw._repromptInfo;
+  if (!info || typeof info !== "object")
+    return;
+  const i = info;
+  if (typeof i.dropCount !== "number" || typeof i.costUsd !== "number" || typeof i.outcome !== "string") {
+    return;
+  }
+  return {
+    dropCount: i.dropCount,
+    costUsd: i.costUsd,
+    outcome: i.outcome
+  };
+}
+function evaluateRepromptTrigger2(shape, input) {
+  if (input.semanticConfig.acRegroundOnDrop === false)
+    return { shouldReprompt: false };
+  if (shape.passed)
+    return { shouldReprompt: false };
+  const { accepted, dropped } = filterByAcGroundingMinimal(shape.findings, input.story.acceptanceCriteria);
+  const threshold = input.blockingThreshold ?? "error";
+  const blockingAccepted = accepted.filter((f) => isBlockingSeverity(f.severity, threshold));
+  if (blockingAccepted.length > 0)
+    return { shouldReprompt: false };
+  if (dropped.length === 0)
+    return { shouldReprompt: false };
+  return { shouldReprompt: true, acDropped: dropped };
+}
+async function performSemanticReground(turn, firstParsed, drops, ctx) {
+  const threshold = ctx.input.blockingThreshold ?? "error";
+  const acceptanceCriteria = ctx.input.story.acceptanceCriteria;
+  const { accepted: firstAccepted } = filterByAcGroundingMinimal(firstParsed.findings, acceptanceCriteria);
+  const firstAdvisory = firstAccepted.filter((f) => !isBlockingSeverity(f.severity, threshold));
+  const repromptPrompt = ReviewPromptBuilder.regroundDroppedFindings({
+    drops,
+    acceptanceCriteria
+  });
+  const secondTurn = await ctx.send(repromptPrompt);
+  const secondParsed = validateLLMShape(tryParseLLMJson(secondTurn.output));
+  const costUsd = (turn.estimatedCostUsd ?? 0) + (secondTurn.estimatedCostUsd ?? 0);
+  const dropCount = drops.length;
+  if (!secondParsed) {
+    return {
+      ...turn,
+      output: withRepromptMarker2(turn.output, { dropCount, outcome: "parse-failed", costUsd })
+    };
+  }
+  const { accepted: secondAccepted } = filterByAcGroundingMinimal(secondParsed.findings, acceptanceCriteria);
+  const secondBlocking = secondAccepted.filter((f) => isBlockingSeverity(f.severity, threshold));
+  if (secondBlocking.length > 0) {
+    return {
+      ...turn,
+      output: JSON.stringify({
+        passed: false,
+        findings: secondParsed.findings,
+        _repromptInfo: { dropCount, outcome: "recovered-blocking", costUsd }
+      }),
+      estimatedCostUsd: costUsd
+    };
+  }
+  if (secondParsed.passed) {
+    const secondAdvisory = secondAccepted.filter((f) => !isBlockingSeverity(f.severity, threshold));
+    return {
+      ...turn,
+      output: JSON.stringify({
+        passed: true,
+        findings: [...firstAdvisory, ...secondAdvisory],
+        _repromptInfo: { dropCount, outcome: "recovered-advisory-only", costUsd }
+      }),
+      estimatedCostUsd: costUsd
+    };
+  }
+  return {
+    ...turn,
+    output: withRepromptMarker2(turn.output, { dropCount, outcome: "still-dropped", costUsd })
+  };
+}
 async function requoteBlockingFindings(findings, ctx) {
   const threshold = ctx.input.blockingThreshold ?? "error";
   const maxRequotes = ctx.input.semanticConfig.substantiation?.maxRequotes ?? DEFAULT_MAX_REQUOTES2;
@@ -35243,14 +35590,24 @@ var FAIL_OPEN2, SEMANTIC_REQUOTE_RECOVERED_EVENT = "review.semantic.finding.requ
   if (!parsed)
     return turn;
   const requoted = await requoteBlockingFindings(parsed.findings, ctx);
-  if (!requoted.changed)
+  if (requoted.changed) {
+    const passed = !requoted.findings.some((finding) => isBlockingSeverity(finding.severity, ctx.input.blockingThreshold ?? "error"));
+    return {
+      ...turn,
+      output: JSON.stringify({ passed, findings: requoted.findings }),
+      estimatedCostUsd: (turn.estimatedCostUsd ?? 0) + requoted.extraCostUsd
+    };
+  }
+  if (ctx.input.mode !== "ref")
     return turn;
-  const passed = !requoted.findings.some((finding) => isBlockingSeverity(finding.severity, ctx.input.blockingThreshold ?? "error"));
-  return {
-    ...turn,
-    output: JSON.stringify({ passed, findings: requoted.findings }),
-    estimatedCostUsd: (turn.estimatedCostUsd ?? 0) + requoted.extraCostUsd
-  };
+  const regroundEnabled = ctx.input.semanticConfig.acRegroundOnDrop !== false;
+  if (!regroundEnabled)
+    return turn;
+  const firstShape = { passed: parsed.passed, findings: requoted.findings };
+  const trigger = evaluateRepromptTrigger2(firstShape, ctx.input);
+  if (!trigger.shouldReprompt)
+    return turn;
+  return performSemanticReground(turn, firstShape, trigger.acDropped, ctx);
 }, semanticReviewOp;
 var init_semantic_review = __esm(() => {
   init_retry();
@@ -35259,7 +35616,13 @@ var init_semantic_review = __esm(() => {
   init_prompts();
   init_finding_filters();
   init_requote_response();
-  FAIL_OPEN2 = { passed: true, findings: [], normalizedFindings: [], failOpen: true };
+  FAIL_OPEN2 = {
+    passed: true,
+    findings: [],
+    normalizedFindings: [],
+    acDropped: [],
+    failOpen: true
+  };
   semanticReviewOp = {
     kind: "run",
     name: "semantic-review",
@@ -35276,7 +35639,7 @@ var init_semantic_review = __esm(() => {
         invalid: () => ReviewPromptBuilder.jsonRetry(),
         truncated: () => ReviewPromptBuilder.jsonRetryCondensed({ blockingThreshold: input.blockingThreshold })
       },
-      exhaustedFallback: (lastOutput) => /"passed"\s*:\s*false/.test(lastOutput) ? { passed: false, findings: [], normalizedFindings: [], looksLikeFail: true } : FAIL_OPEN2,
+      exhaustedFallback: (lastOutput) => /"passed"\s*:\s*false/.test(lastOutput) ? { passed: false, findings: [], normalizedFindings: [], acDropped: [], looksLikeFail: true } : FAIL_OPEN2,
       logContext: { blockingThreshold: input.blockingThreshold ?? "error" }
     }),
     hopBody: semanticReviewHopBody,
@@ -35298,15 +35661,25 @@ var init_semantic_review = __esm(() => {
     parse(output, _input, _ctx) {
       const raw = tryParseLLMJson(output);
       const parsed = validateLLMShape(raw);
+      const repromptEvent = extractRepromptInfo2(raw);
       if (parsed) {
         return {
           passed: parsed.passed,
           findings: parsed.findings,
-          normalizedFindings: []
+          normalizedFindings: [],
+          acDropped: [],
+          repromptEvent
         };
       }
       if (/"passed"\s*:\s*false/.test(output)) {
-        return { passed: false, findings: [], normalizedFindings: [], looksLikeFail: true };
+        return {
+          passed: false,
+          findings: [],
+          normalizedFindings: [],
+          acDropped: [],
+          looksLikeFail: true,
+          repromptEvent
+        };
       }
       return FAIL_OPEN2;
     },
@@ -35319,14 +35692,15 @@ var init_semantic_review = __esm(() => {
       const findings = parsed.findings;
       const sanitized = sanitizeRefModeFindings(findings, input.mode, threshold);
       const substantiated = await substantiateSemanticEvidence(sanitized, input.mode, input.workdir, input.story.id, threshold);
-      const { accepted } = filterByAcGroundingMinimal(substantiated, input.story.acceptanceCriteria);
+      const { accepted, dropped } = filterByAcGroundingMinimal(substantiated, input.story.acceptanceCriteria);
       const blocking = accepted.filter((f) => isBlockingSeverity(f.severity, threshold));
       const passed = parsed.passed && blocking.length === 0;
       return {
         ...parsed,
         passed,
         findings: accepted,
-        normalizedFindings: toReviewFindings(blocking)
+        normalizedFindings: toReviewFindings(blocking),
+        acDropped: dropped
       };
     }
   };
@@ -35398,6 +35772,16 @@ function parseTestEditDeclarations(output) {
   }
   return result;
 }
+function normaliseWs(s) {
+  return s.replace(/\s+/g, " ").replace(/\s*([(),<>])\s*/g, "$1").replace(/\s*:\s*/g, ": ").trim();
+}
+function validatePrdQuote(prdQuote, story) {
+  if (!prdQuote.trim())
+    return false;
+  const needle = normaliseWs(prdQuote);
+  const haystack = normaliseWs([story.description, ...story.acceptanceCriteria].join(" "));
+  return haystack.includes(needle);
+}
 var REASON_RE;
 var init_test_edit_declaration = __esm(() => {
   REASON_RE = /^TEST_EDIT_REASON:\s*(prd_contract|lint_only|sibling_scope|mock_structure)\s*$/m;
@@ -37368,7 +37752,7 @@ var init_greenfield_gate = __esm(() => {
 });
 // src/verification/rectification.ts
 function shouldRetryRectification(state, config2) {
-  if (state.attempt >= config2.maxRetries) {
+  if (state.attempt >= config2.maxAttemptsTotal) {
     return false;
   }
   if (state.lastExitCode !== undefined && state.lastExitCode !== 0 && state.currentFailures === 0) {
@@ -37471,7 +37855,7 @@ var init_full_suite_gate = __esm(() => {
 });
 
 // src/operations/full-suite-rectify.ts
-function makeFullSuiteRectifyStrategy(story) {
+function makeFullSuiteRectifyStrategy(story, config2) {
   return {
     name: "full-suite-rectify",
     appliesTo: (finding) => finding.source === "test-runner" && finding.category === "failed-test",
@@ -37481,7 +37865,7 @@ function makeFullSuiteRectifyStrategy(story) {
       contextMarkdown: RectifierPromptBuilder.failingTestContext(findings)
     }),
     extractApplied: () => ({ targetFiles: [], summary: "Fixed failing tests" }),
-    maxAttempts: 3,
+    maxAttempts: config2.execution.rectification.maxAttemptsPerStrategy,
     coRun: "exclusive"
   };
 }
@@ -37522,7 +37906,7 @@ var init__finding_to_check = __esm(() => {
 });
 
 // src/operations/autofix-implementer-strategy.ts
-function makeAutofixImplementerStrategy(story) {
+function makeAutofixImplementerStrategy(story, config2, sink) {
   return {
     name: "autofix-implementer",
     appliesTo: (f) => f.fixTarget === "source" && IMPLEMENTER_SOURCES.has(f.source),
@@ -37531,11 +37915,20 @@ function makeAutofixImplementerStrategy(story) {
       failedChecks: findingsToFailedChecks(findings),
       story
     }),
-    extractApplied: (output) => ({
-      summary: output.unresolvedReason ?? "",
-      unresolved: output.unresolvedReason
-    }),
-    maxAttempts: 3,
+    extractApplied: (output) => {
+      for (const decl of output.testEditDeclarations) {
+        if (decl.reason === "mock_structure" && decl.files && decl.reasonDetail) {
+          sink.mockHandoffs.push({ files: decl.files, reasonDetail: decl.reasonDetail });
+        } else if (decl.reason !== "mock_structure") {
+          sink.testEdits.push(decl);
+        }
+      }
+      return {
+        summary: output.unresolvedReason ?? "",
+        unresolved: output.unresolvedReason
+      };
+    },
+    maxAttempts: config2.execution.rectification.maxAttemptsPerStrategy,
     coRun: "co-run-sequential"
   };
 }
@@ -37547,17 +37940,43 @@ var init_autofix_implementer_strategy = __esm(() => {
 });
 
 // src/operations/autofix-test-writer-strategy.ts
-function makeAutofixTestWriterStrategy(story, config2) {
+function makeAutofixTestWriterStrategy(story, config2, sink) {
   return {
     name: "autofix-test-writer",
-    appliesTo: (f) => f.fixTarget === "test" || f.source === "adversarial-review",
+    appliesTo: (f) => f.fixTarget === "test" || f.source === "adversarial-review" || sink.mockHandoffs.length > 0,
     fixOp: testWriterRectifyOp,
-    buildInput: (findings, _prior, _cycleCtx) => ({
-      failedChecks: findingsToFailedChecks(findings),
-      story,
-      blockingThreshold: config2.review?.blockingThreshold
-    }),
-    maxAttempts: 2,
+    buildInput: (findings, _prior, _cycleCtx) => {
+      if (sink.mockHandoffs.length > 0) {
+        const handoffs = sink.mockHandoffs.splice(0);
+        const seenFiles = new Set;
+        const handoffFiles = [];
+        for (const h of handoffs) {
+          for (const f of h.files) {
+            if (!seenFiles.has(f)) {
+              seenFiles.add(f);
+              handoffFiles.push(f);
+            }
+          }
+        }
+        const handoffReason = handoffs.map((h) => h.reasonDetail).join(`
+---
+`);
+        return {
+          failedChecks: findingsToFailedChecks(findings),
+          story,
+          mode: "mock-restructure",
+          blockingThreshold: config2.review?.blockingThreshold,
+          handoffReason,
+          handoffFiles
+        };
+      }
+      return {
+        failedChecks: findingsToFailedChecks(findings),
+        story,
+        blockingThreshold: config2.review?.blockingThreshold
+      };
+    },
+    maxAttempts: config2.execution.rectification.maxAttemptsPerStrategy,
     coRun: "co-run-sequential"
   };
 }
@@ -37566,6 +37985,100 @@ var init_autofix_test_writer_strategy = __esm(() => {
   init_autofix_test_writer();
 });
 
+// src/operations/apply-test-edit-declarations.ts
+function applyTestEditDeclarations(findings, declarations, story, invalidMockStructure) {
+  let result = [...findings];
+  const advisories = [];
+  for (const d of declarations) {
+    if (d.reason === "prd_contract") {
+      const prdQuote = d.prdQuote ?? "";
+      const valid = validatePrdQuote(prdQuote, story);
+      if (valid) {
+        result = result.map((f) => {
+          if (f.file === d.file && f.fixTarget === "source") {
+            return {
+              ...f,
+              fixTarget: "test",
+              meta: {
+                ...f.meta,
+                prdContractDeclaration: d
+              }
+            };
+          }
+          return f;
+        });
+      } else {
+        advisories.push({
+          source: "autofix",
+          severity: "warning",
+          category: "prd_quote_mismatch",
+          message: `PRD quote not found verbatim in story text for file: ${d.file}`,
+          file: d.file,
+          fixTarget: "source"
+        });
+      }
+    }
+  }
+  if (invalidMockStructure && invalidMockStructure.length > 0) {
+    for (const d of invalidMockStructure) {
+      const fileList = (d.files ?? [d.file]).join(", ");
+      advisories.push({
+        source: "autofix",
+        severity: "warning",
+        category: "mock_structure_invalid_files",
+        message: `Mock structure handoff references file that does not exist or is not a test file: ${fileList}`,
+        fixTarget: "source"
+      });
+    }
+  }
+  return [...result, ...advisories];
+}
+var init_apply_test_edit_declarations = __esm(() => {
+  init_test_edit_declaration();
+});
+
+// src/operations/validate-mock-structure-files.ts
+import { join as join23 } from "path";
+async function validateMockStructureFiles(declarations, resolvedTestPatterns, packageDir, deps) {
+  const fileExists = deps?.fileExists ?? defaultFileExists;
+  const valid = [];
+  const invalid = [];
+  for (const d of declarations) {
+    if (d.reason !== "mock_structure") {
+      valid.push(d);
+      continue;
+    }
+    const files = d.files ?? [d.file];
+    let allValid = true;
+    for (const file3 of files) {
+      const absolutePath = join23(packageDir, file3);
+      const exists = await fileExists(absolutePath);
+      if (!exists) {
+        allValid = false;
+        break;
+      }
+      const matchesPattern = resolvedTestPatterns.regex.some((re) => re.test(file3));
+      if (!matchesPattern) {
+        allValid = false;
+        break;
+      }
+    }
+    if (allValid) {
+      valid.push(d);
+    } else {
+      invalid.push(d);
+    }
+  }
+  return { valid, invalid };
+}
+var defaultFileExists = (p) => Bun.file(p).exists();
+var init_validate_mock_structure_files = () => {};
+
+// src/operations/declaration-sink.ts
+function makeDeclarationSink() {
+  return { testEdits: [], mockHandoffs: [] };
+}
+
 // src/operations/mechanical-lintfix-strategy.ts
 function shellQuotePath2(path5) {
   return `'${path5.replaceAll("'", `'\\''`)}'`;
@@ -38046,6 +38559,8 @@ var init_operations = __esm(() => {
   init_full_suite_rectify();
   init_autofix_implementer_strategy();
   init_autofix_test_writer_strategy();
+  init_apply_test_edit_declarations();
+  init_validate_mock_structure_files();
   init__finding_to_check();
   init_mechanical_lintfix_strategy();
   init_mechanical_formatfix_strategy();
@@ -38696,7 +39211,7 @@ var init_lint_parsing = __esm(() => {
 });
 
 // src/review/scoped-lint.ts
-import { join as join23, relative as relative10 } from "path";
+import { join as join24, relative as relative10 } from "path";
 function shellQuotePath4(path5) {
   return `'${path5.replaceAll("'", "'\\''")}'`;
 }
@@ -38744,7 +39259,7 @@ function uniqueFiles(files) {
 async function filterFilesToScope(files, workdir, projectDir, activePackageDir) {
   const inScope = [];
   for (const relPath of files) {
-    const absPath = join23(workdir, relPath);
+    const absPath = join24(workdir, relPath);
     const exists = await _scopedLintDeps.fileExists(absPath);
     if (!exists)
       continue;
@@ -39502,6 +40017,42 @@ async function runSemanticReview(opts) {
       durationMs: Date.now() - startTime
     };
   }
+  if (opResult.looksLikeFail) {
+    logger?.warn("semantic", "LLM returned truncated JSON with passed:false \u2014 treating as failure", {
+      storyId: story.id
+    });
+    recordSemanticAudit({
+      runtime,
+      workdir,
+      projectDir,
+      storyId: story.id,
+      featureName,
+      parsed: false,
+      looksLikeFail: true,
+      failOpen: false,
+      passed: false,
+      blockingThreshold,
+      result: null
+    });
+    return {
+      check: "semantic",
+      success: false,
+      command: "",
+      exitCode: 1,
+      output: "semantic review: LLM response truncated but indicated failure (passed:false found in partial response)",
+      durationMs: Date.now() - startTime
+    };
+  }
+  if (opResult.repromptEvent) {
+    runtime.dispatchEvents.emitReviewReprompt({
+      kind: "review-reprompt-on-drop",
+      storyId: story.id,
+      reviewer: "semantic",
+      dropCount: opResult.repromptEvent.dropCount,
+      repromptOutcome: opResult.repromptEvent.outcome,
+      costUsd: opResult.repromptEvent.costUsd
+    });
+  }
   const threshold = blockingThreshold ?? "error";
   const allFindings = opResult.findings;
   const blockingFindings = allFindings.filter((f) => isBlockingSeverity(f.severity, threshold));
@@ -39903,6 +40454,18 @@ async function runReview(opts) {
       naxIgnoreIndex
     }) : normalizeMechanicalFindings(checkName, await runCheck(checkName, command, workdir, storyId, env2), workdir);
     checks3.push(result);
+    if (result.success) {
+      logger?.info("review", `${checkName} passed`, {
+        storyId,
+        durationMs: result.durationMs
+      });
+    } else {
+      logger?.warn("review", `${checkName} failed`, {
+        storyId,
+        exitCode: result.exitCode,
+        durationMs: result.durationMs
+      });
+    }
     if (!result.success && !firstFailure) {
       firstFailure = `${checkName} failed (exit code ${result.exitCode})`;
     }
@@ -39962,9 +40525,34 @@ var init_review = __esm(() => {
 });
 
 // src/prompts/builders/rectifier-builder-helpers.ts
+function buildEscapeHatch(opts) {
+  const exceptions = [EXCEPTION_1_LINT_ONLY, EXCEPTION_2_PRD_CONTRACT, EXCEPTION_3_SIBLING_SCOPE];
+  if (opts.includeMockHandoff)
+    exceptions.push(EXCEPTION_4_MOCK_HANDOFF);
+  const count = exceptions.length;
+  const countWord = ["zero", "one", "two", "three", "four"][count];
+  return `
+If two findings in this list contradict each other and you cannot satisfy both, do not guess.
+Emit fixes for defects you can resolve, then output a line in this exact format:
+UNRESOLVED: <brief explanation of which findings conflicted and why they cannot both be satisfied>
+
+Before emitting UNRESOLVED, confirm none of Exceptions 1\u2013${count} apply.
+
+## Test-file edit exceptions
+
+The "do not modify test files" rule has ${countWord} narrow escape valves. Each requires a
+declaration in your output. Outside these ${countWord} cases the rule is absolute.
+
+${exceptions.join(`
+
+`)}`;
+}
+function exceptionCountWord(story) {
+  return THREE_SESSION_STRATEGIES.has(story.routing?.testStrategy ?? "") ? "four" : "three";
+}
 function escapeHatchFor(story) {
   const isTdd = THREE_SESSION_STRATEGIES.has(story.routing?.testStrategy ?? "");
-  return isTdd ? CONTRADICTION_ESCAPE_HATCH : CONTRADICTION_ESCAPE_HATCH.replace(EXCEPTION_4_MOCK_HANDOFF, "");
+  return buildEscapeHatch({ includeMockHandoff: isTdd });
 }
 function noTestIsolationBlock(story) {
   if (story.routing?.testStrategy !== "no-test")
@@ -40034,7 +40622,7 @@ ${errors3}
 2. Only fix findings that are actually valid problems
 3. Do NOT add keys, functions, or imports that already exist \u2014 check first
 
-Do NOT change test files or test behavior \u2014 see the three narrow exceptions appended below.
+Do NOT change test files or test behavior \u2014 see the ${exceptionCountWord(story)} narrow exceptions appended below.
 Do NOT add new features \u2014 only fix valid issues.
 Commit your fixes when done.${scopeConstraint}${noTestIsolationBlock(story)}${escapeHatchFor(story)}`;
 }
@@ -40096,21 +40684,11 @@ The following quality checks failed after implementation:
 
 ${errors3}
 
-Fix all errors listed above that are within this story's scope \u2014 see the three narrow exceptions appended below for sibling-story spillover. Do NOT change test files or test behavior except via those exceptions.
+Fix all errors listed above that are within this story's scope \u2014 see the ${exceptionCountWord(story)} narrow exceptions appended below for sibling-story spillover. Do NOT change test files or test behavior except via those exceptions.
 Do NOT add new features \u2014 only fix the quality check errors.
 After fixing, re-run the failing check(s) to verify they pass, then commit your changes.${scopeConstraint}${noTestIsolationBlock(story)}${escapeHatchFor(story)}`;
 }
-var CONTRADICTION_ESCAPE_HATCH = `
-If two findings in this list contradict each other and you cannot satisfy both, do not guess.
-Emit fixes for defects you can resolve, then output a line in this exact format:
-UNRESOLVED: <brief explanation of which findings conflicted and why they cannot both be satisfied>
-
-## Test-file edit exceptions
-
-The "do not modify test files" rule has three narrow escape valves. Each requires a
-declaration in your output. Outside these three cases the rule is absolute.
-
-### Exception 1 \u2014 Lint-only edit
+var EXCEPTION_1_LINT_ONLY = `### Exception 1 \u2014 Lint-only edit
 
 You MAY edit a test file ONLY when ALL of the following hold:
 - The failing check is \`lint\` \u2014 not \`test\`, \`typecheck\`, \`semantic\`, or \`adversarial\`.
@@ -40126,9 +40704,7 @@ TEST_EDIT_REASON: lint_only
 FILE: <test file path>
 FINDING: <lint rule or message verbatim>
 CHANGE: <before line> \u2192 <after line>
-\`\`\`
-
-### Exception 2 \u2014 PRD-contract mismatch
+\`\`\``, EXCEPTION_2_PRD_CONTRACT = `### Exception 2 \u2014 PRD-contract mismatch
 
 You MAY correct a test's argument arity, type, or return-handling ONLY when the test's
 call contradicts a literal interface signature stated in this story's description or
@@ -40144,9 +40720,7 @@ TEST_AFTER: <corrected call line>
 \`\`\`
 
 Do NOT use this exception to change test logic, assertions, or mock setup \u2014 only call
-signatures that directly contradict a quoted PRD interface.
-
-### Exception 3 \u2014 Unrelated sibling spillover
+signatures that directly contradict a quoted PRD interface.`, EXCEPTION_3_SIBLING_SCOPE = `### Exception 3 \u2014 Unrelated sibling spillover
 
 When a lint or typecheck error is outside this story's intended scope, do NOT edit that
 file. If the smallest package-local fix is required to satisfy this story's acceptance
@@ -40156,46 +40730,37 @@ TEST_EDIT_REASON: sibling_scope
 SIBLING_FILE: <file path>
 FINDING: <error summary>
 \`\`\`
-and continue. Sibling-scope failures do not block your story.
-
-### Exception 4 \u2014 Mock-structure handoff
+and continue. Sibling-scope failures do not block your story.`, EXCEPTION_4_MOCK_HANDOFF = `### Exception 4 \u2014 Mock-structure handoff
 
 Use ONLY when the only path to satisfy the ACs requires a structural test rewrite
-that does NOT fit Exception 2. Examples: mocks reference primitives the new code
-bypasses; assertion topology must change to match a new dispatch shape.
-
-Declare with:
-\`\`\`
-TEST_EDIT_REASON: mock_structure
-FILES: <comma-separated test file paths>
-REASON: <one paragraph: which mock is wrong vs which dispatch the new code uses>
-\`\`\`
+that does NOT fit Exception 2. Two cases qualify:
 
-Rules:
-- Do NOT make any edits yourself; the test-writer will fulfill.
-- Do NOT also emit \`UNRESOLVED:\` in the same turn \u2014 this declaration IS the handoff.
-- FILES must list real test files. Each path must exist and be a test file.`, EXCEPTION_4_MOCK_HANDOFF = `
-### Exception 4 \u2014 Mock-structure handoff
+  (a) Existing mocks are wrong \u2014 mocks reference primitives the new code bypasses,
+      or assertion topology must change to match a new dispatch shape.
 
-Use ONLY when the only path to satisfy the ACs requires a structural test rewrite
-that does NOT fit Exception 2. Examples: mocks reference primitives the new code
-bypasses; assertion topology must change to match a new dispatch shape.
+  (b) Required test-infrastructure does not yet exist and must be introduced \u2014
+      e.g. in-process fake servers, network-level request interception, hermetic
+      fixture-backed HTTP, or equivalent. Applies whenever the AC describes a
+      hermetic/fixture-backed test surface that the current test setup cannot
+      satisfy without new infrastructure.
 
 Declare with:
 \`\`\`
 TEST_EDIT_REASON: mock_structure
 FILES: <comma-separated test file paths>
-REASON: <one paragraph: which mock is wrong vs which dispatch the new code uses>
+REASON: <one paragraph: which mock is wrong vs which dispatch the new code uses,
+         or what infrastructure must be introduced>
 \`\`\`
 
 Rules:
 - Do NOT make any edits yourself; the test-writer will fulfill.
 - Do NOT also emit \`UNRESOLVED:\` in the same turn \u2014 this declaration IS the handoff.
-- FILES must list real test files. Each path must exist and be a test file.`, THREE_SESSION_STRATEGIES, MAX_STRUCTURED_FINDINGS = 10, RAW_WITH_FINDINGS_LIMIT = 1000, RAW_FALLBACK_LIMIT = 4000;
+- FILES must list real test files. Each path must exist and be a test file.`, THREE_SESSION_STRATEGIES, CONTRADICTION_ESCAPE_HATCH, MAX_STRUCTURED_FINDINGS = 10, RAW_WITH_FINDINGS_LIMIT = 1000, RAW_FALLBACK_LIMIT = 4000;
 var init_rectifier_builder_helpers = __esm(() => {
   init_review();
   init_sections2();
   THREE_SESSION_STRATEGIES = new Set(["three-session-tdd", "three-session-tdd-lite"]);
+  CONTRADICTION_ESCAPE_HATCH = buildEscapeHatch({ includeMockHandoff: false });
 });
 
 // src/prompts/builders/rectifier-builder.ts
@@ -40276,15 +40841,16 @@ function renderPrioritizedFailures(failedChecks, opts) {
 }
 
 class RectifierPromptBuilder {
-  static firstAttemptDelta(failedChecks, maxAttempts, guardrailLevel) {
+  static firstAttemptDelta(failedChecks, maxAttempts, guardrailLevel, story) {
     const parts = [];
     const attemptWord = maxAttempts === 1 ? "1 attempt" : `${maxAttempts} attempts`;
+    const exCount = story ? exceptionCountWord(story) : "three";
     parts.push(`Review failed after your implementation. Fix the following issues (${attemptWord} available before escalation):
 `);
     parts.push(renderPrioritizedFailures(failedChecks));
     parts.push(`
-Fix in priority order. After fixing each priority, re-run the failing check(s) at that level to verify they pass before moving on. Do NOT change test files or test behavior \u2014 see the three narrow exceptions appended below. Commit your changes when all checks pass.`);
-    parts.push(CONTRADICTION_ESCAPE_HATCH);
+Fix in priority order. After fixing each priority, re-run the failing check(s) at that level to verify they pass before moving on. Do NOT change test files or test behavior \u2014 see the ${exCount} narrow exceptions appended below. Commit your changes when all checks pass.`);
+    parts.push(story ? escapeHatchFor(story) : CONTRADICTION_ESCAPE_HATCH);
     const guardrails = buildBehavioralGuardrailsSection("implementer", guardrailLevel ?? "lite");
     if (guardrails) {
       parts.push(`
@@ -40294,7 +40860,7 @@ ${guardrails}`);
     return parts.join(`
 `);
   }
-  static continuation(failedChecks, attempt, rethinkAtAttempt, urgencyAtAttempt, guardrailLevel) {
+  static continuation(failedChecks, attempt, rethinkAtAttempt, urgencyAtAttempt, guardrailLevel, story) {
     const parts = [];
     parts.push(`Your previous fix attempt did not resolve all issues. Here are the remaining failures:
 `);
@@ -40307,7 +40873,7 @@ ${guardrails}`);
     if (attempt >= urgencyAtAttempt) {
       parts.push("\n**URGENT: This is your final attempt.** If you cannot fix all issues, emit `UNRESOLVED: <reason>` to escalate.\n");
     }
-    parts.push(CONTRADICTION_ESCAPE_HATCH);
+    parts.push(story ? escapeHatchFor(story) : CONTRADICTION_ESCAPE_HATCH);
     const guardrails = buildBehavioralGuardrailsSection("implementer", guardrailLevel ?? "lite");
     if (guardrails) {
       parts.push(`
@@ -40429,7 +40995,7 @@ ${importantNote}
 
 Commit your fixes when done.${scopeConstraint}`;
   }
-  static noOpReprompt(failedChecks, noOpCount, maxNoOpReprompts, opts) {
+  static noOpReprompt(failedChecks, noOpCount, maxNoOpReprompts, opts, story) {
     const parts = [];
     parts.push(`**Your previous turn produced no committed file changes.**
 
@@ -40470,7 +41036,7 @@ ${output}
 `);
       }
     }
-    parts.push(CONTRADICTION_ESCAPE_HATCH);
+    parts.push(story ? escapeHatchFor(story) : CONTRADICTION_ESCAPE_HATCH);
     return parts.join("");
   }
   static escalated(failures, story, priorAttempts, originalTier, targetTier, config2, testCommand, testScopedTemplate) {
@@ -40546,11 +41112,11 @@ ${testCommands}
 6. Ensure ALL tests pass before completing.
 
 **IMPORTANT:**
-- Do NOT modify test files \u2014 see the three narrow exceptions in the escape valve section if you believe a test has a lint error, a PRD-contract mismatch, or belongs to a sibling story.
+- Do NOT modify test files \u2014 see the ${exceptionCountWord(story)} narrow exceptions appended below if you believe a test has a lint error, a PRD-contract mismatch, or belongs to a sibling story.
 - Do NOT loosen assertions to mask implementation bugs.
 - Focus on fixing the source code to meet the test requirements.
 - When running tests, run ONLY the failing test files shown above${cmd ? ` \u2014 NEVER run \`${cmd}\` without a file filter` : " \u2014 never run the full test suite without a file filter"}.
-`;
+${escapeHatchFor(story)}`;
   }
   static reviewRectification(failedChecks, story, opts) {
     const scopeConstraint = story.workdir ? `
@@ -40607,7 +41173,7 @@ ${llmSection}
 **Important:** LLM reviewers may flag false positives. Before making changes for LLM review findings, read the relevant files to verify each finding is a real issue. Do NOT add keys, functions, or imports that already exist.
 
 Do NOT add new features \u2014 only fix the identified issues.
-Commit your fixes when done.${scopeConstraint}${CONTRADICTION_ESCAPE_HATCH}`;
+Commit your fixes when done.${scopeConstraint}${escapeHatchFor(story)}`;
   }
   static dialogueAwareRectification(failedChecks, story, opts) {
     const scopeConstraint = story.workdir ? `
@@ -40646,9 +41212,9 @@ ${errors3}${reasoningSection}${historySection}
 2. Only fix findings that are actually valid problems
 3. Do NOT add keys, functions, or imports that already exist \u2014 check first
 
-Do NOT change test files or test behavior \u2014 see the three narrow exceptions appended below.
+Do NOT change test files or test behavior \u2014 see the ${exceptionCountWord(story)} narrow exceptions appended below.
 Do NOT add new features \u2014 only fix valid issues.
-Commit your fixes when done.${scopeConstraint}${CONTRADICTION_ESCAPE_HATCH}`;
+Commit your fixes when done.${scopeConstraint}${escapeHatchFor(story)}`;
   }
   static swapHandoff(basePrompt, pushMarkdown) {
     const trimmed = pushMarkdown?.trim();
@@ -40740,9 +41306,10 @@ Tests are failing. Fix the source so all tests pass \u2014 not just the ones lis
 4. Do not declare done until step 3 shows 0 failures.
 
 **IMPORTANT:**
-- Do NOT modify test files \u2014 see the three narrow exceptions in the escape valve section if you believe a test has a lint error, a PRD-contract mismatch, or belongs to a sibling story.
+- Do NOT modify test files \u2014 see the ${exceptionCountWord(opts.story)} narrow exceptions appended below if you believe a test has a lint error, a PRD-contract mismatch, or belongs to a sibling story.
 - Do NOT loosen assertions to mask implementation bugs.
 - Focus on fixing the source code to meet the test requirements.`);
+    parts.push(escapeHatchFor(opts.story));
     return parts.join("");
   }
   static failingTestContext(findings) {
@@ -42076,7 +42643,7 @@ var init_call = __esm(() => {
 
 // src/runtime/cost-aggregator.ts
 import { mkdirSync as mkdirSync2 } from "fs";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 function makeCorrelationId() {
   return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -42267,7 +42834,7 @@ class CostAggregator {
       if (events.length === 0 && errors3.length === 0)
         return;
       mkdirSync2(this._drainDir, { recursive: true });
-      const path5 = join24(this._drainDir, `${this._runId}.jsonl`);
+      const path5 = join25(this._drainDir, `${this._runId}.jsonl`);
       const sorted = [...events, ...errors3].sort((a, b) => a.ts - b.ts);
       await _costAggDeps.write(path5, `${sorted.map((e) => JSON.stringify(e)).join(`
 `)}
@@ -42307,7 +42874,7 @@ var init_cost_aggregator = __esm(() => {
 // src/runtime/prompt-auditor.ts
 import { appendFileSync } from "fs";
 import { mkdir as mkdir4 } from "fs/promises";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 function createNoOpPromptAuditor() {
   return {
     record() {},
@@ -42373,8 +42940,8 @@ class PromptAuditor {
   _jsonlPath;
   _featureDir;
   constructor(runId, flushDir, featureName) {
-    this._featureDir = join25(flushDir, featureName);
-    this._jsonlPath = join25(this._featureDir, `${runId}.jsonl`);
+    this._featureDir = join26(flushDir, featureName);
+    this._jsonlPath = join26(this._featureDir, `${runId}.jsonl`);
   }
   record(entry) {
     this._enqueue(entry);
@@ -42423,7 +42990,7 @@ class PromptAuditor {
     const auditEntry = entry;
     const filename = deriveTxtFilename(auditEntry);
     try {
-      await _promptAuditorDeps.write(join25(this._featureDir, filename), buildTxtContent(auditEntry));
+      await _promptAuditorDeps.write(join26(this._featureDir, filename), buildTxtContent(auditEntry));
     } catch (err) {
       throw tagAuditError(err, "txt");
     }
@@ -43511,7 +44078,7 @@ var init_pid_registry = __esm(() => {
 // src/session/manager-deps.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { mkdir as mkdir5 } from "fs/promises";
-import { isAbsolute as isAbsolute9, join as join26, relative as relative12, sep as sep3 } from "path";
+import { isAbsolute as isAbsolute9, join as join27, relative as relative12, sep as sep3 } from "path";
 function resolveProjectDirFromScratchDir(scratchDir) {
   const marker = `${sep3}.nax${sep3}features${sep3}`;
   const markerIdx = scratchDir.lastIndexOf(marker);
@@ -43532,7 +44099,7 @@ var init_manager_deps = __esm(() => {
     now: () => new Date().toISOString(),
     nowMs: () => Date.now(),
     uuid: () => randomUUID3(),
-    sessionScratchDir: (projectDir, featureName, sessionId) => join26(projectDir, ".nax", "features", featureName, "sessions", sessionId),
+    sessionScratchDir: (projectDir, featureName, sessionId) => join27(projectDir, ".nax", "features", featureName, "sessions", sessionId),
     writeDescriptor: async (scratchDir, descriptor, projectDir) => {
       await mkdir5(scratchDir, { recursive: true });
       const { handle: _handle, ...persistable } = descriptor;
@@ -43543,7 +44110,7 @@ var init_manager_deps = __esm(() => {
           persistable.scratchDir = toProjectRelativePath(derivedProjectDir, persistable.scratchDir);
         }
       }
-      await Bun.write(join26(scratchDir, "descriptor.json"), JSON.stringify(persistable, null, 2));
+      await Bun.write(join27(scratchDir, "descriptor.json"), JSON.stringify(persistable, null, 2));
     }
   };
 });
@@ -44294,7 +44861,7 @@ __export(exports_runtime, {
   CostAggregator: () => CostAggregator,
   AgentStreamEventBus: () => AgentStreamEventBus
 });
-import { basename as basename5, join as join27 } from "path";
+import { basename as basename5, join as join28 } from "path";
 function createRuntime(config2, workdir, opts) {
   const runId = crypto.randomUUID();
   const controller = new AbortController;
@@ -44310,10 +44877,10 @@ function createRuntime(config2, workdir, opts) {
   const outputDir = projectOutputDir(projectKey, config2.outputDir);
   const globalDir = globalOutputDir();
   const curatorRollupPathValue = curatorRollupPath(globalDir, config2.curator?.rollupPath);
-  const costDir = join27(outputDir, "cost");
+  const costDir = join28(outputDir, "cost");
   const costAggregator = opts?.costAggregator ?? new CostAggregator(runId, costDir);
   const auditEnabled = config2.agent?.promptAudit?.enabled ?? false;
-  const auditDir = config2.agent?.promptAudit?.dir ?? join27(outputDir, "prompt-audit");
+  const auditDir = config2.agent?.promptAudit?.dir ?? join28(outputDir, "prompt-audit");
   let promptAuditor;
   if (opts?.promptAuditor) {
     promptAuditor = opts.promptAuditor;
@@ -44464,9 +45031,9 @@ async function allSettledBounded(tasks, limit) {
 
 // src/context/injector.ts
 import { existsSync as existsSync8 } from "fs";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 async function detectNode(workdir) {
-  const pkgPath = join28(workdir, "package.json");
+  const pkgPath = join29(workdir, "package.json");
   if (!existsSync8(pkgPath))
     return null;
   try {
@@ -44483,7 +45050,7 @@ async function detectNode(workdir) {
   }
 }
 async function detectGo(workdir) {
-  const goMod = join28(workdir, "go.mod");
+  const goMod = join29(workdir, "go.mod");
   if (!existsSync8(goMod))
     return null;
   try {
@@ -44507,7 +45074,7 @@ async function detectGo(workdir) {
   }
 }
 async function detectRust(workdir) {
-  const cargoPath = join28(workdir, "Cargo.toml");
+  const cargoPath = join29(workdir, "Cargo.toml");
   if (!existsSync8(cargoPath))
     return null;
   try {
@@ -44523,8 +45090,8 @@ async function detectRust(workdir) {
   }
 }
 async function detectPython(workdir) {
-  const pyproject = join28(workdir, "pyproject.toml");
-  const requirements = join28(workdir, "requirements.txt");
+  const pyproject = join29(workdir, "pyproject.toml");
+  const requirements = join29(workdir, "requirements.txt");
   if (!existsSync8(pyproject) && !existsSync8(requirements))
     return null;
   try {
@@ -44543,7 +45110,7 @@ async function detectPython(workdir) {
   }
 }
 async function detectPhp(workdir) {
-  const composerPath = join28(workdir, "composer.json");
+  const composerPath = join29(workdir, "composer.json");
   if (!existsSync8(composerPath))
     return null;
   try {
@@ -44556,7 +45123,7 @@ async function detectPhp(workdir) {
   }
 }
 async function detectRuby(workdir) {
-  const gemfile = join28(workdir, "Gemfile");
+  const gemfile = join29(workdir, "Gemfile");
   if (!existsSync8(gemfile))
     return null;
   try {
@@ -44568,9 +45135,9 @@ async function detectRuby(workdir) {
   }
 }
 async function detectJvm(workdir) {
-  const pom = join28(workdir, "pom.xml");
-  const gradle = join28(workdir, "build.gradle");
-  const gradleKts = join28(workdir, "build.gradle.kts");
+  const pom = join29(workdir, "pom.xml");
+  const gradle = join29(workdir, "build.gradle");
+  const gradleKts = join29(workdir, "build.gradle.kts");
   if (!existsSync8(pom) && !existsSync8(gradle) && !existsSync8(gradleKts))
     return null;
   try {
@@ -44578,7 +45145,7 @@ async function detectJvm(workdir) {
       const content2 = await Bun.file(pom).text();
       const nameMatch = content2.match(/<artifactId>([^<]+)<\/artifactId>/);
       const deps2 = [...content2.matchAll(/<artifactId>([^<]+)<\/artifactId>/g)].map((m) => m[1]).filter((d) => d !== nameMatch?.[1]).slice(0, 10);
-      const lang2 = existsSync8(join28(workdir, "src/main/kotlin")) ? "Kotlin" : "Java";
+      const lang2 = existsSync8(join29(workdir, "src/main/kotlin")) ? "Kotlin" : "Java";
       return { name: nameMatch?.[1], lang: lang2, dependencies: deps2 };
     }
     const gradleFile = existsSync8(gradleKts) ? gradleKts : gradle;
@@ -44832,7 +45399,7 @@ var init_windsurf = __esm(() => {
 
 // src/context/generator.ts
 import { existsSync as existsSync9 } from "fs";
-import { join as join29, relative as relative13 } from "path";
+import { join as join30, relative as relative13 } from "path";
 async function loadContextContent(options, config2) {
   if (!_generatorDeps.existsSync(options.contextPath)) {
     throw new Error(`Context file not found: ${options.contextPath}`);
@@ -44850,7 +45417,7 @@ async function generateFor(agent, options, config2) {
   try {
     const context = await loadContextContent(options, config2);
     const content = generator.generate(context);
-    const outputPath = join29(options.outputDir, generator.outputFile);
+    const outputPath = join30(options.outputDir, generator.outputFile);
     validateFilePath(outputPath, options.outputDir);
     if (!options.dryRun) {
       await _generatorDeps.writeFile(outputPath, content);
@@ -44868,7 +45435,7 @@ async function generateAll(options, config2, agentFilter) {
   for (const [agentKey, generator] of entries) {
     try {
       const content = generator.generate(context);
-      const outputPath = join29(options.outputDir, generator.outputFile);
+      const outputPath = join30(options.outputDir, generator.outputFile);
       validateFilePath(outputPath, options.outputDir);
       if (!options.dryRun) {
         await _generatorDeps.writeFile(outputPath, content);
@@ -44888,7 +45455,7 @@ async function discoverPackages(repoRoot) {
     const glob = new Bun.Glob(pattern);
     for await (const match of glob.scan({ cwd: repoRoot, dot: true })) {
       const pkgRelative = match.replace(/^\.nax\/mono\//, "").replace(/\/context\.md$/, "");
-      const pkgAbsolute = join29(repoRoot, pkgRelative);
+      const pkgAbsolute = join30(repoRoot, pkgRelative);
       if (!seen.has(pkgAbsolute)) {
         seen.add(pkgAbsolute);
         packages.push(pkgAbsolute);
@@ -44920,14 +45487,14 @@ async function discoverWorkspacePackages2(repoRoot) {
       }
     }
   }
-  const turboPath = join29(repoRoot, "turbo.json");
+  const turboPath = join30(repoRoot, "turbo.json");
   try {
     const turbo = JSON.parse(await _generatorDeps.readTextFile(turboPath));
     if (Array.isArray(turbo.packages)) {
       await resolveGlobs(turbo.packages);
     }
   } catch {}
-  const pkgPath = join29(repoRoot, "package.json");
+  const pkgPath = join30(repoRoot, "package.json");
   try {
     const pkg = JSON.parse(await _generatorDeps.readTextFile(pkgPath));
     const ws = pkg.workspaces;
@@ -44935,7 +45502,7 @@ async function discoverWorkspacePackages2(repoRoot) {
     if (patterns.length > 0)
       await resolveGlobs(patterns);
   } catch {}
-  const pnpmPath = join29(repoRoot, "pnpm-workspace.yaml");
+  const pnpmPath = join30(repoRoot, "pnpm-workspace.yaml");
   try {
     const raw = await _generatorDeps.readTextFile(pnpmPath);
     const lines = raw.split(`
@@ -44961,7 +45528,7 @@ async function discoverWorkspacePackages2(repoRoot) {
 async function generateForPackage(packageDir, config2, dryRun = false, repoRoot) {
   const resolvedRepoRoot = repoRoot ?? packageDir;
   const relativePkgPath = relative13(resolvedRepoRoot, packageDir);
-  const contextPath = join29(resolvedRepoRoot, ".nax", "mono", relativePkgPath, "context.md");
+  const contextPath = join30(resolvedRepoRoot, ".nax", "mono", relativePkgPath, "context.md");
   if (!_generatorDeps.existsSync(contextPath)) {
     return [
       {
@@ -45029,7 +45596,7 @@ var init_generator2 = __esm(() => {
 });
 
 // src/analyze/scanner.ts
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 function resolveFrameworkAndRunner(language, pkg) {
   if (language === "go")
     return { framework: "", testRunner: "go-test" };
@@ -45051,7 +45618,7 @@ async function scanSourceRoots(workdir) {
     });
     try {
       const language = await deps.detectLanguage(workdir);
-      const pkg = await deps.readPackageJson(join30(workdir, "package.json"));
+      const pkg = await deps.readPackageJson(join31(workdir, "package.json"));
       const { framework, testRunner } = resolveFrameworkAndRunner(language, pkg);
       return [{ path: ".", language, framework, testRunner }];
     } catch {
@@ -45069,9 +45636,9 @@ async function scanSourceRoots(workdir) {
     packages = packages.slice(0, MAX_SOURCE_ROOTS);
   }
   return Promise.all(packages.map(async (pkgPath) => {
-    const pkgDir = pkgPath === "." ? workdir : join30(workdir, pkgPath);
+    const pkgDir = pkgPath === "." ? workdir : join31(workdir, pkgPath);
     const language = await deps.detectLanguage(pkgDir);
-    const pkg = await deps.readPackageJson(join30(pkgDir, "package.json"));
+    const pkg = await deps.readPackageJson(join31(pkgDir, "package.json"));
     const { framework, testRunner } = resolveFrameworkAndRunner(language, pkg);
     return { path: pkgPath, language, framework, testRunner };
   }));
@@ -45104,7 +45671,7 @@ var init_analyze = __esm(() => {
 });
 
 // src/debate/pre-phase/grounder.ts
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 async function buildCodebaseContext(workdir) {
   const roots = await _grounderDeps.scanSourceRoots(workdir);
   return buildSourceRootsSection(normalizeRoots(workdir, roots));
@@ -45116,7 +45683,7 @@ function normalizeRoots(workdir, roots) {
   }));
 }
 async function writeManifestArtifact(ctx, manifest) {
-  const manifestPath = join31(ctx.workdir, ".nax", "runs", ctx.ctx.runtime.runId, "plan", ctx.storyId, "facts-manifest.json");
+  const manifestPath = join32(ctx.workdir, ".nax", "runs", ctx.ctx.runtime.runId, "plan", ctx.storyId, "facts-manifest.json");
   await _grounderDeps.write(manifestPath, JSON.stringify(manifest, null, 2));
 }
 var _grounderDeps, grounderStrategy = async (ctx) => {
@@ -45477,7 +46044,7 @@ function formatSpecDeltas(blockers, manifest) {
 
 // src/debate/verifiers/checks.ts
 import { existsSync as defaultExistsSync } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 function checkFilesExist(prd, workdir, deps) {
   const existsSync10 = deps?.existsSync ?? defaultExistsSync;
   const findings = [];
@@ -45487,7 +46054,7 @@ function checkFilesExist(prd, workdir, deps) {
     for (const entry of story.contextFiles) {
       const filePath = typeof entry === "string" ? entry : entry.path;
       const factId = typeof entry === "string" ? undefined : entry.factId;
-      const absPath = join32(workdir, filePath);
+      const absPath = join33(workdir, filePath);
       if (existsSync10(absPath))
         continue;
       if (factId) {
@@ -45598,7 +46165,7 @@ var init_checks3 = () => {};
 
 // src/debate/verifiers/plan-checklist.ts
 import { existsSync as existsSync10 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 function parsePrd(output) {
   if (!output)
     return null;
@@ -45609,7 +46176,7 @@ function parsePrd(output) {
   }
 }
 async function loadManifest(ctx) {
-  const manifestPath = join33(ctx.workdir, ".nax", "runs", ctx.ctx.runtime.runId, "plan", ctx.storyId, "facts-manifest.json");
+  const manifestPath = join34(ctx.workdir, ".nax", "runs", ctx.ctx.runtime.runId, "plan", ctx.storyId, "facts-manifest.json");
   const raw = await _planChecklistDeps.readFile(manifestPath);
   if (!raw)
     return null;
@@ -45622,7 +46189,7 @@ async function loadManifest(ctx) {
   }
 }
 async function emitSpecDeltas(ctx, blockers, manifest) {
-  const artifactPath = join33(ctx.workdir, ".nax", "runs", ctx.ctx.runtime.runId, "plan", ctx.storyId, "spec-deltas.md");
+  const artifactPath = join34(ctx.workdir, ".nax", "runs", ctx.ctx.runtime.runId, "plan", ctx.storyId, "spec-deltas.md");
   const content = formatSpecDeltas(blockers, manifest ?? { repoFacts: [], specClaims: [], gaps: [] });
   await _planChecklistDeps.write(artifactPath, content);
   return artifactPath;
@@ -45973,7 +46540,7 @@ var init_runner_plan_helpers = __esm(() => {
 });
 
 // src/debate/runner-plan.ts
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 async function runPlan(ctx, taskContext, outputFormat, opts) {
   const logger = _debateSessionDeps.getSafeLogger();
   const config2 = ctx.stageConfig;
@@ -46032,7 +46599,7 @@ async function runPlan(ctx, taskContext, outputFormat, opts) {
     sessionMode: ctx.stageConfig.sessionMode ?? "one-shot",
     proposers: ctx.stageConfig.proposers
   });
-  const outputPaths = resolved.map((_, i) => join34(opts.outputDir, `prd-debate-${i}.json`));
+  const outputPaths = resolved.map((_, i) => join35(opts.outputDir, `prd-debate-${i}.json`));
   const successful = [];
   let rebuttalList;
   if (selectorKind === "verifier-pick") {
@@ -48280,9 +48847,9 @@ function validateFeatureName(feature) {
 
 // src/plan/critic.ts
 import { mkdir as mkdir6 } from "fs/promises";
-import { dirname as dirname7, join as join37 } from "path";
+import { dirname as dirname7, join as join38 } from "path";
 async function writeSpecDeltas(findings, workdir, runId, storyId, manifest) {
-  const path7 = join37(workdir, ".nax", "runs", runId, "plan", storyId, "spec-deltas.md");
+  const path7 = join38(workdir, ".nax", "runs", runId, "plan", storyId, "spec-deltas.md");
   await mkdir6(dirname7(path7), { recursive: true });
   await Bun.write(path7, formatSpecDeltas(findings, manifest));
   return path7;
@@ -49495,9 +50062,9 @@ __export(exports_plan_decompose, {
   runReplanLoop: () => runReplanLoop,
   planDecomposeCommand: () => planDecomposeCommand
 });
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 async function planDecomposeCommand(workdir, config2, options) {
-  const prdPath = join38(workdir, ".nax", "features", options.feature, "prd.json");
+  const prdPath = join39(workdir, ".nax", "features", options.feature, "prd.json");
   if (!_planDeps.existsSync(prdPath)) {
     throw new NaxError(`PRD not found: ${prdPath}`, "PRD_NOT_FOUND", {
       stage: "decompose",
@@ -49671,7 +50238,7 @@ var init_plan_decompose = __esm(() => {
 
 // src/cli/plan-runtime.ts
 import { existsSync as existsSync15 } from "fs";
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 function isRuntimeWithAgentManager(value) {
   return typeof value === "object" && value !== null && "agentManager" in value;
 }
@@ -49723,7 +50290,7 @@ var init_plan_runtime = __esm(() => {
     writeFile: (path7, content) => Bun.write(path7, content).then(() => {}),
     scanSourceRoots: (workdir) => scanSourceRoots(workdir),
     createRuntime: (cfg, wd, featureName) => createRuntime(cfg, wd, { featureName }),
-    readPackageJson: (workdir) => Bun.file(join39(workdir, "package.json")).json().catch(() => null),
+    readPackageJson: (workdir) => Bun.file(join40(workdir, "package.json")).json().catch(() => null),
     spawnSync: (cmd, opts) => {
       const result = Bun.spawnSync(cmd, opts ? { cwd: opts.cwd } : {});
       return { stdout: result.stdout, exitCode: result.exitCode };
@@ -50108,7 +50675,7 @@ var init_metrics = __esm(() => {
 
 // src/commands/common.ts
 import { existsSync as existsSync16, readdirSync as readdirSync2, realpathSync as realpathSync3 } from "fs";
-import { join as join40, resolve as resolve13 } from "path";
+import { join as join41, resolve as resolve13 } from "path";
 function resolveProject(options = {}) {
   const { dir, feature } = options;
   let projectRoot;
@@ -50116,12 +50683,12 @@ function resolveProject(options = {}) {
   let configPath;
   if (dir) {
     projectRoot = realpathSync3(resolve13(dir));
-    naxDir = join40(projectRoot, ".nax");
+    naxDir = join41(projectRoot, ".nax");
     if (!existsSync16(naxDir)) {
       throw new NaxError(`Directory does not contain a nax project: ${projectRoot}
 Expected to find: ${naxDir}`, "NAX_DIR_NOT_FOUND", { projectRoot, naxDir });
     }
-    configPath = join40(naxDir, "config.json");
+    configPath = join41(naxDir, "config.json");
     if (!existsSync16(configPath)) {
       throw new NaxError(`.nax directory found but config.json is missing: ${naxDir}
 Expected to find: ${configPath}`, "CONFIG_NOT_FOUND", { naxDir, configPath });
@@ -50129,17 +50696,17 @@ Expected to find: ${configPath}`, "CONFIG_NOT_FOUND", { naxDir, configPath });
   } else {
     const found = findProjectRoot(process.cwd());
     if (!found) {
-      const cwdNaxDir = join40(process.cwd(), ".nax");
+      const cwdNaxDir = join41(process.cwd(), ".nax");
       if (existsSync16(cwdNaxDir)) {
-        const cwdConfigPath = join40(cwdNaxDir, "config.json");
+        const cwdConfigPath = join41(cwdNaxDir, "config.json");
         throw new NaxError(`.nax directory found but config.json is missing: ${cwdNaxDir}
 Expected to find: ${cwdConfigPath}`, "CONFIG_NOT_FOUND", { naxDir: cwdNaxDir, configPath: cwdConfigPath });
       }
       throw new NaxError("No nax project found. Run this command from within a nax project directory, or use -d flag to specify the project path.", "PROJECT_NOT_FOUND", { cwd: process.cwd() });
     }
     projectRoot = found;
-    naxDir = join40(projectRoot, ".nax");
-    configPath = join40(naxDir, "config.json");
+    naxDir = join41(projectRoot, ".nax");
+    configPath = join41(naxDir, "config.json");
   }
   let featureDir;
   if (feature) {
@@ -50148,8 +50715,8 @@ Expected to find: ${cwdConfigPath}`, "CONFIG_NOT_FOUND", { naxDir: cwdNaxDir, co
     } catch (error48) {
       throw new NaxError(error48.message, "FEATURE_INVALID", { feature });
     }
-    const featuresDir = join40(naxDir, "features");
-    featureDir = join40(featuresDir, feature);
+    const featuresDir = join41(naxDir, "features");
+    featureDir = join41(featuresDir, feature);
     if (!existsSync16(featureDir)) {
       const availableFeatures = existsSync16(featuresDir) ? readdirSync2(featuresDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name) : [];
       const availableMsg = availableFeatures.length > 0 ? `
@@ -50182,7 +50749,7 @@ async function resolveProjectAsync(options = {}) {
   }
   const isPlainName = !dir.includes("/") && !dir.includes("\\");
   if (isPlainName) {
-    const registryIdentityPath = join40(globalConfigDir(), dir, ".identity");
+    const registryIdentityPath = join41(globalConfigDir(), dir, ".identity");
     const identityFile = Bun.file(registryIdentityPath);
     if (await identityFile.exists()) {
       try {
@@ -50214,12 +50781,12 @@ function findProjectRoot(startDir) {
   let current = resolve13(startDir);
   let depth = 0;
   while (depth < MAX_DIRECTORY_DEPTH) {
-    const naxDir = join40(current, ".nax");
-    const configPath = join40(naxDir, "config.json");
+    const naxDir = join41(current, ".nax");
+    const configPath = join41(naxDir, "config.json");
     if (existsSync16(configPath)) {
       return realpathSync3(current);
     }
-    const parent = join40(current, "..");
+    const parent = join41(current, "..");
     if (parent === current) {
       break;
     }
@@ -51378,10 +51945,10 @@ var init_effectiveness = __esm(() => {
 
 // src/execution/progress.ts
 import { appendFile as appendFile3, mkdir as mkdir7 } from "fs/promises";
-import { join as join43 } from "path";
+import { join as join44 } from "path";
 async function appendProgress(featureDir, storyId, status, message) {
   await mkdir7(featureDir, { recursive: true });
-  const progressPath = join43(featureDir, "progress.txt");
+  const progressPath = join44(featureDir, "progress.txt");
   const timestamp = new Date().toISOString();
   const entry = `[${timestamp}] ${storyId} \u2014 ${status.toUpperCase()} \u2014 ${message}
 `;
@@ -51570,7 +52137,7 @@ var init_completion = __esm(() => {
 
 // src/constitution/loader.ts
 import { existsSync as existsSync19 } from "fs";
-import { join as join44 } from "path";
+import { join as join45 } from "path";
 function truncateToTokens(text, maxTokens) {
   const maxChars = maxTokens * 3;
   if (text.length <= maxChars) {
@@ -51592,7 +52159,7 @@ async function loadConstitution(projectDir, config2) {
   }
   let combinedContent = "";
   if (!config2.skipGlobal) {
-    const globalPath = join44(globalConfigDir(), config2.path);
+    const globalPath = join45(globalConfigDir(), config2.path);
     if (existsSync19(globalPath)) {
       const validatedPath = validateFilePath(globalPath, globalConfigDir());
       const globalFile = Bun.file(validatedPath);
@@ -51602,7 +52169,7 @@ async function loadConstitution(projectDir, config2) {
       }
     }
   }
-  const projectPath = join44(projectDir, config2.path);
+  const projectPath = join45(projectDir, config2.path);
   if (existsSync19(projectPath)) {
     const validatedPath = validateFilePath(projectPath, projectDir);
     const projectFile = Bun.file(validatedPath);
@@ -52209,11 +52776,24 @@ function toReviewDecisionPayload(opName, output) {
   if (typeof record2.passed !== "boolean" || !Array.isArray(record2.findings)) {
     return null;
   }
+  const acDropped = Array.isArray(record2.acDropped) ? record2.acDropped.map((d) => {
+    const entry = d ?? {};
+    const finding = entry.finding ?? {};
+    return {
+      code: typeof entry.code === "string" ? entry.code : undefined,
+      severity: typeof finding.severity === "string" ? finding.severity : undefined,
+      file: typeof finding.file === "string" ? finding.file : undefined,
+      line: typeof finding.line === "number" ? finding.line : undefined,
+      issue: typeof finding.issue === "string" ? finding.issue : undefined,
+      acIndex: typeof finding.acIndex === "number" ? finding.acIndex : undefined
+    };
+  }) : undefined;
   return {
     reviewer,
     parsed: true,
     passed: record2.passed,
-    result: { passed: record2.passed, findings: record2.findings }
+    result: { passed: record2.passed, findings: record2.findings },
+    acDropped
   };
 }
 function emitReviewDecision(ctx, opName, output) {
@@ -52262,12 +52842,38 @@ function logUnifiedReviewPhaseResult(storyId, opName, output) {
   const title = payload.reviewer === "semantic" ? "Semantic review" : "Adversarial review";
   if (payload.passed) {
     logger?.info("review", `${title} passed`, { storyId });
-  } else {
-    logger?.warn("review", `${title} failed: ${findingsCount} findings`, {
+    return;
+  }
+  if (findingsCount === 0) {
+    const dropped = payload.acDropped ?? [];
+    const droppedSummary = dropped.slice(0, 5);
+    logger?.warn("review", `${title} failed: 0 findings \u2014 ${dropped.length > 0 ? `${dropped.length} blocking finding(s) dropped as ungrounded by AC-grounding filter` : "model emitted passed:false but produced no findings (likely empty output)"}`, {
       storyId,
-      findingsCount
+      findingsCount,
+      reason: dropped.length > 0 ? "ac-grounding-drop" : "passed-false-no-findings",
+      droppedCount: dropped.length || undefined,
+      droppedFindings: droppedSummary.length > 0 ? droppedSummary : undefined,
+      droppedTruncated: dropped.length > droppedSummary.length || undefined
     });
+    return;
   }
+  const findingsSummary = payload.result.findings.slice(0, 5).map((f) => {
+    const r = f ?? {};
+    return {
+      severity: typeof r.severity === "string" ? r.severity : undefined,
+      file: typeof r.file === "string" ? r.file : undefined,
+      line: typeof r.line === "number" ? r.line : undefined,
+      rule: typeof r.rule === "string" ? r.rule : undefined,
+      issue: typeof r.issue === "string" ? r.issue : typeof r.message === "string" ? r.message : undefined,
+      acIndex: typeof r.acIndex === "number" ? r.acIndex : undefined
+    };
+  });
+  logger?.warn("review", `${title} failed: ${findingsCount} findings`, {
+    storyId,
+    findingsCount,
+    findings: findingsSummary,
+    truncated: findingsCount > findingsSummary.length
+  });
 }
 async function runPhase(ctx, slot, phaseCosts, phaseOutputs, isThreeSession = false) {
   const logger = getSafeLogger();
@@ -52386,7 +52992,7 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs) {
           continue;
         findings.push(...extractPhaseFindings(phaseOutputs[phase.slot.op.name]));
       }
-      return findings;
+      return rectification2.postValidate ? await rectification2.postValidate(findings, _validateCtx) : findings;
     }
   };
   const cycleResult = await _storyOrchestratorDeps.runFixCycle(cycle, ctx, "story-orchestrator-rectification", { callOp: wrappedCallOp });
@@ -52400,7 +53006,8 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs) {
     "max-attempts-total",
     "max-attempts-per-strategy",
     "bail-when",
-    "no-strategy"
+    "no-strategy",
+    "agent-gave-up"
   ]);
   if (exhaustedReasons.has(cycleResult.exitReason) && cycleResult.finalFindings.length > 0) {
     return { rectificationExhausted: true, unfixedFindings: cycleResult.finalFindings };
@@ -52585,6 +53192,7 @@ var init_story_orchestrator = __esm(() => {
 });
 
 // src/execution/build-plan-for-strategy.ts
+import { join as join46 } from "path";
 function isThreeSessionStrategy(strategy) {
   return THREE_SESSION_STRATEGIES2.has(strategy);
 }
@@ -52596,7 +53204,7 @@ function isFreshRun(story) {
   const hasReviewEscalation = (story.priorFailures ?? []).some((f) => f.stage === "review");
   return !hasAttempts && !hasReviewEscalation;
 }
-function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
+async function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
   const isThreeSession = isThreeSessionStrategy(testStrategy);
   const freshRun = isFreshRun(story);
   const builder = new StoryOrchestratorBuilder;
@@ -52631,6 +53239,9 @@ function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
     builder.addAdversarialReview(inputs.adversarialReview);
   }
   if (shouldRunRectification(config2) && inputs.rectification) {
+    const sink = makeDeclarationSink();
+    const packageDir = join46(ctx.packageDir, story.workdir ?? "");
+    const resolvedTestPatterns = await resolveTestFilePatterns(config2, ctx.packageDir, story.workdir);
     const strategies = [];
     if (config2.quality.commands.lintFix || config2.quality.commands.lintFixScoped) {
       strategies.push(makeMechanicalLintFixStrategy());
@@ -52639,15 +53250,31 @@ function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
       strategies.push(makeMechanicalFormatFixStrategy());
     }
     if (isThreeSession && inputs.fullSuiteGate) {
-      strategies.push(makeFullSuiteRectifyStrategy(story));
+      strategies.push(makeFullSuiteRectifyStrategy(story, config2));
     }
     if (config2.quality.autofix?.enabled !== false) {
-      strategies.push(makeAutofixImplementerStrategy(story));
-      strategies.push(makeAutofixTestWriterStrategy(story, config2));
-    }
+      strategies.push(makeAutofixImplementerStrategy(story, config2, sink));
+      strategies.push(makeAutofixTestWriterStrategy(story, config2, sink));
+    }
+    const postValidate = async (findings, _validateCtx) => {
+      if (sink.testEdits.length === 0 && sink.mockHandoffs.length === 0)
+        return findings;
+      const pendingMock = sink.mockHandoffs.map((h) => ({
+        reason: "mock_structure",
+        file: h.files[0] ?? "",
+        files: h.files,
+        reasonDetail: h.reasonDetail
+      }));
+      const { valid, invalid } = await validateMockStructureFiles(pendingMock, resolvedTestPatterns, packageDir);
+      sink.mockHandoffs = valid.map((d) => ({ files: d.files ?? [], reasonDetail: d.reasonDetail ?? "" }));
+      const allDeclarations = [...sink.testEdits, ...valid];
+      sink.testEdits = [];
+      return applyTestEditDeclarations(findings, allDeclarations, story, invalid);
+    };
     const rectOpts = {
       ...inputs.rectification,
-      strategies: [...strategies, ...inputs.rectification.strategies]
+      strategies: [...strategies, ...inputs.rectification.strategies],
+      postValidate
     };
     builder.addRectification(rectOpts);
   }
@@ -52658,6 +53285,7 @@ var init_build_plan_for_strategy = __esm(() => {
   init_operations();
   init_execution_gates();
   init_full_suite_rectify();
+  init_test_runners();
   init_story_orchestrator();
   THREE_SESSION_STRATEGIES2 = new Set(["three-session-tdd", "three-session-tdd-lite"]);
 });
@@ -52783,9 +53411,9 @@ async function assemblePlanInputsFromCtx(ctx) {
     blockingThreshold: ctx.config.review.blockingThreshold
   } : undefined;
   const rectificationInput = ctx.config.execution?.rectification?.enabled === true ? {
-    maxAttempts: ctx.config.execution.rectification.maxRetries ?? 2,
+    maxAttempts: ctx.config.execution.rectification.maxAttemptsTotal,
     strategies: [],
-    abortOnIncreasingFailures: ctx.config.execution.rectification.abortOnIncreasingFailures ?? true
+    abortOnIncreasingFailures: ctx.config.execution.rectification.abortOnIncreasingFailures
   } : undefined;
   return {
     story,
@@ -53249,10 +53877,29 @@ Category: ${failureCategory ?? "unknown"}`,
     }
   }
   if (!planResult.success) {
+    const failedPhases = {};
+    for (const [name, output] of Object.entries(planResult.phaseOutputs)) {
+      if (!output || typeof output !== "object")
+        continue;
+      const r = output;
+      const passed = typeof r.passed === "boolean" ? r.passed : undefined;
+      const success2 = typeof r.success === "boolean" ? r.success : undefined;
+      const explicitFail = passed === false || success2 === false;
+      if (!explicitFail)
+        continue;
+      const findings = Array.isArray(r.findings) ? r.findings.length : undefined;
+      failedPhases[name] = { passed, success: success2, findingsCount: findings };
+    }
+    const stderrTail = (agentResult.stderr ?? "").slice(-500);
+    const outputTail = (agentResult.output ?? "").slice(-500);
     logger.error("execution", "Agent session failed", {
       storyId: ctx.story.id,
       exitCode: agentResult.exitCode,
-      rateLimited: agentResult.rateLimited
+      rateLimited: agentResult.rateLimited,
+      failureCategory: failureCategory ?? "unknown",
+      failedPhases: Object.keys(failedPhases).length > 0 ? failedPhases : undefined,
+      stderrTail: stderrTail || undefined,
+      outputTail: outputTail || undefined
     });
     if (agentResult.rateLimited) {
       logger.warn("execution", "Rate limited \u2014 will retry", { storyId: ctx.story.id });
@@ -53357,7 +54004,7 @@ var init_execution = __esm(() => {
       } : null;
       const initialRef = tddMode ? await _executionDeps.captureGitRef(ctx.workdir) ?? "HEAD" : null;
       const inputs = await _executionDeps.assemblePlanInputsFromCtx(ctx);
-      const plan = buildPlanForStrategy(callCtx, ctx.story, ctx.config, ctx.routing.testStrategy, inputs);
+      const plan = await buildPlanForStrategy(callCtx, ctx.story, ctx.config, ctx.routing.testStrategy, inputs);
       let planResult;
       try {
         planResult = await plan.run();
@@ -53976,6 +54623,11 @@ class RegressionStrategy {
     const durationMs = Date.now() - start;
     if (result.success) {
       const parsed2 = result.output ? parseTestOutput(result.output) : { passed: 0, failed: 0, failures: [] };
+      logger?.info("verify[regression]", "Full-suite regression gate passed", {
+        storyId: ctx.storyId,
+        passCount: parsed2.passed,
+        durationMs
+      });
       return makePassResult(ctx.storyId, "regression", {
         rawOutput: result.output,
         passCount: parsed2.passed,
@@ -53989,9 +54641,19 @@ class RegressionStrategy {
       return makePassResult(ctx.storyId, "regression", { durationMs });
     }
     if (result.status === "TIMEOUT") {
+      logger?.warn("verify[regression]", "Full-suite regression gate timed out", {
+        storyId: ctx.storyId,
+        durationMs
+      });
       return makeFailResult(ctx.storyId, "regression", "TIMEOUT", { rawOutput: result.output, durationMs });
     }
     const parsed = result.output ? parseTestOutput(result.output) : { passed: 0, failed: 0, failures: [] };
+    logger?.warn("verify[regression]", "Full-suite regression gate failed", {
+      storyId: ctx.storyId,
+      passCount: parsed.passed,
+      failCount: parsed.failed,
+      durationMs
+    });
     return makeFailResult(ctx.storyId, "regression", "TEST_FAILURE", {
       rawOutput: result.output,
       passCount: parsed.passed,
@@ -54289,7 +54951,7 @@ function buildFrontmatter(story, ctx, role) {
 }
 
 // src/cli/prompts-tdd.ts
-import { join as join45 } from "path";
+import { join as join47 } from "path";
 async function handleThreeSessionTddPrompts(story, ctx, outputDir, logger) {
   const [testWriterPrompt, implementerPrompt, verifierPrompt] = await Promise.all([
     TddPromptBuilder.for("test-writer", { isolation: "strict" }).withLoader(ctx.workdir, ctx.config).story(story).context(ctx.contextMarkdown).constitution(ctx.constitution?.content).testCommand(ctx.config.quality?.commands?.test).build(),
@@ -54308,7 +54970,7 @@ ${frontmatter}---
 
 ${session.prompt}`;
     if (outputDir) {
-      const promptFile = join45(outputDir, `${story.id}.${session.role}.md`);
+      const promptFile = join47(outputDir, `${story.id}.${session.role}.md`);
       await Bun.write(promptFile, fullOutput);
       logger.info("cli", "Written TDD prompt file", {
         storyId: story.id,
@@ -54324,7 +54986,7 @@ ${"=".repeat(80)}`);
     }
   }
   if (outputDir && ctx.contextMarkdown) {
-    const contextFile = join45(outputDir, `${story.id}.context.md`);
+    const contextFile = join47(outputDir, `${story.id}.context.md`);
     const frontmatter = buildFrontmatter(story, ctx);
     const contextOutput = `---
 ${frontmatter}---
@@ -54339,16 +55001,16 @@ var init_prompts_tdd = __esm(() => {
 
 // src/cli/prompts-main.ts
 import { existsSync as existsSync20, mkdirSync as mkdirSync3 } from "fs";
-import { join as join46 } from "path";
+import { join as join48 } from "path";
 async function promptsCommand(options) {
   const logger = getLogger();
   const { feature, workdir, config: config2, storyId, outputDir } = options;
-  const naxDir = join46(workdir, ".nax");
+  const naxDir = join48(workdir, ".nax");
   if (!existsSync20(naxDir)) {
     throw new Error(`.nax directory not found. Run 'nax init' first in ${workdir}`);
   }
-  const featureDir = join46(naxDir, "features", feature);
-  const prdPath = join46(featureDir, "prd.json");
+  const featureDir = join48(naxDir, "features", feature);
+  const prdPath = join48(featureDir, "prd.json");
   if (!existsSync20(prdPath)) {
     throw new Error(`Feature "${feature}" not found or missing prd.json`);
   }
@@ -54415,10 +55077,10 @@ ${frontmatter}---
 
 ${ctx.prompt}`;
     if (outputDir) {
-      const promptFile = join46(outputDir, `${story.id}.prompt.md`);
+      const promptFile = join48(outputDir, `${story.id}.prompt.md`);
       await Bun.write(promptFile, fullOutput);
       if (ctx.contextMarkdown) {
-        const contextFile = join46(outputDir, `${story.id}.context.md`);
+        const contextFile = join48(outputDir, `${story.id}.context.md`);
         const contextOutput = `---
 ${frontmatter}---
 
@@ -54454,12 +55116,12 @@ var init_prompts_main = __esm(() => {
 
 // src/cli/prompts-init.ts
 import { existsSync as existsSync21, mkdirSync as mkdirSync4 } from "fs";
-import { join as join47 } from "path";
+import { join as join49 } from "path";
 async function promptsInitCommand(options) {
   const { workdir, force = false, autoWireConfig = true } = options;
-  const templatesDir = join47(workdir, ".nax", "templates");
+  const templatesDir = join49(workdir, ".nax", "templates");
   mkdirSync4(templatesDir, { recursive: true });
-  const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync21(join47(templatesDir, f)));
+  const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync21(join49(templatesDir, f)));
   if (existingFiles.length > 0 && !force) {
     _promptsInitDeps.warn(`[WARN] nax/templates/ already contains files: ${existingFiles.join(", ")}. No files overwritten.
        Pass --force to overwrite existing templates.`);
@@ -54467,7 +55129,7 @@ async function promptsInitCommand(options) {
   }
   const written = [];
   for (const template of TEMPLATE_ROLES) {
-    const filePath = join47(templatesDir, template.file);
+    const filePath = join49(templatesDir, template.file);
     const roleBody = template.role === "implementer" ? buildRoleTaskSection(template.role, template.variant) : buildRoleTaskSection(template.role);
     const content = TEMPLATE_HEADER + roleBody;
     await Bun.write(filePath, content);
@@ -54483,7 +55145,7 @@ async function promptsInitCommand(options) {
   return written;
 }
 async function autoWirePromptsConfig(workdir) {
-  const configPath = join47(workdir, "nax.config.json");
+  const configPath = join49(workdir, "nax.config.json");
   if (!existsSync21(configPath)) {
     const exampleConfig = JSON.stringify({
       prompts: {
@@ -54653,7 +55315,7 @@ __export(exports_init_context, {
 });
 import { existsSync as existsSync22 } from "fs";
 import { mkdir as mkdir8 } from "fs/promises";
-import { basename as basename9, join as join48 } from "path";
+import { basename as basename9, join as join50 } from "path";
 async function findFiles(dir, maxFiles = 200) {
   try {
     const proc = Bun.spawnSync([
@@ -54681,7 +55343,7 @@ async function findFiles(dir, maxFiles = 200) {
   return [];
 }
 async function readPackageManifest(projectRoot) {
-  const packageJsonPath = join48(projectRoot, "package.json");
+  const packageJsonPath = join50(projectRoot, "package.json");
   if (!existsSync22(packageJsonPath)) {
     return null;
   }
@@ -54699,7 +55361,7 @@ async function readPackageManifest(projectRoot) {
   }
 }
 async function readReadmeSnippet(projectRoot) {
-  const readmePath = join48(projectRoot, "README.md");
+  const readmePath = join50(projectRoot, "README.md");
   if (!existsSync22(readmePath)) {
     return null;
   }
@@ -54717,7 +55379,7 @@ async function detectEntryPoints(projectRoot) {
   const candidates = ["src/index.ts", "src/main.ts", "main.go", "src/lib.rs"];
   const found = [];
   for (const candidate of candidates) {
-    const path14 = join48(projectRoot, candidate);
+    const path14 = join50(projectRoot, candidate);
     if (existsSync22(path14)) {
       found.push(candidate);
     }
@@ -54728,7 +55390,7 @@ async function detectConfigFiles(projectRoot) {
   const candidates = ["tsconfig.json", "biome.json", "turbo.json", ".env.example"];
   const found = [];
   for (const candidate of candidates) {
-    const path14 = join48(projectRoot, candidate);
+    const path14 = join50(projectRoot, candidate);
     if (existsSync22(path14)) {
       found.push(candidate);
     }
@@ -54889,8 +55551,8 @@ function generatePackageContextTemplate(packagePath) {
 }
 async function initPackage(repoRoot, packagePath, force = false) {
   const logger = getLogger();
-  const naxDir = join48(repoRoot, ".nax", "mono", packagePath);
-  const contextPath = join48(naxDir, "context.md");
+  const naxDir = join50(repoRoot, ".nax", "mono", packagePath);
+  const contextPath = join50(naxDir, "context.md");
   if (existsSync22(contextPath) && !force) {
     logger.info("init", "Package context.md already exists (use --force to overwrite)", { path: contextPath });
     return;
@@ -54904,8 +55566,8 @@ async function initPackage(repoRoot, packagePath, force = false) {
 }
 async function initContext(projectRoot, options = {}) {
   const logger = getLogger();
-  const naxDir = join48(projectRoot, ".nax");
-  const contextPath = join48(naxDir, "context.md");
+  const naxDir = join50(projectRoot, ".nax");
+  const contextPath = join50(naxDir, "context.md");
   if (existsSync22(contextPath) && !options.force) {
     logger.info("init", "context.md already exists, skipping (use --force to overwrite)", { path: contextPath });
     return;
@@ -54935,9 +55597,9 @@ var init_init_context = __esm(() => {
 
 // src/cli/init-detect.ts
 import { existsSync as existsSync23, readFileSync } from "fs";
-import { join as join49 } from "path";
+import { join as join51 } from "path";
 function readPackageJson(projectRoot) {
-  const pkgPath = join49(projectRoot, "package.json");
+  const pkgPath = join51(projectRoot, "package.json");
   if (!existsSync23(pkgPath))
     return;
   try {
@@ -54980,41 +55642,41 @@ function detectStack(projectRoot) {
   };
 }
 function detectRuntime(projectRoot) {
-  if (existsSync23(join49(projectRoot, "bun.lockb")) || existsSync23(join49(projectRoot, "bunfig.toml"))) {
+  if (existsSync23(join51(projectRoot, "bun.lockb")) || existsSync23(join51(projectRoot, "bunfig.toml"))) {
     return "bun";
   }
-  if (existsSync23(join49(projectRoot, "package-lock.json")) || existsSync23(join49(projectRoot, "yarn.lock")) || existsSync23(join49(projectRoot, "pnpm-lock.yaml"))) {
+  if (existsSync23(join51(projectRoot, "package-lock.json")) || existsSync23(join51(projectRoot, "yarn.lock")) || existsSync23(join51(projectRoot, "pnpm-lock.yaml"))) {
     return "node";
   }
   return "unknown";
 }
 function detectLanguage2(projectRoot) {
-  if (existsSync23(join49(projectRoot, "tsconfig.json")))
+  if (existsSync23(join51(projectRoot, "tsconfig.json")))
     return "typescript";
-  if (existsSync23(join49(projectRoot, "pyproject.toml")) || existsSync23(join49(projectRoot, "setup.py"))) {
+  if (existsSync23(join51(projectRoot, "pyproject.toml")) || existsSync23(join51(projectRoot, "setup.py"))) {
     return "python";
   }
-  if (existsSync23(join49(projectRoot, "Cargo.toml")))
+  if (existsSync23(join51(projectRoot, "Cargo.toml")))
     return "rust";
-  if (existsSync23(join49(projectRoot, "go.mod")))
+  if (existsSync23(join51(projectRoot, "go.mod")))
     return "go";
   return "unknown";
 }
 function detectLinter(projectRoot) {
-  if (existsSync23(join49(projectRoot, "biome.json")) || existsSync23(join49(projectRoot, "biome.jsonc"))) {
+  if (existsSync23(join51(projectRoot, "biome.json")) || existsSync23(join51(projectRoot, "biome.jsonc"))) {
     return "biome";
   }
-  if (existsSync23(join49(projectRoot, ".eslintrc.json")) || existsSync23(join49(projectRoot, ".eslintrc.js")) || existsSync23(join49(projectRoot, "eslint.config.js"))) {
+  if (existsSync23(join51(projectRoot, ".eslintrc.json")) || existsSync23(join51(projectRoot, ".eslintrc.js")) || existsSync23(join51(projectRoot, "eslint.config.js"))) {
     return "eslint";
   }
   return "unknown";
 }
 function detectMonorepo(projectRoot) {
-  if (existsSync23(join49(projectRoot, "turbo.json")))
+  if (existsSync23(join51(projectRoot, "turbo.json")))
     return "turborepo";
-  if (existsSync23(join49(projectRoot, "nx.json")))
+  if (existsSync23(join51(projectRoot, "nx.json")))
     return "nx";
-  if (existsSync23(join49(projectRoot, "pnpm-workspace.yaml")))
+  if (existsSync23(join51(projectRoot, "pnpm-workspace.yaml")))
     return "pnpm-workspaces";
   const pkg = readPackageJson(projectRoot);
   if (pkg?.workspaces)
@@ -55158,7 +55820,7 @@ __export(exports_init, {
 });
 import { existsSync as existsSync24 } from "fs";
 import { mkdir as mkdir9 } from "fs/promises";
-import { join as join50 } from "path";
+import { join as join52 } from "path";
 function validateProjectName(name) {
   if (!name)
     return { valid: false, error: "name must be non-empty" };
@@ -55194,7 +55856,7 @@ async function checkInitCollision(name, currentWorkdir, currentRemote) {
 }
 async function updateGitignore(projectRoot) {
   const logger = getLogger();
-  const gitignorePath = join50(projectRoot, ".gitignore");
+  const gitignorePath = join52(projectRoot, ".gitignore");
   let existing = "";
   if (existsSync24(gitignorePath)) {
     existing = await Bun.file(gitignorePath).text();
@@ -55280,7 +55942,7 @@ async function initGlobal() {
     await mkdir9(globalDir, { recursive: true });
     logger.info("init", "Created global config directory", { path: globalDir });
   }
-  const configPath = join50(globalDir, "config.json");
+  const configPath = join52(globalDir, "config.json");
   if (!existsSync24(configPath)) {
     await Bun.write(configPath, `${JSON.stringify(MINIMAL_GLOBAL_CONFIG, null, 2)}
 `);
@@ -55288,14 +55950,14 @@ async function initGlobal() {
   } else {
     logger.info("init", "Global config already exists", { path: configPath });
   }
-  const constitutionPath = join50(globalDir, "constitution.md");
+  const constitutionPath = join52(globalDir, "constitution.md");
   if (!existsSync24(constitutionPath)) {
     await Bun.write(constitutionPath, buildConstitution({ runtime: "unknown", language: "unknown", linter: "unknown", monorepo: "none" }));
     logger.info("init", "Created global constitution", { path: constitutionPath });
   } else {
     logger.info("init", "Global constitution already exists", { path: constitutionPath });
   }
-  const hooksDir = join50(globalDir, "hooks");
+  const hooksDir = join52(globalDir, "hooks");
   if (!existsSync24(hooksDir)) {
     await mkdir9(hooksDir, { recursive: true });
     logger.info("init", "Created global hooks directory", { path: hooksDir });
@@ -55328,7 +55990,7 @@ async function initProject(projectRoot, options) {
   if (detectedName && !options?.force) {
     const collision = await checkInitCollision(detectedName, projectRoot, currentRemote);
     if (collision.collision && collision.existing) {
-      const configPath2 = join50(projectDir, "config.json");
+      const configPath2 = join52(projectDir, "config.json");
       throw new NaxError([
         `Project name collision: "${detectedName}"`,
         `  This project:    ${projectRoot}`,
@@ -55356,7 +56018,7 @@ async function initProject(projectRoot, options) {
     linter: stack.linter,
     monorepo: stack.monorepo
   });
-  const configPath = join50(projectDir, "config.json");
+  const configPath = join52(projectDir, "config.json");
   if (!existsSync24(configPath)) {
     await Bun.write(configPath, `${JSON.stringify(projectConfig, null, 2)}
 `);
@@ -55365,14 +56027,14 @@ async function initProject(projectRoot, options) {
     logger.info("init", "Project config already exists", { path: configPath });
   }
   await initContext(projectRoot, { ai: options?.ai, force: options?.force });
-  const constitutionPath = join50(projectDir, "constitution.md");
+  const constitutionPath = join52(projectDir, "constitution.md");
   if (!existsSync24(constitutionPath) || options?.force) {
     await Bun.write(constitutionPath, buildConstitution(stack));
     logger.info("init", "Created project constitution", { path: constitutionPath });
   } else {
     logger.info("init", "Project constitution already exists", { path: constitutionPath });
   }
-  const hooksDir = join50(projectDir, "hooks");
+  const hooksDir = join52(projectDir, "hooks");
   if (!existsSync24(hooksDir)) {
     await mkdir9(hooksDir, { recursive: true });
     logger.info("init", "Created project hooks directory", { path: hooksDir });
@@ -56807,12 +57469,12 @@ var init_loader4 = __esm(() => {
 });
 
 // src/utils/paths.ts
-import { join as join62 } from "path";
+import { join as join64 } from "path";
 function getRunsDir() {
-  return process.env.NAX_RUNS_DIR ?? join62(globalConfigDir(), "runs");
+  return process.env.NAX_RUNS_DIR ?? join64(globalConfigDir(), "runs");
 }
 function getEventsRootDir() {
-  return join62(globalConfigDir(), "events");
+  return join64(globalConfigDir(), "events");
 }
 var init_paths3 = __esm(() => {
   init_paths();
@@ -56872,7 +57534,7 @@ var init_command_argv = __esm(() => {
 });
 
 // src/hooks/runner.ts
-import { join as join69 } from "path";
+import { join as join71 } from "path";
 function createDrainDeadline2(deadlineMs) {
   let timeoutId;
   const promise2 = new Promise((resolve16) => {
@@ -56891,14 +57553,14 @@ async function loadHooksConfig(projectDir, globalDir) {
   let globalHooks = { hooks: {} };
   let projectHooks = { hooks: {} };
   let skipGlobal = false;
-  const projectPath = join69(projectDir, "hooks.json");
+  const projectPath = join71(projectDir, "hooks.json");
   const projectData = await loadJsonFile(projectPath, "hooks");
   if (projectData) {
     projectHooks = projectData;
     skipGlobal = projectData.skipGlobal ?? false;
   }
   if (!skipGlobal && globalDir) {
-    const globalPath = join69(globalDir, "hooks.json");
+    const globalPath = join71(globalDir, "hooks.json");
     const globalData = await loadJsonFile(globalPath, "hooks");
     if (globalData) {
       globalHooks = globalData;
@@ -57068,7 +57730,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.67.10",
+    version: "0.67.12",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -57163,8 +57825,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("1d0ef5ac"))
-        return "1d0ef5ac";
+      if (/^[0-9a-f]{6,10}$/.test("c747dea2"))
+        return "c747dea2";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -58033,15 +58695,15 @@ var init_acceptance_loop = __esm(() => {
 
 // src/session/scratch-purge.ts
 import { mkdir as mkdir13, rename, rm } from "fs/promises";
-import { dirname as dirname12, join as join70 } from "path";
+import { dirname as dirname12, join as join72 } from "path";
 async function purgeStaleScratch(projectDir, featureName, retentionDays, archiveInsteadOfDelete = false) {
-  const sessionsDir = join70(projectDir, ".nax", "features", featureName, "sessions");
+  const sessionsDir = join72(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 = join70(sessionsDir, sessionId);
-    const descriptorPath = join70(sessionDir, "descriptor.json");
+    const sessionDir = join72(sessionsDir, sessionId);
+    const descriptorPath = join72(sessionDir, "descriptor.json");
     if (!await _scratchPurgeDeps.fileExists(descriptorPath))
       continue;
     let lastActivityAt;
@@ -58057,7 +58719,7 @@ async function purgeStaleScratch(projectDir, featureName, retentionDays, archive
     if (new Date(lastActivityAt).getTime() >= cutoffMs)
       continue;
     if (archiveInsteadOfDelete) {
-      const archiveDest = join70(projectDir, ".nax", "features", featureName, "_archive", "sessions", sessionId);
+      const archiveDest = join72(projectDir, ".nax", "features", featureName, "_archive", "sessions", sessionId);
       await _scratchPurgeDeps.move(sessionDir, archiveDest);
     } else {
       await _scratchPurgeDeps.remove(sessionDir);
@@ -58138,7 +58800,7 @@ async function runDeferredRegression(options) {
   }
   const testCommand = config2.quality.commands.test ?? "bun test";
   const timeoutSeconds = config2.execution.regressionGate?.timeoutSeconds ?? 120;
-  const maxRectificationAttempts = config2.execution.regressionGate?.maxRectificationAttempts ?? 2;
+  const maxRectificationAttempts = config2.execution.rectification.maxAttemptsTotal;
   const acceptOnTimeout = config2.execution.regressionGate?.acceptOnTimeout ?? true;
   const verifyOpts = {
     workdir,
@@ -58302,7 +58964,7 @@ async function runDeferredRegression(options) {
     const cycle = {
       findings: initialFindings,
       iterations: [],
-      strategies: [makeFullSuiteRectifyStrategy(story)],
+      strategies: [makeFullSuiteRectifyStrategy(story, config2)],
       config: { maxAttemptsTotal: maxRectificationAttempts, validatorRetries: 1 },
       validate: async (_cycleCtx, _opts) => {
         const verification = await _regressionDeps.runVerification(verifyOpts);
@@ -58766,12 +59428,12 @@ var DEFAULT_MAX_BATCH_SIZE = 4;
 
 // src/pipeline/subscribers/events-writer.ts
 import { appendFile as appendFile5, mkdir as mkdir14 } from "fs/promises";
-import { basename as basename14, join as join71 } from "path";
+import { basename as basename14, join as join73 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename14(workdir);
-  const eventsDir = join71(getEventsRootDir(), project);
-  const eventsFile = join71(eventsDir, "events.jsonl");
+  const eventsDir = join73(getEventsRootDir(), project);
+  const eventsFile = join73(eventsDir, "events.jsonl");
   let dirReady = false;
   const write = (line) => {
     return (async () => {
@@ -58952,12 +59614,12 @@ var init_interaction2 = __esm(() => {
 
 // src/pipeline/subscribers/registry.ts
 import { mkdir as mkdir15, writeFile as writeFile2 } from "fs/promises";
-import { basename as basename15, join as join72 } from "path";
+import { basename as basename15, join as join74 } from "path";
 function wireRegistry(bus, feature, runId, workdir, outputDir) {
   const logger = getSafeLogger();
   const project = basename15(workdir);
-  const runDir = join72(getRunsDir(), `${project}-${feature}-${runId}`);
-  const metaFile = join72(runDir, "meta.json");
+  const runDir = join74(getRunsDir(), `${project}-${feature}-${runId}`);
+  const metaFile = join74(runDir, "meta.json");
   const unsub = bus.on("run:started", (_ev) => {
     return (async () => {
       try {
@@ -58967,8 +59629,8 @@ function wireRegistry(bus, feature, runId, workdir, outputDir) {
           project,
           feature,
           workdir,
-          statusPath: join72(outputDir, "features", feature, "status.json"),
-          eventsDir: join72(outputDir, "features", feature, "runs"),
+          statusPath: join74(outputDir, "features", feature, "status.json"),
+          eventsDir: join74(outputDir, "features", feature, "runs"),
           registeredAt: new Date().toISOString()
         };
         await writeFile2(metaFile, JSON.stringify(meta3, null, 2));
@@ -59214,7 +59876,7 @@ var init_types9 = __esm(() => {
 
 // src/worktree/dependencies.ts
 import { existsSync as existsSync32 } from "fs";
-import { join as join73 } from "path";
+import { join as join75 } from "path";
 async function prepareWorktreeDependencies(options) {
   const mode = options.config.execution.worktreeDependencies.mode;
   const resolvedCwd = resolveDependencyCwd(options);
@@ -59228,7 +59890,7 @@ async function prepareWorktreeDependencies(options) {
   }
 }
 function resolveDependencyCwd(options) {
-  return options.storyWorkdir ? join73(options.worktreeRoot, options.storyWorkdir) : options.worktreeRoot;
+  return options.storyWorkdir ? join75(options.worktreeRoot, options.storyWorkdir) : options.worktreeRoot;
 }
 function resolveInheritedDependencies(options, resolvedCwd) {
   if (hasDependencyManifests(options.worktreeRoot, resolvedCwd)) {
@@ -59238,7 +59900,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(join73(directory, filename))));
+  return directories.some((directory) => PHASE_ONE_INHERIT_UNSUPPORTED_FILES.some((filename) => _worktreeDependencyDeps.existsSync(join75(directory, filename))));
 }
 async function provisionDependencies(config2, worktreeRoot, resolvedCwd) {
   const setupCommand = config2.execution.worktreeDependencies.setupCommand;
@@ -59302,13 +59964,13 @@ __export(exports_manager, {
 });
 import { existsSync as existsSync33, symlinkSync } from "fs";
 import { mkdir as mkdir16 } from "fs/promises";
-import { join as join74 } from "path";
+import { join as join76 } from "path";
 
 class WorktreeManager {
   async ensureGitExcludes(projectRoot) {
     const logger = getSafeLogger();
-    const infoDir = join74(projectRoot, ".git", "info");
-    const excludePath = join74(infoDir, "exclude");
+    const infoDir = join76(projectRoot, ".git", "info");
+    const excludePath = join76(infoDir, "exclude");
     try {
       await mkdir16(infoDir, { recursive: true });
       let existing = "";
@@ -59335,7 +59997,7 @@ ${missing.join(`
   }
   async create(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join74(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join76(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const pruneProc = _managerDeps.spawn(["git", "worktree", "prune"], {
@@ -59376,9 +60038,9 @@ ${missing.join(`
       }
       throw new Error(`Failed to create worktree: ${String(error48)}`);
     }
-    const envSource = join74(projectRoot, ".env");
+    const envSource = join76(projectRoot, ".env");
     if (existsSync33(envSource)) {
-      const envTarget = join74(worktreePath, ".env");
+      const envTarget = join76(worktreePath, ".env");
       try {
         symlinkSync(envSource, envTarget, "file");
       } catch (error48) {
@@ -59389,7 +60051,7 @@ ${missing.join(`
   }
   async remove(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join74(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join76(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const proc = _managerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
@@ -60189,10 +60851,10 @@ var init_merge_conflict_rectify = __esm(() => {
 });
 
 // src/execution/pipeline-result-handler.ts
-import { join as join75 } from "path";
+import { join as join77 } from "path";
 async function removeWorktreeDirectory(projectRoot, storyId) {
   const logger = getSafeLogger();
-  const worktreePath = join75(projectRoot, ".nax-wt", storyId);
+  const worktreePath = join77(projectRoot, ".nax-wt", storyId);
   try {
     const proc = _resultHandlerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
       cwd: projectRoot,
@@ -60348,7 +61010,7 @@ async function handlePipelineFailure(ctx, pipelineResult) {
         feature: ctx.feature,
         attempts: ctx.story.attempts
       });
-      if (ctx.story.attempts !== undefined && ctx.story.attempts >= ctx.config.execution.rectification.maxRetries) {
+      if (ctx.story.attempts !== undefined && ctx.story.attempts >= ctx.config.execution.rectification.maxAttemptsTotal) {
         await pipelineEventBus.emitAsync({
           type: "human-review:requested",
           storyId: ctx.story.id,
@@ -60403,7 +61065,7 @@ var init_pipeline_result_handler = __esm(() => {
 
 // src/execution/iteration-runner.ts
 import { existsSync as existsSync34 } from "fs";
-import { join as join76 } from "path";
+import { join as join78 } from "path";
 async function runIteration(ctx, prd, selection, iterations, totalCost, allStoryMetrics) {
   const { story, storiesToExecute, routing, isBatchExecution } = selection;
   if (ctx.dryRun) {
@@ -60428,7 +61090,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 = join76(ctx.workdir, ".nax-wt", story.id);
+    const worktreePath = join78(ctx.workdir, ".nax-wt", story.id);
     const worktreeExists = _iterationRunnerDeps.existsSync(worktreePath);
     if (!worktreeExists) {
       await _iterationRunnerDeps.worktreeManager.ensureGitExcludes(ctx.workdir);
@@ -60448,7 +61110,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
   }
   const accumulatedAttemptCost = (story.priorFailures || []).reduce((sum, f) => sum + (f.cost || 0), 0);
   const profileOverride = ctx.config.profile && ctx.config.profile !== "default" ? { profile: ctx.config.profile } : undefined;
-  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join76(ctx.workdir, ".nax", "config.json"), story.workdir, profileOverride) : ctx.config;
+  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join78(ctx.workdir, ".nax", "config.json"), story.workdir, profileOverride) : ctx.config;
   let dependencyContext;
   if (ctx.config.execution.storyIsolation === "worktree") {
     try {
@@ -60475,7 +61137,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
       };
     }
   }
-  const resolvedWorkdir = dependencyContext?.cwd ? dependencyContext.cwd : ctx.config.execution.storyIsolation === "worktree" ? story.workdir ? join76(effectiveWorkdir, story.workdir) : effectiveWorkdir : story.workdir ? join76(ctx.workdir, story.workdir) : ctx.workdir;
+  const resolvedWorkdir = dependencyContext?.cwd ? dependencyContext.cwd : ctx.config.execution.storyIsolation === "worktree" ? story.workdir ? join78(effectiveWorkdir, story.workdir) : effectiveWorkdir : story.workdir ? join78(ctx.workdir, story.workdir) : ctx.workdir;
   const pipelineContext = {
     config: effectiveConfig,
     rootConfig: ctx.config,
@@ -60631,7 +61293,7 @@ function selectNextStories(prd, config2, batchPlan, currentBatchIndex, lastStory
       nextBatchIndex: currentBatchIndex + 1
     };
   }
-  const story = getNextStory(prd, lastStoryId, config2.execution.rectification?.maxRetries ?? 2);
+  const story = getNextStory(prd, lastStoryId, config2.execution.rectification?.maxAttemptsTotal ?? 12);
   if (!story)
     return null;
   return {
@@ -60676,7 +61338,7 @@ __export(exports_parallel_worker, {
   executeParallelBatch: () => executeParallelBatch,
   _parallelWorkerDeps: () => _parallelWorkerDeps
 });
-import { join as join77 } from "path";
+import { join as join79 } from "path";
 async function executeStoryInWorktree(story, worktreePath, dependencyContext, context, routing, eventEmitter) {
   const logger = getSafeLogger();
   try {
@@ -60696,7 +61358,7 @@ async function executeStoryInWorktree(story, worktreePath, dependencyContext, co
       story,
       stories: [story],
       projectDir: context.projectDir,
-      workdir: dependencyContext.cwd ?? (story.workdir ? join77(worktreePath, story.workdir) : worktreePath),
+      workdir: dependencyContext.cwd ?? (story.workdir ? join79(worktreePath, story.workdir) : worktreePath),
       worktreeDependencyContext: dependencyContext,
       routing,
       storyGitRef: storyGitRef ?? undefined
@@ -61525,7 +62187,7 @@ async function writeStatusFile(filePath, status) {
 var init_status_file = () => {};
 
 // src/execution/status-writer.ts
-import { join as join78 } from "path";
+import { join as join80 } from "path";
 
 class StatusWriter {
   statusFile;
@@ -61644,7 +62306,7 @@ class StatusWriter {
     if (!this._prd)
       return;
     const safeLogger = getSafeLogger();
-    const featureStatusPath = join78(featureDir, "status.json");
+    const featureStatusPath = join80(featureDir, "status.json");
     const write = async () => {
       try {
         const base = this.getSnapshot(totalCost, iterations);
@@ -62078,7 +62740,7 @@ __export(exports_run_initialization, {
   initializeRun: () => initializeRun,
   _reconcileDeps: () => _reconcileDeps
 });
-import { join as join79 } from "path";
+import { join as join81 } from "path";
 async function reconcileState(prd, prdPath, workdir, config2) {
   const logger = getSafeLogger();
   let reconciledCount = 0;
@@ -62095,7 +62757,7 @@ async function reconcileState(prd, prdPath, workdir, config2) {
       });
       continue;
     }
-    const effectiveWorkdir = story.workdir ? join79(workdir, story.workdir) : workdir;
+    const effectiveWorkdir = story.workdir ? join81(workdir, story.workdir) : workdir;
     try {
       const reviewResult = await _reconcileDeps.runReview(config2.review, effectiveWorkdir, config2.execution);
       if (!reviewResult.success) {
@@ -93527,7 +94189,7 @@ __export(exports_curator, {
 });
 import { readdirSync as readdirSync9 } from "fs";
 import { unlink as unlink4 } from "fs/promises";
-import { basename as basename16, join as join81 } from "path";
+import { basename as basename16, join as join83 } from "path";
 function getProjectKey(config2, projectDir) {
   return config2.name?.trim() || basename16(projectDir);
 }
@@ -93610,7 +94272,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 = join81(outputDir, "runs");
+  const runsDir = join83(outputDir, "runs");
   const runIds = listRunIds(runsDir);
   let runId;
   if (options.run) {
@@ -93627,8 +94289,8 @@ async function curatorStatus(options) {
     runId = runIds[runIds.length - 1];
   }
   console.log(`Run: ${runId}`);
-  const runDir = join81(runsDir, runId);
-  const observationsPath = join81(runDir, "observations.jsonl");
+  const runDir = join83(runsDir, runId);
+  const observationsPath = join83(runDir, "observations.jsonl");
   const observations = await parseObservations(observationsPath);
   const counts = new Map;
   for (const obs of observations) {
@@ -93638,7 +94300,7 @@ async function curatorStatus(options) {
   for (const [kind, count] of counts.entries()) {
     console.log(`  ${kind}: ${count}`);
   }
-  const proposalsPath = join81(runDir, "curator-proposals.md");
+  const proposalsPath = join83(runDir, "curator-proposals.md");
   const proposalText = await _curatorCmdDeps.readFile(proposalsPath).catch(() => null);
   if (proposalText !== null) {
     console.log("");
@@ -93652,8 +94314,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 = join81(outputDir, "runs", options.runId);
-  const proposalsPath = join81(runDir, "curator-proposals.md");
+  const runDir = join83(outputDir, "runs", options.runId);
+  const proposalsPath = join83(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}.`);
@@ -93669,7 +94331,7 @@ async function curatorCommit(options) {
   const dropFileState = new Map;
   const skippedDrops = new Set;
   for (const drop2 of drops) {
-    const targetPath = join81(resolved.projectDir, drop2.canonicalFile);
+    const targetPath = join83(resolved.projectDir, drop2.canonicalFile);
     if (!dropFileState.has(targetPath)) {
       const fileExists2 = await Bun.file(targetPath).exists();
       const existing = fileExists2 ? await _curatorCmdDeps.readFile(targetPath).catch(() => "") : "";
@@ -93703,7 +94365,7 @@ async function curatorCommit(options) {
     if (skippedDrops.has(drop2)) {
       continue;
     }
-    const targetPath = join81(resolved.projectDir, drop2.canonicalFile);
+    const targetPath = join83(resolved.projectDir, drop2.canonicalFile);
     const existing = await _curatorCmdDeps.readFile(targetPath).catch(() => "");
     const filtered = filterDropContent(existing, drop2.description);
     await _curatorCmdDeps.writeFile(targetPath, filtered);
@@ -93712,7 +94374,7 @@ async function curatorCommit(options) {
   }
   const adds = proposals.filter((p) => p.action === "add" || p.action === "advisory");
   for (const add2 of adds) {
-    const targetPath = join81(resolved.projectDir, add2.canonicalFile);
+    const targetPath = join83(resolved.projectDir, add2.canonicalFile);
     const content = buildAddContent(add2);
     await _curatorCmdDeps.appendFile(targetPath, content);
     modifiedFiles.add(targetPath);
@@ -93749,7 +94411,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 = join81(outputDir, "runs");
+  const runsDir = join83(outputDir, "runs");
   const runIds = listRunIds(runsDir);
   if (runIds.length === 0) {
     console.log("No runs found.");
@@ -93760,7 +94422,7 @@ async function curatorDryrun(options) {
     console.log(`Run ${options.run} not found in ${runsDir}.`);
     return;
   }
-  const observationsPath = join81(runsDir, runId, "observations.jsonl");
+  const observationsPath = join83(runsDir, runId, "observations.jsonl");
   const observations = await parseObservations(observationsPath);
   const thresholds = getThresholds(config2);
   const proposals = runHeuristics(observations, thresholds);
@@ -93801,12 +94463,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 = join81(outputDir, "runs");
+  const perRunsDir = join83(outputDir, "runs");
   for (const runId of uniqueRunIds) {
     if (!keepSet.has(runId)) {
-      const runDir = join81(perRunsDir, runId);
-      await _curatorCmdDeps.removeFile(join81(runDir, "observations.jsonl"));
-      await _curatorCmdDeps.removeFile(join81(runDir, "curator-proposals.md"));
+      const runDir = join83(perRunsDir, runId);
+      await _curatorCmdDeps.removeFile(join83(runDir, "observations.jsonl"));
+      await _curatorCmdDeps.removeFile(join83(runDir, "curator-proposals.md"));
     }
   }
   console.log(`[gc] Pruned rollup to ${keep} most recent runs (was ${uniqueRunIds.length}).`);
@@ -93851,7 +94513,7 @@ var init_curator2 = __esm(() => {
 init_source();
 import { existsSync as existsSync37, mkdirSync as mkdirSync7 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename as basename17, join as join82 } from "path";
+import { basename as basename17, join as join84 } from "path";
 
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -93875,12 +94537,12 @@ init_errors();
 init_operations();
 
 // src/plan/strategies/context-builder.ts
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 init_config();
 init_errors();
 init_interaction();
 async function buildPlanModeContext(workdir, fullConfig, options, deps) {
-  const naxDir = join36(workdir, ".nax");
+  const naxDir = join37(workdir, ".nax");
   if (!deps.existsSync(naxDir)) {
     throw new NaxError(`.nax directory not found. Run 'nax init' first in ${workdir}`, "PLAN_CONTEXT_NO_NAX_DIR", {
       stage: "plan",
@@ -93888,8 +94550,8 @@ async function buildPlanModeContext(workdir, fullConfig, options, deps) {
     });
   }
   validateFeatureName(options.feature);
-  const outputDir = join36(naxDir, "features", options.feature);
-  const outputPath = join36(outputDir, "prd.json");
+  const outputDir = join37(naxDir, "features", options.feature);
+  const outputPath = join37(outputDir, "prd.json");
   const [specContent, sourceRoots, pkg] = await Promise.all([
     deps.readFile(options.from),
     deps.scanSourceRoots(workdir),
@@ -93904,7 +94566,7 @@ async function buildPlanModeContext(workdir, fullConfig, options, deps) {
     ...new Set(sourceRoots.map((root) => root.path).filter((path7) => path7 !== ".").map((path7) => path7.startsWith("/") ? path7.replace(`${workdir}/`, "") : path7))
   ];
   const packageDetails = relativePackages.length === 0 ? [] : await Promise.all(relativePackages.map(async (relativePath) => {
-    const packageJson = await deps.readPackageJsonAt(join36(workdir, relativePath, "package.json"));
+    const packageJson = await deps.readPackageJsonAt(join37(workdir, relativePath, "package.json"));
     return buildPackageSummary(relativePath, packageJson);
   }));
   const projectName = detectProjectName(workdir, pkg);
@@ -94505,7 +95167,7 @@ init_interaction();
 init_prd();
 init_runtime();
 import { existsSync as existsSync17, readdirSync as readdirSync3 } from "fs";
-import { basename as basename7, join as join41, resolve as resolve14 } from "path";
+import { basename as basename7, join as join42, resolve as resolve14 } from "path";
 var _statusFeaturesDeps = {
   projectOutputDir,
   loadConfig
@@ -94519,7 +95181,7 @@ function isPidAlive(pid) {
   }
 }
 async function loadStatusFile(featureDir) {
-  const statusPath = join41(featureDir, "status.json");
+  const statusPath = join42(featureDir, "status.json");
   if (!existsSync17(statusPath)) {
     return null;
   }
@@ -94534,7 +95196,7 @@ async function loadProjectStatusFile(projectDir) {
   const config2 = await _statusFeaturesDeps.loadConfig(projectDir).catch(() => null);
   const projectKey = config2?.name?.trim() || basename7(projectDir);
   const outputDir = _statusFeaturesDeps.projectOutputDir(projectKey, config2?.outputDir);
-  const statusPath = join41(outputDir, "status.json");
+  const statusPath = join42(outputDir, "status.json");
   if (!existsSync17(statusPath)) {
     return null;
   }
@@ -94546,7 +95208,7 @@ async function loadProjectStatusFile(projectDir) {
   }
 }
 async function getFeatureSummary(featureName, featureDir) {
-  const prdPath = join41(featureDir, "prd.json");
+  const prdPath = join42(featureDir, "prd.json");
   if (!existsSync17(prdPath)) {
     return {
       name: featureName,
@@ -94589,7 +95251,7 @@ async function getFeatureSummary(featureName, featureDir) {
       };
     }
   }
-  const runsDir = join41(featureDir, "runs");
+  const runsDir = join42(featureDir, "runs");
   if (existsSync17(runsDir)) {
     const runs = readdirSync3(runsDir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".jsonl") && e.name !== "latest.jsonl").map((e) => e.name).sort().reverse();
     if (runs.length > 0) {
@@ -94603,7 +95265,7 @@ async function displayAllFeatures(projectDir) {
   const config2 = await _statusFeaturesDeps.loadConfig(projectDir).catch(() => null);
   const projectKey = config2?.name?.trim() || basename7(projectDir);
   const outputDir = _statusFeaturesDeps.projectOutputDir(projectKey, config2?.outputDir);
-  const featuresDir = join41(outputDir, "features");
+  const featuresDir = join42(outputDir, "features");
   if (!existsSync17(featuresDir)) {
     console.log(source_default.dim("No features found."));
     return;
@@ -94644,7 +95306,7 @@ async function displayAllFeatures(projectDir) {
       console.log();
     }
   }
-  const summaries = await Promise.all(features.map((name) => getFeatureSummary(name, join41(featuresDir, name))));
+  const summaries = await Promise.all(features.map((name) => getFeatureSummary(name, join42(featuresDir, name))));
   console.log(source_default.bold(`\uD83D\uDCCA Features
 `));
   const header = `  ${"Feature".padEnd(25)} ${"Done".padEnd(6)} ${"Failed".padEnd(8)} ${"Pending".padEnd(9)} ${"Last Run".padEnd(22)} ${"Cost".padEnd(10)} Status`;
@@ -94670,7 +95332,7 @@ async function displayAllFeatures(projectDir) {
   console.log();
 }
 async function displayFeatureDetails(featureName, featureDir) {
-  const prdPath = join41(featureDir, "prd.json");
+  const prdPath = join42(featureDir, "prd.json");
   if (!existsSync17(prdPath)) {
     console.log(source_default.bold(`
 \uD83D\uDCCA ${featureName}
@@ -94816,7 +95478,7 @@ async function displayFeatureStatus(options = {}) {
       const config2 = await _statusFeaturesDeps.loadConfig(projectDir).catch(() => null);
       const projectKey = config2?.name?.trim() || basename7(projectDir);
       const outputDir = _statusFeaturesDeps.projectOutputDir(projectKey, config2?.outputDir);
-      featureDir = join41(outputDir, "features", options.feature);
+      featureDir = join42(outputDir, "features", options.feature);
     } else {
       const resolved = resolveProject({ feature: options.feature });
       if (!resolved.featureDir) {
@@ -94836,7 +95498,7 @@ init_errors();
 init_logger2();
 init_runtime();
 import { existsSync as existsSync18, readdirSync as readdirSync4 } from "fs";
-import { basename as basename8, join as join42 } from "path";
+import { basename as basename8, join as join43 } from "path";
 async function resolveOutputDir2(workdir, override) {
   if (override)
     return override;
@@ -94860,7 +95522,7 @@ async function runsListCommand(options) {
   const logger = getLogger();
   const { feature, workdir } = options;
   const outputDir = await resolveOutputDir2(workdir, options.outputDir);
-  const runsDir = join42(outputDir, "features", feature, "runs");
+  const runsDir = join43(outputDir, "features", feature, "runs");
   if (!existsSync18(runsDir)) {
     logger.info("cli", "No runs found for feature", { feature, hint: `Directory not found: ${runsDir}` });
     return;
@@ -94872,7 +95534,7 @@ async function runsListCommand(options) {
   }
   logger.info("cli", `Runs for ${feature}`, { count: files.length });
   for (const file3 of files.sort().reverse()) {
-    const logPath = join42(runsDir, file3);
+    const logPath = join43(runsDir, file3);
     const entries = await parseRunLog(logPath);
     const startEvent = entries.find((e) => e.message === "run.start");
     const completeEvent = entries.find((e) => e.message === "run.complete");
@@ -94899,7 +95561,7 @@ async function runsShowCommand(options) {
   const logger = getLogger();
   const { runId, feature, workdir } = options;
   const outputDir = await resolveOutputDir2(workdir, options.outputDir);
-  const logPath = join42(outputDir, "features", feature, "runs", `${runId}.jsonl`);
+  const logPath = join43(outputDir, "features", feature, "runs", `${runId}.jsonl`);
   if (!existsSync18(logPath)) {
     logger.error("cli", "Run not found", { runId, feature, logPath });
     throw new NaxError("Run not found", "RUN_NOT_FOUND", { runId, feature, logPath });
@@ -95012,7 +95674,7 @@ init_logger2();
 init_prd();
 init_runtime();
 import { existsSync as existsSync25, readdirSync as readdirSync5 } from "fs";
-import { basename as basename12, join as join55 } from "path";
+import { basename as basename12, join as join57 } from "path";
 
 // src/cli/diagnose-analysis.ts
 function detectFailurePattern(story, _prd, status) {
@@ -95215,7 +95877,7 @@ function isProcessAlive2(pid) {
   }
 }
 async function loadStatusFile2(outputDir) {
-  const statusPath = join55(outputDir, "status.json");
+  const statusPath = join57(outputDir, "status.json");
   if (!existsSync25(statusPath))
     return null;
   try {
@@ -95243,7 +95905,7 @@ async function countCommitsSince(workdir, since) {
   }
 }
 async function checkLock(workdir) {
-  const lockFile = Bun.file(join55(workdir, "nax.lock"));
+  const lockFile = Bun.file(join57(workdir, "nax.lock"));
   if (!await lockFile.exists())
     return { lockPresent: false };
   try {
@@ -95261,8 +95923,8 @@ async function diagnoseCommand(options = {}) {
   const logger = getLogger();
   const workdir = options.workdir ?? process.cwd();
   const naxSubdir = findProjectDir(workdir);
-  let projectDir = naxSubdir ? join55(naxSubdir, "..") : null;
-  if (!projectDir && existsSync25(join55(workdir, ".nax"))) {
+  let projectDir = naxSubdir ? join57(naxSubdir, "..") : null;
+  if (!projectDir && existsSync25(join57(workdir, ".nax"))) {
     projectDir = workdir;
   }
   if (!projectDir)
@@ -95276,7 +95938,7 @@ async function diagnoseCommand(options = {}) {
     if (status2) {
       feature = status2.run.feature;
     } else {
-      const featuresDir = join55(outputDir, "features");
+      const featuresDir = join57(outputDir, "features");
       if (!existsSync25(featuresDir))
         throw new Error("No features found in project");
       const features = readdirSync5(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
@@ -95286,8 +95948,8 @@ async function diagnoseCommand(options = {}) {
       logger.info("diagnose", "No feature specified, using first found", { feature });
     }
   }
-  const featureDir = join55(outputDir, "features", feature);
-  const prdPath = join55(featureDir, "prd.json");
+  const featureDir = join57(outputDir, "features", feature);
+  const prdPath = join57(featureDir, "prd.json");
   if (!existsSync25(prdPath))
     throw new Error(`Feature not found: ${feature}`);
   const prd = await loadPRD(prdPath);
@@ -95332,7 +95994,7 @@ init_source();
 init_loader();
 init_generator2();
 import { existsSync as existsSync26 } from "fs";
-import { join as join56 } from "path";
+import { join as join58 } from "path";
 var VALID_AGENTS = ["claude", "codex", "opencode", "cursor", "windsurf", "aider", "gemini"];
 async function generateCommand(options) {
   const workdir = options.dir ?? process.cwd();
@@ -95375,7 +96037,7 @@ async function generateCommand(options) {
     return;
   }
   if (options.package) {
-    const packageDir = join56(workdir, options.package);
+    const packageDir = join58(workdir, options.package);
     if (dryRun) {
       console.log(source_default.yellow("\u26A0 Dry run \u2014 no files will be written"));
     }
@@ -95395,8 +96057,8 @@ async function generateCommand(options) {
       process.exit(1);
     return;
   }
-  const contextPath = options.context ? join56(workdir, options.context) : join56(workdir, ".nax/context.md");
-  const outputDir = options.output ? join56(workdir, options.output) : workdir;
+  const contextPath = options.context ? join58(workdir, options.context) : join58(workdir, ".nax/context.md");
+  const outputDir = options.output ? join58(workdir, options.output) : workdir;
   const autoInject = !options.noAutoInject;
   if (!existsSync26(contextPath)) {
     console.error(source_default.red(`\u2717 Context file not found: ${contextPath}`));
@@ -95502,7 +96164,7 @@ async function generateCommand(options) {
 // src/cli/config-display.ts
 init_loader();
 import { existsSync as existsSync28 } from "fs";
-import { join as join58 } from "path";
+import { join as join60 } from "path";
 
 // src/cli/config-descriptions.ts
 var FIELD_DESCRIPTIONS = {
@@ -95551,15 +96213,16 @@ var FIELD_DESCRIPTIONS = {
   "execution.contextProviderTokenBudget": "Token budget for plugin context providers",
   "execution.lintCommand": "Lint command override (null=disabled, undefined=auto-detect)",
   "execution.typecheckCommand": "Typecheck command override (null=disabled, undefined=auto-detect)",
-  "execution.rectification": "Rectification loop settings (retry failed tests)",
+  "execution.rectification": "Unified fix-cycle settings \u2014 shared by story-orchestrator (semantic + adversarial + mechanical) and post-run regression cycles",
   "execution.rectification.enabled": "Enable rectification loop",
-  "execution.rectification.maxRetries": "Max retry attempts per story",
+  "execution.rectification.maxAttemptsTotal": "Total iteration cap for the unified fix cycle (default: 12). Per-strategy caps are the granular bound.",
+  "execution.rectification.maxAttemptsPerStrategy": "Default per-strategy cap for LLM-driven strategies \u2014 autofix-implementer / autofix-test-writer / full-suite-rectify (default: 3). Mechanical strategies stay at 1.",
   "execution.rectification.fullSuiteTimeoutSeconds": "Timeout for full test suite run in seconds",
   "execution.rectification.maxFailureSummaryChars": "Max characters in failure summary",
   "execution.rectification.abortOnIncreasingFailures": "Abort if failure count increases",
-  "execution.rectification.escalateOnExhaustion": "Enable model tier escalation when retries are exhausted with remaining failures",
-  "execution.rectification.rethinkAtAttempt": "Attempt number at which 'rethink your approach' language is injected into the prompt (default: 2, set >= maxRetries to disable)",
-  "execution.rectification.urgencyAtAttempt": "Attempt number at which 'final chance before escalation' urgency is added to the prompt (default: 3, set >= maxRetries to disable)",
+  "execution.rectification.escalateOnExhaustion": "Enable model tier escalation when attempts are exhausted with remaining failures",
+  "execution.rectification.rethinkAtAttempt": "Attempt number at which 'rethink your approach' language is injected into the prompt (default: 2)",
+  "execution.rectification.urgencyAtAttempt": "Attempt number at which 'final chance before escalation' urgency is added (default: 3)",
   "execution.regressionGate": "Regression gate settings (full suite after scoped tests)",
   "execution.regressionGate.enabled": "Enable full-suite regression gate",
   "execution.regressionGate.timeoutSeconds": "Timeout for regression run in seconds",
@@ -95752,7 +96415,7 @@ function deepEqual(a, b) {
 init_defaults();
 init_loader();
 import { existsSync as existsSync27 } from "fs";
-import { join as join57 } from "path";
+import { join as join59 } from "path";
 async function loadConfigFile(path19) {
   if (!existsSync27(path19))
     return null;
@@ -95774,7 +96437,7 @@ async function loadProjectConfig() {
   const projectDir = findProjectDir();
   if (!projectDir)
     return null;
-  const projectPath = join57(projectDir, "config.json");
+  const projectPath = join59(projectDir, "config.json");
   return await loadConfigFile(projectPath);
 }
 
@@ -95834,7 +96497,7 @@ async function configCommand(config2, options = {}) {
 function determineConfigSources() {
   const globalPath = globalConfigPath();
   const projectDir = findProjectDir();
-  const projectPath = projectDir ? join58(projectDir, "config.json") : null;
+  const projectPath = projectDir ? join60(projectDir, "config.json") : null;
   return {
     global: fileExists(globalPath) ? globalPath : null,
     project: projectPath && fileExists(projectPath) ? projectPath : null
@@ -95983,15 +96646,15 @@ init_paths();
 init_profile();
 import { mkdirSync as mkdirSync5 } from "fs";
 import { readdirSync as readdirSync6 } from "fs";
-import { join as join59 } from "path";
+import { join as join61 } 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 = join59(globalConfigDir(), "profiles");
-  const projectProfilesDir = join59(projectConfigDir(startDir), "profiles");
+  const globalProfilesDir = join61(globalConfigDir(), "profiles");
+  const projectProfilesDir = join61(projectConfigDir(startDir), "profiles");
   const globalProfiles = scanProfileDir(globalProfilesDir);
   const projectProfiles = scanProfileDir(projectProfilesDir);
   const activeProfile = await resolveProfileName({}, _profileCLIDeps.env, startDir);
@@ -96050,7 +96713,7 @@ function maskProfileValues(obj) {
   return result;
 }
 async function profileUseCommand(profileName, startDir) {
-  const configPath = join59(projectConfigDir(startDir), "config.json");
+  const configPath = join61(projectConfigDir(startDir), "config.json");
   const configFile = Bun.file(configPath);
   let existing = {};
   if (await configFile.exists()) {
@@ -96069,8 +96732,8 @@ async function profileCurrentCommand(startDir) {
   return resolveProfileName({}, _profileCLIDeps.env, startDir);
 }
 async function profileCreateCommand(profileName, startDir) {
-  const profilesDir = join59(projectConfigDir(startDir), "profiles");
-  const profilePath = join59(profilesDir, `${profileName}.json`);
+  const profilesDir = join61(projectConfigDir(startDir), "profiles");
+  const profilePath = join61(profilesDir, `${profileName}.json`);
   const profileFile = Bun.file(profilePath);
   if (await profileFile.exists()) {
     throw new Error(`Profile "${profileName}" already exists at ${profilePath}`);
@@ -96192,7 +96855,7 @@ async function contextInspectCommand(options) {
 init_canonical_loader();
 init_errors();
 import { mkdir as mkdir12 } from "fs/promises";
-import { basename as basename13, join as join60 } from "path";
+import { basename as basename13, join as join62 } from "path";
 var _rulesCLIDeps = {
   readFile: async (path19) => Bun.file(path19).text(),
   writeFile: async (path19, content) => {
@@ -96201,7 +96864,7 @@ var _rulesCLIDeps = {
   fileExists: async (path19) => Bun.file(path19).exists(),
   globInDir: (dir) => {
     try {
-      return [...new Bun.Glob("*.md").scanSync({ cwd: dir })].sort().map((f) => join60(dir, f));
+      return [...new Bun.Glob("*.md").scanSync({ cwd: dir })].sort().map((f) => join62(dir, f));
     } catch {
       return [];
     }
@@ -96250,7 +96913,7 @@ ${r.content}`).join(`
 `);
   const shimContent = `${header + body}
 `;
-  const shimPath = join60(workdir, shimFileName);
+  const shimPath = join62(workdir, shimFileName);
   if (options.dryRun) {
     console.log(`[dry-run] Would write ${shimPath} (${shimContent.length} bytes)`);
     return;
@@ -96279,14 +96942,14 @@ function neutralizeContent(content) {
 }
 async function collectMigrationSources(workdir) {
   const sources = [];
-  const claudeMdPath = join60(workdir, "CLAUDE.md");
+  const claudeMdPath = join62(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 = join60(workdir, ".claude", "rules");
+  const rulesDir = join62(workdir, ".claude", "rules");
   const ruleFiles = _rulesCLIDeps.globInDir(rulesDir);
   for (const filePath of ruleFiles) {
     try {
@@ -96306,7 +96969,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 = join60(workdir, CANONICAL_RULES_DIR);
+  const targetDir = join62(workdir, CANONICAL_RULES_DIR);
   if (!options.dryRun) {
     try {
       await _rulesCLIDeps.mkdir(targetDir);
@@ -96317,7 +96980,7 @@ async function rulesMigrateCommand(options) {
   let written = 0;
   let skipped = 0;
   for (const { sourcePath, targetFileName, content } of sources) {
-    const targetPath = join60(targetDir, targetFileName);
+    const targetPath = join62(targetDir, targetFileName);
     if (!force && !options.dryRun && await _rulesCLIDeps.fileExists(targetPath)) {
       console.log(`[skip] ${targetFileName} already exists (use --force to overwrite)`);
       skipped++;
@@ -96356,7 +97019,7 @@ function collectCanonicalRuleRoots(workdir) {
     const packageRel = normalized.slice(0, idx);
     if (!packageRel)
       continue;
-    roots.add(join60(workdir, packageRel));
+    roots.add(join62(workdir, packageRel));
   }
   return [...roots].sort();
 }
@@ -96378,7 +97041,7 @@ init_logger2();
 init_detect2();
 init_workspace();
 init_common();
-import { join as join61 } from "path";
+import { join as join63 } from "path";
 function resolveEffective(detected, configPatterns) {
   if (configPatterns !== undefined)
     return "config";
@@ -96463,7 +97126,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 = join61(workdir, ".nax", "mono", dir, "config.json");
+    const pkgConfigPath = join63(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;
@@ -96517,13 +97180,13 @@ async function detectCommand(options) {
     if (rootDetected.confidence === "empty") {
       console.log(source_default.yellow("  root: skipped (empty detection)"));
     } else {
-      const rootConfigPath = join61(workdir, ".nax", "config.json");
+      const rootConfigPath = join63(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 ${join61(".nax", "config.json")}`));
+          console.log(source_default.green(`  root: ${status} \u2192 ${join63(".nax", "config.json")}`));
         }
       } catch (err) {
         console.error(source_default.red(`  root: write failed \u2014 ${err.message}`));
@@ -96536,13 +97199,13 @@ async function detectCommand(options) {
         console.log(source_default.dim(`  ${dir}: skipped (empty detection)`));
         continue;
       }
-      const pkgConfigPath = join61(workdir, ".nax", "mono", dir, "config.json");
+      const pkgConfigPath = join63(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 ${join61(".nax", "mono", dir, "config.json")}`));
+          console.log(source_default.green(`  ${dir}: ${status} \u2192 ${join63(".nax", "mono", dir, "config.json")}`));
         }
       } catch (err) {
         console.error(source_default.red(`  ${dir}: write failed \u2014 ${err.message}`));
@@ -96565,19 +97228,19 @@ async function diagnose(options) {
 // src/commands/logs.ts
 init_common();
 import { existsSync as existsSync30 } from "fs";
-import { join as join65 } from "path";
+import { join as join67 } from "path";
 
 // src/commands/logs-formatter.ts
 init_source();
 init_formatter();
 import { readdirSync as readdirSync8 } from "fs";
-import { join as join64 } from "path";
+import { join as join66 } from "path";
 
 // src/commands/logs-reader.ts
 init_paths3();
 import { existsSync as existsSync29, readdirSync as readdirSync7 } from "fs";
 import { readdir as readdir4 } from "fs/promises";
-import { join as join63 } from "path";
+import { join as join65 } from "path";
 var _logsReaderDeps = {
   getRunsDir
 };
@@ -96591,7 +97254,7 @@ async function resolveRunFileFromRegistry(runId) {
   }
   let matched = null;
   for (const entry of entries) {
-    const metaPath = join63(runsDir, entry, "meta.json");
+    const metaPath = join65(runsDir, entry, "meta.json");
     try {
       const meta3 = await Bun.file(metaPath).json();
       if (meta3.runId === runId || meta3.runId.startsWith(runId)) {
@@ -96613,14 +97276,14 @@ async function resolveRunFileFromRegistry(runId) {
     return null;
   }
   const specificFile = files.find((f) => f === `${matched.runId}.jsonl`);
-  return join63(matched.eventsDir, specificFile ?? files[0]);
+  return join65(matched.eventsDir, specificFile ?? files[0]);
 }
 async function selectRunFile(runsDir) {
   const files = readdirSync7(runsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
   if (files.length === 0) {
     return null;
   }
-  return join63(runsDir, files[0]);
+  return join65(runsDir, files[0]);
 }
 async function extractRunSummary(filePath) {
   const file3 = Bun.file(filePath);
@@ -96706,7 +97369,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 = join64(runsDir, file3);
+    const filePath = join66(runsDir, file3);
     const summary = await extractRunSummary(filePath);
     const timestamp = file3.replace(".jsonl", "");
     const stories = summary ? `${summary.passed}/${summary.total}` : "?/?";
@@ -96820,7 +97483,7 @@ async function logsCommand(options) {
     return;
   }
   const resolved = resolveProject({ dir: options.dir });
-  const naxDir = join65(resolved.projectDir, ".nax");
+  const naxDir = join67(resolved.projectDir, ".nax");
   const configPath = resolved.configPath;
   const configFile = Bun.file(configPath);
   const config2 = await configFile.json();
@@ -96828,8 +97491,8 @@ async function logsCommand(options) {
   if (!featureName) {
     throw new Error("No feature specified in config.json");
   }
-  const featureDir = join65(naxDir, "features", featureName);
-  const runsDir = join65(featureDir, "runs");
+  const featureDir = join67(naxDir, "features", featureName);
+  const runsDir = join67(featureDir, "runs");
   if (!existsSync30(runsDir)) {
     throw new Error(`No runs directory found for feature: ${featureName}`);
   }
@@ -96855,7 +97518,7 @@ init_prd();
 init_precheck();
 init_common();
 import { existsSync as existsSync31 } from "fs";
-import { join as join66 } from "path";
+import { join as join68 } from "path";
 async function precheckCommand(options) {
   const resolved = resolveProject({
     dir: options.dir,
@@ -96877,9 +97540,9 @@ async function precheckCommand(options) {
       process.exit(1);
     }
   }
-  const naxDir = join66(resolved.projectDir, ".nax");
-  const featureDir = join66(naxDir, "features", featureName);
-  const prdPath = join66(featureDir, "prd.json");
+  const naxDir = join68(resolved.projectDir, ".nax");
+  const featureDir = join68(naxDir, "features", featureName);
+  const prdPath = join68(featureDir, "prd.json");
   if (!existsSync31(featureDir)) {
     console.error(source_default.red(`Feature not found: ${featureName}`));
     process.exit(1);
@@ -96902,7 +97565,7 @@ async function precheckCommand(options) {
 init_source();
 init_paths3();
 import { readdir as readdir5 } from "fs/promises";
-import { join as join67 } from "path";
+import { join as join69 } from "path";
 var DEFAULT_LIMIT = 20;
 var _runsCmdDeps = {
   getRunsDir
@@ -96957,7 +97620,7 @@ async function runsCommand(options = {}) {
   }
   const rows = [];
   for (const entry of entries) {
-    const metaPath = join67(runsDir, entry, "meta.json");
+    const metaPath = join69(runsDir, entry, "meta.json");
     let meta3;
     try {
       meta3 = await Bun.file(metaPath).json();
@@ -97034,7 +97697,7 @@ async function runsCommand(options = {}) {
 
 // src/commands/unlock.ts
 init_source();
-import { join as join68 } from "path";
+import { join as join70 } from "path";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -97049,7 +97712,7 @@ function formatLockAge(ageMs) {
 }
 async function unlockCommand(options) {
   const workdir = options.dir ?? process.cwd();
-  const lockPath = join68(workdir, "nax.lock");
+  const lockPath = join70(workdir, "nax.lock");
   const lockFile = Bun.file(lockPath);
   const exists = await lockFile.exists();
   if (!exists) {
@@ -105122,7 +105785,7 @@ Next: nax generate --package ${options.package}`));
     }
     return;
   }
-  const naxDir = join82(workdir, ".nax");
+  const naxDir = join84(workdir, ".nax");
   if (existsSync37(naxDir) && !options.force) {
     console.log(source_default.yellow("nax already initialized. Use --force to overwrite."));
     return;
@@ -105151,11 +105814,11 @@ Next: nax generate --package ${options.package}`));
       }
     }
   }
-  mkdirSync7(join82(naxDir, "features"), { recursive: true });
-  mkdirSync7(join82(naxDir, "hooks"), { recursive: true });
+  mkdirSync7(join84(naxDir, "features"), { recursive: true });
+  mkdirSync7(join84(naxDir, "hooks"), { recursive: true });
   const initConfig = options.name ? { ...DEFAULT_CONFIG, name: options.name } : DEFAULT_CONFIG;
-  await Bun.write(join82(naxDir, "config.json"), JSON.stringify(initConfig, null, 2));
-  await Bun.write(join82(naxDir, "hooks.json"), JSON.stringify({
+  await Bun.write(join84(naxDir, "config.json"), JSON.stringify(initConfig, null, 2));
+  await Bun.write(join84(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 },
@@ -105163,12 +105826,12 @@ Next: nax generate --package ${options.package}`));
       "on-error": { command: 'echo "nax error: $NAX_REASON"', enabled: false }
     }
   }, null, 2));
-  await Bun.write(join82(naxDir, ".gitignore"), `# nax temp files
+  await Bun.write(join84(naxDir, ".gitignore"), `# nax temp files
 *.tmp
 .paused.json
 .nax-verifier-verdict.json
 `);
-  await Bun.write(join82(naxDir, "context.md"), `# Project Context
+  await Bun.write(join84(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.
@@ -105298,8 +105961,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 = join82(naxDir, "features", options.feature);
-  const prdPath = join82(featureDir, "prd.json");
+  const featureDir = join84(naxDir, "features", options.feature);
+  const prdPath = join84(featureDir, "prd.json");
   if (options.plan && options.from) {
     if (existsSync37(prdPath) && !options.force) {
       console.error(source_default.red(`Error: prd.json already exists for feature "${options.feature}".`));
@@ -105321,10 +105984,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
       }
     }
     try {
-      const planLogDir = join82(featureDir, "plan");
+      const planLogDir = join84(featureDir, "plan");
       mkdirSync7(planLogDir, { recursive: true });
       const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-      const planLogPath = join82(planLogDir, `${planLogId}.jsonl`);
+      const planLogPath = join84(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]"));
@@ -105370,10 +106033,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
   resetLogger();
   const projectKey = config2.name?.trim() || basename17(workdir);
   const outputDir = projectOutputDir(projectKey, config2.outputDir);
-  const runsDir = join82(outputDir, "features", options.feature, "runs");
+  const runsDir = join84(outputDir, "features", options.feature, "runs");
   mkdirSync7(runsDir, { recursive: true });
   const runId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const logFilePath = join82(runsDir, `${runId}.jsonl`);
+  const logFilePath = join84(runsDir, `${runId}.jsonl`);
   const isTTY = process.stdout.isTTY ?? false;
   const headlessFlag = options.headless ?? false;
   const headlessEnv = process.env.NAX_HEADLESS === "1";
@@ -105390,7 +106053,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 = join82(homedir3(), ".nax");
+  const globalNaxDir = join84(homedir3(), ".nax");
   const hooks = await loadHooksConfig(naxDir, globalNaxDir);
   const eventEmitter = new PipelineEventEmitter;
   let tuiInstance;
@@ -105413,7 +106076,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
   } else {
     console.log(source_default.dim("   [Headless mode \u2014 pipe output]"));
   }
-  const statusFilePath = join82(outputDir, "status.json");
+  const statusFilePath = join84(outputDir, "status.json");
   let parallel;
   if (options.parallel !== undefined) {
     parallel = Number.parseInt(options.parallel, 10);
@@ -105439,7 +106102,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     headless: useHeadless,
     skipPrecheck: options.skipPrecheck ?? false
   });
-  const latestSymlink = join82(runsDir, "latest.jsonl");
+  const latestSymlink = join84(runsDir, "latest.jsonl");
   try {
     if (existsSync37(latestSymlink)) {
       Bun.spawnSync(["rm", latestSymlink]);
@@ -105500,9 +106163,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 = join82(naxDir, "features", name);
+  const featureDir = join84(naxDir, "features", name);
   mkdirSync7(featureDir, { recursive: true });
-  await Bun.write(join82(featureDir, "spec.md"), `# Feature: ${name}
+  await Bun.write(join84(featureDir, "spec.md"), `# Feature: ${name}
 
 ## Overview
 
@@ -105535,7 +106198,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 
 <!-- What this feature explicitly does NOT cover. -->
 `);
-  await Bun.write(join82(featureDir, "progress.txt"), `# Progress: ${name}
+  await Bun.write(join84(featureDir, "progress.txt"), `# Progress: ${name}
 
 Created: ${new Date().toISOString()}
 
@@ -105561,7 +106224,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 = join82(naxDir, "features");
+  const featuresDir = join84(naxDir, "features");
   if (!existsSync37(featuresDir)) {
     console.log(source_default.dim("No features yet."));
     return;
@@ -105576,7 +106239,7 @@ features.command("list").description("List all features").option("-d, --dir <pat
 Features:
 `));
   for (const name of entries) {
-    const prdPath = join82(featuresDir, name, "prd.json");
+    const prdPath = join84(featuresDir, name, "prd.json");
     if (existsSync37(prdPath)) {
       const prd = await loadPRD(prdPath);
       const c = countStories(prd);
@@ -105611,10 +106274,10 @@ Use: nax plan -f <feature> --from <spec>`));
     cliOverrides.profile = options.profile;
   }
   const config2 = await loadConfig(workdir, cliOverrides);
-  const featureLogDir = join82(naxDir, "features", options.feature, "plan");
+  const featureLogDir = join84(naxDir, "features", options.feature, "plan");
   mkdirSync7(featureLogDir, { recursive: true });
   const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const planLogPath = join82(featureLogDir, `${planLogId}.jsonl`);
+  const planLogPath = join84(featureLogDir, `${planLogId}.jsonl`);
   initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
   console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
   try {