@nathapp/nax 0.75.4 → 0.75.5

package/dist/nax.js

@@ -17823,6 +17823,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 +17836,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 +17846,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 }
       }
     }),
@@ -42623,7 +42626,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.75.4",
+    version: "0.75.5",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -42727,8 +42730,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("c8f74c5f"))
+        return "c8f74c5f";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -57571,10 +57574,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 +57590,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 +57628,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 +57657,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 +57705,7 @@ var init_effectiveness = __esm(() => {
     "you",
     "your"
   ]);
+  TOKEN_PATTERN = /[^\s_\-./:,;()\[\]{}'"!?]+/g;
 });
 
 // src/execution/progress.ts
@@ -57711,19 +57722,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 +57786,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 +57856,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 +57872,9 @@ var init_completion = __esm(() => {
     checkReviewGate,
     persistSemanticVerdict,
     savePRD,
-    getDiffText
+    getDiffText,
+    readTextStreamPrefix,
+    spawn: Bun.spawn
   };
 });
 
@@ -58520,161 +58577,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 +58707,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 +58759,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 +59191,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 +59208,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 +59221,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(() => {
@@ -59590,6 +59732,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 +59801,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 +59873,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 +59890,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 +60044,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 +60069,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,6 +60222,7 @@ var init_story_orchestrator = __esm(() => {
   init_execution_plan();
   init_phase_eval();
   init_rectification();
+  init_nbf_flake_triage();
   init_run_phase();
   init_types9();
 });
@@ -64843,6 +65010,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 +65035,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 +65103,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 +65133,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 +65181,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 +65325,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 +66375,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 +66414,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 +66735,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 +66747,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 +66758,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 +67152,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 +67232,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 +67368,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 +70020,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 +70090,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 +71307,22 @@ 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.priorSemanticIterations = undefined;
+  ctx.priorAdversarialIterations = 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 +71503,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;
@@ -73463,8 +73749,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 +73878,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 +73885,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 +73902,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 +74106,7 @@ async function run(options) {
         prdPath,
         branch,
         version: NAX_VERSION,
+        hooks,
         runCompleted,
         outputDir: runtime.outputDir,
         globalDir: runtime.globalDir,
@@ -73840,12 +74165,14 @@ __export(exports_execution, {
   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 +74205,7 @@ __export(exports_execution, {
   describeGateRegression: () => describeGateRegression,
   deriveTddFailureCategory: () => deriveTddFailureCategory,
   decideStageAction: () => decideStageAction,
+  createNbfFlakeTriageTransaction: () => createNbfFlakeTriageTransaction,
   createCheckpointWriter: () => createCheckpointWriter,
   countOscillationOutcomes: () => countOscillationOutcomes,
   clearQueueFile: () => clearQueueFile,
@@ -73900,6 +74228,7 @@ __export(exports_execution, {
   _runnerDeps: () => _runnerDeps,
   _runnerCompletionDeps: () => _runnerCompletionDeps,
   _runCompletionDeps: () => _runCompletionDeps,
+  _runCleanupDeps: () => _runCleanupDeps,
   _regressionDeps: () => _regressionDeps,
   _postRunDeps: () => _postRunDeps,
   _pidRegistryDeps: () => _pidRegistryDeps,
@@ -73917,6 +74246,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 +74258,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();