@nathapp/nax 0.75.3 → 0.75.5

package/dist/nax.js

@@ -17317,7 +17317,11 @@ var init_schemas_reporters = __esm(() => {
     maxBatchSize: exports_external.number().int().positive().default(64),
     flushIntervalMs: exports_external.number().int().positive().default(5000),
     maxQueueSize: exports_external.number().int().positive().default(2048),
-    phases: exports_external.array(exports_external.string()).optional()
+    phases: exports_external.array(exports_external.string()).optional(),
+    logs: exports_external.object({
+      enabled: exports_external.boolean().default(false),
+      level: exports_external.enum(["silent", "error", "warn", "info", "debug"]).default("info")
+    }).default({ enabled: false, level: "info" })
   }).default({
     enabled: false,
     headers: {},
@@ -17327,7 +17331,8 @@ var init_schemas_reporters = __esm(() => {
     heartbeatIntervalMs: 1e4,
     maxBatchSize: 64,
     flushIntervalMs: 5000,
-    maxQueueSize: 2048
+    maxQueueSize: 2048,
+    logs: { enabled: false, level: "info" }
   });
   ReportersConfigSchema = exports_external.object({
     webhook: WebhookReporterConfigSchema,
@@ -17347,7 +17352,8 @@ var init_schemas_reporters = __esm(() => {
       heartbeatIntervalMs: 1e4,
       maxBatchSize: 64,
       flushIntervalMs: 5000,
-      maxQueueSize: 2048
+      maxQueueSize: 2048,
+      logs: { enabled: false, level: "info" }
     }
   });
 });
@@ -17817,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),
@@ -17829,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({
@@ -17838,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 }
       }
     }),
@@ -18388,6 +18397,30 @@ var init_redact = __esm(() => {
   ];
 });
 
+// src/logger/sink-registry.ts
+class SinkRegistry {
+  sinks = [];
+  add(sink) {
+    this.sinks.push(sink);
+    return () => {
+      const idx = this.sinks.indexOf(sink);
+      if (idx !== -1) {
+        this.sinks.splice(idx, 1);
+      }
+    };
+  }
+  dispatch(entry) {
+    for (const sink of this.sinks) {
+      try {
+        sink({ ...entry });
+      } catch (error48) {
+        process.stderr.write(`[logger] Sink threw: ${error48}
+`);
+      }
+    }
+  }
+}
+
 // src/logger/logger.ts
 import { mkdirSync } from "fs";
 import { appendFile } from "fs/promises";
