@nathapp/nax 0.75.4 → 0.75.6

package/dist/nax.js

@@ -17377,7 +17377,11 @@ var init_schemas_review = __esm(() => {
       maxRequotes: 5
     }),
     excludePatterns: exports_external.array(exports_external.string()).optional(),
-    demandInspectionTrail: exports_external.boolean().default(true)
+    demandInspectionTrail: exports_external.boolean().default(true),
+    recurrenceDemotion: exports_external.object({
+      enabled: exports_external.boolean().default(false),
+      maxBlockingRounds: exports_external.number().int().min(1).default(2)
+    }).default({ enabled: false, maxBlockingRounds: 2 })
   });
   AdversarialReviewConfigSchema = exports_external.object({
     model: ConfiguredModelSchema.default("balanced"),
@@ -17641,6 +17645,7 @@ var init_schemas3 = __esm(() => {
         rules: [],
         timeoutMs: 600000,
         demandInspectionTrail: true,
+        recurrenceDemotion: { enabled: false, maxBlockingRounds: 2 },
         substantiation: {
           requote: true,
           maxRequotes: 5
@@ -17823,6 +17828,7 @@ var init_schemas3 = __esm(() => {
           quality: exports_external.string().nullable().default(null)
         }).default({ spec: null, quality: null }),
         escalate: exports_external.object({ telegram: exports_external.boolean().default(true) }).default({ telegram: true }),
+        notify: exports_external.object({ mode: exports_external.enum(["escalation", "always", "off"]).default("escalation") }).default({ mode: "escalation" }),
         timeouts: exports_external.object({
           acceptanceMs: exports_external.number().int().positive().default(600000),
           gateMs: exports_external.number().int().positive().default(900000),
@@ -17835,6 +17841,7 @@ var init_schemas3 = __esm(() => {
         defaultAgent: null,
         reviewers: { spec: null, quality: null },
         escalate: { telegram: true },
+        notify: { mode: "escalation" },
         timeouts: { acceptanceMs: 600000, gateMs: 900000, flowMs: 5400000, stepMs: null }
       })
     }).default({
@@ -17844,6 +17851,7 @@ var init_schemas3 = __esm(() => {
         defaultAgent: null,
         reviewers: { spec: null, quality: null },
         escalate: { telegram: true },
+        notify: { mode: "escalation" },
         timeouts: { acceptanceMs: 600000, gateMs: 900000, flowMs: 5400000, stepMs: null }
       }
     }),
@@ -21654,7 +21662,7 @@ class AcpAgentAdapter {
     }
   }
 }
-var MAX_AGENT_OUTPUT_CHARS = 5000, INTERACTION_TIMEOUT_MS, AGENT_REGISTRY, DEFAULT_ENTRY, ACP_ADAPTER_NAMES;
+var INTERACTION_TIMEOUT_MS, AGENT_REGISTRY, DEFAULT_ENTRY, ACP_ADAPTER_NAMES;
 var init_adapter = __esm(() => {
   init_errors();
   init_logger2();
@@ -22944,11 +22952,38 @@ var init_compose = __esm(() => {
 
 // src/review/truncation.ts
 function looksLikeTruncatedJson(raw) {
-  return raw.trimEnd().length >= MAX_AGENT_OUTPUT_CHARS - 100;
+  const text = raw.trimEnd();
+  if (text.length === 0)
+    return false;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  let opened = false;
+  for (const ch of text) {
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (inString) {
+      if (ch === "\\")
+        escaped = true;
+      else if (ch === '"')
+        inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{" || ch === "[") {
+      depth++;
+      opened = true;
+    } else if (ch === "}" || ch === "]") {
+      depth--;
+    }
+  }
+  return opened && (inString || depth > 0);
 }
-var init_truncation = __esm(() => {
-  init_adapter();
-});
 
 // src/utils/llm-json.ts
 function extractJsonFromMarkdown(text) {
@@ -23091,9 +23126,9 @@ function makeParseRetryStrategy(opts) {
     }
   };
 }
+var UNPARSED_PREVIEW_BYTES = 600;
 var init_parse_retry = __esm(() => {
   init_logger2();
-  init_truncation();
   init_types4();
 });
 
@@ -23111,7 +23146,7 @@ function makeTieredParseRetryStrategy(opts) {
       if (attempt >= opts.maxAttempts - 1) {
         return { retry: false, fallback: opts.exhaustedFallback(inspection, ctx.lastOutput) };
       }
-      const isTruncated = ctx.lastOutput.trimEnd().length >= MAX_AGENT_OUTPUT_CHARS - 100;
+      const isTruncated = looksLikeTruncatedJson(ctx.lastOutput);
       const logger = opts._logger ?? getSafeLogger();
       logger?.warn(opts.reviewerKind, `Parse retry \u2014 ${inspection.kind ?? "unknown"}`, {
         storyId: ctx.storyId,
@@ -23125,7 +23160,6 @@ function makeTieredParseRetryStrategy(opts) {
 }
 var init_tiered_parse_retry = __esm(() => {
   init_logger2();
-  init_adapter();
   init_types4();
 });
 
@@ -36186,6 +36220,89 @@ var init_finding_filters = __esm(() => {
   init_ac_quote_validator();
 });
 
+// src/review/recurrence-demotion.ts
+function normalizeIssueText(s) {
+  return s.replace(/`/g, "").replace(/\s+/g, " ").trim().toLowerCase().slice(0, MAX_ISSUE_PREFIX);
+}
+function normalizeFingerprintPath(file3) {
+  return (file3 ?? "").replace(/\\/g, "/").replace(/^(?:\.{1,2}\/)+/, "");
+}
+function fingerprintFor(file3, category, text, acIndex) {
+  const normFile = normalizeFingerprintPath(file3);
+  if (typeof acIndex === "number" && Number.isInteger(acIndex) && acIndex >= 1) {
+    return `${normFile}|ac${acIndex}`;
+  }
+  return `${normFile}|${category ?? ""}|${normalizeIssueText(text).slice(0, FP_ISSUE_PREFIX)}`;
+}
+function lookupPriorAppearance(priorCounts, finding) {
+  const acKey = finding.acIndex === undefined ? undefined : priorCounts.get(fingerprintFor(finding.file, finding.category, finding.issue, finding.acIndex));
+  const proseKey = priorCounts.get(fingerprintFor(finding.file, finding.category, finding.issue));
+  if (!acKey)
+    return proseKey;
+  if (!proseKey)
+    return acKey;
+  return acKey.count >= proseKey.count ? acKey : proseKey;
+}
+function countPriorAppearances(priorIterations, source = "adversarial-review") {
+  const counts = new Map;
+  for (const it of priorIterations) {
+    const seenThisIter = new Map;
+    for (const f of it.findingsAfter ?? []) {
+      if (f.source !== source)
+        continue;
+      const acIndex = typeof f.meta?.acIndex === "number" ? f.meta.acIndex : undefined;
+      seenThisIter.set(fingerprintFor(f.file, f.category, f.message), f.severity);
+      if (acIndex !== undefined) {
+        seenThisIter.set(fingerprintFor(f.file, f.category, f.message, acIndex), f.severity);
+      }
+    }
+    for (const [fp, sev] of seenThisIter) {
+      const cur = counts.get(fp);
+      counts.set(fp, { count: (cur?.count ?? 0) + 1, lastSeverity: sev });
+    }
+  }
+  return counts;
+}
+function tagCoverageGap(findings) {
+  return findings.map((f) => ({ ...f, meta: { ...f.meta ?? {}, coverageGap: true } }));
+}
+function classifyRecurrence(accepted, priorIterations, cfg, testFileMatch, threshold, source = "adversarial-review") {
+  const blocking = [];
+  const advisory = [];
+  const demoted = [];
+  if (!cfg.enabled) {
+    for (const f of accepted)
+      (isBlockingSeverity(f.severity, threshold) ? blocking : advisory).push(f);
+    return { blocking, advisory, demoted };
+  }
+  const priorCounts = countPriorAppearances(priorIterations, source);
+  for (const f of accepted) {
+    if (f.category === "test-gap" && testFileMatch(f.file) && isBlockingSeverity(f.severity, threshold)) {
+      blocking.push(f);
+      continue;
+    }
+    if (!isBlockingSeverity(f.severity, threshold)) {
+      advisory.push(f);
+      continue;
+    }
+    const prior = lookupPriorAppearance(priorCounts, f);
+    const n = (prior?.count ?? 0) + 1;
+    const prevWasBlocking = prior !== undefined && isBlockingSeverity(prior.lastSeverity, threshold);
+    if (n >= cfg.maxBlockingRounds + 1) {
+      demoted.push(f);
+    } else if (n === 1 || prevWasBlocking) {
+      blocking.push(f);
+    } else {
+      advisory.push(f);
+    }
+  }
+  return { blocking, advisory, demoted };
+}
+var MAX_ISSUE_PREFIX = 160, FP_ISSUE_PREFIX = 48;
+var init_recurrence_demotion = __esm(() => {
+  init_adversarial_helpers();
+});
+
 // src/review/requote-response.ts
 function parseRequoteResponse(output) {
   const parsed = tryParseLLMJson(output);
@@ -36233,6 +36350,17 @@ function isRecord(value) {
 }
 var init_requote_response = () => {};
 
+// src/operations/_review-fallback.ts
+function reviewExhaustedFallback(lastOutput, failOpen) {
+  const unparsedPreview = previewOutput(lastOutput, UNPARSED_PREVIEW_BYTES);
+  if (!/"passed"\s*:\s*false/.test(lastOutput))
+    return { ...failOpen, unparsedPreview };
+  return { ...failOpen, passed: false, failOpen: false, looksLikeFail: true, unparsedPreview };
+}
+var init__review_fallback = __esm(() => {
+  init_retry();
+});
+
 // src/operations/semantic-review.ts
 function withRepromptMarker(output, info) {
   const parsed = tryParseLLMJson(output);
@@ -36451,7 +36579,9 @@ var init_semantic_review = __esm(() => {
   init_logger2();
   init_prompts();
   init_finding_filters();
+  init_recurrence_demotion();
   init_requote_response();
+  init__review_fallback();
   FAIL_OPEN = {
     passed: true,
     findings: [],
@@ -36475,7 +36605,8 @@ 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_OPEN,
+      exhaustedFallback: (lastOutput) => reviewExhaustedFallback(lastOutput, FAIL_OPEN),
+      outputPreviewBytes: UNPARSED_PREVIEW_BYTES,
       logContext: { blockingThreshold: input.blockingThreshold ?? "error" }
     }),
     hopBody: semanticReviewHopBody,
@@ -36507,6 +36638,7 @@ var init_semantic_review = __esm(() => {
           repromptEvent
         };
       }
+      const unparsedPreview = previewOutput(output, UNPARSED_PREVIEW_BYTES);
       if (/"passed"\s*:\s*false/.test(output)) {
         return {
           passed: false,
@@ -36514,10 +36646,11 @@ var init_semantic_review = __esm(() => {
           normalizedFindings: [],
           acDropped: [],
           looksLikeFail: true,
+          unparsedPreview,
           repromptEvent
         };
       }
-      return FAIL_OPEN;
+      return { ...FAIL_OPEN, unparsedPreview };
     },
     async verify(parsed, input, _verifyCtx) {
       if (parsed.failOpen || parsed.looksLikeFail)
@@ -36529,84 +36662,30 @@ var init_semantic_review = __esm(() => {
       const sanitized = sanitizeRefModeFindings(findings, input.mode, threshold);
       const substantiated = await substantiateSemanticEvidence(sanitized, input.mode, input.workdir, input.story.id, threshold, input.repoRoot);
       const { accepted, dropped } = filterByAcGroundingMinimal(substantiated, input.story.acceptanceCriteria);
-      const blocking = accepted.filter((f) => isBlockingSeverity(f.severity, threshold));
+      const isTestFile3 = semanticTestFileMatch(input);
+      const recurrenceCfg = input.semanticConfig.recurrenceDemotion ?? { enabled: false, maxBlockingRounds: 2 };
+      const {
+        blocking,
+        advisory: subThreshold,
+        demoted
+      } = classifyRecurrence(accepted, input.priorSemanticIterations ?? [], recurrenceCfg, isTestFile3, threshold, "semantic-review");
+      const advisoryFindings = [
+        ...toReviewFindings(subThreshold.filter((f) => isBlockingSeverity(f.severity, threshold)), { isTestFile: isTestFile3 }),
+        ...tagCoverageGap(toReviewFindings(demoted, { isTestFile: isTestFile3 }))
+      ];
       const passed = blocking.length === 0 && (parsed.passed || accepted.length > 0);
       return {
         ...parsed,
         passed,
         findings: accepted,
-        normalizedFindings: toReviewFindings(blocking, { isTestFile: semanticTestFileMatch(input) }),
+        normalizedFindings: toReviewFindings(blocking, { isTestFile: isTestFile3 }),
+        advisoryFindings,
         acDropped: dropped
       };
     }
   };
 });
 
-// src/review/recurrence-demotion.ts
-function normalizeIssueText(s) {
-  return s.replace(/`/g, "").replace(/\s+/g, " ").trim().toLowerCase().slice(0, MAX_ISSUE_PREFIX);
-}
-function fingerprintFor(file3, category, text) {
-  const normFile = (file3 ?? "").replace(/\\/g, "/");
-  return `${normFile}|${category ?? ""}|${normalizeIssueText(text).slice(0, FP_ISSUE_PREFIX)}`;
-}
-function countPriorAppearances(priorIterations) {
-  const counts = new Map;
-  for (const it of priorIterations) {
-    const seenThisIter = new Map;
-    for (const f of it.findingsAfter ?? []) {
-      if (f.source !== "adversarial-review")
-        continue;
-      const fp = fingerprintFor(f.file, f.category, f.message);
-      seenThisIter.set(fp, f.severity);
-    }
-    for (const [fp, sev] of seenThisIter) {
-      const cur = counts.get(fp);
-      counts.set(fp, { count: (cur?.count ?? 0) + 1, lastSeverity: sev });
-    }
-  }
-  return counts;
-}
-function tagCoverageGap(findings) {
-  return findings.map((f) => ({ ...f, meta: { ...f.meta ?? {}, coverageGap: true } }));
-}
-function classifyRecurrence(accepted, priorIterations, cfg, testFileMatch, threshold) {
-  const blocking = [];
-  const advisory = [];
-  const demoted = [];
-  if (!cfg.enabled) {
-    for (const f of accepted)
-      (isBlockingSeverity(f.severity, threshold) ? blocking : advisory).push(f);
-    return { blocking, advisory, demoted };
-  }
-  const priorCounts = countPriorAppearances(priorIterations);
-  for (const f of accepted) {
-    if (f.category === "test-gap" && testFileMatch(f.file) && isBlockingSeverity(f.severity, threshold)) {
-      blocking.push(f);
-      continue;
-    }
-    if (!isBlockingSeverity(f.severity, threshold)) {
-      advisory.push(f);
-      continue;
-    }
-    const prior = priorCounts.get(fingerprintFor(f.file, f.category, f.issue));
-    const n = (prior?.count ?? 0) + 1;
-    const prevWasBlocking = prior !== undefined && isBlockingSeverity(prior.lastSeverity, threshold);
-    if (n >= cfg.maxBlockingRounds + 1) {
-      demoted.push(f);
-    } else if (n === 1 || prevWasBlocking) {
-      blocking.push(f);
-    } else {
-      advisory.push(f);
-    }
-  }
-  return { blocking, advisory, demoted };
-}
-var MAX_ISSUE_PREFIX = 160, FP_ISSUE_PREFIX = 48;
-var init_recurrence_demotion = __esm(() => {
-  init_adversarial_helpers();
-});
-
 // src/operations/adversarial-review.ts
 function withRepromptMarker2(output, info) {
   const parsed = tryParseLLMJson(output);
@@ -36791,7 +36870,8 @@ var FAIL_OPEN2, ADVERSARIAL_REQUOTE_RECOVERED_EVENT = "review.adversarial.findin
     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,
+  exhaustedFallback: (lastOutput) => reviewExhaustedFallback(lastOutput, FAIL_OPEN2),
+  outputPreviewBytes: UNPARSED_PREVIEW_BYTES,
   logContext: { blockingThreshold: input.blockingThreshold ?? "error" }
 }), adversarialReviewOp;
 var init_adversarial_review = __esm(() => {
@@ -36803,6 +36883,7 @@ var init_adversarial_review = __esm(() => {
   init_finding_filters();
   init_recurrence_demotion();
   init_requote_response();
+  init__review_fallback();
   FAIL_OPEN2 = {
     passed: true,
     findings: [],
@@ -38723,7 +38804,6 @@ var init_ground = __esm(() => {
   init_errors();
   init_logger2();
   init_prompts();
-  init_truncation();
   groundOp = {
     kind: "run",
     name: "ground",
@@ -42160,11 +42240,11 @@ var init_findings = __esm(() => {
   init_cycle();
 });
 
-// src/review/adversarial-iteration-store.ts
-function getAdversarialIterations(store, storyId) {
+// src/review/review-iteration-store.ts
+function getReviewIterations(store, storyId) {
   return store.get(storyId) ?? [];
 }
-function recordAdversarialIteration(store, storyId, roundFindings) {
+function recordReviewIteration(store, storyId, roundFindings) {
   const prior = store.get(storyId) ?? [];
   const findingsBefore = prior.length > 0 ? prior[prior.length - 1].findingsAfter : [];
   const findingsAfter = [...roundFindings];
@@ -42180,7 +42260,7 @@ function recordAdversarialIteration(store, storyId, roundFindings) {
   };
   store.set(storyId, [...prior, iteration]);
 }
-var init_adversarial_iteration_store = __esm(() => {
+var init_review_iteration_store = __esm(() => {
   init_findings();
 });
 
@@ -42623,7 +42703,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.75.4",
+    version: "0.75.6",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -42727,8 +42807,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("5aee16bf"))
-        return "5aee16bf";
+      if (/^[0-9a-f]{6,10}$/.test("064f9083"))
+        return "064f9083";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -42775,6 +42855,8 @@ function toPersistedEntry(entry, epochMs) {
     blockingThreshold: entry.blockingThreshold ?? "error",
     result: entry.result,
     advisoryFindings: entry.advisoryFindings ?? null,
+    acDropped: entry.acDropped ?? null,
+    ...entry.parsed ? {} : { unparsedPreview: entry.unparsedPreview ?? null },
     diffAvailable: entry.diffAvailable ?? null,
     adversarialDropAnalysis: entry.adversarialDropAnalysis ?? null,
     adversarialAcceptAnalysis: entry.adversarialAcceptAnalysis ?? null
@@ -44746,7 +44828,7 @@ var init_review = __esm(() => {
   init_category_fix_target();
   init_finding_filters();
   init_ac_quote_validator();
-  init_adversarial_iteration_store();
+  init_review_iteration_store();
   init_ac_structural_counterfactual();
   init_adversarial();
   init_semantic_evidence();
@@ -48169,6 +48251,8 @@ function attachReviewAuditSubscriber(bus, auditor, runId) {
       blockingThreshold: event.blockingThreshold,
       result: event.result,
       advisoryFindings: event.advisoryFindings,
+      acDropped: event.acDropped ? [...event.acDropped] : undefined,
+      unparsedPreview: event.unparsedPreview,
       diffAvailable: event.diffAvailable,
       adversarialDropAnalysis: event.adversarialDropAnalysis,
       adversarialAcceptAnalysis: event.adversarialAcceptAnalysis
@@ -49860,6 +49944,7 @@ function createRuntime(config2, workdir, opts) {
   const logger = getLogger();
   const quarantineMemo = createQuarantineMemo();
   const adversarialIterations = new Map;
+  const semanticIterations = new Map;
   const rectificationOscillations = new Map;
   let closed = false;
   return {
@@ -49883,6 +49968,7 @@ function createRuntime(config2, workdir, opts) {
     logger,
     quarantineMemo,
     adversarialIterations,
+    semanticIterations,
     rectificationOscillations,
     get signal() {
       return controller.signal;
@@ -57571,10 +57657,13 @@ ${stderr}` };
 
 // src/context/engine/effectiveness.ts
 function tokenize2(text) {
-  if (!text)
-    return new Set;
-  const raw = text.toLowerCase().split(/[\s_\-./:,;()\[\]{}'"!?]+/).filter((t) => t.length >= MIN_TOKEN_LEN2 && !STOPWORDS2.has(t));
-  return new Set(raw);
+  const terms = new Set;
+  for (const match of text.matchAll(TOKEN_PATTERN)) {
+    const term = match[0].toLowerCase();
+    if (term.length >= MIN_TOKEN_LEN2 && !STOPWORDS2.has(term))
+      terms.add(term);
+  }
+  return terms;
 }
 function sharedTermCount2(a, b) {
   let count = 0;
@@ -57584,34 +57673,35 @@ function sharedTermCount2(a, b) {
   }
   return count;
 }
-function classifyEffectiveness(chunkSummary, agentOutput, diffText, findingMessages) {
-  const summaryTerms = tokenize2(chunkSummary);
-  if (summaryTerms.size < MIN_SIGNIFICANT_TERMS) {
-    return { signal: "unknown" };
+function buildEvidenceTerms(agentOutput, diffText, findingMessages) {
+  const diffTerms = diffText ? _effectivenessDeps.tokenize(diffText) : undefined;
+  const outputTerms = agentOutput ? _effectivenessDeps.tokenize(agentOutput) : undefined;
+  let combined;
+  if (diffTerms || outputTerms) {
+    combined = new Set(diffTerms);
+    for (const term of outputTerms ?? [])
+      combined.add(term);
   }
-  for (const finding of findingMessages) {
-    const findingTerms = tokenize2(finding);
-    if (sharedTermCount2(summaryTerms, findingTerms) >= MIN_SIGNIFICANT_TERMS) {
-      return {
-        signal: "contradicted",
-        evidence: finding.slice(0, 200)
-      };
+  return {
+    findings: findingMessages.map((message) => ({ message, terms: _effectivenessDeps.tokenize(message) })),
+    diff: diffTerms,
+    combined
+  };
+}
+function classifyWithTerms(chunkSummary, evidence) {
+  const summaryTerms = _effectivenessDeps.tokenize(chunkSummary);
+  if (summaryTerms.size < MIN_SIGNIFICANT_TERMS)
+    return { signal: "unknown" };
+  for (const finding of evidence.findings) {
+    if (sharedTermCount2(summaryTerms, finding.terms) >= MIN_SIGNIFICANT_TERMS) {
+      return { signal: "contradicted", evidence: finding.message.slice(0, 200) };
     }
   }
-  if (diffText) {
-    const diffTerms = tokenize2(diffText);
-    if (sharedTermCount2(summaryTerms, diffTerms) >= MIN_SIGNIFICANT_TERMS) {
-      return {
-        signal: "followed",
-        evidence: "terms found in diff"
-      };
-    }
+  if (evidence.diff && sharedTermCount2(summaryTerms, evidence.diff) >= MIN_SIGNIFICANT_TERMS) {
+    return { signal: "followed", evidence: "terms found in diff" };
   }
-  if (diffText || agentOutput) {
-    const combinedTerms = tokenize2(`${diffText} ${agentOutput}`);
-    if (sharedTermCount2(summaryTerms, combinedTerms) < MIN_SIGNIFICANT_TERMS) {
-      return { signal: "ignored" };
-    }
+  if (evidence.combined && sharedTermCount2(summaryTerms, evidence.combined) < MIN_SIGNIFICANT_TERMS) {
+    return { signal: "ignored" };
   }
   return { signal: "unknown" };
 }
@@ -57621,16 +57711,18 @@ async function annotateManifestEffectiveness(projectDir, featureId, storyId, {
   findingMessages
 }) {
   const stored = await loadContextManifests(projectDir, storyId, featureId);
+  let evidenceTerms;
   for (const item of stored) {
     const { manifest } = item;
     if (!manifest.chunkSummaries || manifest.includedChunks.length === 0)
       continue;
+    evidenceTerms ??= buildEvidenceTerms(agentOutput, diffText, findingMessages);
     const effectiveness = {};
     for (const id of manifest.includedChunks) {
       const summary = manifest.chunkSummaries[id];
       if (!summary)
         continue;
-      effectiveness[id] = classifyEffectiveness(summary, agentOutput, diffText, findingMessages);
+      effectiveness[id] = classifyWithTerms(summary, evidenceTerms);
     }
     if (Object.keys(effectiveness).length === 0)
       continue;
@@ -57648,12 +57740,13 @@ async function annotateManifestEffectiveness(projectDir, featureId, storyId, {
     }
   }
 }
-var _effectivenessDeps, MIN_SIGNIFICANT_TERMS = 3, STOPWORDS2, MIN_TOKEN_LEN2 = 4;
+var _effectivenessDeps, MIN_SIGNIFICANT_TERMS = 3, STOPWORDS2, MIN_TOKEN_LEN2 = 4, TOKEN_PATTERN;
 var init_effectiveness = __esm(() => {
   init_logger2();
   init_manifest_store();
   _effectivenessDeps = {
-    getLogger
+    getLogger,
+    tokenize: tokenize2
   };
   STOPWORDS2 = new Set([
     "the",
@@ -57695,6 +57788,7 @@ var init_effectiveness = __esm(() => {
     "you",
     "your"
   ]);
+  TOKEN_PATTERN = /[^\s_\-./:,;()\[\]{}'"!?]+/g;
 });
 
 // src/execution/progress.ts
@@ -57711,19 +57805,61 @@ async function appendProgress(featureDir, storyId, status, message) {
 var init_progress = () => {};
 
 // src/pipeline/stages/completion.ts
+function logHighMemoryCheckpoint(logger, ctx) {
+  const usage = process.memoryUsage();
+  if (usage.heapUsed < HIGH_MEMORY_TELEMETRY_BYTES && usage.rss < HIGH_MEMORY_TELEMETRY_BYTES)
+    return;
+  logger.debug("completion.memory", "High memory at completion boundary", {
+    storyId: ctx.story.id,
+    heapUsedBytes: usage.heapUsed,
+    rssBytes: usage.rss,
+    externalBytes: usage.external,
+    arrayBuffersBytes: usage.arrayBuffers,
+    agentOutputChars: ctx.agentResult?.output.length ?? 0
+  });
+}
+async function readTextStreamPrefix(stream, maxChars) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let output = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (output.length >= maxChars)
+        continue;
+      const decoded = decoder.decode(value, { stream: true });
+      output += decoded.slice(0, maxChars - output.length);
+    }
+    if (output.length < maxChars) {
+      output += decoder.decode().slice(0, maxChars - output.length);
+    }
+    return output;
+  } finally {
+    reader.releaseLock();
+  }
+}
 async function getDiffText(workdir, baseRef) {
   if (!baseRef)
     return "";
   try {
-    const proc = Bun.spawn(["git", "diff", `${baseRef}..HEAD`], { cwd: workdir, stdout: "pipe", stderr: "pipe" });
-    const output = await new Response(proc.stdout).text();
-    await proc.exited;
-    return output.slice(0, 8000);
+    const proc = _completionDeps.spawn(["git", "diff", `${baseRef}..HEAD`], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [output] = await Promise.all([
+      readTextStreamPrefix(proc.stdout, MAX_EFFECTIVENESS_DIFF_CHARS),
+      readTextStreamPrefix(proc.stderr, 0),
+      proc.exited
+    ]);
+    return output;
   } catch {
     return "";
   }
 }
-var completionStage, _completionDeps;
+var MAX_EFFECTIVENESS_DIFF_CHARS = 8000, HIGH_MEMORY_TELEMETRY_BYTES, completionStage, _completionDeps;
 var init_completion = __esm(() => {
   init_semantic_verdict();
   init_effectiveness();
@@ -57733,6 +57869,7 @@ var init_completion = __esm(() => {
   init_metrics();
   init_prd();
   init_event_bus();
+  HIGH_MEMORY_TELEMETRY_BYTES = 512 * 1024 * 1024;
   completionStage = {
     name: "completion",
     enabled: () => true,
@@ -57802,6 +57939,7 @@ var init_completion = __esm(() => {
       if (persistPrd) {
         await _completionDeps.savePRD(ctx.prd, prdPath);
       }
+      logHighMemoryCheckpoint(logger, ctx);
       const updatedCounts = countStories(ctx.prd);
       logger.info("completion", "Progress update", {
         storyId: ctx.story.id,
@@ -57817,7 +57955,9 @@ var init_completion = __esm(() => {
     checkReviewGate,
     persistSemanticVerdict,
     savePRD,
-    getDiffText
+    getDiffText,
+    readTextStreamPrefix,
+    spawn: Bun.spawn
   };
 });
 
@@ -58520,161 +58660,6 @@ var init_paths3 = __esm(() => {
   init_paths();
 });
 
-// src/execution/non-blocking-fix.ts
-function actionableAdvisoryFindings(findings) {
-  return findings.filter((f) => f.actionRequired !== false);
-}
-function shouldRunNonBlockingFix(cfg, advisoryCount) {
-  return cfg?.enabled === true && advisoryCount > 0;
-}
-function nonBlockingExcludePhases() {
-  return REVIEW_PHASE_KINDS;
-}
-function nonBlockingExtraPhases(cfg) {
-  return (cfg.scope === "both" || cfg.scope === "triage") && cfg.verifierGuard ? ["verifier"] : [];
-}
-function createMeasureSourceDiff(args) {
-  const packageDirRel = packageDirRelative(args.projectDir, args.packageDir);
-  return async (workdir, fromRef) => {
-    const resolved = await _nonBlockingFixDeps.resolveTestFilePatterns(args.config, args.projectDir, packageDirRel);
-    const isTestFile3 = createTestFileClassifier(resolved);
-    const proc = _nonBlockingFixDeps.spawn(["git", "diff", "--numstat", fromRef], {
-      cwd: workdir,
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const stdout = await Bun.readableStreamToText(proc.stdout);
-    const stderr = await Bun.readableStreamToText(proc.stderr);
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-      const detail = stderr.trim() || `exit ${exitCode}`;
-      throw new Error(`[non-blocking-fix] git diff --numstat failed: ${detail}`);
-    }
-    let fileCount = 0;
-    let sourceLineCount = 0;
-    for (const line of stdout.trim().split(`
-`).filter(Boolean)) {
-      const [addedStr, _deletedStr, filePath] = line.split("\t");
-      if (!filePath || isTestFile3(filePath))
-        continue;
-      fileCount += 1;
-      const added = Number.parseInt(addedStr ?? "", 10);
-      if (Number.isFinite(added))
-        sourceLineCount += added;
-    }
-    return { fileCount, sourceLineCount };
-  };
-}
-async function runNonBlockingFix(args, overrides = {}) {
-  const _deps = { ...DEFAULT_DEPS, ...overrides };
-  const logger = getSafeLogger();
-  if (!shouldRunNonBlockingFix(args.cfg, args.advisoryFindings.length)) {
-    return { ran: false, kept: false, restored: false };
-  }
-  const phaseOutputsSnapshot = { ...args.phaseOutputs };
-  const phaseCostsSnapshot = { ...args.phaseCosts };
-  let restoreRef;
-  try {
-    restoreRef = await _deps.captureSnapshotRef(args.workdir, args.storyId);
-  } catch (err) {
-    logger?.warn("non-blocking-fix", "snapshot capture failed \u2014 skipping best-effort pass (no rollback point)", {
-      storyId: args.storyId,
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return { ran: false, kept: false, restored: false };
-  }
-  const maxAttempts = 1 + args.cfg.regressionAttempts;
-  let exhausted = false;
-  try {
-    const result = await args.runRectify(maxAttempts);
-    exhausted = result.rectificationExhausted === true;
-  } catch (err) {
-    logger?.warn("non-blocking-fix", "best-effort pass threw \u2014 restoring", {
-      storyId: args.storyId,
-      error: err instanceof Error ? err.message : String(err)
-    });
-    exhausted = true;
-  }
-  if (!exhausted) {
-    const gateVerdict = args.keptTreeRegressed?.();
-    if (gateVerdict?.regressed) {
-      logGateRegression(logger, args.storyId, "kept tree regressed the full-suite gate \u2014 restoring (ADR-024 \xA73)", gateVerdict);
-      return restoreToSnapshot(args, _deps, restoreRef, phaseOutputsSnapshot, phaseCostsSnapshot, logger);
-    }
-    const cap = args.cfg.sourceDiffCap;
-    if (cap) {
-      let metrics;
-      try {
-        metrics = await _deps.measureSourceDiff(args.workdir, restoreRef);
-      } catch (err) {
-        logger?.warn("non-blocking-fix", "source-diff measurement threw \u2014 restoring", {
-          storyId: args.storyId,
-          error: err instanceof Error ? err.message : String(err)
-        });
-        return restoreToSnapshot(args, _deps, restoreRef, phaseOutputsSnapshot, phaseCostsSnapshot, logger);
-      }
-      if (metrics.fileCount > cap.maxFiles || metrics.sourceLineCount > cap.maxLines) {
-        logger?.info("non-blocking-fix", "source diff exceeded cap \u2014 restoring", {
-          storyId: args.storyId,
-          fileCount: metrics.fileCount,
-          sourceLineCount: metrics.sourceLineCount,
-          cap
-        });
-        return restoreToSnapshot(args, _deps, restoreRef, phaseOutputsSnapshot, phaseCostsSnapshot, logger);
-      }
-    }
-    logger?.info("non-blocking-fix", "best-effort fix kept", { storyId: args.storyId });
-    return { ran: true, kept: true, restored: false };
-  }
-  const exhaustedGateVerdict = args.keptTreeRegressed?.();
-  if (exhaustedGateVerdict?.regressed) {
-    logGateRegression(logger, args.storyId, "best-effort fix exhausted with the full-suite gate red", exhaustedGateVerdict);
-  }
-  return restoreToSnapshot(args, _deps, restoreRef, phaseOutputsSnapshot, phaseCostsSnapshot, logger);
-}
-function logGateRegression(logger, storyId, message, verdict) {
-  logger?.info("non-blocking-fix", message, {
-    storyId,
-    regressedKeys: verdict.regressedKeys.slice(0, MAX_LOGGED_REGRESSED_KEYS),
-    regressedKeyCount: verdict.regressedKeys.length,
-    baselineKeySize: verdict.baselineKeySize,
-    keyless: verdict.keyless,
-    memoExcludedKeyCount: verdict.memoExcludedKeys.length,
-    flakeTriageRan: false
-  });
-}
-async function restoreToSnapshot(args, _deps, restoreRef, phaseOutputsSnapshot, phaseCostsSnapshot, logger) {
-  await _deps.rollbackToRef(args.workdir, restoreRef);
-  for (const key of Object.keys(args.phaseOutputs))
-    delete args.phaseOutputs[key];
-  Object.assign(args.phaseOutputs, phaseOutputsSnapshot);
-  for (const key of Object.keys(args.phaseCosts))
-    delete args.phaseCosts[key];
-  Object.assign(args.phaseCosts, phaseCostsSnapshot);
-  logger?.info("non-blocking-fix", "best-effort fix exhausted \u2014 restored to adversarial-passed", {
-    storyId: args.storyId
-  });
-  return { ran: true, kept: false, restored: true };
-}
-var REVIEW_PHASE_KINDS, MAX_LOGGED_REGRESSED_KEYS = 10, _nonBlockingFixDeps, DEFAULT_DEPS;
-var init_non_blocking_fix = __esm(() => {
-  init_logger2();
-  init_rollback();
-  init_test_runners();
-  init_bun_deps();
-  init_paths3();
-  REVIEW_PHASE_KINDS = ["semantic-review", "adversarial-review"];
-  _nonBlockingFixDeps = {
-    spawn: typedSpawn,
-    resolveTestFilePatterns
-  };
-  DEFAULT_DEPS = {
-    captureSnapshotRef,
-    rollbackToRef,
-    measureSourceDiff: async () => ({ fileCount: 0, sourceLineCount: 0 })
-  };
-});
-
 // src/execution/story-orchestrator/types.ts
 var EXHAUSTED_EXIT_REASONS, TDD_OP_NAMES, CANONICAL_ORDER, PHASE_KIND_TO_STATE_KEY, STRATEGY_TO_REVALIDATION_PHASES, STRICT_VERDICT_PHASE_NAMES;
 var init_types9 = __esm(() => {
@@ -58805,7 +58790,8 @@ function gateFindingKey(finding) {
 function isQuarantinedFlake(finding, quarantineMemo) {
   if (finding.source !== "test-runner")
     return false;
-  return quarantineMemo?.has(gateFindingKey(finding)) === true;
+  const key = gateFindingKey(finding);
+  return key !== KEYLESS_GATE_FAILURE_KEY && quarantineMemo?.has(key) === true;
 }
 function describeGateRegression(input) {
   const { gateOutput, baselineKeys, gateName, storyId, quarantineMemo } = input;
@@ -58856,6 +58842,245 @@ var init_phase_eval = __esm(() => {
   init_types9();
 });
 
+// src/execution/story-orchestrator/nbf-flake-triage.ts
+function isCandidate(input) {
+  if (input.finding.source !== "test-runner" || input.finding.category !== "failed-test")
+    return false;
+  const key = gateFindingKey(input.finding);
+  return !input.transactionInput.baselineKeys.has(key) && !input.memo.has(key) && !input.attemptedKeys.has(key);
+}
+function createNbfFlakeTriageTransaction(input) {
+  const pendingKeys = new Set;
+  const attemptedKeys = new Set;
+  let flakeTriageRan = false;
+  const memo2 = {
+    has: (key) => pendingKeys.has(key) || input.baseMemo?.has(key) === true,
+    add: (key) => pendingKeys.add(key)
+  };
+  return {
+    memo: memo2,
+    get flakeTriageRan() {
+      return flakeTriageRan;
+    },
+    candidates: (findings) => findings.filter((finding) => isCandidate({ finding, transactionInput: input, memo: memo2, attemptedKeys })),
+    recordAttempt: (findings, ran) => {
+      if (!ran)
+        return;
+      flakeTriageRan = true;
+      for (const finding of findings)
+        attemptedKeys.add(gateFindingKey(finding));
+    },
+    commit: () => {
+      for (const key of pendingKeys)
+        input.baseMemo?.add(key);
+    }
+  };
+}
+async function triageNbfGate(input) {
+  const candidates = input.transaction.candidates(extractPhaseFindings(input.output));
+  if (candidates.length === 0)
+    return;
+  const record2 = input.output;
+  const rawOutput = typeof record2.rawOutput === "string" ? record2.rawOutput : "";
+  try {
+    const [, report] = await input.triage(candidates, {
+      ctx: input.ctx,
+      rawOutput,
+      quarantineMemo: input.transaction.memo
+    });
+    const ran = report.flakeTriageRan ?? true;
+    if (ran) {
+      for (const key of report.quarantinedKeys)
+        input.transaction.memo.add(key);
+    }
+    input.transaction.recordAttempt(candidates, ran);
+  } catch (err) {
+    getSafeLogger()?.warn("story-orchestrator", "NBF flake triage threw \u2014 keeping findings blocking", {
+      storyId: input.ctx.storyId,
+      gateName: input.gateName,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+var init_nbf_flake_triage = __esm(() => {
+  init_logger2();
+  init_phase_eval();
+});
+
+// src/execution/non-blocking-fix.ts
+function actionableAdvisoryFindings(findings) {
+  return findings.filter((f) => f.actionRequired !== false);
+}
+function shouldRunNonBlockingFix(cfg, advisoryCount) {
+  return cfg?.enabled === true && advisoryCount > 0;
+}
+function nonBlockingExcludePhases() {
+  return REVIEW_PHASE_KINDS;
+}
+function nonBlockingExtraPhases(cfg) {
+  return (cfg.scope === "both" || cfg.scope === "triage") && cfg.verifierGuard ? ["verifier"] : [];
+}
+function createMeasureSourceDiff(args) {
+  const packageDirRel = packageDirRelative(args.projectDir, args.packageDir);
+  return async (workdir, fromRef) => {
+    const resolved = await _nonBlockingFixDeps.resolveTestFilePatterns(args.config, args.projectDir, packageDirRel);
+    const isTestFile3 = createTestFileClassifier(resolved);
+    const proc = _nonBlockingFixDeps.spawn(["git", "diff", "--numstat", fromRef], {
+      cwd: workdir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const stdout = await Bun.readableStreamToText(proc.stdout);
+    const stderr = await Bun.readableStreamToText(proc.stderr);
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      const detail = stderr.trim() || `exit ${exitCode}`;
+      throw new Error(`[non-blocking-fix] git diff --numstat failed: ${detail}`);
+    }
+    let fileCount = 0;
+    let sourceLineCount = 0;
+    for (const line of stdout.trim().split(`
+`).filter(Boolean)) {
+      const [addedStr, _deletedStr, filePath] = line.split("\t");
+      if (!filePath || isTestFile3(filePath))
+        continue;
+      fileCount += 1;
+      const added = Number.parseInt(addedStr ?? "", 10);
+      if (Number.isFinite(added))
+        sourceLineCount += added;
+    }
+    return { fileCount, sourceLineCount };
+  };
+}
+async function runNonBlockingFix(args, overrides = {}) {
+  const _deps = { ...DEFAULT_DEPS, ...overrides };
+  const logger = getSafeLogger();
+  if (!shouldRunNonBlockingFix(args.cfg, args.advisoryFindings.length)) {
+    return { ran: false, kept: false, restored: false };
+  }
+  const phaseOutputsSnapshot = { ...args.phaseOutputs };
+  const phaseCostsSnapshot = { ...args.phaseCosts };
+  let restoreRef;
+  try {
+    restoreRef = await _deps.captureSnapshotRef(args.workdir, args.storyId);
+  } catch (err) {
+    logger?.warn("non-blocking-fix", "snapshot capture failed \u2014 skipping best-effort pass (no rollback point)", {
+      storyId: args.storyId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return { ran: false, kept: false, restored: false };
+  }
+  const maxAttempts = 1 + args.cfg.regressionAttempts;
+  const flakeTriage = createNbfFlakeTriageTransaction({
+    baseMemo: args.quarantineMemo,
+    baselineKeys: args.gateBaselineKeys ?? new Set
+  });
+  let exhausted = false;
+  try {
+    const result = await args.runRectify(maxAttempts, flakeTriage);
+    exhausted = result.rectificationExhausted === true;
+  } catch (err) {
+    logger?.warn("non-blocking-fix", "best-effort pass threw \u2014 restoring", {
+      storyId: args.storyId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    exhausted = true;
+  }
+  if (!exhausted) {
+    const gateVerdict = args.keptTreeRegressed?.(flakeTriage.memo);
+    if (gateVerdict?.regressed) {
+      logGateRegression({
+        logger,
+        storyId: args.storyId,
+        message: "kept tree regressed the full-suite gate \u2014 restoring (ADR-024 \xA73)",
+        verdict: gateVerdict,
+        flakeTriageRan: flakeTriage.flakeTriageRan
+      });
+      return restoreToSnapshot(args, _deps, restoreRef, phaseOutputsSnapshot, phaseCostsSnapshot, logger);
+    }
+    const cap = args.cfg.sourceDiffCap;
+    if (cap) {
+      let metrics;
+      try {
+        metrics = await _deps.measureSourceDiff(args.workdir, restoreRef);
+      } catch (err) {
+        logger?.warn("non-blocking-fix", "source-diff measurement threw \u2014 restoring", {
+          storyId: args.storyId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        return restoreToSnapshot(args, _deps, restoreRef, phaseOutputsSnapshot, phaseCostsSnapshot, logger);
+      }
+      if (metrics.fileCount > cap.maxFiles || metrics.sourceLineCount > cap.maxLines) {
+        logger?.info("non-blocking-fix", "source diff exceeded cap \u2014 restoring", {
+          storyId: args.storyId,
+          fileCount: metrics.fileCount,
+          sourceLineCount: metrics.sourceLineCount,
+          cap
+        });
+        return restoreToSnapshot(args, _deps, restoreRef, phaseOutputsSnapshot, phaseCostsSnapshot, logger);
+      }
+    }
+    flakeTriage.commit();
+    logger?.info("non-blocking-fix", "best-effort fix kept", { storyId: args.storyId });
+    return { ran: true, kept: true, restored: false };
+  }
+  const exhaustedGateVerdict = args.keptTreeRegressed?.(flakeTriage.memo);
+  if (exhaustedGateVerdict?.regressed) {
+    logGateRegression({
+      logger,
+      storyId: args.storyId,
+      message: "best-effort fix exhausted with the full-suite gate red",
+      verdict: exhaustedGateVerdict,
+      flakeTriageRan: flakeTriage.flakeTriageRan
+    });
+  }
+  return restoreToSnapshot(args, _deps, restoreRef, phaseOutputsSnapshot, phaseCostsSnapshot, logger);
+}
+function logGateRegression(input) {
+  const { logger, storyId, message, verdict, flakeTriageRan } = input;
+  logger?.info("non-blocking-fix", message, {
+    storyId,
+    regressedKeys: verdict.regressedKeys.slice(0, MAX_LOGGED_REGRESSED_KEYS),
+    regressedKeyCount: verdict.regressedKeys.length,
+    baselineKeySize: verdict.baselineKeySize,
+    keyless: verdict.keyless,
+    memoExcludedKeyCount: verdict.memoExcludedKeys.length,
+    flakeTriageRan
+  });
+}
+async function restoreToSnapshot(args, _deps, restoreRef, phaseOutputsSnapshot, phaseCostsSnapshot, logger) {
+  await _deps.rollbackToRef(args.workdir, restoreRef);
+  for (const key of Object.keys(args.phaseOutputs))
+    delete args.phaseOutputs[key];
+  Object.assign(args.phaseOutputs, phaseOutputsSnapshot);
+  for (const key of Object.keys(args.phaseCosts))
+    delete args.phaseCosts[key];
+  Object.assign(args.phaseCosts, phaseCostsSnapshot);
+  logger?.info("non-blocking-fix", "best-effort fix exhausted \u2014 restored to adversarial-passed", {
+    storyId: args.storyId
+  });
+  return { ran: true, kept: false, restored: true };
+}
+var REVIEW_PHASE_KINDS, MAX_LOGGED_REGRESSED_KEYS = 10, _nonBlockingFixDeps, DEFAULT_DEPS;
+var init_non_blocking_fix = __esm(() => {
+  init_logger2();
+  init_rollback();
+  init_test_runners();
+  init_bun_deps();
+  init_paths3();
+  init_nbf_flake_triage();
+  REVIEW_PHASE_KINDS = ["semantic-review", "adversarial-review"];
+  _nonBlockingFixDeps = {
+    spawn: typedSpawn,
+    resolveTestFilePatterns
+  };
+  DEFAULT_DEPS = {
+    captureSnapshotRef,
+    rollbackToRef,
+    measureSourceDiff: async () => ({ fileCount: 0, sourceLineCount: 0 })
+  };
+});
+
 // src/execution/story-orchestrator/phase-state.ts
 function isSlot(value) {
   return value !== null && typeof value === "object" && "op" in value && "input" in value && typeof value.op?.kind === "string";
@@ -59049,15 +59274,15 @@ var init_verification = __esm(() => {
 });
 
 // src/execution/story-orchestrator/flake-triage-seam.ts
-var productionTriageSeam = async (gateFindings, { ctx, rawOutput }) => {
+var productionTriageSeam = async (gateFindings, { ctx, rawOutput, quarantineMemo }) => {
   const config2 = ctx.packageView.config;
   const flakeDetection = config2.execution?.flakeDetection;
   if (!flakeDetection?.enabled) {
-    return [gateFindings, { quarantinedKeys: [] }];
+    return [gateFindings, { quarantinedKeys: [], flakeTriageRan: false }];
   }
   const framework = detectFramework(rawOutput);
   if (framework === "unknown") {
-    return [gateFindings, { quarantinedKeys: [] }];
+    return [gateFindings, { quarantinedKeys: [], flakeTriageRan: false }];
   }
   const workdir = ctx.runtime.workdir;
   const storyWorkdir = ctx.story?.workdir;
@@ -59066,11 +59291,11 @@ var productionTriageSeam = async (gateFindings, { ctx, rawOutput }) => {
     const { testCommand } = await resolveQualityTestCommands2(config2, workdir, storyWorkdir);
     const baseCommand = testCommand ?? config2.quality?.commands?.test;
     if (!baseCommand) {
-      return [gateFindings, { quarantinedKeys: [] }];
+      return [gateFindings, { quarantinedKeys: [], flakeTriageRan: false }];
     }
     const diff = await resolveFlakeBaselineDiff(config2, workdir, storyWorkdir);
     if (diff === null) {
-      return [gateFindings, { quarantinedKeys: [] }];
+      return [gateFindings, { quarantinedKeys: [], flakeTriageRan: false }];
     }
     const result = await triageFlakyFindings({
       findings: gateFindings,
@@ -59079,15 +59304,15 @@ var productionTriageSeam = async (gateFindings, { ctx, rawOutput }) => {
       baseCommand,
       cwd: ctx.packageDir,
       framework,
-      quarantineMemo: ctx.runtime.quarantineMemo
+      quarantineMemo: quarantineMemo ?? ctx.runtime.quarantineMemo
     });
-    return [result.findings, { quarantinedKeys: result.quarantineReport.keys }];
+    return [result.findings, { quarantinedKeys: result.quarantineReport.keys, flakeTriageRan: true }];
   } catch (err) {
     getSafeLogger()?.warn("story-orchestrator", "Flake triage seam failed resolving context \u2014 keeping findings blocking (no quarantine)", {
       storyId: ctx.storyId,
       error: errorMessage(err)
     });
-    return [gateFindings, { quarantinedKeys: [] }];
+    return [gateFindings, { quarantinedKeys: [], flakeTriageRan: false }];
   }
 };
 var init_flake_triage_seam = __esm(() => {
@@ -59104,11 +59329,12 @@ function toReviewDecisionPayload(opName, output) {
   const reviewer = opName === "semantic-review" ? "semantic" : opName === "adversarial-review" ? "adversarial" : null;
   if (!reviewer)
     return null;
+  const unparsedPreview = typeof record2.unparsedPreview === "string" ? record2.unparsedPreview : undefined;
   if (record2.failOpen === true) {
-    return { reviewer, parsed: false, passed: true, failOpen: true, result: null };
+    return { reviewer, parsed: false, passed: true, failOpen: true, result: null, unparsedPreview };
   }
   if (record2.looksLikeFail === true) {
-    return { reviewer, parsed: false, passed: false, looksLikeFail: true, result: null };
+    return { reviewer, parsed: false, passed: false, looksLikeFail: true, result: null, unparsedPreview };
   }
   if (typeof record2.passed !== "boolean" || !Array.isArray(record2.findings)) {
     return null;
@@ -59130,7 +59356,8 @@ function toReviewDecisionPayload(opName, output) {
     parsed: true,
     passed: record2.passed,
     result: { passed: record2.passed, findings: record2.findings },
-    acDropped
+    acDropped,
+    ...Array.isArray(record2.advisoryFindings) ? { advisoryFindings: record2.advisoryFindings } : {}
   };
 }
 function emitReviewDecision(ctx, opName, output) {
@@ -59151,7 +59378,10 @@ function emitReviewDecision(ctx, opName, output) {
     looksLikeFail: payload.parsed ? undefined : payload.looksLikeFail,
     failOpen: payload.parsed ? false : payload.failOpen,
     passed: payload.passed,
-    result: payload.result
+    result: payload.result,
+    advisoryFindings: payload.parsed ? payload.advisoryFindings : undefined,
+    acDropped: payload.parsed ? payload.acDropped : undefined,
+    unparsedPreview: payload.parsed ? undefined : payload.unparsedPreview
   });
 }
 function logUnifiedReviewPhaseStart(storyId, opName) {
@@ -59288,13 +59518,19 @@ async function runPhase(ctx, slot, phaseCosts, phaseOutputs, isThreeSession = fa
   dispatchInput = await refreshReviewInputForDispatch(opName, dispatchInput);
   let advIterationBefore = 0;
   if (opName === "adversarial-review" && ctx.storyId) {
-    const priorIterations = getAdversarialIterations(ctx.runtime.adversarialIterations, ctx.storyId);
+    const priorIterations = getReviewIterations(ctx.runtime.adversarialIterations, ctx.storyId);
     advIterationBefore = priorIterations.length;
     dispatchInput = {
       ...dispatchInput,
       priorAdversarialIterations: priorIterations
     };
   }
+  if (opName === "semantic-review" && ctx.storyId) {
+    dispatchInput = {
+      ...dispatchInput,
+      priorSemanticIterations: getReviewIterations(ctx.runtime.semanticIterations, ctx.storyId)
+    };
+  }
   if (isTddPhase) {
     logger?.info("tdd", `-> Session: ${opName}`, { storyId: ctx.storyId, role: opName, ...progressData });
   } else if (isThreeSession && opName === "full-suite-gate") {
@@ -59316,11 +59552,18 @@ async function runPhase(ctx, slot, phaseCosts, phaseOutputs, isThreeSession = fa
     emitReviewDecision(ctx, opName, output);
     if (opName === "adversarial-review" && ctx.storyId) {
       const advOut = output;
-      recordAdversarialIteration(ctx.runtime.adversarialIterations, ctx.storyId, [
+      recordReviewIteration(ctx.runtime.adversarialIterations, ctx.storyId, [
         ...advOut.normalizedFindings ?? [],
         ...advOut.advisoryFindings ?? []
       ]);
     }
+    if (opName === "semantic-review" && ctx.storyId) {
+      const semOut = output;
+      recordReviewIteration(ctx.runtime.semanticIterations, ctx.storyId, [
+        ...semOut.normalizedFindings ?? [],
+        ...semOut.advisoryFindings ?? []
+      ]);
+    }
     logUnifiedReviewPhaseResult(ctx.storyId, opName, output);
     logDeterministicPhaseOutcome(ctx.storyId, opName, output, Date.now() - phaseStartedAt, isTddPhase, slot.op.stage, progressData);
     outcome = derivePhaseOutcome(output);
@@ -59590,6 +59833,9 @@ function collectRectificationPhases(state) {
     state.adversarialReview
   ].filter((phase) => phase !== undefined);
 }
+function isQuarantinedOnlyGateFailure(phase, rawFindings, blockingFindings) {
+  return phase.kind === "full-suite-gate" && rawFindings.length > 0 && blockingFindings.length === 0;
+}
 async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides) {
   const rectification2 = state.rectification;
   const baseValidationPhases = collectRectificationPhases(state);
@@ -59656,9 +59902,21 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
         if (shouldSkipPhaseForRectification({ phase, state, phaseOutputs, nbfPath }))
           continue;
         const output = phaseOutputs[phase.slot.op.name];
+        const nbfFlakeTriage = overrides?.nbfFlakeTriage;
+        if (nbfPath && phase.kind === "full-suite-gate" && nbfFlakeTriage) {
+          await triageNbfGate({
+            output,
+            gateName: phase.slot.op.name,
+            ctx,
+            transaction: nbfFlakeTriage,
+            triage: _storyOrchestratorDeps.triage
+          });
+        }
         const phaseFindings = extractPhaseFindings(output);
-        findings.push(...nbfPath ? phaseFindings.filter((f) => !isQuarantinedFlake(f, ctx.runtime.quarantineMemo)) : phaseFindings);
-        if (!phasePassed(phase.slot.op.name, output, ctx.storyId)) {
+        const blockingFindings = nbfPath ? phaseFindings.filter((finding) => !isQuarantinedFlake(finding, nbfFlakeTriage?.memo ?? ctx.runtime.quarantineMemo)) : phaseFindings;
+        findings.push(...blockingFindings);
+        const quarantinedOnly = nbfPath && isQuarantinedOnlyGateFailure(phase, phaseFindings, blockingFindings);
+        if (!phasePassed(phase.slot.op.name, output, ctx.storyId) && !quarantinedOnly) {
           getSafeLogger()?.warn("story-orchestrator", "Short-circuiting revalidation on phase failure", {
             storyId: ctx.storyId,
             phase: phase.slot.op.name
@@ -59716,6 +59974,7 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
 }
 var init_rectification = __esm(() => {
   init_logger2();
+  init_nbf_flake_triage();
   init_phase_eval();
   init_phase_eval();
   init_run_phase();
@@ -59732,13 +59991,13 @@ class ExecutionPlan {
     this.state = state;
     this.isThreeSession = isThreeSession;
   }
-  describeGateRegressionNow(phaseOutputs, gateName, baselineKeys) {
+  describeGateRegressionNow(phaseOutputs, gateName, options) {
     return describeGateRegression({
       gateOutput: gateName === undefined ? undefined : phaseOutputs[gateName],
-      baselineKeys,
+      baselineKeys: options.baselineKeys,
       gateName,
       storyId: this.ctx.storyId,
-      quarantineMemo: this.ctx.runtime.quarantineMemo
+      quarantineMemo: options.quarantineMemo ?? this.ctx.runtime.quarantineMemo
     });
   }
   phaseNames() {
@@ -59886,15 +60145,21 @@ class ExecutionPlan {
         cfg: advCfg,
         phaseOutputs,
         phaseCosts,
-        runRectify: (maxAttempts) => runRectification(this.ctx, this.state, phaseCosts, phaseOutputs, {
+        quarantineMemo: this.ctx.runtime.quarantineMemo,
+        gateBaselineKeys: preRectGateFailureKeys,
+        runRectify: (maxAttempts, nbfFlakeTriage) => runRectification(this.ctx, this.state, phaseCosts, phaseOutputs, {
           initialFindings: advisoryFindings,
+          nbfFlakeTriage,
           strategies: this.state.nonBlockingFixStrategies ?? [],
           excludePhaseKinds: nonBlockingExcludePhases(),
           extraRevalidationKinds: nonBlockingExtraPhases(advCfg),
           maxAttempts,
           postValidate: this.state.nonBlockingFixPostValidate
         }),
-        keptTreeRegressed: () => this.describeGateRegressionNow(phaseOutputs, gateName, preRectGateFailureKeys)
+        keptTreeRegressed: (quarantineMemo) => this.describeGateRegressionNow(phaseOutputs, gateName, {
+          baselineKeys: preRectGateFailureKeys,
+          quarantineMemo
+        })
       }, {
         measureSourceDiff: createMeasureSourceDiff({
           config: this.ctx.runtime.configLoader.current(),
@@ -59905,7 +60170,9 @@ class ExecutionPlan {
     }
     const verifierName = this.state.verifier?.slot.op.name;
     const verifierExplicitlyPassed = verifierName !== undefined && phaseExplicitlyPassed(phaseOutputs[verifierName]);
-    const gateRegressedDuringRect = this.describeGateRegressionNow(phaseOutputs, gateName, preRectGateFailureKeys).regressed;
+    const gateRegressedDuringRect = this.describeGateRegressionNow(phaseOutputs, gateName, {
+      baselineKeys: preRectGateFailureKeys
+    }).regressed;
     const verifierPassedSsot = verifierExplicitlyPassed && !gateRegressedDuringRect;
     if (verifierExplicitlyPassed && gateRegressedDuringRect) {
       logger?.warn("story-orchestrator", "Gate regressed during rectification after verifier passed \u2014 verifier verdict is stale, failing story", { storyId: this.ctx.storyId, packageDir: this.ctx.packageDir });
@@ -60056,7 +60323,9 @@ var init_story_orchestrator = __esm(() => {
   init_execution_plan();
   init_phase_eval();
   init_rectification();
+  init_nbf_flake_triage();
   init_run_phase();
+  init_review_decision();
   init_types9();
 });
 
@@ -60406,7 +60675,6 @@ async function assemblePlanInputsFromCtx(ctx) {
       diff: prepared.diff,
       excludePatterns: prepared.excludePatterns,
       featureCtxBlock: buildFeatureCtxBlock(ctx, "reviewer-semantic"),
-      priorSemanticIterations: ctx.priorSemanticIterations,
       resolvedTestPatterns,
       blockingThreshold: ctx.config.review.blockingThreshold,
       _refresh: {
@@ -60444,7 +60712,6 @@ async function assemblePlanInputsFromCtx(ctx) {
       testGlobs: prepared.testGlobs,
       refExcludePatterns: prepared.refExcludePatterns,
       featureCtxBlock: buildFeatureCtxBlock(ctx, "reviewer-adversarial"),
-      priorAdversarialIterations: ctx.priorAdversarialIterations,
       resolvedTestPatterns,
       blockingThreshold: ctx.config.review.blockingThreshold,
       _refresh: {
@@ -61946,7 +62213,7 @@ async function fanOutReporters(reporters, hook, invoke) {
     }
   }
 }
-function wireReporters(bus, pluginRegistry, runId, startTime) {
+function wireReporters(bus, pluginRegistry, runId, startTime, projectKey) {
   const logger = getSafeLogger();
   const safe = (name, fn) => {
     return fn().catch((err) => logger?.warn("reporters-subscriber", `Reporter "${name}" error`, { error: String(err) })).catch(() => {});
@@ -61996,7 +62263,8 @@ function wireReporters(bus, pluginRegistry, runId, startTime) {
               runId,
               feature: ev.feature,
               totalStories: ev.totalStories,
-              startTime: new Date(startTime).toISOString()
+              startTime: new Date(startTime).toISOString(),
+              project: projectKey
             });
           } catch (err) {
             logger?.warn("plugins", `Reporter '${r.name}' onRunStart failed`, { error: err });
@@ -64843,6 +65111,7 @@ function getFinishAutoFlowConfig(ctx) {
       quality: autoFlow.reviewers?.quality ?? null
     },
     escalate: { telegram: autoFlow.escalate?.telegram !== false },
+    notify: { mode: autoFlow.notify?.mode ?? defaults.notify.mode },
     timeouts: {
       acceptanceMs: autoFlow.timeouts?.acceptanceMs ?? defaults.timeouts.acceptanceMs,
       gateMs: autoFlow.timeouts?.gateMs ?? defaults.timeouts.gateMs,
@@ -64867,11 +65136,38 @@ var init_config2 = __esm(() => {
     defaultAgent: null,
     reviewers: { spec: null, quality: null },
     escalate: { telegram: true },
+    notify: { mode: "escalation" },
     timeouts: { acceptanceMs: 600000, gateMs: 900000, flowMs: 5400000, stepMs: null }
   };
 });
 
+// src/plugins/builtin/nax-finish/output.ts
+function logTail(stream) {
+  if (stream.length <= LOG_TAIL_CHARS)
+    return stream;
+  return `[\u2026${stream.length - LOG_TAIL_CHARS} chars truncated\u2026]
+${stream.slice(-LOG_TAIL_CHARS)}`;
+}
+function stderrTail(stderr) {
+  const trimmed = stderr.trim();
+  if (!trimmed)
+    return "";
+  const tail = trimmed.length > STDERR_TAIL_CHARS ? `\u2026${trimmed.slice(-STDERR_TAIL_CHARS)}` : trimmed;
+  return tail.replace(/\s+/g, " ");
+}
+var STDERR_TAIL_CHARS = 400, LOG_TAIL_CHARS = 20000;
+
 // src/plugins/builtin/nax-finish/telegram.ts
+function buildTerminalMessage(options) {
+  const lines = [`nax-finish ${options.status} ${options.feature}`];
+  if (options.detail)
+    lines.push(options.detail);
+  if (options.url)
+    lines.push(options.url);
+  const message = lines.join(`
+`);
+  return message.length <= TELEGRAM_MAX_MESSAGE_CHARS ? message : `${message.slice(0, TELEGRAM_MAX_MESSAGE_CHARS - 1)}\u2026`;
+}
 function buildEscalationMessage(feature, reason, findings) {
   const head = `nax-finish escalated ${feature}: ${reason}`;
   if (findings.length === 0)
@@ -64908,19 +65204,6 @@ var init_telegram2 = __esm(() => {
 
 // src/plugins/builtin/nax-finish/index.ts
 import * as path21 from "path";
-function logTail(stream) {
-  if (stream.length <= LOG_TAIL_CHARS)
-    return stream;
-  return `[\u2026${stream.length - LOG_TAIL_CHARS} chars truncated\u2026]
-${stream.slice(-LOG_TAIL_CHARS)}`;
-}
-function stderrTail(stderr) {
-  const trimmed = stderr.trim();
-  if (!trimmed)
-    return "";
-  const tail = trimmed.length > STDERR_TAIL_CHARS ? `\u2026${trimmed.slice(-STDERR_TAIL_CHARS)}` : trimmed;
-  return tail.replace(/\s+/g, " ");
-}
 async function defaultRun2(cmd, opts) {
   const proc = Bun.spawn(cmd, { cwd: opts.cwd, env: opts.env, stdout: "pipe", stderr: "pipe" });
   let timedOut = false;
@@ -64951,6 +65234,11 @@ async function defaultReadResult(workdir) {
     return null;
   return JSON.parse(await f.text());
 }
+async function defaultClearResult(workdir) {
+  const file3 = Bun.file(path21.join(workdir, ".nax", "nax-finish-result.json"));
+  if (await file3.exists())
+    await file3.delete();
+}
 function isFeatureBranch(b) {
   return b !== "main" && b !== "master" && b.length > 0;
 }
@@ -64994,13 +65282,133 @@ function buildFlowEnv(cfg) {
     env2.NAX_FINISH_QUALITY_PROFILE = cfg.reviewers.quality;
   return env2;
 }
-var PLUGIN_NAME4 = "nax-finish", PLUGIN_VERSION4 = "0.1.0", PACKAGE_ROOT_SEARCH_DEPTH = 6, STDERR_TAIL_CHARS = 400, LOG_TAIL_CHARS = 20000, _naxFinishDeps, naxFinishAction, naxFinishPlugin;
+function missingResultOutcome(ctx, res, escalateTelegram) {
+  ctx.logger.warn("nax-finish flow produced no result file", {
+    exitCode: res.exitCode,
+    stdout: logTail(res.stdout),
+    stderr: logTail(res.stderr)
+  });
+  const tail = stderrTail(res.stderr);
+  return {
+    actionResult: {
+      success: false,
+      message: `nax-finish flow exited ${res.exitCode} (no result file)${tail ? `: ${tail}` : ""}`
+    },
+    escalateTelegram
+  };
+}
+async function executeFinishFlow(options) {
+  const { ctx, cfg, escalateTelegram } = options;
+  const flowPath = await resolveFlowPath(ctx.workdir, cfg.flowPath);
+  if (!flowPath) {
+    return {
+      actionResult: {
+        success: false,
+        message: `nax-finish: flow module "${cfg.flowPath}" not found in the nax install or ${ctx.workdir}`
+      },
+      escalateTelegram
+    };
+  }
+  await _naxFinishDeps.clearResult(ctx.workdir);
+  const input = {
+    feature: ctx.feature,
+    workdir: ctx.workdir,
+    branch: ctx.branch,
+    prdPath: ctx.prdPath,
+    escalateTelegram,
+    timeouts: { acceptanceMs: cfg.timeouts.acceptanceMs, gateMs: cfg.timeouts.gateMs }
+  };
+  const cmd = buildFlowArgv(flowPath, JSON.stringify(input), cfg.defaultAgent, cfg.timeouts.stepMs);
+  const res = await _naxFinishDeps.run(cmd, {
+    cwd: ctx.workdir,
+    env: buildFlowEnv(cfg),
+    timeoutMs: cfg.timeouts.flowMs
+  });
+  const result = await _naxFinishDeps.readResult(ctx.workdir);
+  if (!result)
+    return missingResultOutcome(ctx, res, escalateTelegram);
+  return {
+    actionResult: { success: true, message: `nax-finish: ${result.status}`, url: result.url },
+    result,
+    escalateTelegram
+  };
+}
+async function settleFinishFlow(options) {
+  const escalateTelegram = options.cfg.notify.mode !== "off" && options.cfg.escalate.telegram && options.creds !== null;
+  try {
+    return await executeFinishFlow({ ...options, escalateTelegram });
+  } catch (error48) {
+    options.ctx.logger.warn("nax-finish execute failed", { error: errorMessage(error48) });
+    return {
+      actionResult: { success: false, message: `nax-finish failed: ${errorMessage(error48)}` },
+      escalateTelegram
+    };
+  }
+}
+async function notifyBestEffort(ctx, creds, message) {
+  if (!creds) {
+    ctx.logger.warn("nax-finish terminal notification skipped: Telegram credentials are unavailable");
+    return;
+  }
+  try {
+    if (!await _naxFinishDeps.notify(creds, message)) {
+      ctx.logger.warn("nax-finish terminal notification was rejected", { feature: ctx.feature });
+    }
+  } catch (error48) {
+    ctx.logger.warn("nax-finish terminal notification failed", { feature: ctx.feature, error: errorMessage(error48) });
+  }
+}
+async function finalizeEscalation(ctx, outcome, creds) {
+  const result = outcome.result;
+  if (!result)
+    return outcome.actionResult;
+  const problems = [];
+  let delivered = !outcome.escalateTelegram && !result.deliveryError;
+  if (outcome.escalateTelegram && creds) {
+    try {
+      delivered = await _naxFinishDeps.notify(creds, buildEscalationMessage(result.feature, result.escalationReason ?? "", result.findings ?? []));
+      if (!delivered)
+        problems.push("Telegram rejected the message");
+    } catch (error48) {
+      problems.push(`Telegram failed: ${errorMessage(error48)}`);
+    }
+  }
+  if (delivered)
+    return outcome.actionResult;
+  if (result.deliveryError)
+    problems.push(`the flow could not post it: ${result.deliveryError}`);
+  if (problems.length === 0)
+    problems.push("no escalation channel was reachable");
+  ctx.logger.warn("nax-finish escalation was not delivered", {
+    feature: result.feature,
+    reasons: problems,
+    escalationReason: result.escalationReason
+  });
+  return {
+    success: false,
+    message: `nax-finish: escalated but undelivered \u2014 ${problems.join("; ")}`,
+    url: result.url
+  };
+}
+async function finalizeFinishOutcome(options) {
+  const { ctx, cfg, creds, outcome } = options;
+  if (outcome.result?.status === "escalated")
+    return finalizeEscalation(ctx, outcome, creds);
+  if (cfg.notify.mode === "always") {
+    const status = outcome.result?.status ?? "failed";
+    const detail = outcome.result ? undefined : outcome.actionResult.message;
+    await notifyBestEffort(ctx, creds, buildTerminalMessage({ feature: ctx.feature, status, detail, url: outcome.actionResult.url }));
+  }
+  return outcome.actionResult;
+}
+var PLUGIN_NAME4 = "nax-finish", PLUGIN_VERSION4 = "0.1.0", PACKAGE_ROOT_SEARCH_DEPTH = 6, _naxFinishDeps, naxFinishAction, naxFinishPlugin;
 var init_nax_finish = __esm(() => {
   init_config2();
   init_telegram2();
   _naxFinishDeps = {
     run: defaultRun2,
     readResult: defaultReadResult,
+    clearResult: defaultClearResult,
     exists: (p) => Bun.file(p).exists(),
     moduleDir: import.meta.dir,
     notify: sendTelegramNotify
@@ -65018,76 +65426,10 @@ var init_nax_finish = __esm(() => {
       return isFeatureBranch(ctx.branch);
     },
     async execute(ctx) {
-      try {
-        const cfg = getFinishAutoFlowConfig(ctx);
-        const flowPath = await resolveFlowPath(ctx.workdir, cfg.flowPath);
-        if (!flowPath) {
-          return {
-            success: false,
-            message: `nax-finish: flow module "${cfg.flowPath}" not found in the nax install or ${ctx.workdir}`
-          };
-        }
-        const creds = telegramCreds(ctx.config);
-        const escalateTelegram = cfg.escalate.telegram && creds !== null;
-        const input = {
-          feature: ctx.feature,
-          workdir: ctx.workdir,
-          branch: ctx.branch,
-          prdPath: ctx.prdPath,
-          escalateTelegram,
-          timeouts: { acceptanceMs: cfg.timeouts.acceptanceMs, gateMs: cfg.timeouts.gateMs }
-        };
-        const cmd = buildFlowArgv(flowPath, JSON.stringify(input), cfg.defaultAgent, cfg.timeouts.stepMs);
-        const res = await _naxFinishDeps.run(cmd, {
-          cwd: ctx.workdir,
-          env: buildFlowEnv(cfg),
-          timeoutMs: cfg.timeouts.flowMs
-        });
-        const result = await _naxFinishDeps.readResult(ctx.workdir);
-        if (!result) {
-          ctx.logger.warn("nax-finish flow produced no result file", {
-            exitCode: res.exitCode,
-            stdout: logTail(res.stdout),
-            stderr: logTail(res.stderr)
-          });
-          const tail = stderrTail(res.stderr);
-          return {
-            success: false,
-            message: `nax-finish flow exited ${res.exitCode} (no result file)${tail ? `: ${tail}` : ""}`
-          };
-        }
-        if (result.status === "escalated") {
-          const problems = [];
-          let delivered = !escalateTelegram && !result.deliveryError;
-          if (escalateTelegram && creds) {
-            const sent = await _naxFinishDeps.notify(creds, buildEscalationMessage(result.feature, result.escalationReason ?? "", result.findings ?? []));
-            if (sent)
-              delivered = true;
-            else
-              problems.push("Telegram rejected the message");
-          }
-          if (!delivered) {
-            if (result.deliveryError)
-              problems.push(`the flow could not post it: ${result.deliveryError}`);
-            if (problems.length === 0)
-              problems.push("no escalation channel was reachable");
-            ctx.logger.warn("nax-finish escalation was not delivered", {
-              feature: result.feature,
-              reasons: problems,
-              escalationReason: result.escalationReason
-            });
-            return {
-              success: false,
-              message: `nax-finish: escalated but undelivered \u2014 ${problems.join("; ")}`,
-              url: result.url
-            };
-          }
-        }
-        return { success: true, message: `nax-finish: ${result.status}`, url: result.url };
-      } catch (err) {
-        ctx.logger.warn("nax-finish execute failed", { error: String(err) });
-        return { success: false, message: `nax-finish failed: ${String(err)}` };
-      }
+      const cfg = getFinishAutoFlowConfig(ctx);
+      const creds = telegramCreds(ctx.config);
+      const outcome = await settleFinishFlow({ ctx, cfg, creds });
+      return finalizeFinishOutcome({ ctx, cfg, creds, outcome });
     }
   };
   naxFinishPlugin = {
@@ -66134,7 +66476,7 @@ class PluginRegistry {
   sources;
   builtinPostRunActions;
   constructor(loadedPlugins, builtinPostRunActions = []) {
-    this.builtinPostRunActions = builtinPostRunActions;
+    this.builtinPostRunActions = builtinPostRunActions.map((registration) => ("action" in registration) ? registration : { pluginName: registration.name, action: registration });
     if (loadedPlugins.length > 0 && "plugin" in loadedPlugins[0]) {
       const typed = loadedPlugins;
       this.plugins = typed.map((lp) => lp.plugin);
@@ -66173,7 +66515,13 @@ class PluginRegistry {
     return this.plugins.filter((p) => p.provides.includes("reporter")).map((p) => p.extensions.reporter).filter((reporter) => reporter !== undefined);
   }
   getPostRunActions() {
-    const pluginActions = this.plugins.filter((p) => p.provides.includes("post-run-action")).map((p) => p.extensions.postRunAction).filter((action) => action !== undefined);
+    return this.getPostRunActionRegistrations().map(({ action }) => action);
+  }
+  getPostRunActionRegistrations() {
+    const pluginActions = this.plugins.flatMap((plugin) => {
+      const action = plugin.extensions.postRunAction;
+      return plugin.provides.includes("post-run-action") && action ? [{ pluginName: plugin.name, action }] : [];
+    });
     return [...pluginActions, ...this.builtinPostRunActions];
   }
   async teardownAll() {
@@ -66488,7 +66836,7 @@ async function loadPlugins(globalDir, projectDir, configPlugins, projectRoot, di
     }
     const autoPrAction2 = autoPrPlugin.extensions.postRunAction;
     if (autoPrAction2) {
-      builtinPostRunActions.push(autoPrAction2);
+      builtinPostRunActions.push({ pluginName: autoPrPlugin.name, action: autoPrAction2 });
     }
   } else {
     logger?.info("plugins", `Skipping disabled plugin: '${autoPrPlugin.name}' (built-in)`);
@@ -66500,7 +66848,7 @@ async function loadPlugins(globalDir, projectDir, configPlugins, projectRoot, di
     }
     const action = naxFinishPlugin.extensions.postRunAction;
     if (action)
-      builtinPostRunActions.push(action);
+      builtinPostRunActions.push({ pluginName: naxFinishPlugin.name, action });
   } else {
     logger?.info("plugins", `Skipping disabled plugin: '${naxFinishPlugin.name}' (built-in)`);
   }
@@ -66511,7 +66859,7 @@ async function loadPlugins(globalDir, projectDir, configPlugins, projectRoot, di
     }
     const autoRouteAction2 = autoRoutePlugin.extensions.postRunAction;
     if (autoRouteAction2) {
-      builtinPostRunActions.push(autoRouteAction2);
+      builtinPostRunActions.push({ pluginName: autoRoutePlugin.name, action: autoRouteAction2 });
     }
   } else {
     logger?.info("plugins", `Skipping disabled plugin: '${autoRoutePlugin.name}' (built-in)`);
@@ -66905,6 +67253,25 @@ var init_checkpoint = __esm(() => {
   init_resume_cli();
 });
 
+// src/hooks/types.ts
+var HOOK_EVENTS;
+var init_types10 = __esm(() => {
+  HOOK_EVENTS = [
+    "on-start",
+    "on-story-start",
+    "on-story-complete",
+    "on-story-fail",
+    "on-pause",
+    "on-resume",
+    "on-session-end",
+    "on-all-stories-complete",
+    "on-complete",
+    "on-error",
+    "on-final-regression-fail",
+    "on-post-run-action"
+  ];
+});
+
 // src/hooks/runner.ts
 import { join as join84 } from "path";
 function createDrainDeadline2(deadlineMs) {
@@ -66966,6 +67333,12 @@ function buildEnv(ctx) {
     env2.NAX_AGENT = escapeEnvValue(ctx.agent);
   if (ctx.iteration !== undefined)
     env2.NAX_ITERATION = String(ctx.iteration);
+  if (ctx.pluginName)
+    env2.NAX_PLUGIN_NAME = escapeEnvValue(ctx.pluginName);
+  if (ctx.actionName)
+    env2.NAX_ACTION_NAME = escapeEnvValue(ctx.actionName);
+  if (ctx.url)
+    env2.NAX_RESULT_URL = escapeEnvValue(ctx.url);
   return env2;
 }
 function hasShellOperators(command) {
@@ -67096,9 +67469,11 @@ var init_runner5 = __esm(() => {
 var exports_hooks = {};
 __export(exports_hooks, {
   loadHooksConfig: () => loadHooksConfig,
-  fireHook: () => fireHook
+  fireHook: () => fireHook,
+  HOOK_EVENTS: () => HOOK_EVENTS
 });
 var init_hooks = __esm(() => {
+  init_types10();
   init_runner5();
 });
 
@@ -69746,7 +70121,7 @@ function buildPreviewRouting(story, config2) {
 
 // src/worktree/types.ts
 var WorktreeDependencyPreparationError;
-var init_types10 = __esm(() => {
+var init_types11 = __esm(() => {
   WorktreeDependencyPreparationError = class WorktreeDependencyPreparationError extends Error {
     mode;
     failureCategory = "dependency-prep";
@@ -69816,7 +70191,7 @@ var PHASE_ONE_INHERIT_UNSUPPORTED_FILES, _worktreeDependencyDeps;
 var init_dependencies = __esm(() => {
   init_bun_deps();
   init_command_argv();
-  init_types10();
+  init_types11();
   PHASE_ONE_INHERIT_UNSUPPORTED_FILES = [
     "package.json",
     "bun.lock",
@@ -71033,6 +71408,20 @@ var init_pipeline_result_handler = __esm(() => {
 // src/execution/iteration-runner.ts
 import { existsSync as existsSync35 } from "fs";
 import { join as join91 } from "path";
+function releaseHeavyPipelineContext(ctx) {
+  ctx.agentResult = undefined;
+  ctx.prompt = undefined;
+  ctx.contextMarkdown = undefined;
+  ctx.featureContextMarkdown = undefined;
+  ctx.builtContext = undefined;
+  ctx.contextBundle = undefined;
+  ctx.constitution = undefined;
+  ctx.acceptanceFailures = undefined;
+  ctx.autofixPriorIterations = undefined;
+  ctx.reviewFindings = undefined;
+  ctx.selfVerification = undefined;
+  ctx.tddIsolations = undefined;
+}
 async function runIteration(ctx, prd, selection, iterations, totalCost2, allStoryMetrics) {
   const { story, storiesToExecute, routing, isBatchExecution } = selection;
   if (ctx.dryRun) {
@@ -71213,11 +71602,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost2, allStor
       subStoryCount: pipelineResult.subStoryCount
     };
   }
-  pipelineContext.agentResult = undefined;
-  pipelineContext.prompt = undefined;
-  pipelineContext.contextMarkdown = undefined;
-  pipelineContext.builtContext = undefined;
-  pipelineContext.constitution = undefined;
+  releaseHeavyPipelineContext(pipelineContext);
   return iterResult;
 }
 var _iterationRunnerDeps;
@@ -71691,7 +72076,7 @@ async function executeUnified(ctx, initialPrd) {
   _prevRunUnsubscribers = [];
   const thisRunUnsubscribers = [
     wireHooks(pipelineEventBus, ctx.hooks, ctx.workdir, ctx.feature),
-    wireReporters(pipelineEventBus, ctx.pluginRegistry, ctx.runId, ctx.startTime),
+    wireReporters(pipelineEventBus, ctx.pluginRegistry, ctx.runId, ctx.startTime, ctx.runtime.projectKey),
     wireInteraction(pipelineEventBus, ctx.interactionChain, ctx.config),
     wireEventsWriter(pipelineEventBus, ctx.feature, ctx.runId, ctx.workdir),
     wireRegistry(pipelineEventBus, ctx.feature, ctx.runId, ctx.workdir, ctx.runtime.outputDir)
@@ -73463,8 +73848,63 @@ async function runSetupPhase(options) {
 var exports_run_cleanup = {};
 __export(exports_run_cleanup, {
   cleanupRun: () => cleanupRun,
-  buildPostRunContext: () => buildPostRunContext
+  buildPostRunContext: () => buildPostRunContext,
+  _runCleanupDeps: () => _runCleanupDeps
 });
+async function settlePostRunAction(action, ctx) {
+  try {
+    if (!await action.shouldRun(ctx))
+      return { status: "skipped", reason: "shouldRun=false" };
+    return outcomeFromResult(await action.execute(ctx));
+  } catch (error48) {
+    return { status: "error", reason: errorMessage(error48) };
+  }
+}
+function outcomeFromResult(result) {
+  if (result.skipped)
+    return { status: "skipped", reason: result.reason ?? result.message };
+  if (!result.success)
+    return { status: "failed", message: result.message, url: result.url };
+  return { status: "succeeded", message: result.message, url: result.url };
+}
+function logPostRunOutcome(actionName, outcome) {
+  const logger = getSafeLogger();
+  if (outcome.status === "skipped") {
+    const level = outcome.reason === "shouldRun=false" ? "debug" : "info";
+    logger?.[level]("post-run", `[post-run] ${actionName}: skipped \u2014 ${outcome.reason}`);
+  } else if (outcome.status === "failed") {
+    logger?.warn("post-run", `[post-run] ${actionName}: failed \u2014 ${outcome.message}`);
+  } else if (outcome.status === "error") {
+    logger?.warn("post-run", `[post-run] ${actionName}: error \u2014 ${outcome.reason}`);
+  } else {
+    const suffix = outcome.url ? `${outcome.message} (${outcome.url})` : outcome.message;
+    logger?.info("post-run", `[post-run] ${actionName}: ${suffix}`);
+  }
+}
+function postRunHookContext(feature, registration, outcome) {
+  const reason = outcome.status === "succeeded" || outcome.status === "failed" ? outcome.message : outcome.reason;
+  return {
+    event: "on-post-run-action",
+    feature,
+    pluginName: registration.pluginName,
+    actionName: registration.action.name,
+    status: outcome.status,
+    reason,
+    url: "url" in outcome ? outcome.url : undefined
+  };
+}
+async function runPostRunActions(options, ctx) {
+  const registrations = options.pluginRegistry.getPostRunActionRegistrations();
+  for (const registration of registrations) {
+    const outcome = await settlePostRunAction(registration.action, ctx);
+    logPostRunOutcome(registration.action.name, outcome);
+    try {
+      await _runCleanupDeps.fireHook(options.hooks, "on-post-run-action", postRunHookContext(options.feature, registration, outcome), options.workdir);
+    } catch (error48) {
+      getSafeLogger()?.warn("hooks", `on-post-run-action hook failed for '${registration.pluginName}'`, { error: error48 });
+    }
+  }
+}
 function buildPostRunContext(opts, durationMs, logger) {
   const {
     runId,
@@ -73537,7 +73977,6 @@ async function cleanupRun(options) {
       }
     }
   }
-  const actions = pluginRegistry.getPostRunActions();
   const pluginLogger = {
     debug: (msg, data) => logger?.debug("post-run", msg, data),
     info: (msg, data) => logger?.info("post-run", msg, data),
@@ -73545,26 +73984,7 @@ async function cleanupRun(options) {
     error: (msg, data) => logger?.error("post-run", msg, data)
   };
   const ctx = buildPostRunContext(options, durationMs, pluginLogger);
-  for (const action of actions) {
-    try {
-      const shouldRun = await action.shouldRun(ctx);
-      if (!shouldRun) {
-        logger?.debug("post-run", `[post-run] ${action.name}: shouldRun=false, skipping`);
-        continue;
-      }
-      const result = await action.execute(ctx);
-      if (result.skipped) {
-        logger?.info("post-run", `[post-run] ${action.name}: skipped \u2014 ${result.reason}`);
-      } else if (!result.success) {
-        logger?.warn("post-run", `[post-run] ${action.name}: failed \u2014 ${result.message}`);
-      } else {
-        const msg = result.url ? `[post-run] ${action.name}: ${result.message} (${result.url})` : `[post-run] ${action.name}: ${result.message}`;
-        logger?.info("post-run", msg);
-      }
-    } catch (error48) {
-      logger?.warn("post-run", `[post-run] ${action.name}: error \u2014 ${error48}`);
-    }
-  }
+  await runPostRunActions(options, ctx);
   try {
     await pluginRegistry.teardownAll();
   } catch (error48) {
@@ -73581,11 +74001,14 @@ async function cleanupRun(options) {
   disposeFeatureResolver(workdir);
   await releaseLock(workdir);
 }
+var _runCleanupDeps;
 var init_run_cleanup = __esm(() => {
   init_context();
+  init_hooks();
   init_logger2();
   init_prd();
   init_helpers();
+  _runCleanupDeps = { fireHook };
 });
 
 // src/execution/runner.ts
@@ -73782,6 +74205,7 @@ async function run(options) {
         prdPath,
         branch,
         version: NAX_VERSION,
+        hooks,
         runCompleted,
         outputDir: runtime.outputDir,
         globalDir: runtime.globalDir,
@@ -73835,17 +74259,20 @@ var exports_execution = {};
 __export(exports_execution, {
   writeExitSummary: () => writeExitSummary,
   withIncreasingFailuresBail: () => withIncreasingFailuresBail,
+  toReviewDecisionPayload: () => toReviewDecisionPayload,
   synthesizeBackfillMetric: () => synthesizeBackfillMetric,
   stopHeartbeat: () => stopHeartbeat,
   startHeartbeat: () => startHeartbeat2,
   runRectification: () => runRectification,
   runPhase: () => runPhase,
+  runNonBlockingFix: () => runNonBlockingFix,
   runDeferredRegression: () => runDeferredRegression,
   runCompletionPhase: () => runCompletionPhase,
   run: () => run,
   resolveMaxAttemptsOutcome: () => resolveMaxAttemptsOutcome,
   resetCrashHandlers: () => resetCrashHandlers,
   releaseLock: () => releaseLock,
+  releaseHeavyPipelineContext: () => releaseHeavyPipelineContext,
   refreshReviewInputForDispatch: () => refreshReviewInputForDispatch,
   recordOscillations: () => recordOscillations,
   readQueueFile: () => readQueueFile,
@@ -73878,6 +74305,7 @@ __export(exports_execution, {
   describeGateRegression: () => describeGateRegression,
   deriveTddFailureCategory: () => deriveTddFailureCategory,
   decideStageAction: () => decideStageAction,
+  createNbfFlakeTriageTransaction: () => createNbfFlakeTriageTransaction,
   createCheckpointWriter: () => createCheckpointWriter,
   countOscillationOutcomes: () => countOscillationOutcomes,
   clearQueueFile: () => clearQueueFile,
@@ -73900,6 +74328,7 @@ __export(exports_execution, {
   _runnerDeps: () => _runnerDeps,
   _runnerCompletionDeps: () => _runnerCompletionDeps,
   _runCompletionDeps: () => _runCompletionDeps,
+  _runCleanupDeps: () => _runCleanupDeps,
   _regressionDeps: () => _regressionDeps,
   _postRunDeps: () => _postRunDeps,
   _pidRegistryDeps: () => _pidRegistryDeps,
@@ -73917,6 +74346,7 @@ var init_execution2 = __esm(() => {
   init_oscillation_breaker();
   init_runner6();
   init_progress();
+  init_iteration_runner();
   init_escalation();
   init_queue_handler();
   init_ensure_package_dirs();
@@ -73928,6 +74358,7 @@ var init_execution2 = __esm(() => {
   init_story_orchestrator();
   init_story_orchestrator_logging();
   init_plan_inputs();
+  init_non_blocking_fix();
   init_build_plan_for_strategy();
   init_checkpoint();
   init_runner_completion();