@nathapp/nax 0.67.10 → 0.67.11

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
       };
     }
   };
@@ -37368,7 +37742,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 +37845,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 +37855,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 +37896,7 @@ var init__finding_to_check = __esm(() => {
 });
 
 // src/operations/autofix-implementer-strategy.ts
-function makeAutofixImplementerStrategy(story) {
+function makeAutofixImplementerStrategy(story, config2) {
   return {
     name: "autofix-implementer",
     appliesTo: (f) => f.fixTarget === "source" && IMPLEMENTER_SOURCES.has(f.source),
@@ -37535,7 +37909,7 @@ function makeAutofixImplementerStrategy(story) {
       summary: output.unresolvedReason ?? "",
       unresolved: output.unresolvedReason
     }),
-    maxAttempts: 3,
+    maxAttempts: config2.execution.rectification.maxAttemptsPerStrategy,
     coRun: "co-run-sequential"
   };
 }
@@ -37557,7 +37931,7 @@ function makeAutofixTestWriterStrategy(story, config2) {
       story,
       blockingThreshold: config2.review?.blockingThreshold
     }),
-    maxAttempts: 2,
+    maxAttempts: config2.execution.rectification.maxAttemptsPerStrategy,
     coRun: "co-run-sequential"
   };
 }
@@ -39502,6 +39876,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 +40313,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})`;
     }
@@ -52209,11 +52631,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 +52697,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();
@@ -52639,10 +53100,10 @@ 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(makeAutofixImplementerStrategy(story, config2));
       strategies.push(makeAutofixTestWriterStrategy(story, config2));
     }
     const rectOpts = {
@@ -52783,9 +53244,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 +53710,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 });
@@ -53976,6 +54456,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 +54474,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,
@@ -57068,7 +57563,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.67.10",
+    version: "0.67.11",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -57163,8 +57658,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("0db5c72e"))
+        return "0db5c72e";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -58138,7 +58633,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 +58797,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);
@@ -60348,7 +60843,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,
@@ -60631,7 +61126,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 {
@@ -95551,15 +96046,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",