@@ -18400,6 +18433,7 @@ class Logger {
   suppressConsole;
   writeQueueTail = Promise.resolve();
   pendingLines = [];
+  sinkRegistry = new SinkRegistry;
   constructor(options) {
     this.level = options.level;
     this.filePath = options.filePath;
@@ -18443,10 +18477,11 @@ class Logger {
       ...sessionRole && { sessionRole },
       ...strippedData && { data: strippedData }
     };
+    const entry = redactEntry(rawEntry);
+    this.sinkRegistry.dispatch(entry);
     const consoleEnabled = this.shouldLog(level) && !this.suppressConsole;
     if (!consoleEnabled && !this.filePath)
       return;
-    const entry = redactEntry(rawEntry);
     if (consoleEnabled) {
       let consoleOutput = null;
       if (this.formatterMode) {
@@ -18530,8 +18565,19 @@ ${JSON.stringify(entry.data, null, 2)}`;
       debug: (stage, message, data) => this.log("debug", stage, message, data, storyId)
     };
   }
+  addSink(sink) {
+    return this.sinkRegistry.add(sink);
+  }
   close() {}
 }
+function addSink(sink) {
+  if (!instance) {
+    throw new NaxError("Logger not initialized. Call initLogger() before addSink().", "LOGGER_NOT_INITIALIZED", {
+      stage: "logger"
+    });
+  }
+  return instance.addSink(sink);
+}
 function initLogger(options = { level: "silent" }) {
   if (instance) {
     throw new Error("Logger already initialized. Call getLogger() to access existing instance.");
@@ -18560,6 +18606,7 @@ function resetLogger() {
 }
 var LOG_LEVEL_PRIORITY, MAX_BATCH_BYTES, instance = null, noopLogger;
 var init_logger = __esm(() => {
+  init_errors();
   init_log_format();
   init_formatters();
   init_redact();
@@ -42579,7 +42626,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.75.3",
+    version: "0.75.5",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -42683,8 +42730,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("ae716fd4"))
-        return "ae716fd4";
+      if (/^[0-9a-f]{6,10}$/.test("c8f74c5f"))
+        return "c8f74c5f";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -57527,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;
@@ -57540,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" };
 }
@@ -57577,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;
@@ -57604,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",
@@ -57651,6 +57705,7 @@ var init_effectiveness = __esm(() => {
     "you",
     "your"
   ]);
+  TOKEN_PATTERN = /[^\s_\-./:,;()\[\]{}'"!?]+/g;
 });
 
 // src/execution/progress.ts
@@ -57667,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();
@@ -57689,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,
@@ -57758,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,
@@ -57773,7 +57872,9 @@ var init_completion = __esm(() => {
     checkReviewGate,
     persistSemanticVerdict,
     savePRD,
-    getDiffText
+    getDiffText,
+    readTextStreamPrefix,
+    spawn: Bun.spawn
   };
 });
 
@@ -58476,6 +58577,253 @@ var init_paths3 = __esm(() => {
   init_paths();
 });
 
+// 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(() => {
+  EXHAUSTED_EXIT_REASONS = new Set([
+    "max-attempts-total",
+    "max-attempts-per-strategy",
+    "bail-when",
+    "no-strategy",
+    "agent-gave-up",
+    "validate-short-circuit"
+  ]);
+  TDD_OP_NAMES = new Set(["test-writer", "implementer", "verifier"]);
+  CANONICAL_ORDER = [
+    "test-writer",
+    "greenfield-gate",
+    "implementer",
+    "test-presence-gate",
+    "full-suite-gate",
+    "mutation-check",
+    "verifier",
+    "verify-scoped",
+    "lint-check",
+    "typecheck-check",
+    "semantic-review",
+    "adversarial-review"
+  ];
+  PHASE_KIND_TO_STATE_KEY = {
+    "test-writer": "testWriter",
+    "greenfield-gate": "greenfieldGate",
+    implementer: "implementer",
+    "test-presence-gate": "testPresenceGate",
+    "full-suite-gate": "fullSuiteGate",
+    "mutation-check": "mutationCheck",
+    verifier: "verifier",
+    "verify-scoped": "verifyScoped",
+    "lint-check": "lintCheck",
+    "typecheck-check": "typecheckCheck",
+    "semantic-review": "semanticReview",
+    "adversarial-review": "adversarialReview"
+  };
+  STRATEGY_TO_REVALIDATION_PHASES = {
+    "mechanical-lintfix": ["lint-check"],
+    "mechanical-formatfix": ["lint-check"],
+    "autofix-implementer": ["lint-check", "typecheck-check", "full-suite-gate", "semantic-review", "adversarial-review"],
+    "autofix-test-writer": ["lint-check", "typecheck-check", "full-suite-gate", "adversarial-review"],
+    "full-suite-rectify": [
+      "lint-check",
+      "typecheck-check",
+      "full-suite-gate",
+      "verifier",
+      "verify-scoped",
+      "semantic-review",
+      "adversarial-review"
+    ]
+  };
+  STRICT_VERDICT_PHASE_NAMES = new Set([
+    "full-suite-gate",
+    "verify-scoped",
+    "lint-check",
+    "typecheck-check",
+    "verifier"
+  ]);
+});
+
+// src/execution/story-orchestrator/phase-eval.ts
+function phaseExplicitlyPassed(output) {
+  if (output === null || output === undefined || typeof output !== "object")
+    return false;
+  const r = output;
+  return r.success === true || r.passed === true;
+}
+function phasePassed(opName, output, storyId) {
+  const strictVerdictPhase = STRICT_VERDICT_PHASE_NAMES.has(opName);
+  if (output === null || output === undefined) {
+    getSafeLogger()?.warn("story-orchestrator", strictVerdictPhase ? "Strict phase produced no output \u2014 treating as fail" : "Phase produced no output \u2014 treating as pass", {
+      storyId,
+      phase: opName
+    });
+    return !strictVerdictPhase;
+  }
+  if (typeof output !== "object") {
+    if (!strictVerdictPhase)
+      return true;
+    getSafeLogger()?.warn("story-orchestrator", "Strict phase produced non-object output \u2014 treating as fail", {
+      storyId,
+      phase: opName
+    });
+    return false;
+  }
+  const r = output;
+  if ("success" in r)
+    return r.success !== false;
+  if ("passed" in r)
+    return r.passed !== false;
+  getSafeLogger()?.warn("story-orchestrator", strictVerdictPhase ? "Strict phase output has neither 'success' nor 'passed' \u2014 treating as fail" : "Phase output has neither 'success' nor 'passed' \u2014 treating as pass", {
+    storyId,
+    phase: opName
+  });
+  return !strictVerdictPhase;
+}
+function isFinding(value) {
+  return typeof value === "object" && value !== null && typeof value.source === "string" && value.source.length > 0;
+}
+function extractPhaseFindings(output) {
+  if (output === null || output === undefined || typeof output !== "object") {
+    return [];
+  }
+  const record2 = output;
+  const rawArray = Array.isArray(record2.normalizedFindings) && record2.normalizedFindings.length > 0 ? record2.normalizedFindings : Array.isArray(record2.findings) ? record2.findings : [];
+  const findings = rawArray.filter(isFinding);
+  const success2 = "success" in record2 ? record2.success === true : ("passed" in record2) ? record2.passed === true : findings.length === 0;
+  return success2 ? [] : findings;
+}
+function gateFailureKeys(gateOutput) {
+  const keys = new Set;
+  for (const f of extractPhaseFindings(gateOutput)) {
+    if (f.source !== "test-runner")
+      continue;
+    if (f.category === "flaky-test")
+      continue;
+    keys.add(gateFindingKey(f));
+  }
+  return keys;
+}
+function gateFindingKey(finding) {
+  return `${finding.file ?? ""}::${finding.rule ?? ""}`;
+}
+function isQuarantinedFlake(finding, quarantineMemo) {
+  if (finding.source !== "test-runner")
+    return false;
+  const key = gateFindingKey(finding);
+  return key !== KEYLESS_GATE_FAILURE_KEY && quarantineMemo?.has(key) === true;
+}
+function describeGateRegression(input) {
+  const { gateOutput, baselineKeys, gateName, storyId, quarantineMemo } = input;
+  const notRegressed = {
+    regressed: false,
+    regressedKeys: [],
+    memoExcludedKeys: [],
+    baselineKeySize: baselineKeys.size,
+    keyless: false
+  };
+  if (gateName === undefined || phasePassed(gateName, gateOutput, storyId))
+    return notRegressed;
+  const allKeys = gateFailureKeys(gateOutput);
+  const memoExcludedKeys = quarantineMemo ? [...allKeys].filter((k) => quarantineMemo.has(k)) : [];
+  const excluded = new Set(memoExcludedKeys);
+  const regressedKeys = [...allKeys].filter((k) => !baselineKeys.has(k) && !excluded.has(k));
+  const keyless = allKeys.size === 0 || allKeys.has(KEYLESS_GATE_FAILURE_KEY);
+  return {
+    regressed: regressedKeys.length > 0 || keyless,
+    regressedKeys,
+    memoExcludedKeys,
+    baselineKeySize: baselineKeys.size,
+    keyless
+  };
+}
+function phasesToRevalidate(strategiesRun, allPhases) {
+  if (!strategiesRun || strategiesRun.length === 0)
+    return allPhases;
+  const unknown2 = strategiesRun.some((name) => STRATEGY_TO_REVALIDATION_PHASES[name] === undefined);
+  if (unknown2)
+    return allPhases;
+  const needed = new Set;
+  for (const name of strategiesRun) {
+    for (const kind of STRATEGY_TO_REVALIDATION_PHASES[name] ?? []) {
+      needed.add(kind);
+    }
+  }
+  return allPhases.filter((p) => needed.has(p.kind));
+}
+function orderGateLast(phases) {
+  const rest = phases.filter((p) => p.kind !== "full-suite-gate");
+  const gates = phases.filter((p) => p.kind === "full-suite-gate");
+  return [...rest, ...gates];
+}
+var KEYLESS_GATE_FAILURE_KEY = "::";
+var init_phase_eval = __esm(() => {
+  init_logger2();
+  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);
@@ -58540,9 +58888,13 @@ async function runNonBlockingFix(args, overrides = {}) {
     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);
+    const result = await args.runRectify(maxAttempts, flakeTriage);
     exhausted = result.rectificationExhausted === true;
   } catch (err) {
     logger?.warn("non-blocking-fix", "best-effort pass threw \u2014 restoring", {
@@ -58552,16 +58904,14 @@ async function runNonBlockingFix(args, overrides = {}) {
     exhausted = true;
   }
   if (!exhausted) {
-    const gateVerdict = args.keptTreeRegressed?.();
+    const gateVerdict = args.keptTreeRegressed?.(flakeTriage.memo);
     if (gateVerdict?.regressed) {
-      logger?.info("non-blocking-fix", "kept tree regressed the full-suite gate \u2014 restoring (ADR-024 \xA73)", {
+      logGateRegression({
+        logger,
         storyId: args.storyId,
-        regressedKeys: gateVerdict.regressedKeys.slice(0, MAX_LOGGED_REGRESSED_KEYS),
-        regressedKeyCount: gateVerdict.regressedKeys.length,
-        baselineKeySize: gateVerdict.baselineKeySize,
-        keyless: gateVerdict.keyless,
-        memoExcludedKeyCount: gateVerdict.memoExcludedKeys.length,
-        flakeTriageRan: false
+        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);
     }
@@ -58587,11 +58937,34 @@ async function runNonBlockingFix(args, overrides = {}) {
         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))
@@ -58612,6 +58985,7 @@ var init_non_blocking_fix = __esm(() => {
   init_test_runners();
   init_bun_deps();
   init_paths3();
+  init_nbf_flake_triage();
   REVIEW_PHASE_KINDS = ["semantic-review", "adversarial-review"];
   _nonBlockingFixDeps = {
     spawn: typedSpawn,
@@ -58624,179 +58998,6 @@ var init_non_blocking_fix = __esm(() => {
   };
 });
 
-// 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(() => {
-  EXHAUSTED_EXIT_REASONS = new Set([
-    "max-attempts-total",
-    "max-attempts-per-strategy",
-    "bail-when",
-    "no-strategy",
-    "agent-gave-up",
-    "validate-short-circuit"
-  ]);
-  TDD_OP_NAMES = new Set(["test-writer", "implementer", "verifier"]);
-  CANONICAL_ORDER = [
-    "test-writer",
-    "greenfield-gate",
-    "implementer",
-    "test-presence-gate",
-    "full-suite-gate",
-    "mutation-check",
-    "verifier",
-    "verify-scoped",
-    "lint-check",
-    "typecheck-check",
-    "semantic-review",
-    "adversarial-review"
-  ];
-  PHASE_KIND_TO_STATE_KEY = {
-    "test-writer": "testWriter",
-    "greenfield-gate": "greenfieldGate",
-    implementer: "implementer",
-    "test-presence-gate": "testPresenceGate",
-    "full-suite-gate": "fullSuiteGate",
-    "mutation-check": "mutationCheck",
-    verifier: "verifier",
-    "verify-scoped": "verifyScoped",
-    "lint-check": "lintCheck",
-    "typecheck-check": "typecheckCheck",
-    "semantic-review": "semanticReview",
-    "adversarial-review": "adversarialReview"
-  };
-  STRATEGY_TO_REVALIDATION_PHASES = {
-    "mechanical-lintfix": ["lint-check"],
-    "mechanical-formatfix": ["lint-check"],
-    "autofix-implementer": ["lint-check", "typecheck-check", "full-suite-gate", "semantic-review", "adversarial-review"],
-    "autofix-test-writer": ["lint-check", "typecheck-check", "full-suite-gate", "adversarial-review"],
-    "full-suite-rectify": [
-      "lint-check",
-      "typecheck-check",
-      "full-suite-gate",
-      "verifier",
-      "verify-scoped",
-      "semantic-review",
-      "adversarial-review"
-    ]
-  };
-  STRICT_VERDICT_PHASE_NAMES = new Set([
-    "full-suite-gate",
-    "verify-scoped",
-    "lint-check",
-    "typecheck-check",
-    "verifier"
-  ]);
-});
-
-// src/execution/story-orchestrator/phase-eval.ts
-function phaseExplicitlyPassed(output) {
-  if (output === null || output === undefined || typeof output !== "object")
-    return false;
-  const r = output;
-  return r.success === true || r.passed === true;
-}
-function phasePassed(opName, output, storyId) {
-  const strictVerdictPhase = STRICT_VERDICT_PHASE_NAMES.has(opName);
-  if (output === null || output === undefined) {
-    getSafeLogger()?.warn("story-orchestrator", strictVerdictPhase ? "Strict phase produced no output \u2014 treating as fail" : "Phase produced no output \u2014 treating as pass", {
-      storyId,
-      phase: opName
-    });
-    return !strictVerdictPhase;
-  }
-  if (typeof output !== "object") {
-    if (!strictVerdictPhase)
-      return true;
-    getSafeLogger()?.warn("story-orchestrator", "Strict phase produced non-object output \u2014 treating as fail", {
-      storyId,
-      phase: opName
-    });
-    return false;
-  }
-  const r = output;
-  if ("success" in r)
-    return r.success !== false;
-  if ("passed" in r)
-    return r.passed !== false;
-  getSafeLogger()?.warn("story-orchestrator", strictVerdictPhase ? "Strict phase output has neither 'success' nor 'passed' \u2014 treating as fail" : "Phase output has neither 'success' nor 'passed' \u2014 treating as pass", {
-    storyId,
-    phase: opName
-  });
-  return !strictVerdictPhase;
-}
-function isFinding(value) {
-  return typeof value === "object" && value !== null && typeof value.source === "string" && value.source.length > 0;
-}
-function extractPhaseFindings(output) {
-  if (output === null || output === undefined || typeof output !== "object") {
-    return [];
-  }
-  const record2 = output;
-  const rawArray = Array.isArray(record2.normalizedFindings) && record2.normalizedFindings.length > 0 ? record2.normalizedFindings : Array.isArray(record2.findings) ? record2.findings : [];
-  const findings = rawArray.filter(isFinding);
-  const success2 = "success" in record2 ? record2.success === true : ("passed" in record2) ? record2.passed === true : findings.length === 0;
-  return success2 ? [] : findings;
-}
-function gateFailureKeys(gateOutput) {
-  const keys = new Set;
-  for (const f of extractPhaseFindings(gateOutput)) {
-    if (f.source !== "test-runner")
-      continue;
-    if (f.category === "flaky-test")
-      continue;
-    keys.add(`${f.file ?? ""}::${f.rule ?? ""}`);
-  }
-  return keys;
-}
-function describeGateRegression(input) {
-  const { gateOutput, baselineKeys, gateName, storyId, quarantineMemo } = input;
-  const notRegressed = {
-    regressed: false,
-    regressedKeys: [],
-    memoExcludedKeys: [],
-    baselineKeySize: baselineKeys.size,
-    keyless: false
-  };
-  if (gateName === undefined || phasePassed(gateName, gateOutput, storyId))
-    return notRegressed;
-  const allKeys = gateFailureKeys(gateOutput);
-  const memoExcludedKeys = quarantineMemo ? [...allKeys].filter((k) => quarantineMemo.has(k)) : [];
-  const excluded = new Set(memoExcludedKeys);
-  const regressedKeys = [...allKeys].filter((k) => !baselineKeys.has(k) && !excluded.has(k));
-  const keyless = allKeys.size === 0 || allKeys.has(KEYLESS_GATE_FAILURE_KEY);
-  return {
-    regressed: regressedKeys.length > 0 || keyless,
-    regressedKeys,
-    memoExcludedKeys,
-    baselineKeySize: baselineKeys.size,
-    keyless
-  };
-}
-function phasesToRevalidate(strategiesRun, allPhases) {
-  if (!strategiesRun || strategiesRun.length === 0)
-    return allPhases;
-  const unknown2 = strategiesRun.some((name) => STRATEGY_TO_REVALIDATION_PHASES[name] === undefined);
-  if (unknown2)
-    return allPhases;
-  const needed = new Set;
-  for (const name of strategiesRun) {
-    for (const kind of STRATEGY_TO_REVALIDATION_PHASES[name] ?? []) {
-      needed.add(kind);
-    }
-  }
-  return allPhases.filter((p) => needed.has(p.kind));
-}
-function orderGateLast(phases) {
-  const rest = phases.filter((p) => p.kind !== "full-suite-gate");
-  const gates = phases.filter((p) => p.kind === "full-suite-gate");
-  return [...rest, ...gates];
-}
-var KEYLESS_GATE_FAILURE_KEY = "::";
-var init_phase_eval = __esm(() => {
-  init_logger2();
-  init_types9();
-});
-
 // 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";
@@ -58990,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;
@@ -59007,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,
@@ -59020,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(() => {
@@ -59447,9 +59648,12 @@ var init_run_phase = __esm(() => {
 });
 
 // src/execution/story-orchestrator/rectification.ts
-function shouldSkipPhaseForRectification(phase, state, phaseOutputs) {
+function shouldSkipPhaseForRectification(input) {
+  const { phase, state, phaseOutputs, nbfPath } = input;
   if (phase.kind !== "full-suite-gate")
     return false;
+  if (nbfPath)
+    return false;
   const verifierName = state.verifier?.slot.op.name;
   if (!verifierName)
     return false;
@@ -59458,7 +59662,7 @@ function shouldSkipPhaseForRectification(phase, state, phaseOutputs) {
 function gatherRectificationFindings(phaseOutputs, phases, state) {
   const findings = [];
   for (const phase of phases) {
-    if (shouldSkipPhaseForRectification(phase, state, phaseOutputs))
+    if (shouldSkipPhaseForRectification({ phase, state, phaseOutputs }))
       continue;
     for (const f of extractPhaseFindings(phaseOutputs[phase.slot.op.name])) {
       if (f.category === "flaky-test")
@@ -59528,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);
@@ -59539,7 +59746,9 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
     return {};
   }
   let initialFindings;
+  let nbfPath = false;
   if (overrides?.initialFindings) {
+    nbfPath = true;
     initialFindings = [...overrides.initialFindings];
   } else {
     const gateName = state.fullSuiteGate?.slot.op.name;
@@ -59589,11 +59798,24 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
       let shortCircuited = false;
       for (const phase of phases) {
         await runPhase(ctx, phase.slot, phaseCosts, phaseOutputs);
-        if (shouldSkipPhaseForRectification(phase, state, phaseOutputs))
+        if (shouldSkipPhaseForRectification({ phase, state, phaseOutputs, nbfPath }))
           continue;
         const output = phaseOutputs[phase.slot.op.name];
-        findings.push(...extractPhaseFindings(output));
-        if (!phasePassed(phase.slot.op.name, output, ctx.storyId)) {
+        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);
+        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
@@ -59651,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();
@@ -59667,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() {
@@ -59821,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(),
@@ -59840,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 });
@@ -59991,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();
 });
@@ -64778,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,
@@ -64802,39 +65035,74 @@ 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)
+    return head;
+  const footerReserve = `
+\u2026and ${findings.length} more`.length;
+  const lines = [];
+  let used = head.length;
+  for (const f of findings) {
+    const title = f.title.length > MAX_FINDING_TITLE_CHARS ? `${f.title.slice(0, MAX_FINDING_TITLE_CHARS)}\u2026` : f.title;
+    const line = `
+- [${f.severity}] ${title}`;
+    if (used + line.length + footerReserve > TELEGRAM_MAX_MESSAGE_CHARS)
+      break;
+    lines.push(line);
+    used += line.length;
+  }
+  const omitted = findings.length - lines.length;
+  return `${head}${lines.join("")}${omitted > 0 ? `
+\u2026and ${omitted} more` : ""}`;
+}
 async function sendTelegramNotify(cfg, text) {
   const res = await _telegramDeps.fetch(`https://api.telegram.org/bot${cfg.token}/sendMessage`, {
     method: "POST",
     headers: { "content-type": "application/json" },
-    body: JSON.stringify({ chat_id: cfg.chatId, text, parse_mode: "Markdown" })
+    body: JSON.stringify({ chat_id: cfg.chatId, text })
   });
   return res.ok;
 }
-var _telegramDeps;
+var TELEGRAM_MAX_MESSAGE_CHARS = 4096, MAX_FINDING_TITLE_CHARS = 120, _telegramDeps;
 var init_telegram2 = __esm(() => {
   _telegramDeps = { fetch: (...a) => fetch(...a) };
 });
 
 // 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;
@@ -64865,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;
 }
