@nathapp/nax 0.67.9 → 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),
@@ -17224,7 +17218,12 @@ var init_schemas_review = __esm(() => {
     timeoutMs: exports_external.number().int().positive().default(600000),
     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)
+    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)
+    }).optional()
   });
   ReviewConfigSchema = exports_external.object({
     enabled: exports_external.boolean(),
@@ -17320,7 +17319,8 @@ var init_schemas3 = __esm(() => {
       maxStoriesPerFeature: 500,
       rectification: {
         enabled: true,
-        maxRetries: 2,
+        maxAttemptsTotal: 12,
+        maxAttemptsPerStrategy: 3,
         fullSuiteTimeoutSeconds: 300,
         maxFailureSummaryChars: 2000,
         abortOnIncreasingFailures: true,
@@ -17332,8 +17332,7 @@ var init_schemas3 = __esm(() => {
         enabled: true,
         timeoutSeconds: 300,
         acceptOnTimeout: true,
-        mode: "deferred",
-        maxRectificationAttempts: 3
+        mode: "deferred"
       },
       contextProviderTokenBudget: 2000,
       permissionProfile: "unrestricted",
@@ -17359,9 +17358,6 @@ var init_schemas3 = __esm(() => {
       autofix: {
         enabled: true,
         maxAttempts: 3,
-        maxTotalAttempts: 12,
-        rethinkAtAttempt: 2,
-        urgencyAtAttempt: 3,
         enforceTestWriterIsolation: true
       },
       forceExit: false,
@@ -17450,6 +17446,19 @@ var init_schemas3 = __esm(() => {
           ":!.nax/",
           ":!.nax-pids"
         ]
+      },
+      adversarial: {
+        model: "balanced",
+        diffMode: "ref",
+        rules: [],
+        timeoutMs: 600000,
+        parallel: false,
+        maxConcurrentSessions: 2,
+        acRegroundOnDrop: true,
+        substantiation: {
+          requote: true,
+          maxRequotes: 5
+        }
       }
     }),
     plan: PlanConfigSchema.default({
@@ -18662,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;
@@ -18768,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) => {
@@ -18820,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;
@@ -21043,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);
@@ -21059,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 {
@@ -21095,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();
@@ -21922,7 +21988,8 @@ function makeParseRetryStrategy(opts) {
         if (ctx.site === "complete") {
           getSafeLogger()?.warn(opts.reviewerKind, "makeParseRetryStrategy: lastOutput is not populated on complete-kind ops \u2014 retry will never fire", { storyId: ctx.storyId });
         }
-        return { retry: false };
+        const fallback = opts.exhaustedFallback ? opts.exhaustedFallback("") : undefined;
+        return { retry: false, ...fallback !== undefined ? { fallback } : {} };
       }
       let parsed;
       try {
@@ -30325,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)
 
@@ -30476,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
@@ -30561,72 +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("");
-  }
-}
 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.
@@ -30735,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) {
@@ -31249,8 +31405,420 @@ var init_adversarial_helpers = __esm(() => {
   init_severity();
 });
 
+// src/review/semantic-helpers.ts
+function validateLLMShape(parsed) {
+  if (typeof parsed !== "object" || parsed === null)
+    return null;
+  const obj = parsed;
+  if (typeof obj.passed !== "boolean")
+    return null;
+  if (!Array.isArray(obj.findings))
+    return null;
+  return { passed: obj.passed, findings: obj.findings };
+}
+function parseLLMResponse(raw) {
+  try {
+    return validateLLMShape(tryParseLLMJson(raw));
+  } catch {
+    return null;
+  }
+}
+function formatFindings2(findings) {
+  return findings.map((f) => `[${f.severity}] ${f.file}:${f.line} \u2014 ${f.issue}
+  Suggestion: ${f.suggestion}`).join(`
+`);
+}
+function normalizeSeverity2(sev) {
+  if (sev === "warn")
+    return "warning";
+  if (sev === "critical" || sev === "error" || sev === "warning" || sev === "info" || sev === "low" || sev === "unverifiable")
+    return sev;
+  return "info";
+}
+function sanitizeRefModeFindings(findings, diffMode, blockingThreshold = "error") {
+  if (diffMode !== "ref")
+    return findings;
+  return findings.map((finding) => needsDowngradeForMissingEvidence(finding, blockingThreshold) ? downgradeToUnverifiable(finding) : finding);
+}
+function needsDowngradeForMissingEvidence(finding, blockingThreshold) {
+  if (!isBlockingSeverity(finding.severity, blockingThreshold))
+    return false;
+  return mentionsUnverifiedSource(finding) || !hasVerifiedEvidence(finding);
+}
+function mentionsUnverifiedSource(finding) {
+  const text = `${finding.issue} ${finding.suggestion}`.toLowerCase();
+  return UNVERIFIED_FINDING_PATTERNS.some((pattern) => text.includes(pattern));
+}
+function hasVerifiedEvidence(finding) {
+  const evidence = finding.verifiedBy;
+  return !!evidence?.file?.trim() && !!evidence.observed?.trim();
+}
+function downgradeToUnverifiable(finding) {
+  return {
+    ...finding,
+    severity: "unverifiable"
+  };
+}
+function llmFindingToFinding(f) {
+  const metaExtras = {};
+  if (f.verifiedBy)
+    metaExtras.verifiedBy = f.verifiedBy;
+  if (f.acQuote)
+    metaExtras.acQuote = f.acQuote;
+  if (f.acIndex != null)
+    metaExtras.acIndex = f.acIndex;
+  return {
+    source: "semantic-review",
+    severity: normalizeSeverity2(f.severity),
+    category: "",
+    file: f.file,
+    line: f.line,
+    message: f.issue,
+    suggestion: f.suggestion ?? undefined,
+    fixTarget: "source",
+    meta: Object.keys(metaExtras).length > 0 ? metaExtras : undefined
+  };
+}
+function toReviewFindings(findings) {
+  return findings.map(llmFindingToFinding);
+}
+var UNVERIFIED_FINDING_PATTERNS;
+var init_semantic_helpers = __esm(() => {
+  init_severity();
+  UNVERIFIED_FINDING_PATTERNS = [
+    "cannot verify",
+    "can't verify",
+    "from diff alone",
+    "missing from diff",
+    "not found in diff",
+    "not present in diff",
+    "does not appear in diff"
+  ];
+});
+
+// src/review/semantic-evidence.ts
+import { isAbsolute as isAbsolute8 } from "path";
+async function substantiateSemanticEvidence(findings, diffMode, workdir, storyId, blockingThreshold = "error") {
+  if (diffMode !== "ref")
+    return findings;
+  return Promise.all(findings.map(async (finding) => {
+    if (!isBlockingSeverity(finding.severity, blockingThreshold))
+      return finding;
+    const evidence = await checkFindingEvidence({ finding, workdir });
+    if (evidence.status !== "unmatched")
+      return finding;
+    return downgradeUnsubstantiatedFinding({ finding, storyId, ...evidence });
+  }));
+}
+async function checkFindingEvidence(opts) {
+  const observed = opts.finding.verifiedBy?.observed?.trim();
+  const file3 = opts.finding.verifiedBy?.file?.trim() || opts.finding.file;
+  const line = opts.finding.verifiedBy?.line ?? opts.finding.line;
+  if (!observed)
+    return { status: "missing-observed", file: file3, line };
+  const contents = await readSafeFile(opts.workdir, file3);
+  if (contents === null)
+    return { status: "unreadable", file: file3, line, observed };
+  return matchesEvidence(contents, observed, line) ? { status: "matched", file: file3, line, observed } : { status: "unmatched", file: file3, line, observed };
+}
+function matchesEvidence(contents, observed, line) {
+  if (!line || line <= 0) {
+    return normalizedIncludes(contents, observed);
+  }
+  const lines = contents.split(`
+`);
+  const cited = Math.min(Math.max(0, line - 1), lines.length - 1);
+  const start = Math.max(0, cited - EVIDENCE_LINE_WINDOW);
+  const end = Math.min(lines.length, cited + EVIDENCE_LINE_WINDOW + 1);
+  const windowText = lines.slice(start, end).join(`
+`);
+  return normalizedIncludes(windowText, observed);
+}
+function downgradeUnsubstantiatedFinding(opts) {
+  _evidenceDeps.getLogger()?.warn("review", "Downgraded unsubstantiated review finding", {
+    storyId: opts.storyId,
+    event: opts.event ?? SEMANTIC_FINDING_DOWNGRADED_EVENT,
+    file: opts.file ?? opts.finding.verifiedBy?.file ?? opts.finding.file,
+    line: opts.line ?? opts.finding.verifiedBy?.line ?? opts.finding.line,
+    issue: opts.finding.issue?.slice(0, ISSUE_PREVIEW_CHARS),
+    observed: opts.observed?.slice(0, OBSERVED_PREVIEW_CHARS)
+  });
+  return { ...opts.finding, severity: "unverifiable" };
+}
+async function readSafeFile(workdir, file3) {
+  const validated = validateModulePath(file3, [workdir]);
+  if (validated.valid && validated.absolutePath) {
+    try {
+      return await Bun.file(validated.absolutePath).text();
+    } catch {
+      return null;
+    }
+  }
+  if (isAbsolute8(file3)) {
+    try {
+      return await Bun.file(file3).text();
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function normalizedIncludes(contents, observed) {
+  const normalizedObserved = normalizeEvidenceText(observed);
+  return normalizedObserved.length > 0 && normalizeEvidenceText(contents).includes(normalizedObserved);
+}
+function normalizeEvidenceText(text) {
+  return stripWrappingQuotes(text).replace(/\s+/g, " ").trim();
+}
+function stripWrappingQuotes(text) {
+  let trimmed = text.trim();
+  while (trimmed.length >= 2 && isMatchingWrapper(trimmed[0], trimmed[trimmed.length - 1])) {
+    trimmed = trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+}
+function isMatchingWrapper(first, last) {
+  return first === "`" && last === "`" || first === `"` && last === `"` || first === "'" && last === "'";
+}
+var OBSERVED_PREVIEW_CHARS = 160, ISSUE_PREVIEW_CHARS = 200, EVIDENCE_LINE_WINDOW = 10, SEMANTIC_FINDING_DOWNGRADED_EVENT = "review.semantic.finding.downgraded", ADVERSARIAL_FINDING_DOWNGRADED_EVENT = "review.adversarial.finding.downgraded", _evidenceDeps;
+var init_semantic_evidence = __esm(() => {
+  init_logger2();
+  init_path_security2();
+  init_semantic_helpers();
+  _evidenceDeps = {
+    getLogger: getSafeLogger
+  };
+});
+
+// src/review/finding-filters.ts
+async function substantiateAdversarialFindings(opts) {
+  const { findings, workdir, storyId, blockingThreshold } = opts;
+  return Promise.all(findings.map(async (finding) => {
+    if (!isBlockingSeverity(finding.severity, blockingThreshold))
+      return finding;
+    const evidence = await checkFindingEvidence({ finding, workdir });
+    if (evidence.status !== "unmatched" && evidence.status !== "missing-observed")
+      return finding;
+    return downgradeUnsubstantiatedFinding({
+      finding,
+      storyId,
+      event: ADVERSARIAL_FINDING_DOWNGRADED_EVENT,
+      file: evidence.file,
+      line: evidence.line,
+      observed: evidence.observed
+    });
+  }));
+}
+var init_finding_filters = __esm(() => {
+  init_adversarial_helpers();
+  init_semantic_evidence();
+  init_semantic_helpers();
+  init_semantic_evidence();
+  init_ac_quote_validator();
+});
+
+// src/review/requote-response.ts
+function parseRequoteResponse(output) {
+  const parsed = tryParseLLMJson(output);
+  if (!isRecord(parsed))
+    return null;
+  const canonical = extractCanonical(parsed);
+  if (canonical)
+    return canonical;
+  const findings = parsed.findings;
+  if (!Array.isArray(findings) || findings.length !== 1)
+    return null;
+  const finding = findings[0];
+  if (!isRecord(finding))
+    return null;
+  return extractCanonical(finding.verifiedBy) ?? extractCanonical(finding);
+}
+function extractCanonical(value) {
+  if (!isRecord(value))
+    return null;
+  if (typeof value.file !== "string" || typeof value.observed !== "string")
+    return null;
+  const file3 = value.file.trim();
+  if (!file3)
+    return null;
+  const line = coerceLine(value.line);
+  if (line === null)
+    return null;
+  return {
+    file: file3,
+    line: line === undefined ? undefined : line,
+    observed: value.observed
+  };
+}
+function coerceLine(value) {
+  if (value == null)
+    return;
+  if (typeof value === "number")
+    return value;
+  if (typeof value === "string" && /^\d+$/.test(value))
+    return Number.parseInt(value, 10);
+  return null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var init_requote_response = () => {};
+
 // src/operations/adversarial-review.ts
-var FAIL_OPEN, adversarialParseRetry = (input) => makeParseRetryStrategy({
+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;
+  const requoteEnabled = ctx.input.adversarialConfig.substantiation?.requote ?? true;
+  if (ctx.input.mode !== "ref" || !requoteEnabled || maxRequotes <= 0) {
+    return { findings, changed: false, extraCostUsd: 0 };
+  }
+  const next = [...findings];
+  let changed = false;
+  let extraCostUsd = 0;
+  let used = 0;
+  for (const [index, finding] of next.entries()) {
+    if (!isBlockingSeverity(finding.severity, threshold))
+      continue;
+    const initialEvidence = await checkFindingEvidence({ finding, workdir: ctx.input.workdir });
+    if (initialEvidence.status !== "unmatched")
+      continue;
+    if (used >= maxRequotes)
+      break;
+    used += 1;
+    const retry = await ctx.send(AdversarialReviewPromptBuilder.requoteVerbatim({ finding }));
+    extraCostUsd += retry.estimatedCostUsd ?? 0;
+    const requote = parseRequoteResponse(retry.output);
+    if (!requote) {
+      next[index] = downgradeUnsubstantiatedFinding({
+        finding,
+        storyId: ctx.input.story.id,
+        event: ADVERSARIAL_REQUOTE_FAILED_EVENT,
+        ...initialEvidence
+      });
+      changed = true;
+      continue;
+    }
+    const updatedFinding = {
+      ...finding,
+      verifiedBy: {
+        file: requote.file,
+        line: requote.line,
+        observed: requote.observed
+      }
+    };
+    const requotedEvidence = await checkFindingEvidence({
+      finding: updatedFinding,
+      workdir: ctx.input.workdir
+    });
+    if (requotedEvidence.status === "matched") {
+      getSafeLogger()?.info("review", "Recovered adversarial finding via same-session requote", {
+        storyId: ctx.input.story.id,
+        event: ADVERSARIAL_REQUOTE_RECOVERED_EVENT,
+        file: requotedEvidence.file,
+        line: requotedEvidence.line
+      });
+      next[index] = updatedFinding;
+      changed = true;
+      continue;
+    }
+    next[index] = downgradeUnsubstantiatedFinding({
+      finding: updatedFinding,
+      storyId: ctx.input.story.id,
+      event: ADVERSARIAL_REQUOTE_FAILED_EVENT,
+      file: requotedEvidence.file,
+      line: requotedEvidence.line,
+      observed: requotedEvidence.observed
+    });
+    changed = true;
+  }
+  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",
   maxAttempts: 2,
@@ -31258,15 +31826,24 @@ var FAIL_OPEN, adversarialParseRetry = (input) => makeParseRetryStrategy({
     invalid: () => ReviewPromptBuilder.jsonRetry(),
     truncated: () => ReviewPromptBuilder.jsonRetryCondensed({ blockingThreshold: input.blockingThreshold })
   },
-  exhaustedFallback: (lastOutput) => /"passed"\s*:\s*false/.test(lastOutput) ? { passed: false, findings: [], looksLikeFail: true } : FAIL_OPEN,
+  exhaustedFallback: (lastOutput) => /"passed"\s*:\s*false/.test(lastOutput) ? { passed: false, findings: [], normalizedFindings: [], acDropped: [], looksLikeFail: true } : FAIL_OPEN,
   logContext: { blockingThreshold: input.blockingThreshold ?? "error" }
 }), adversarialReviewOp;
 var init_adversarial_review = __esm(() => {
   init_retry();
   init_config();
+  init_logger2();
   init_prompts();
   init_adversarial_helpers();
-  FAIL_OPEN = { passed: true, findings: [], failOpen: true };
+  init_finding_filters();
+  init_requote_response();
+  FAIL_OPEN = {
+    passed: true,
+    findings: [],
+    normalizedFindings: [],
+    acDropped: [],
+    failOpen: true
+  };
   adversarialReviewOp = {
     kind: "run",
     name: "adversarial-review",
@@ -31276,6 +31853,36 @@ var init_adversarial_review = __esm(() => {
     model: (input) => input.adversarialConfig.model,
     timeoutMs: (input) => input.adversarialConfig.timeoutMs,
     retry: (input) => adversarialParseRetry(input),
+    async hopBody(initialPrompt, ctx) {
+      const turn = await ctx.sendWithParseRetry(initialPrompt);
+      const parsed = validateAdversarialShape(tryParseLLMJson(turn.output));
+      if (!parsed)
+        return turn;
+      if (ctx.input.mode !== "ref")
+        return turn;
+      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, {
         mode: input.mode,
@@ -31298,12 +31905,51 @@ var init_adversarial_review = __esm(() => {
     parse(output, _input, _ctx) {
       const raw = tryParseLLMJson(output);
       const parsed = validateAdversarialShape(raw);
-      if (parsed)
-        return { passed: parsed.passed, findings: parsed.findings };
+      const repromptEvent = extractRepromptInfo(raw);
+      if (parsed) {
+        return {
+          passed: parsed.passed,
+          findings: parsed.findings,
+          normalizedFindings: [],
+          acDropped: [],
+          repromptEvent
+        };
+      }
       if (/"passed"\s*:\s*false/.test(output) && !/"findings"\s*:\s*\[\s*\{/.test(output)) {
-        return { passed: false, findings: [], looksLikeFail: true };
+        return {
+          passed: false,
+          findings: [],
+          normalizedFindings: [],
+          acDropped: [],
+          looksLikeFail: true,
+          repromptEvent
+        };
       }
       throw new ParseValidationError("[adversarial-review] parse failed: invalid JSON shape");
+    },
+    async verify(parsed, input, _verifyCtx) {
+      if (parsed.failOpen || parsed.looksLikeFail)
+        return parsed;
+      if (parsed.findings.length === 0)
+        return parsed;
+      const threshold = input.blockingThreshold ?? "error";
+      const findings = parsed.findings;
+      const substantiated = await substantiateAdversarialFindings({
+        findings,
+        workdir: input.workdir,
+        storyId: input.story.id,
+        blockingThreshold: threshold
+      });
+      const { accepted, dropped } = filterByAcQuote(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: toAdversarialReviewFindings(blocking),
+        acDropped: dropped
+      };
     }
   };
 });
@@ -31738,191 +32384,6 @@ var init_review_audit = __esm(() => {
   };
 });
 
-// src/review/semantic-helpers.ts
-function validateLLMShape(parsed) {
-  if (typeof parsed !== "object" || parsed === null)
-    return null;
-  const obj = parsed;
-  if (typeof obj.passed !== "boolean")
-    return null;
-  if (!Array.isArray(obj.findings))
-    return null;
-  return { passed: obj.passed, findings: obj.findings };
-}
-function parseLLMResponse(raw) {
-  try {
-    return validateLLMShape(tryParseLLMJson(raw));
-  } catch {
-    return null;
-  }
-}
-function formatFindings2(findings) {
-  return findings.map((f) => `[${f.severity}] ${f.file}:${f.line} \u2014 ${f.issue}
-  Suggestion: ${f.suggestion}`).join(`
-`);
-}
-function normalizeSeverity2(sev) {
-  if (sev === "warn")
-    return "warning";
-  if (sev === "critical" || sev === "error" || sev === "warning" || sev === "info" || sev === "low" || sev === "unverifiable")
-    return sev;
-  return "info";
-}
-function sanitizeRefModeFindings(findings, diffMode, blockingThreshold = "error") {
-  if (diffMode !== "ref")
-    return findings;
-  return findings.map((finding) => needsDowngradeForMissingEvidence(finding, blockingThreshold) ? downgradeToUnverifiable(finding) : finding);
-}
-function needsDowngradeForMissingEvidence(finding, blockingThreshold) {
-  if (!isBlockingSeverity(finding.severity, blockingThreshold))
-    return false;
-  return mentionsUnverifiedSource(finding) || !hasVerifiedEvidence(finding);
-}
-function mentionsUnverifiedSource(finding) {
-  const text = `${finding.issue} ${finding.suggestion}`.toLowerCase();
-  return UNVERIFIED_FINDING_PATTERNS.some((pattern) => text.includes(pattern));
-}
-function hasVerifiedEvidence(finding) {
-  const evidence = finding.verifiedBy;
-  return !!evidence?.file?.trim() && !!evidence.observed?.trim();
-}
-function downgradeToUnverifiable(finding) {
-  return {
-    ...finding,
-    severity: "unverifiable"
-  };
-}
-function llmFindingToFinding(f) {
-  const metaExtras = {};
-  if (f.verifiedBy)
-    metaExtras.verifiedBy = f.verifiedBy;
-  if (f.acQuote)
-    metaExtras.acQuote = f.acQuote;
-  if (f.acIndex != null)
-    metaExtras.acIndex = f.acIndex;
-  return {
-    source: "semantic-review",
-    severity: normalizeSeverity2(f.severity),
-    category: "",
-    file: f.file,
-    line: f.line,
-    message: f.issue,
-    suggestion: f.suggestion ?? undefined,
-    fixTarget: "source",
-    meta: Object.keys(metaExtras).length > 0 ? metaExtras : undefined
-  };
-}
-function toReviewFindings(findings) {
-  return findings.map(llmFindingToFinding);
-}
-var UNVERIFIED_FINDING_PATTERNS;
-var init_semantic_helpers = __esm(() => {
-  init_severity();
-  UNVERIFIED_FINDING_PATTERNS = [
-    "cannot verify",
-    "can't verify",
-    "from diff alone",
-    "missing from diff",
-    "not found in diff",
-    "not present in diff",
-    "does not appear in diff"
-  ];
-});
-
-// src/review/semantic-evidence.ts
-import { isAbsolute as isAbsolute8 } from "path";
-async function substantiateSemanticEvidence(findings, diffMode, workdir, storyId, blockingThreshold = "error") {
-  if (diffMode !== "ref")
-    return findings;
-  return Promise.all(findings.map(async (finding) => {
-    if (!isBlockingSeverity(finding.severity, blockingThreshold))
-      return finding;
-    const evidence = await checkFindingEvidence({ finding, workdir });
-    if (evidence.status !== "unmatched")
-      return finding;
-    return downgradeUnsubstantiatedFinding({ finding, storyId, ...evidence });
-  }));
-}
-async function checkFindingEvidence(opts) {
-  const observed = opts.finding.verifiedBy?.observed?.trim();
-  const file3 = opts.finding.verifiedBy?.file?.trim() || opts.finding.file;
-  const line = opts.finding.verifiedBy?.line ?? opts.finding.line;
-  if (!observed)
-    return { status: "missing-observed", file: file3, line };
-  const contents = await readSafeFile(opts.workdir, file3);
-  if (contents === null)
-    return { status: "unreadable", file: file3, line, observed };
-  return matchesEvidence(contents, observed, line) ? { status: "matched", file: file3, line, observed } : { status: "unmatched", file: file3, line, observed };
-}
-function matchesEvidence(contents, observed, line) {
-  if (!line || line <= 0) {
-    return normalizedIncludes(contents, observed);
-  }
-  const lines = contents.split(`
-`);
-  const cited = Math.min(Math.max(0, line - 1), lines.length - 1);
-  const start = Math.max(0, cited - EVIDENCE_LINE_WINDOW);
-  const end = Math.min(lines.length, cited + EVIDENCE_LINE_WINDOW + 1);
-  const windowText = lines.slice(start, end).join(`
-`);
-  return normalizedIncludes(windowText, observed);
-}
-function downgradeUnsubstantiatedFinding(opts) {
-  _evidenceDeps.getLogger()?.warn("review", "Downgraded unsubstantiated review finding", {
-    storyId: opts.storyId,
-    event: opts.event ?? SEMANTIC_FINDING_DOWNGRADED_EVENT,
-    file: opts.file ?? opts.finding.verifiedBy?.file ?? opts.finding.file,
-    line: opts.line ?? opts.finding.verifiedBy?.line ?? opts.finding.line,
-    issue: opts.finding.issue?.slice(0, ISSUE_PREVIEW_CHARS),
-    observed: opts.observed?.slice(0, OBSERVED_PREVIEW_CHARS)
-  });
-  return { ...opts.finding, severity: "unverifiable" };
-}
-async function readSafeFile(workdir, file3) {
-  const validated = validateModulePath(file3, [workdir]);
-  if (validated.valid && validated.absolutePath) {
-    try {
-      return await Bun.file(validated.absolutePath).text();
-    } catch {
-      return null;
-    }
-  }
-  if (isAbsolute8(file3)) {
-    try {
-      return await Bun.file(file3).text();
-    } catch {
-      return null;
-    }
-  }
-  return null;
-}
-function normalizedIncludes(contents, observed) {
-  const normalizedObserved = normalizeEvidenceText(observed);
-  return normalizedObserved.length > 0 && normalizeEvidenceText(contents).includes(normalizedObserved);
-}
-function normalizeEvidenceText(text) {
-  return stripWrappingQuotes(text).replace(/\s+/g, " ").trim();
-}
-function stripWrappingQuotes(text) {
-  let trimmed = text.trim();
-  while (trimmed.length >= 2 && isMatchingWrapper(trimmed[0], trimmed[trimmed.length - 1])) {
-    trimmed = trimmed.slice(1, -1).trim();
-  }
-  return trimmed;
-}
-function isMatchingWrapper(first, last) {
-  return first === "`" && last === "`" || first === `"` && last === `"` || first === "'" && last === "'";
-}
-var OBSERVED_PREVIEW_CHARS = 160, ISSUE_PREVIEW_CHARS = 200, EVIDENCE_LINE_WINDOW = 10, SEMANTIC_FINDING_DOWNGRADED_EVENT = "review.semantic.finding.downgraded", ADVERSARIAL_FINDING_DOWNGRADED_EVENT = "review.adversarial.finding.downgraded", _evidenceDeps;
-var init_semantic_evidence = __esm(() => {
-  init_logger2();
-  init_path_security2();
-  init_semantic_helpers();
-  _evidenceDeps = {
-    getLogger: getSafeLogger
-  };
-});
-
 // src/review/adversarial.ts
 import { relative as relative7, sep } from "path";
 function recordAdversarialAudit(opts) {
@@ -31955,7 +32416,6 @@ async function runAdversarialReview(opts) {
     agentManager,
     config: naxConfig,
     featureName,
-    priorFailures,
     blockingThreshold,
     featureContextMarkdown,
     contextBundle,
@@ -31966,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",
@@ -31985,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",
@@ -32076,13 +32536,13 @@ async function runAdversarialReview(opts) {
   let opResult;
   try {
     opResult = await _adversarialDeps.callOp(callCtx, adversarialReviewOp, {
+      workdir,
       story,
       adversarialConfig,
       mode: diffMode,
       diff,
       storyGitRef: effectiveRef,
       stat,
-      priorFailures,
       testInventory,
       excludePatterns: adversarialConfig.excludePatterns,
       testGlobs: resolvedTestPatterns.globs,
@@ -32167,34 +32627,28 @@ async function runAdversarialReview(opts) {
       durationMs: Date.now() - startTime
     };
   }
-  const rawParsedRaw = {
-    passed: opResult.passed,
-    findings: opResult.findings
-  };
-  const blockingThresholdEffective = blockingThreshold ?? "error";
-  const substantiatedFindings = await Promise.all(rawParsedRaw.findings.map(async (finding) => {
-    if (!isBlockingSeverity(finding.severity, blockingThresholdEffective))
-      return finding;
-    const evidence = await checkFindingEvidence({ finding, workdir });
-    if (evidence.status !== "unmatched" && evidence.status !== "missing-observed")
-      return finding;
-    return downgradeUnsubstantiatedFinding({
-      finding,
+  if (opResult.repromptEvent) {
+    runtime.dispatchEvents.emitReviewReprompt({
+      kind: "review-reprompt-on-drop",
       storyId: story.id,
-      event: ADVERSARIAL_FINDING_DOWNGRADED_EVENT,
-      file: evidence.file,
-      line: evidence.line,
-      observed: evidence.observed
+      reviewer: "adversarial",
+      dropCount: opResult.repromptEvent.dropCount,
+      repromptOutcome: opResult.repromptEvent.outcome,
+      costUsd: opResult.repromptEvent.costUsd
     });
-  }));
-  const rawParsed = { ...rawParsedRaw, findings: substantiatedFindings };
+  }
+  const threshold = blockingThreshold ?? "error";
+  const allFindings = opResult.findings;
+  const blockingFindings = allFindings.filter((f) => isBlockingSeverity(f.severity, threshold));
+  const advisoryFindings = allFindings.filter((f) => !isBlockingSeverity(f.severity, threshold));
+  const acDropped = opResult.acDropped ?? [];
   let diffFiles;
   let diffAvailable;
   if (diff && diff.length > 0) {
     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;
@@ -32203,13 +32657,6 @@ async function runAdversarialReview(opts) {
       diffAvailable = true;
     }
   }
-  const { accepted: acGroundedFindings, dropped: acDropped } = filterByAcQuote(rawParsed.findings, story.acceptanceCriteria);
-  if (acDropped.length > 0) {
-    logger?.warn("review", "Adversarial findings dropped: acQuote validation failed", {
-      storyId: story.id,
-      dropped: acDropped.map((d) => ({ file: d.finding.file, issue: d.finding.issue, code: d.code }))
-    });
-  }
   const adversarialDropAnalysis = acDropped.map((d) => ({
     finding: {
       file: d.finding.file ?? "<unknown>",
@@ -32223,10 +32670,6 @@ async function runAdversarialReview(opts) {
     rawCategory: d.finding.category ?? "",
     counterfactual: analyzeStructuralCounterfactual({ acIndex: d.finding.acIndex, category: d.finding.category, file: d.finding.file }, story.acceptanceCriteria, diffFiles)
   }));
-  const parsed = { ...rawParsed, findings: acGroundedFindings };
-  const threshold = blockingThresholdEffective;
-  const blockingFindings = parsed.findings.filter((f) => isBlockingSeverity(f.severity, threshold));
-  const advisoryFindings = parsed.findings.filter((f) => !isBlockingSeverity(f.severity, threshold));
   const adversarialAcceptAnalysis = blockingFindings.map((f) => ({
     finding: {
       file: f.file,
@@ -32249,11 +32692,11 @@ async function runAdversarialReview(opts) {
       }))
     });
   }
+  const durationMs = Date.now() - startTime;
   if (blockingFindings.length > 0) {
-    const durationMs2 = Date.now() - startTime;
     logger?.warn("review", `Adversarial review failed: ${blockingFindings.length} blocking findings`, {
       storyId: story.id,
-      durationMs: durationMs2,
+      durationMs,
       findings: blockingFindings.map((f) => ({
         severity: f.severity,
         category: f.category,
@@ -32274,72 +32717,37 @@ async function runAdversarialReview(opts) {
       blockingThreshold: threshold,
       result: {
         passed: false,
-        findings: llmFindingsToReviewFindings(parsed.findings, { source: "adversarial-review" })
+        findings: llmFindingsToReviewFindings(allFindings, { source: "adversarial-review" })
       },
       advisoryFindings: advisoryFindings.length > 0 ? llmFindingsToReviewFindings(advisoryFindings, { source: "adversarial-review" }) : undefined,
       diffAvailable,
       adversarialDropAnalysis,
       adversarialAcceptAnalysis
     });
+    const output = blockingFindings.length > 0 ? `Adversarial review failed:
+
+${formatFindings(blockingFindings)}` : "Adversarial review failed (no findings)";
     return {
       check: "adversarial",
       success: false,
       command: "",
       exitCode: 1,
-      output: `Adversarial review failed:
-
-${formatFindings(blockingFindings)}`,
-      durationMs: durationMs2,
-      findings: toAdversarialReviewFindings(blockingFindings),
+      output,
+      durationMs,
+      findings: blockingFindings.length > 0 ? toAdversarialReviewFindings(blockingFindings) : undefined,
       advisoryFindings: advisoryFindings.length > 0 ? toAdversarialReviewFindings(advisoryFindings) : undefined,
       cost: llmCost
     };
   }
-  if (!parsed.passed && blockingFindings.length === 0) {
-    if (acDropped.length > 0) {
-      const durationMs3 = Date.now() - startTime;
-      logger?.warn("review", "Adversarial review fail-closed: blocking findings dropped as ungrounded", {
-        storyId: story.id,
-        durationMs: durationMs3,
-        droppedCount: acDropped.length,
-        dropCodes: acDropped.map((d) => d.code)
-      });
-      const dropSummary = acDropped.map((d, i) => `${i + 1}. [${d.code}] ${d.finding.file ?? "<unknown>"}: ${d.finding.issue}`).join(`
-`);
-      recordAdversarialAudit({
-        runtime,
-        workdir,
-        projectDir,
-        storyId: story.id,
-        featureName,
-        parsed: true,
-        failOpen: false,
-        passed: false,
-        blockingThreshold: threshold,
-        result: { passed: false, findings: [] },
-        advisoryFindings: advisoryFindings.length > 0 ? llmFindingsToReviewFindings(advisoryFindings, { source: "adversarial-review" }) : undefined,
-        diffAvailable,
-        adversarialDropAnalysis,
-        adversarialAcceptAnalysis: []
-      });
-      return {
-        check: "adversarial",
-        success: false,
-        command: "",
-        exitCode: 1,
-        output: `Adversarial review failed: ${acDropped.length} blocking finding(s) dropped as ungrounded \u2014 the model emitted "passed: false" with concerns it could not ground in any acceptance criterion. Either re-classify these as "info" upstream or extend the ACs. Drops:
-
-${dropSummary}`,
-        durationMs: durationMs3,
-        advisoryFindings: advisoryFindings.length > 0 ? toAdversarialReviewFindings(advisoryFindings) : undefined,
-        cost: llmCost
-      };
-    }
-    const durationMs2 = Date.now() - startTime;
-    logger?.info("review", "Adversarial review passed (all findings below blocking threshold)", {
+  if (!opResult.passed && acDropped.length > 0) {
+    logger?.warn("review", "Adversarial review fail-closed: blocking findings dropped as ungrounded", {
       storyId: story.id,
-      durationMs: durationMs2
+      durationMs,
+      droppedCount: acDropped.length,
+      dropCodes: acDropped.map((d) => d.code)
     });
+    const dropSummary = acDropped.map((d, i) => `${i + 1}. [${d.code}] ${d.finding.file ?? "<unknown>"}: ${d.finding.issue}`).join(`
+`);
     recordAdversarialAudit({
       runtime,
       workdir,
@@ -32348,12 +32756,9 @@ ${dropSummary}`,
       featureName,
       parsed: true,
       failOpen: false,
-      passed: true,
+      passed: false,
       blockingThreshold: threshold,
-      result: {
-        passed: true,
-        findings: llmFindingsToReviewFindings(parsed.findings, { source: "adversarial-review" })
-      },
+      result: { passed: false, findings: [] },
       advisoryFindings: advisoryFindings.length > 0 ? llmFindingsToReviewFindings(advisoryFindings, { source: "adversarial-review" }) : undefined,
       diffAvailable,
       adversarialDropAnalysis,
@@ -32361,19 +32766,18 @@ ${dropSummary}`,
     });
     return {
       check: "adversarial",
-      success: true,
+      success: false,
       command: "",
-      exitCode: 0,
-      output: "Adversarial review passed (all findings were advisory \u2014 below blocking threshold)",
-      durationMs: durationMs2,
+      exitCode: 1,
+      output: `Adversarial review failed: ${acDropped.length} blocking finding(s) dropped as ungrounded \u2014 the model emitted "passed: false" with concerns it could not ground in any acceptance criterion. Drops:
+
+${dropSummary}`,
+      durationMs,
       advisoryFindings: advisoryFindings.length > 0 ? toAdversarialReviewFindings(advisoryFindings) : undefined,
       cost: llmCost
     };
   }
-  const durationMs = Date.now() - startTime;
-  if (parsed.passed) {
-    logger?.info("review", "Adversarial review passed", { storyId: story.id, durationMs });
-  }
+  logger?.info("review", "Adversarial review passed", { storyId: story.id, durationMs });
   recordAdversarialAudit({
     runtime,
     workdir,
@@ -32382,23 +32786,23 @@ ${dropSummary}`,
     featureName,
     parsed: true,
     failOpen: false,
-    passed: parsed.passed,
+    passed: true,
     blockingThreshold: threshold,
     result: {
-      passed: parsed.passed,
-      findings: llmFindingsToReviewFindings(parsed.findings, { source: "adversarial-review" })
+      passed: true,
+      findings: llmFindingsToReviewFindings(allFindings, { source: "adversarial-review" })
     },
     advisoryFindings: advisoryFindings.length > 0 ? llmFindingsToReviewFindings(advisoryFindings, { source: "adversarial-review" }) : undefined,
     diffAvailable,
     adversarialDropAnalysis,
-    adversarialAcceptAnalysis
+    adversarialAcceptAnalysis: []
   });
   return {
     check: "adversarial",
-    success: parsed.passed,
+    success: true,
     command: "",
-    exitCode: parsed.passed ? 0 : 1,
-    output: parsed.passed ? "Adversarial review passed" : "Adversarial review failed (no findings)",
+    exitCode: 0,
+    output: allFindings.length === 0 ? "Adversarial review passed" : "Adversarial review passed (all findings were advisory \u2014 below blocking threshold)",
     durationMs,
     advisoryFindings: advisoryFindings.length > 0 ? toAdversarialReviewFindings(advisoryFindings) : undefined,
     cost: llmCost
@@ -32413,16 +32817,17 @@ var init_adversarial = __esm(() => {
   init_adversarial_review();
   init_call();
   init_test_runners();
-  init_ac_quote_validator();
   init_ac_structural_counterfactual();
   init_adversarial_helpers();
   init_diff_utils();
   init_finding_projection();
   init_review_audit();
-  init_semantic_evidence();
   _adversarialDeps = {
     writeReviewAudit,
-    callOp
+    callOp,
+    resolveEffectiveRef,
+    collectDiffStat,
+    collectDiffFileList
   };
 });
 
@@ -33125,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,
@@ -33133,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,
@@ -33141,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,
@@ -35003,57 +35429,95 @@ var init_acceptance_fix = __esm(() => {
   };
 });
 
-// src/review/requote-response.ts
-function parseRequoteResponse(output) {
+// src/operations/semantic-review.ts
+function withRepromptMarker2(output, info) {
   const parsed = tryParseLLMJson(output);
-  if (!isRecord(parsed))
-    return null;
-  const canonical = extractCanonical(parsed);
-  if (canonical)
-    return canonical;
-  const findings = parsed.findings;
-  if (!Array.isArray(findings) || findings.length !== 1)
-    return null;
-  const finding = findings[0];
-  if (!isRecord(finding))
-    return null;
-  return extractCanonical(finding.verifiedBy) ?? extractCanonical(finding);
+  if (!parsed || typeof parsed !== "object")
+    return output;
+  return JSON.stringify({ ...parsed, _repromptInfo: info });
 }
-function extractCanonical(value) {
-  if (!isRecord(value))
-    return null;
-  if (typeof value.file !== "string" || typeof value.observed !== "string")
-    return null;
-  const file3 = value.file.trim();
-  if (!file3)
-    return null;
-  const line = coerceLine(value.line);
-  if (line === null)
-    return null;
+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 {
-    file: file3,
-    line: line === undefined ? undefined : line,
-    observed: value.observed
+    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 })
   };
 }
-function coerceLine(value) {
-  if (value == null)
-    return;
-  if (typeof value === "number")
-    return value;
-  if (typeof value === "string" && /^\d+$/.test(value))
-    return Number.parseInt(value, 10);
-  return null;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var init_requote_response = () => {};
-
-// src/operations/semantic-review.ts
 async function requoteBlockingFindings(findings, ctx) {
   const threshold = ctx.input.blockingThreshold ?? "error";
-  const maxRequotes = ctx.input.semanticConfig.substantiation?.maxRequotes ?? DEFAULT_MAX_REQUOTES;
+  const maxRequotes = ctx.input.semanticConfig.substantiation?.maxRequotes ?? DEFAULT_MAX_REQUOTES2;
   const requoteEnabled = ctx.input.semanticConfig.substantiation?.requote ?? true;
   if (ctx.input.mode !== "ref" || !requoteEnabled || maxRequotes <= 0) {
     return { findings, changed: false, extraCostUsd: 0 };
@@ -35120,30 +35584,45 @@ async function requoteBlockingFindings(findings, ctx) {
   }
   return { findings: next, changed, extraCostUsd };
 }
-var FAIL_OPEN2, SEMANTIC_REQUOTE_RECOVERED_EVENT = "review.semantic.finding.requote_recovered", SEMANTIC_REQUOTE_FAILED_EVENT = "review.semantic.finding.requote_failed", DEFAULT_MAX_REQUOTES = 5, semanticReviewHopBody = async (initialPrompt, ctx) => {
+var FAIL_OPEN2, SEMANTIC_REQUOTE_RECOVERED_EVENT = "review.semantic.finding.requote_recovered", SEMANTIC_REQUOTE_FAILED_EVENT = "review.semantic.finding.requote_failed", DEFAULT_MAX_REQUOTES2 = 5, semanticReviewHopBody = async (initialPrompt, ctx) => {
   const turn = await ctx.sendWithParseRetry(initialPrompt);
   const parsed = validateLLMShape(tryParseLLMJson(turn.output));
   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();
   init_config();
   init_logger2();
   init_prompts();
+  init_finding_filters();
   init_requote_response();
-  init_semantic_evidence();
-  init_semantic_helpers();
-  FAIL_OPEN2 = { passed: true, findings: [], failOpen: true };
+  FAIL_OPEN2 = {
+    passed: true,
+    findings: [],
+    normalizedFindings: [],
+    acDropped: [],
+    failOpen: true
+  };
   semanticReviewOp = {
     kind: "run",
     name: "semantic-review",
@@ -35160,6 +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: [], acDropped: [], looksLikeFail: true } : FAIL_OPEN2,
       logContext: { blockingThreshold: input.blockingThreshold ?? "error" }
     }),
     hopBody: semanticReviewHopBody,
@@ -35181,11 +35661,47 @@ var init_semantic_review = __esm(() => {
     parse(output, _input, _ctx) {
       const raw = tryParseLLMJson(output);
       const parsed = validateLLMShape(raw);
-      if (parsed)
-        return { passed: parsed.passed, findings: parsed.findings };
-      if (/"passed"\s*:\s*false/.test(output))
-        return { passed: false, findings: [], looksLikeFail: true };
+      const repromptEvent = extractRepromptInfo2(raw);
+      if (parsed) {
+        return {
+          passed: parsed.passed,
+          findings: parsed.findings,
+          normalizedFindings: [],
+          acDropped: [],
+          repromptEvent
+        };
+      }
+      if (/"passed"\s*:\s*false/.test(output)) {
+        return {
+          passed: false,
+          findings: [],
+          normalizedFindings: [],
+          acDropped: [],
+          looksLikeFail: true,
+          repromptEvent
+        };
+      }
       return FAIL_OPEN2;
+    },
+    async verify(parsed, input, _verifyCtx) {
+      if (parsed.failOpen || parsed.looksLikeFail)
+        return parsed;
+      if (parsed.findings.length === 0)
+        return parsed;
+      const threshold = input.blockingThreshold ?? "error";
+      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, 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),
+        acDropped: dropped
+      };
     }
   };
 });
@@ -37226,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) {
@@ -37329,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",
@@ -37339,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"
   };
 }
@@ -37380,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),
@@ -37393,7 +37909,7 @@ function makeAutofixImplementerStrategy(story) {
       summary: output.unresolvedReason ?? "",
       unresolved: output.unresolvedReason
     }),
-    maxAttempts: 3,
+    maxAttempts: config2.execution.rectification.maxAttemptsPerStrategy,
     coRun: "co-run-sequential"
   };
 }
@@ -37415,7 +37931,7 @@ function makeAutofixTestWriterStrategy(story, config2) {
       story,
       blockingThreshold: config2.review?.blockingThreshold
     }),
-    maxAttempts: 2,
+    maxAttempts: config2.execution.rectification.maxAttemptsPerStrategy,
     coRun: "co-run-sequential"
   };
 }
@@ -39360,30 +39876,57 @@ async function runSemanticReview(opts) {
       durationMs: Date.now() - startTime
     };
   }
-  const parsed = { passed: opResult.passed, findings: opResult.findings };
-  const sanitizedFindings = await substantiateSemanticEvidence(sanitizeRefModeFindings(parsed.findings, diffMode, blockingThreshold ?? "error"), diffMode, workdir, story.id, blockingThreshold ?? "error");
-  const { accepted: acGroundedFindings, dropped: acDropped } = filterByAcGroundingMinimal(sanitizedFindings, story.acceptanceCriteria);
-  if (acDropped.length > 0) {
-    logger?.warn("review", "Semantic findings dropped: acIndex missing or out of range", {
+  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,
-      dropped: acDropped.map((d) => ({ file: d.finding.file, issue: d.finding.issue, code: d.code }))
+      reviewer: "semantic",
+      dropCount: opResult.repromptEvent.dropCount,
+      repromptOutcome: opResult.repromptEvent.outcome,
+      costUsd: opResult.repromptEvent.costUsd
     });
   }
-  const sanitizedParsed = { ...parsed, findings: acGroundedFindings };
   const threshold = blockingThreshold ?? "error";
-  const blockingFindings = sanitizedParsed.findings.filter((f) => isBlockingSeverity(f.severity, threshold));
-  const advisoryFindings = sanitizedParsed.findings.filter((f) => !isBlockingSeverity(f.severity, threshold));
+  const allFindings = opResult.findings;
+  const blockingFindings = allFindings.filter((f) => isBlockingSeverity(f.severity, threshold));
+  const advisoryFindings = allFindings.filter((f) => !isBlockingSeverity(f.severity, threshold));
   if (advisoryFindings.length > 0) {
     logger?.debug("review", `Semantic review: ${advisoryFindings.length} advisory findings (below threshold '${threshold}')`, {
       storyId: story.id,
       findings: advisoryFindings.map((f) => ({ severity: f.severity, file: f.file, issue: f.issue }))
     });
   }
-  if (!sanitizedParsed.passed && blockingFindings.length > 0) {
-    const durationMs2 = Date.now() - startTime;
+  const durationMs = Date.now() - startTime;
+  if (blockingFindings.length > 0) {
     logger?.warn("review", `Semantic review failed: ${blockingFindings.length} blocking findings`, {
       storyId: story.id,
-      durationMs: durationMs2
+      durationMs
     });
     logger?.debug("review", "Semantic review findings", {
       storyId: story.id,
@@ -39410,7 +39953,7 @@ ${formatFindings2(blockingFindings)}`;
       blockingThreshold: threshold,
       result: {
         passed: false,
-        findings: llmFindingsToReviewFindings(sanitizedParsed.findings, { source: "semantic-review" })
+        findings: llmFindingsToReviewFindings(allFindings, { source: "semantic-review" })
       },
       advisoryFindings: advisoryFindings.length > 0 ? llmFindingsToReviewFindings(advisoryFindings, { source: "semantic-review" }) : undefined
     });
@@ -39420,53 +39963,16 @@ ${formatFindings2(blockingFindings)}`;
       command: "",
       exitCode: 1,
       output,
-      durationMs: durationMs2,
+      durationMs,
       findings: toReviewFindings(blockingFindings),
       advisoryFindings: advisoryFindings.length > 0 ? toReviewFindings(advisoryFindings) : undefined,
       cost: llmCost
     };
   }
-  if (!sanitizedParsed.passed && blockingFindings.length === 0) {
-    if (acDropped.length > 0) {
-      const durationMs3 = Date.now() - startTime;
-      logger?.warn("review", "Semantic review fail-closed: blocking findings dropped (acIndex invalid)", {
-        storyId: story.id,
-        durationMs: durationMs3,
-        droppedCount: acDropped.length,
-        dropCodes: acDropped.map((d) => d.code)
-      });
-      const dropSummary = acDropped.map((d, i) => `${i + 1}. [${d.code}] ${d.finding.file ?? "<unknown>"}: ${d.finding.issue}`).join(`
-`);
-      recordSemanticAudit({
-        runtime,
-        workdir,
-        projectDir,
-        storyId: story.id,
-        featureName,
-        parsed: true,
-        failOpen: false,
-        passed: false,
-        blockingThreshold: threshold,
-        result: { passed: false, findings: [] },
-        advisoryFindings: advisoryFindings.length > 0 ? llmFindingsToReviewFindings(advisoryFindings, { source: "semantic-review" }) : undefined
-      });
-      return {
-        check: "semantic",
-        success: false,
-        command: "",
-        exitCode: 1,
-        output: `Semantic review failed: ${acDropped.length} blocking finding(s) dropped \u2014 acIndex was missing or out of range. The model emitted "passed: false" without valid AC attribution. Either re-classify these as "info" or ensure each error finding includes a valid acIndex. Drops:
-
-${dropSummary}`,
-        durationMs: durationMs3,
-        advisoryFindings: advisoryFindings.length > 0 ? toReviewFindings(advisoryFindings) : undefined,
-        cost: llmCost
-      };
-    }
-    const durationMs2 = Date.now() - startTime;
-    logger?.info("review", "Semantic review passed (all findings below blocking threshold)", {
+  if (!opResult.passed && allFindings.length === 0) {
+    logger?.warn("review", "Semantic review fail-closed: blocking findings dropped (acIndex invalid)", {
       storyId: story.id,
-      durationMs: durationMs2
+      durationMs
     });
     recordSemanticAudit({
       runtime,
@@ -39476,29 +39982,23 @@ ${dropSummary}`,
       featureName,
       parsed: true,
       failOpen: false,
-      passed: true,
+      passed: false,
       blockingThreshold: threshold,
-      result: {
-        passed: true,
-        findings: llmFindingsToReviewFindings(sanitizedParsed.findings, { source: "semantic-review" })
-      },
+      result: { passed: false, findings: [] },
       advisoryFindings: advisoryFindings.length > 0 ? llmFindingsToReviewFindings(advisoryFindings, { source: "semantic-review" }) : undefined
     });
     return {
       check: "semantic",
-      success: true,
+      success: false,
       command: "",
-      exitCode: 0,
-      output: "Semantic review passed (all findings were advisory \u2014 below blocking threshold)",
-      durationMs: durationMs2,
+      exitCode: 1,
+      output: 'Semantic review failed: blocking finding(s) were dropped \u2014 acIndex was missing or out of range. The model emitted "passed: false" without valid AC attribution.',
+      durationMs,
       advisoryFindings: advisoryFindings.length > 0 ? toReviewFindings(advisoryFindings) : undefined,
       cost: llmCost
     };
   }
-  const durationMs = Date.now() - startTime;
-  if (sanitizedParsed.passed) {
-    logger?.info("review", "Semantic review passed", { storyId: story.id, durationMs });
-  }
+  logger?.info("review", "Semantic review passed", { storyId: story.id, durationMs });
   recordSemanticAudit({
     runtime,
     workdir,
@@ -39507,20 +40007,20 @@ ${dropSummary}`,
     featureName,
     parsed: true,
     failOpen: false,
-    passed: sanitizedParsed.passed,
+    passed: true,
     blockingThreshold: threshold,
     result: {
-      passed: sanitizedParsed.passed,
-      findings: llmFindingsToReviewFindings(sanitizedParsed.findings, { source: "semantic-review" })
+      passed: true,
+      findings: llmFindingsToReviewFindings(allFindings, { source: "semantic-review" })
     },
     advisoryFindings: advisoryFindings.length > 0 ? llmFindingsToReviewFindings(advisoryFindings, { source: "semantic-review" }) : undefined
   });
   return {
     check: "semantic",
-    success: sanitizedParsed.passed,
+    success: true,
     command: "",
-    exitCode: sanitizedParsed.passed ? 0 : 1,
-    output: sanitizedParsed.passed ? "Semantic review passed" : "Semantic review failed (no findings)",
+    exitCode: 0,
+    output: allFindings.length === 0 ? "Semantic review passed" : "Semantic review passed (all findings were advisory \u2014 below blocking threshold)",
     durationMs,
     advisoryFindings: advisoryFindings.length > 0 ? toReviewFindings(advisoryFindings) : undefined,
     cost: llmCost
@@ -39537,12 +40037,10 @@ var init_semantic = __esm(() => {
   init_semantic_review();
   init_prompts();
   init_test_runners();
-  init_ac_quote_validator();
   init_diff_utils();
   init_finding_projection();
   init_review_audit();
   init_semantic_debate();
-  init_semantic_evidence();
   init_semantic_helpers();
   _semanticDeps = {
     createDebateRunner: (opts) => new DebateRunner(opts),
@@ -39815,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})`;
     }
@@ -41869,6 +42379,38 @@ async function callOp(ctx, op, input) {
   const rawOutput = outcome.result.output;
   const totalCost = outcome.result.estimatedCostUsd ?? 0;
   if (!rawOutput) {
+    if (maxRetriesExceeded) {
+      getSafeLogger()?.error("callop", "Op retry budget exhausted (empty output)", {
+        storyId: ctx.storyId,
+        opName: op.name,
+        site: "run",
+        totalAttempts: MAX_COMPLETE_RETRY_ATTEMPTS + 1
+      });
+      throw new NaxError(`callOp[${op.name}]: CALL_OP_MAX_RETRIES \u2014 exceeded MAX_COMPLETE_RETRY_ATTEMPTS (${MAX_COMPLETE_RETRY_ATTEMPTS})`, "CALL_OP_MAX_RETRIES", { stage: op.stage, storyId: ctx.storyId });
+    }
+    if (retryFallback !== undefined) {
+      if (typeof retryFallback !== "object" || retryFallback === null) {
+        throw new NaxError(`callOp[${op.name}]: exhaustedFallback returned a non-object (${typeof retryFallback}); fallback must be a plain object`, "CALL_OP_INVALID_FALLBACK", { stage: op.stage, storyId: ctx.storyId });
+      }
+      getSafeLogger()?.warn("callop", "Returning exhaustedFallback on empty output", {
+        storyId: ctx.storyId,
+        opName: op.name,
+        agentName: dispatchAgent
+      });
+      return { ...retryFallback, estimatedCostUsd: totalCost };
+    }
+    if (op.recover) {
+      const verifyCtx = makeVerifyCtx(buildCtx);
+      const recovered = await op.recover(input, verifyCtx);
+      if (recovered !== null) {
+        getSafeLogger()?.warn("callop", "Recovered from empty output via op.recover", {
+          storyId: ctx.storyId,
+          opName: op.name,
+          agentName: dispatchAgent
+        });
+        return recovered;
+      }
+    }
     throw new NaxError(`callOp[${op.name}]: agent returned no output`, "CALL_OP_NO_OUTPUT", {
       stage: op.stage,
       storyId: ctx.storyId,
@@ -52017,12 +52559,16 @@ function phasePassed(opName, output) {
   });
   return true;
 }
+function isFinding(value) {
+  return typeof value === "object" && value !== null && typeof value.source === "string" && value.source.length > 0;
+}
 function extractPhaseFindings(output) {
   if (output === null || output === undefined || typeof output !== "object") {
     return [];
   }
   const record2 = output;
-  const findings = Array.isArray(record2.findings) ? record2.findings : [];
+  const rawArray = Array.isArray(record2.normalizedFindings) ? record2.normalizedFindings : Array.isArray(record2.findings) ? record2.findings : [];
+  const findings = rawArray.filter(isFinding);
   const success2 = "success" in record2 ? record2.success === true : ("passed" in record2) ? record2.passed === true : findings.length === 0;
   return success2 ? [] : findings;
 }
@@ -52085,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) {
@@ -52138,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();
@@ -52515,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 = {
@@ -52650,6 +53235,7 @@ async function assemblePlanInputsFromCtx(ctx) {
     blockingThreshold: ctx.config.review.blockingThreshold
   } : undefined;
   const adversarialReviewInput = ctx.config.review?.enabled === true && ctx.config.review.checks?.includes("adversarial") && ctx.config.review.adversarial ? {
+    workdir: ctx.workdir,
     story,
     adversarialConfig: ctx.config.review.adversarial,
     mode: ctx.config.review.adversarial.diffMode,
@@ -52658,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,
@@ -53124,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 });
@@ -53851,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,
@@ -53864,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,
@@ -56943,7 +57563,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.67.9",
+    version: "0.67.11",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -57038,8 +57658,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("ab2db4bb"))
-        return "ab2db4bb";
+      if (/^[0-9a-f]{6,10}$/.test("0db5c72e"))
+        return "0db5c72e";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -58013,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,
@@ -58177,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);
@@ -60223,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,
@@ -60506,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 {
@@ -95426,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",