@@ -64908,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
@@ -64932,52 +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" && escalateTelegram && creds) {
-          await _naxFinishDeps.notify(creds, `nax-finish escalated *${result.feature}*: ${result.escalationReason ?? ""}`);
-        }
-        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 = {
@@ -65114,6 +65465,7 @@ var init_batch_queue = __esm(() => {
 });
 
 // src/plugins/builtin/otel-reporter/otlp.ts
+import { hostname as hostname3 } from "os";
 function attr(key, value) {
   return typeof value === "number" ? { key, value: { doubleValue: value } } : { key, value: { stringValue: value } };
 }
@@ -65133,8 +65485,25 @@ function buildHistogramPoint(values, bounds, attributes, timeUnixNano) {
 function buildCounterPoint(count, attributes, timeUnixNano) {
   return { attributes, timeUnixNano, asInt: String(count) };
 }
-function buildResourceAttributes(serviceName, runId) {
-  return [attr("service.name", serviceName), attr("nax.run_id", runId)];
+function buildResourceAttributes(input) {
+  const attrs = [
+    attr("service.name", input.serviceName),
+    attr("nax.run_id", input.runId),
+    attr("nax.version", NAX_VERSION),
+    attr("process.pid", process.pid)
+  ];
+  try {
+    attrs.push(attr("host.name", hostname3()));
+  } catch {}
+  if (input.feature !== undefined)
+    attrs.push(attr("nax.feature", input.feature));
+  if (input.project !== undefined)
+    attrs.push(attr("nax.project", input.project));
+  if (input.git?.branch !== undefined)
+    attrs.push(attr("nax.git.branch", input.git.branch));
+  if (input.git?.sha !== undefined)
+    attrs.push(attr("nax.git.sha", input.git.sha));
+  return attrs;
 }
 function buildTracesPayload(p) {
   const span = {
@@ -65160,7 +65529,18 @@ function buildTracesPayload(p) {
   return {
     resourceSpans: [
       {
-        resource: { attributes: [attr("service.name", p.serviceName)] },
+        resource: {
+          attributes: buildResourceAttributes({
+            serviceName: p.serviceName,
+            runId: p.runId,
+            feature: p.feature,
+            project: p.project,
+            git: {
+              branch: p.gitBranch,
+              sha: p.gitSha
+            }
+          })
+        },
         scopeSpans: [{ scope: { name: "nax" }, spans: [span, ...p.extraSpans ?? []] }]
       }
     ]
@@ -65187,7 +65567,18 @@ function buildMetricsPayload(p) {
   return {
     resourceMetrics: [
       {
-        resource: { attributes: [attr("service.name", p.serviceName)] },
+        resource: {
+          attributes: buildResourceAttributes({
+            serviceName: p.serviceName,
+            runId: p.runId,
+            feature: p.feature,
+            project: p.project,
+            git: {
+              branch: p.gitBranch,
+              sha: p.gitSha
+            }
+          })
+        },
         scopeMetrics: [
           {
             scope: { name: "nax" },
@@ -65198,6 +65589,9 @@ function buildMetricsPayload(p) {
     ]
   };
 }
+var init_otlp = __esm(() => {
+  init_version();
+});
 
 // src/plugins/builtin/otel-reporter/heartbeat.ts
 function startHeartbeat(opts) {
@@ -65250,7 +65644,12 @@ function buildHeartbeatMetricsPayload(p) {
   return {
     resourceMetrics: [
       {
-        resource: { attributes: [attr("service.name", p.serviceName)] },
+        resource: {
+          attributes: buildResourceAttributes({
+            serviceName: p.serviceName,
+            runId: p.snapshot.attributes.runId
+          })
+        },
         scopeMetrics: [
           {
             scope: { name: "nax" },
@@ -65268,6 +65667,7 @@ function buildHeartbeatMetricsPayload(p) {
 var STAGE2 = "otel-reporter-heartbeat";
 var init_heartbeat = __esm(() => {
   init_logger2();
+  init_otlp();
 });
 
 // src/plugins/builtin/otel-reporter/ids.ts
@@ -65281,6 +65681,78 @@ function randomHex(bytes) {
 }
 var newTraceId = () => randomHex(16), newSpanId = () => randomHex(8);
 
+// src/plugins/builtin/otel-reporter/logs.ts
+function entryTimestampMs(entry) {
+  return new Date(entry.timestamp).getTime();
+}
+function toLogRecord(entry) {
+  const timeUnixNano = msToUnixNano(entryTimestampMs(entry));
+  const { number: severityNumber, text: severityText } = SEVERITY[entry.level];
+  const attributes = [attr("nax.stage", entry.stage)];
+  if (entry.storyId !== undefined)
+    attributes.push(attr("nax.story_id", entry.storyId));
+  if (entry.sessionRole !== undefined)
+    attributes.push(attr("nax.session_role", entry.sessionRole));
+  const data = entry.data ?? {};
+  const nonScalars = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (typeof value === "string") {
+      attributes.push(attr(`nax.data.${key}`, truncate3(value)));
+    } else if (typeof value === "number") {
+      if (Number.isFinite(value)) {
+        attributes.push(attr(`nax.data.${key}`, value));
+      } else {
+        nonScalars[key] = value;
+      }
+    } else if (typeof value === "boolean") {
+      attributes.push(attr(`nax.data.${key}`, String(value)));
+    } else {
+      nonScalars[key] = value;
+    }
+  }
+  if (Object.keys(nonScalars).length > 0) {
+    attributes.push(attr("nax.data_json", truncate3(JSON.stringify(nonScalars))));
+  }
+  return {
+    body: { stringValue: entry.message },
+    timeUnixNano,
+    severityNumber,
+    severityText,
+    attributes
+  };
+}
+function buildLogsPayload(entries, resource) {
+  const logRecords = entries.map(toLogRecord);
+  return {
+    resourceLogs: [
+      {
+        resource: {
+          attributes: buildResourceAttributes(resource)
+        },
+        scopeLogs: [{ scope: { name: "nax" }, logRecords }]
+      }
+    ]
+  };
+}
+function truncate3(value) {
+  if (value.length <= DATA_JSON_MAX)
+    return value;
+  const marker = TRUNCATION_MARKER;
+  const keep = DATA_JSON_MAX - marker.length;
+  return `${value.slice(0, keep)}${marker}`;
+}
+var SEVERITY, DATA_JSON_MAX = 2048, TRUNCATION_MARKER = "...[truncated]";
+var init_logs = __esm(() => {
+  init_otlp();
+  SEVERITY = {
+    silent: { number: 0, text: "SILENT" },
+    error: { number: 17, text: "ERROR" },
+    warn: { number: 13, text: "WARN" },
+    info: { number: 9, text: "INFO" },
+    debug: { number: 5, text: "DEBUG" }
+  };
+});
+
 // src/plugins/builtin/otel-reporter/span-tree.ts
 function createSpanTree(traceId, runSpanId) {
   const storySpanIds = new Map;
@@ -65364,7 +65836,8 @@ function createPhaseMetricsAggregator() {
   function recordEscalation(toTier, count) {
     bumpCounter(escalations, [attr("to_tier", toTier)], count);
   }
-  function buildMetricsPayload2(serviceName, runId, timeUnixNano) {
+  function buildMetricsPayload2(input) {
+    const { serviceName, runId, timeUnixNano, feature, project, gitBranch, gitSha } = input;
     const groups = [...phaseGroups.values()];
     const counterMetric = (name, source) => ({
       name,
@@ -65400,7 +65873,15 @@ function createPhaseMetricsAggregator() {
     return {
       resourceMetrics: [
         {
-          resource: { attributes: buildResourceAttributes(serviceName, runId) },
+          resource: {
+            attributes: buildResourceAttributes({
+              serviceName,
+              runId,
+              feature,
+              project,
+              git: { branch: gitBranch, sha: gitSha }
+            })
+          },
           scopeMetrics: [{ scope: { name: "nax" }, metrics }]
         }
       ]
@@ -65410,6 +65891,7 @@ function createPhaseMetricsAggregator() {
 }
 var PHASE_DURATION_BOUNDS, PHASE_COST_BOUNDS;
 var init_span_tree = __esm(() => {
+  init_otlp();
   PHASE_DURATION_BOUNDS = [100, 500, 1000, 5000, 15000, 60000, 300000, 900000];
   PHASE_COST_BOUNDS = [0.001, 0.01, 0.05, 0.1, 0.5, 1, 5];
 });
@@ -65484,11 +65966,11 @@ function reviewSpanEvents(details, timeUnixNano, verbose) {
     return { timeUnixNano, name: "review.finding", attributes };
   });
 }
-function createOtelReporterPlugin(cfg, deps) {
+function createOtelReporterPlugin(cfg, deps, workdir) {
   const states = new Map;
   const base = cfg.endpoint?.replace(/\/$/, "");
   let tornDown = false;
-  const sendSpanBatch = async (batch) => {
+  const makeSendSpanBatch = (resourceAttrs) => async (batch) => {
     if (!base || batch.length === 0)
       return true;
     const { resolved, missing } = interpolateHeaders(cfg.headers);
@@ -65499,21 +65981,55 @@ function createOtelReporterPlugin(cfg, deps) {
     const payload = {
       resourceSpans: [
         {
-          resource: { attributes: [attr("service.name", cfg.serviceName)] },
+          resource: { attributes: resourceAttrs },
           scopeSpans: [{ scope: { name: "nax" }, spans: batch }]
         }
       ]
     };
-    return postJson(`${base}/v1/traces`, payload, { headers: resolved, timeoutMs: cfg.timeoutMs, stage: STAGE3, deps });
+    return postJson(`${base}/v1/traces`, payload, {
+      headers: resolved,
+      timeoutMs: cfg.timeoutMs,
+      stage: STAGE3,
+      deps
+    });
   };
-  const makeSpanQueue = () => createBatchQueue({
+  const makeSpanQueue = (resourceAttrs) => createBatchQueue({
     maxBatchSize: cfg.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE,
     flushIntervalMs: cfg.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS,
     maxQueueSize: cfg.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE,
-    send: sendSpanBatch
+    send: makeSendSpanBatch(resourceAttrs)
+  });
+  const makeSendLogsBatch = (resource) => async (batch) => {
+    if (!base || batch.length === 0)
+      return true;
+    const { resolved, missing } = interpolateHeaders(cfg.headers);
+    if (missing.length > 0) {
+      getSafeLogger()?.warn(STAGE3, "Skipping OTLP export \u2014 unresolved env vars", { missing });
+      return true;
+    }
+    const payload = buildLogsPayload(batch, {
+      serviceName: resource.serviceName,
+      runId: resource.runId,
+      feature: resource.feature,
+      project: resource.project,
+      git: { branch: resource.gitBranch, sha: resource.gitSha }
+    });
+    return postJson(`${base}/v1/logs`, payload, {
+      headers: resolved,
+      timeoutMs: cfg.timeoutMs,
+      stage: STAGE3,
+      deps
+    });
+  };
+  const makeLogsQueue = (resource) => createBatchQueue({
+    maxBatchSize: cfg.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE,
+    flushIntervalMs: cfg.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS,
+    maxQueueSize: cfg.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE,
+    send: makeSendLogsBatch(resource)
   });
   const buildOrphanState = (startMs) => {
     const identity = rootSpanIdentity();
+    const orphanAttrs = buildResourceAttributes({ serviceName: cfg.serviceName, runId: "orphan" });
     return {
       ...identity,
       startMs,
@@ -65521,7 +66037,7 @@ function createOtelReporterPlugin(cfg, deps) {
       project: "",
       events: [],
       spanTree: createSpanTree(identity.traceId, identity.spanId),
-      spanQueue: makeSpanQueue(),
+      spanQueue: makeSpanQueue(orphanAttrs),
       metrics: createPhaseMetricsAggregator(),
       storyBounds: new Map,
       costUsd: 0,
@@ -65561,6 +66077,9 @@ function createOtelReporterPlugin(cfg, deps) {
       startUnixNano,
       endUnixNano,
       feature: st.feature,
+      project: st.project,
+      gitBranch: st.gitBranch,
+      gitSha: st.gitSha,
       runId: e.runId,
       storySummary: e.storySummary,
       totalCost: e.totalCost,
@@ -65570,11 +66089,23 @@ function createOtelReporterPlugin(cfg, deps) {
       serviceName: cfg.serviceName,
       runId: e.runId,
       timeUnixNano: endUnixNano,
+      feature: st.feature,
+      project: st.project,
+      gitBranch: st.gitBranch,
+      gitSha: st.gitSha,
       storySummary: e.storySummary,
       totalCost: e.totalCost,
       totalDurationMs: e.totalDurationMs
     });
-    const aggMetrics = st.metrics.buildMetricsPayload(cfg.serviceName, e.runId, endUnixNano);
+    const aggMetrics = st.metrics.buildMetricsPayload({
+      serviceName: cfg.serviceName,
+      runId: e.runId,
+      timeUnixNano: endUnixNano,
+      feature: st.feature,
+      project: st.project,
+      gitBranch: st.gitBranch,
+      gitSha: st.gitSha
+    });
     metrics.resourceMetrics[0].scopeMetrics[0].metrics.push(...aggMetrics.resourceMetrics[0].scopeMetrics[0].metrics);
     const opts = { headers: resolved, timeoutMs: cfg.timeoutMs, stage: STAGE3, deps };
     await postJson(`${base}/v1/traces`, traces, opts);
@@ -65585,14 +66116,41 @@ function createOtelReporterPlugin(cfg, deps) {
     async onRunStart(event) {
       const identity = rootSpanIdentity();
       const runId = event.runId;
+      let gitBranch;
+      let gitSha;
+      if (base && workdir) {
+        const [branchResult, shaResult] = await Promise.all([
+          gitWithTimeout(["rev-parse", "--abbrev-ref", "HEAD"], workdir).catch(() => null),
+          gitWithTimeout(["rev-parse", "HEAD"], workdir).catch(() => null)
+        ]);
+        if (branchResult?.exitCode === 0) {
+          const branch = branchResult.stdout.trim();
+          if (branch && branch !== "HEAD")
+            gitBranch = branch;
+        }
+        if (shaResult?.exitCode === 0) {
+          const sha = shaResult.stdout.trim();
+          if (sha)
+            gitSha = sha;
+        }
+      }
+      const resourceAttrs = buildResourceAttributes({
+        serviceName: cfg.serviceName,
+        runId,
+        feature: event.feature,
+        project: event.project,
+        git: { branch: gitBranch, sha: gitSha }
+      });
       const state = {
         ...identity,
         startMs: Date.parse(event.startTime),
         feature: event.feature,
         project: event.project ?? "",
+        gitBranch,
+        gitSha,
         events: [],
         spanTree: createSpanTree(identity.traceId, identity.spanId),
-        spanQueue: makeSpanQueue(),
+        spanQueue: makeSpanQueue(resourceAttrs),
         metrics: createPhaseMetricsAggregator(),
         storyBounds: new Map,
         costUsd: 0,
@@ -65603,6 +66161,27 @@ function createOtelReporterPlugin(cfg, deps) {
         })
       };
       states.set(runId, state);
+      if (cfg.logs?.enabled) {
+        const logsQueue = makeLogsQueue({
+          serviceName: cfg.serviceName,
+          runId,
+          feature: event.feature,
+          project: event.project ?? "",
+          gitBranch,
+          gitSha
+        });
+        const floorKey = cfg.logs.level;
+        const sank = (entry) => {
+          if (REENTRY_STAGES.has(entry.stage))
+            return;
+          if (LOG_PRIORITY[entry.level] > LOG_PRIORITY[floorKey])
+            return;
+          logsQueue.enqueue(entry);
+        };
+        const addSinkFn = deps?.addSink ?? addSink;
+        state.logsQueue = logsQueue;
+        state.logUnsubscribe = addSinkFn(sank);
+      }
     },
     async onStoryComplete(event) {
       const st = states.get(event.runId);
@@ -65674,6 +66253,11 @@ function createOtelReporterPlugin(cfg, deps) {
       states.delete(event.runId);
       await st.spanQueue.flushNow();
       st.spanQueue.teardown();
+      if (st.logsQueue) {
+        await st.logsQueue.flushNow();
+        st.logsQueue.teardown();
+        st.logUnsubscribe?.();
+      }
       await flush(st, startMs + event.totalDurationMs, event);
     }
   };
@@ -65691,6 +66275,11 @@ function createOtelReporterPlugin(cfg, deps) {
         st.heartbeat.stop();
         await st.spanQueue.flushNow();
         st.spanQueue.teardown();
+        if (st.logsQueue) {
+          await st.logsQueue.flushNow();
+          st.logsQueue.teardown();
+          st.logUnsubscribe?.();
+        }
         const endMs = Date.now();
         await flush(st, endMs, {
           runId,
@@ -65703,14 +66292,25 @@ function createOtelReporterPlugin(cfg, deps) {
     extensions: { reporter }
   };
 }
-var STAGE3 = "otel-reporter", DEFAULT_MAX_BATCH_SIZE = 64, DEFAULT_FLUSH_INTERVAL_MS = 5000, DEFAULT_MAX_QUEUE_SIZE = 2048;
+var STAGE3 = "otel-reporter", REENTRY_STAGE = "otel-batch-queue", REENTRY_STAGES, DEFAULT_MAX_BATCH_SIZE = 64, DEFAULT_FLUSH_INTERVAL_MS = 5000, DEFAULT_MAX_QUEUE_SIZE = 2048, LOG_PRIORITY;
 var init_otel_reporter = __esm(() => {
   init_logger2();
+  init_git();
   init_reporter_shared();
   init_batch_queue();
   init_heartbeat();
+  init_logs();
+  init_otlp();
   init_span_tree();
   init_traceparent();
+  REENTRY_STAGES = new Set([STAGE3, REENTRY_STAGE]);
+  LOG_PRIORITY = {
+    silent: -1,
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3
+  };
 });
 
 // src/plugins/builtin/webhook-reporter/index.ts
@@ -65775,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);
@@ -65814,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() {
@@ -66129,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)`);
@@ -66141,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)`);
   }
@@ -66152,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)`);
@@ -66166,7 +66772,7 @@ async function loadPlugins(globalDir, projectDir, configPlugins, projectRoot, di
     {
       name: "otel-reporter",
       enabled: reporters.otel.enabled,
-      make: () => createOtelReporterPlugin(reporters.otel)
+      make: () => createOtelReporterPlugin(reporters.otel, undefined, effectiveProjectRoot)
     }
   ] : [];
   for (const { name, enabled: reporterEnabled, make } of reporterFactories) {
@@ -66546,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) {
@@ -66607,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) {
@@ -66737,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();
 });
 
@@ -69387,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";
@@ -69457,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",
@@ -70674,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) {
@@ -70854,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;
@@ -73104,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,
@@ -73178,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),
@@ -73186,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) {
@@ -73222,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
@@ -73423,6 +74106,7 @@ async function run(options) {
         prdPath,
         branch,
         version: NAX_VERSION,
+        hooks,
         runCompleted,
         outputDir: runtime.outputDir,
         globalDir: runtime.globalDir,
@@ -73481,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,
@@ -73519,6 +74205,7 @@ __export(exports_execution, {
   describeGateRegression: () => describeGateRegression,
   deriveTddFailureCategory: () => deriveTddFailureCategory,
   decideStageAction: () => decideStageAction,
+  createNbfFlakeTriageTransaction: () => createNbfFlakeTriageTransaction,
   createCheckpointWriter: () => createCheckpointWriter,
   countOscillationOutcomes: () => countOscillationOutcomes,
   clearQueueFile: () => clearQueueFile,
@@ -73541,6 +74228,7 @@ __export(exports_execution, {
   _runnerDeps: () => _runnerDeps,
   _runnerCompletionDeps: () => _runnerCompletionDeps,
   _runCompletionDeps: () => _runCompletionDeps,
+  _runCleanupDeps: () => _runCleanupDeps,
   _regressionDeps: () => _regressionDeps,
   _postRunDeps: () => _postRunDeps,
   _pidRegistryDeps: () => _pidRegistryDeps,
@@ -73558,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();
@@ -73569,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();