@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/dist/clients/runtime-turn.js

@@ -0,0 +1,2900 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { buildActionableWarningsReport, formatActionableWarningsAdvisory, publishActionableWarningsReport, writeDeferredActionableWarningsReport } from "./actionable-warnings.js";
+import { logActionableWarningsEvent } from "./actionable-warnings-logger.js";
+import { appendCodeQualityWarningsHistory, buildCodeQualityWarningsReport, formatCodeQualityWarningsAdvisory, writeCodeQualityWarningsReport } from "./code-quality-warnings.js";
+import { clearGitGuardTestFailure, mergeGitGuardTestFailure, resyncGitGuardAfterInlinePolicy, writeGitGuardRecord } from "./git-guard.js";
+import { cascadeSettleWaitMs } from "./cascade-budget.js";
+import { logCascade } from "./cascade-logger.js";
+import { normalizeMapKey } from "./path-utils.js";
+import { boundDeferredTargets, mergeDeferredTargets, TEST_RUNNER_MAX_PERSISTED_TARGETS } from "./deferred-test-targets.js";
+import { compareOrdinal } from "./string-utils.js";
+
+export { TEST_RUNNER_MAX_PERSISTED_TARGETS };
+import { resolveRunnerPath, toRunnerDisplayPath } from "./dispatch/runner-context.js";
+import { getKnipIgnorePatterns } from "./file-utils.js";
+import { admitsProjectWideFindings, formatCacheAgeLabel } from "./finding-delivery-gate.js";
+import { getFullScanWallClockMs, isWorkspaceSweepActive, runWhenWorkspaceSweepIdle, SWEEP_IDLE_SAFETY_MARGIN_MS } from "./lsp/workspace-sweep-hold.js";
+import { isTestRoleCollateral } from "./collateral-test-role.js";
+import { isSecretWarning, secretLocationKey } from "./secret-findings.js";
+import { govulncheckLane } from "./turn-end/lanes/govulncheck.js";
+import { secretsLane } from "./turn-end/lanes/secrets.js";
+import { planDeliveryHolds, stillReportedParked } from "./turn-end/delivery-holds.js";
+import { isHardFailureSummary } from "./hard-failure-summary.js";
+import { MAX_KNIP_ROOTS_PER_TURN, resolveKnipScanRoots } from "./knip-scan-roots.js";
+import { DEAD_CODE_DELTA_MAX_SHOWN, deadCodeIssueKey, deadCodeIssues, formatDeadCodeDelta, stableFindingKey } from "./dead-code-client.js";
+import { logDeadCodeScan } from "./dead-code-logger.js";
+import { scopeCell } from "./session-scope.js";
+import { PROJECT_DIAGNOSTICS_CACHE_VERSION, writeProjectDiagnosticsDeltaReport } from "./project-diagnostics/cache.js";
+import { deadCodeIssueToProjectDiagnostic } from "./project-diagnostics/runner-adapters/dead-code.js";
+import { trivyFindingToProjectDiagnostic } from "./project-diagnostics/runner-adapters/trivy.js";
+import { knipIssuesToProjectDiagnostics } from "./project-diagnostics/runner-adapters/knip.js";
+import { hasAmbientPythonEnvironment } from "./python-environment.js";
+import { logLatency } from "./latency-logger.js";
+import { getLspBudgetIdleTimeoutMs, shouldShortenLspIdleTimeout } from "./lsp-budget.js";
+import { updateHeartbeat } from "./instance-registry.js";
+import { emitLensTurnFindings } from "./lens-events.js";
+import { RUNTIME_CONFIG } from "./runtime-config.js";
+import { isSubagentSession } from "./subagent-mode.js";
+import { formatRunDurationMs } from "./run-duration.js";
+import { isExcludedTestTarget, isRunnerErrorResult, RUNNERS } from "./test-runner-client.js";
+import { createTurnEndTestRoots } from "./test-target-roots.js";
+import { MAX_ADVISORY_AFFECTED_FILES, gateFindingsByPathFreshness, snapshotAdvisoryProvenance } from "./advisory-provenance.js";
+import { DEPENDENCY_DRIFT_MAX_DELIVERIES, sweepInlineBlockerFreshness } from "./blocker-freshness.js";
+import { sweepInlineBlockerPastEof } from "./blocker-past-eof.js";
+import { getLSPService } from "./lsp/capabilities.js";
+import { drainPendingAuxCapEvictedCount, drainPendingAuxiliaryCoverage, isAuxBacklogPublished, isPendingAuxiliaryPastRearmTtl, rearmPendingAuxiliaryCoverage, MAX_LATE_AUX_REARMS, pendingAuxiliaryCoverageSize, canRearmPendingAuxiliary } from "./lsp/pending-aux-coverage.js";
+import { convertLspDiagnostics } from "./dispatch/utils/lsp-diagnostics.js";
+import { retagAuxiliaryDiagnostics } from "./dispatch/auxiliary-lsp.js";
+import { findingsResult, hasUsableResult } from "./dispatch/types.js";
+import { runPersistentReverify } from "./persistent-reverify.js";
+import { cascadeCarrySuffix } from "./cascade-format.js";
+import { applyPushedFindingPolicy, filterFindingsByDisposition } from "./dispatch/finding-policy.js";
+import { detectFileRole } from "./file-role.js";
+import { judgeDeferredRunnerFindings, recordDeferredRunnerBlockers } from "./deferred-runner-blockers.js";
+import { applyInlineBlockerPolicy, summarizeInlineBlockerPolicy } from "./inline-blocker-dispositions.js";
+import { drainPendingRunnerFindings, dropStaleRunnerFindings, pendingRunnerFindingsSize, requeueRunnerFindings } from "./dispatch/pending-runner-findings.js";
+import { incrementDegradationCount, recordDegradationOnce } from "./degradation-ledger.js";
+import { mapWithConcurrency } from "./map-with-concurrency.js";
+import { getAmbientAbortSignal } from "./safe-spawn.js";
+import { emitBounded } from "./bounded-telemetry.js";
+import { degradeDemotedFindingBody, formatDeliveryCapNote, formatRetirementNote } from "./demoted-finding-render.js";
+import { STALE_LINE_MARKER } from "./stale-marker.js";
+import { getActiveSessionId } from "./session-lifecycle.js";
+import { bounded } from "./deadline-utils.js";
+import { HOOK_WALL_BUDGET_MS } from "./hook-budgets.js";
+import { drainRenderedDependencyDriftFilePaths, getWidgetBlockingFilesForSweep, incrementWidgetDependencyDriftDelivery, markWidgetFileBlockersStale, recordRunner, retireWidgetDependencyDriftBlockers } from "./widget-state.js";
+const LATE_AUX_COVERAGE_GAP_DETAIL_CAP_PER_TURN = 20;
+export const TEST_RUNNER_BATCH_CONCURRENCY = 4;
+export const TEST_RUNNER_MAX_TARGETS = 12;
+const TURN_END_SELECTION_ROOT_ROWS = 8;
+export const TEST_RUNNER_BATCH_BUDGET_MS = 20000;
+export const TEST_RUNNER_MAX_DEFERRALS = 2;
+export async function runTestTargetsBounded(args) {
+  const results = [];
+  if (args.targets.length === 0)
+    return { results, deferred: [] };
+  let stopReason;
+  const batchAbort = new AbortController;
+  let closed = false;
+  const settledBeforeClose = new Set;
+  const budgetMs = Math.max(0, args.budgetMs);
+  const deadline = Date.now() + budgetMs;
+  const shouldStop = () => {
+    if (stopReason !== undefined)
+      return true;
+    if (args.signal?.aborted) {
+      stopReason = "abort";
+      return true;
+    }
+    if (Date.now() >= deadline) {
+      stopReason = "budget";
+      return true;
+    }
+    return false;
+  };
+  const pool = mapWithConcurrency(args.targets.map((target, index) => ({ target, index })), Math.max(1, args.concurrency), async ({ target, index }) => {
+    if (shouldStop())
+      return;
+    const running = args.run(target, batchAbort.signal);
+    const stamp = running.then((value) => {
+      if (closed)
+        return;
+      settledBeforeClose.add(index);
+      results.push({ status: "fulfilled", value });
+    }, (reason) => {
+      if (closed)
+        return;
+      settledBeforeClose.add(index);
+      results.push({ status: "rejected", reason });
+    });
+    await stamp;
+  });
+  pool.catch(() => {});
+  await new Promise((resolve) => {
+    let settled = false;
+    const finish = (reason) => {
+      if (settled)
+        return;
+      settled = true;
+      if (reason !== undefined)
+        stopReason ??= reason;
+      closed = true;
+      batchAbort.abort();
+      clearTimeout(timer);
+      args.signal?.removeEventListener("abort", onAbort);
+      resolve();
+    };
+    const onAbort = () => finish("abort");
+    const timer = setTimeout(() => finish("budget"), budgetMs);
+    timer.unref?.();
+    if (args.signal?.aborted)
+      finish("abort");
+    else
+      args.signal?.addEventListener("abort", onAbort, { once: true });
+    pool.then(() => finish(), () => finish());
+  });
+  return {
+    results,
+    deferred: args.targets.filter((_, index) => !settledBeforeClose.has(index)),
+    stopReason
+  };
+}
+function wouldPoisonCache(prev, next) {
+  return !next.success && prev?.data.success === true;
+}
+const LATE_DEAD_CODE_SCANS = "dead-code-late-scans";
+function lateDeadCodeScansOf(scope) {
+  return scopeCell(scope, LATE_DEAD_CODE_SCANS, () => new Map);
+}
+function joinedEarlierScan(result, askedAt) {
+  return result.scannedAt !== undefined && Date.parse(result.scannedAt) < askedAt;
+}
+function withRowForFailureWrite(scan, cacheManager, cacheKey, cwd, startRow) {
+  return scan.then((result) => result.success || startRow?.data.success === true ? { result, row: startRow } : cacheManager.readCacheAsync(cacheKey, cwd).then((row) => ({ result, row })));
+}
+function lateDeadCodeScanKey(client, cwd) {
+  return `${client.id}\x00${cwd}`;
+}
+function deadCodeScanEvent(client, cwd, result, durationMs) {
+  return {
+    language: client.language,
+    root: cwd,
+    success: result.success,
+    cached: false,
+    unusedExports: result.unusedExports.length,
+    unusedFiles: result.unusedFiles.length,
+    unusedDeps: result.unusedDeps.length,
+    unlistedDeps: result.unlistedDeps.length,
+    durationMs: result.durationMs ?? durationMs,
+    ...result.excludedWorktrees !== undefined && {
+      excludedWorktrees: result.excludedWorktrees
+    },
+    ...!result.success && { reason: result.summary }
+  };
+}
+function dropLateDeadCodeScan(scans, key, client, reason) {
+  scans.delete(key);
+  incrementDegradationCount({
+    kind: "dead-code-late-scan-dropped",
+    subject: client.id,
+    reason
+  });
+}
+function parkLateDeadCodeScan(args) {
+  const { scope, cacheManager, client, cwd, cacheKey, startedAt } = args;
+  const scans = lateDeadCodeScansOf(scope);
+  const key = lateDeadCodeScanKey(client, cwd);
+  const entry = {
+    files: args.files,
+    previousScan: args.previousScan,
+    carry: new Set,
+    settled: null,
+    askedAt: startedAt
+  };
+  scans.set(key, entry);
+  withRowForFailureWrite(args.scan, cacheManager, cacheKey, cwd, entry.previousScan ? { data: entry.previousScan } : null).then(({ result, row }) => {
+    if (!scope.isLive()) {
+      dropLateDeadCodeScan(scans, key, client, "session-ended");
+      return;
+    }
+    const durationMs = Date.now() - startedAt;
+    const cacheKept = wouldPoisonCache(row, result);
+    if (!cacheKept) {
+      cacheManager.writeCache(cacheKey, result, cwd, {
+        scanDurationMs: durationMs
+      });
+    }
+    logDeadCodeScan({
+      ...deadCodeScanEvent(client, cwd, result, durationMs),
+      ...cacheKept && { cacheKept }
+    });
+    if (!result.success) {
+      dropLateDeadCodeScan(scans, key, client, `scan-failed: ${result.summary}`);
+      return;
+    }
+    entry.settled = result;
+  }, (err) => dropLateDeadCodeScan(scans, key, client, `scan-threw: ${err}`));
+}
+let lspIdleResetTimeout = null;
+let pendingSweepRearm = null;
+function emitIdleResetReporterWarning(reportErr) {
+  try {
+    process.emitWarning(`dm-lens LSP idle reset error reporter failed: ${reportErr}`, { code: "DM_LENS_LSP_IDLE_RESET_REPORTER_FAILED" });
+  } catch {}
+}
+function reportIdleResetError(onError, err) {
+  try {
+    onError?.(err);
+  } catch (reportErr) {
+    emitIdleResetReporterWarning(reportErr);
+  }
+}
+function scheduleLSPIdleReset(resetFn, delayMs, options = {}) {
+  if (lspIdleResetTimeout) {
+    clearTimeout(lspIdleResetTimeout);
+  }
+  if (pendingSweepRearm) {
+    pendingSweepRearm.cancelled = true;
+    pendingSweepRearm = null;
+  }
+  lspIdleResetTimeout = setTimeout(() => {
+    lspIdleResetTimeout = null;
+    if (isWorkspaceSweepActive()) {
+      const rearmToken = { cancelled: false };
+      pendingSweepRearm = rearmToken;
+      runWhenWorkspaceSweepIdle(() => {
+        if (rearmToken.cancelled)
+          return;
+        if (pendingSweepRearm === rearmToken)
+          pendingSweepRearm = null;
+        scheduleLSPIdleReset(resetFn, delayMs, options);
+      });
+      return;
+    }
+    try {
+      if (options.isCurrentSession && !options.isCurrentSession()) {
+        return;
+      }
+      if (options.isPrimarySession && !options.isPrimarySession()) {
+        return;
+      }
+      resetFn();
+    } catch (err) {
+      reportIdleResetError(options.onError, err);
+    }
+  }, delayMs);
+  lspIdleResetTimeout.unref();
+}
+const DEFAULT_LSP_IDLE_RESET_MS = 240000;
+function sweepDerivedFloorMs() {
+  return getFullScanWallClockMs() + SWEEP_IDLE_SAFETY_MARGIN_MS;
+}
+function getBaseLspIdleResetMs() {
+  return Math.max(DEFAULT_LSP_IDLE_RESET_MS, sweepDerivedFloorMs());
+}
+function getShortenedLspIdleResetMs() {
+  return Math.max(getLspBudgetIdleTimeoutMs(), sweepDerivedFloorMs());
+}
+export function getEffectiveLspIdleResetMs() {
+  return isSubagentSession() || shouldShortenLspIdleTimeout() ? getShortenedLspIdleResetMs() : getBaseLspIdleResetMs();
+}
+export function cancelLSPIdleReset() {
+  if (lspIdleResetTimeout) {
+    clearTimeout(lspIdleResetTimeout);
+    lspIdleResetTimeout = null;
+  }
+  if (pendingSweepRearm) {
+    pendingSweepRearm.cancelled = true;
+    pendingSweepRearm = null;
+  }
+}
+function capTurnEndMessage(content, held = 0) {
+  const maxLines = RUNTIME_CONFIG.turnEnd.maxLines;
+  const maxChars = RUNTIME_CONFIG.turnEnd.maxChars;
+  const marker = held > 0 ? `... (truncated; ${held} held for the next turn)` : "... (truncated)";
+  let kept = content;
+  let cut = false;
+  const lines = kept.split(`
+`);
+  if (lines.length > maxLines) {
+    kept = lines.slice(0, maxLines).join(`
+`);
+    cut = true;
+  }
+  if (kept.length > maxChars) {
+    kept = sliceAtCodePointBoundaries(kept, 0, maxChars);
+    cut = true;
+  }
+  return cut ? `${kept}
+${marker}` : content;
+}
+function turnEndKeptChars(content) {
+  const maxLines = RUNTIME_CONFIG.turnEnd.maxLines;
+  const maxChars = RUNTIME_CONFIG.turnEnd.maxChars;
+  const lines = content.split(`
+`);
+  const kept = lines.length > maxLines ? lines.slice(0, maxLines).join(`
+`).length : content.length;
+  return Math.min(kept, sliceAtCodePointBoundaries(content, 0, maxChars).length);
+}
+function sliceAtCodePointBoundaries(value, start, end) {
+  if (start > 0 && start < value.length && isLowSurrogate(value.charCodeAt(start)) && isHighSurrogate(value.charCodeAt(start - 1))) {
+    start += 1;
+  }
+  if (end > 0 && end < value.length && isLowSurrogate(value.charCodeAt(end)) && isHighSurrogate(value.charCodeAt(end - 1))) {
+    end -= 1;
+  }
+  return value.slice(start, end);
+}
+function isHighSurrogate(codeUnit) {
+  return codeUnit >= 55296 && codeUnit <= 56319;
+}
+function isLowSurrogate(codeUnit) {
+  return codeUnit >= 56320 && codeUnit <= 57343;
+}
+const RESOLVED_SHARE_OF_CHARS = 0.4;
+const RESOLVED_MAX_LINES = 5;
+function formatWriteOrdinal(n) {
+  const mod100 = n % 100;
+  if (mod100 >= 11 && mod100 <= 13)
+    return `${n}th`;
+  switch (n % 10) {
+    case 1:
+      return `${n}st`;
+    case 2:
+      return `${n}nd`;
+    case 3:
+      return `${n}rd`;
+    default:
+      return `${n}th`;
+  }
+}
+export async function handleTurnEnd(deps) {
+  const { ctxCwd, getFlag, dbg, runtime, cacheManager, knipClient, deadCodeClients, depChecker, testRunnerClient, sessionId, host = "pi", owner, resetLSPService, resetFormatService } = deps;
+  const turnIndexAtDispatch = runtime.turnIndex;
+  const clearOwnedTurnState = () => {
+    if (runtime.turnIndex !== turnIndexAtDispatch) {
+      dbg(`turn_end: retaining newer turn state (dispatch=${turnIndexAtDispatch}, current=${runtime.turnIndex})`);
+      return;
+    }
+    cacheManager.clearTurnState(cwd, currentOwner, isSecondarySession ? sessionId : undefined);
+  };
+  updateHeartbeat().catch(() => {});
+  const cwd = ctxCwd ?? process.cwd();
+  const isSecondarySession = deps.sessionScope?.role === "secondary";
+  const sessionRole = isSecondarySession ? "secondary" : "primary";
+  const allowProjectWideFindings = admitsProjectWideFindings(sessionRole);
+  const turnStateSessionId = isSecondarySession ? sessionId : undefined;
+  let turnState = cacheManager.readTurnState(cwd, turnStateSessionId);
+  const currentOwner = {
+    ...owner ?? {
+      kind: "pi",
+      id: sessionId ?? runtime.telemetrySessionId,
+      pid: process.pid,
+      lastSeen: new Date().toISOString()
+    },
+    sessionStartedAt: owner?.sessionStartedAt ?? runtime.sessionStartedAt
+  };
+  const access = isSecondarySession ? "owned" : cacheManager.getTurnStateAccess(cwd, currentOwner);
+  const gateOwnerLabel = turnState.owner ? `${turnState.owner.kind}:${turnState.owner.id}` : turnState.sessionId ? `legacy:${turnState.sessionId}` : "none";
+  const sameProcessPiSessionHandoff = access === "foreign-live" && currentOwner.kind === "pi" && turnState.owner?.kind === "pi" && turnState.owner.pid === process.pid && turnState.owner.id !== currentOwner.id;
+  if (access === "foreign-live" && !sameProcessPiSessionHandoff) {
+    dbg(`turn_end: foreign live owner retained (${turnState.owner?.kind ?? "legacy"}:${turnState.owner?.id ?? turnState.sessionId})`);
+    return;
+  }
+  if (access === "available" && (turnState.files || turnState.owner || turnState.sessionId)) {
+    dbg("turn_end: evicting stale turn-state owner");
+    clearOwnedTurnState();
+    turnState = cacheManager.readTurnState(cwd, turnStateSessionId);
+  }
+  const ownFiles = Object.keys(turnState.files);
+  const files = ownFiles;
+  let widgetDemotedFindingsRetired = 0;
+  for (const wPath of drainRenderedDependencyDriftFilePaths()) {
+    const deliveryCount = incrementWidgetDependencyDriftDelivery(wPath);
+    if (deliveryCount >= DEPENDENCY_DRIFT_MAX_DELIVERIES) {
+      const capRetired = retireWidgetDependencyDriftBlockers(wPath);
+      if (capRetired) {
+        widgetDemotedFindingsRetired += 1;
+        incrementDegradationCount({
+          kind: "demoted-finding-retired",
+          subject: `widget-blocker:${toRunnerDisplayPath(cwd, wPath)}`,
+          reason: `capped after ${deliveryCount} deliveries with no re-run; hidden from the dm-lens footer, still listed by lens_diagnostics mode=all — re-run can still confirm`
+        });
+      }
+    }
+  }
+  if (files.length === 0 && !runtime.hasCascadeRuns() && !isSecondarySession) {
+    if (getFlag("lens-guard") && !runtime.gitGuardHasBlockers) {
+      const guardRecord = cacheManager.readCache("turn-end-findings", cwd)?.data;
+      if (guardRecord?.sessionId === runtime.telemetrySessionId && guardRecord.testFailures !== true) {
+        cacheManager.clearCache("turn-end-findings", cwd);
+      }
+    }
+    const idleResetMs = getEffectiveLspIdleResetMs();
+    dbg(`turn_end: no modified files, scheduling LSP idle reset (${idleResetMs / 1000}s)`);
+    if (!getFlag("no-lsp")) {
+      const sessionGeneration = runtime.sessionGeneration;
+      scheduleLSPIdleReset(resetLSPService, idleResetMs, {
+        isCurrentSession: () => runtime.isCurrentSession(sessionGeneration),
+        isPrimarySession: () => {
+          const activePrimarySessionId = getActiveSessionId();
+          return activePrimarySessionId === undefined || activePrimarySessionId === runtime.telemetrySessionId;
+        },
+        onError: (err) => dbg(`lsp idle reset failed: ${err}`)
+      });
+    }
+    resetFormatService();
+    if (pendingRunnerFindingsSize() === 0 && !runtime.hasResolvedBlockerFiles())
+      return;
+  }
+  if (files.length > 0 && (lspIdleResetTimeout || pendingSweepRearm)) {
+    cancelLSPIdleReset();
+    dbg("turn_end: cancelled pending LSP idle reset (active editing)");
+  }
+  dbg(`turn_end: ${files.length} file(s) modified, cycles: ${turnState.turnCycles}/${turnState.maxCycles}, access: ${access}, owner: ${gateOwnerLabel}`);
+  if (cacheManager.isMaxCyclesExceeded(cwd, turnStateSessionId)) {
+    dbg("turn_end: max cycles exceeded, clearing state and forcing through");
+    clearOwnedTurnState();
+    runtime.fixedThisTurn.clear();
+    resetFormatService();
+    return;
+  }
+  const turnEndStart = Date.now();
+  const blockerParts = [];
+  const staleSecretParts = [];
+  const advisoryParts = [];
+  const deliveryHolds = [];
+  const turnScope = deps.sessionScope ?? runtime.sessionScope;
+  const holdScope = runtime.captureSessionGeneration();
+  const carryScope = sessionId ?? runtime.telemetrySessionId;
+  const carryLane = (...parts) => [carryScope, ...parts].join(":");
+  const takeParked = (lane) => holdScope.guardedWrite(`turn-end:${lane}`, () => runtime.takeCutAdvisoryItems(lane)) ?? [];
+  const cutAdvisoryHold = (family, lane, part, shown, isReOffer) => {
+    const fresh = shown.filter((item) => !isReOffer(item));
+    const recordDropped = (reason) => {
+      incrementDegradationCount({
+        kind: "turn-end-advisory-carry-dropped",
+        subject: family,
+        reason
+      });
+    };
+    return {
+      part,
+      canHold: () => fresh.length > 0,
+      onHeld: () => {
+        for (const evicted of runtime.parkCutAdvisoryItems(lane, fresh)) {
+          recordDropped(`${evicted} evicted: more lanes had cut items parked than the carry bound keeps`);
+        }
+        if (fresh.length < shown.length) {
+          recordDropped("the cap cut items this lane had already re-offered once");
+        }
+      },
+      onDropped: () => recordDropped("the cap cut a part that showed only items it had already re-offered once")
+    };
+  };
+  const projectDiagnosticsDelta = [];
+  const projectDiagnosticsSources = new Set;
+  const runnerFindingsStart = Date.now();
+  const runnerDrainSignal = deps.signal;
+  const deliverySessionId = sessionId ?? runtime.telemetrySessionId;
+  const pendingRunnerFindings = await bounded(drainPendingRunnerFindings(0, runtime.sessionScope.capture(), deliverySessionId), {
+    ms: HOOK_WALL_BUDGET_MS.turn_end,
+    signal: runnerDrainSignal,
+    hook: "turn_end",
+    label: "drainPendingRunnerFindings"
+  }) ?? [];
+  let runnerFindingsDelivered = 0;
+  let runnerFindingsStale = 0;
+  let runnerFindingsFailed = 0;
+  let runnerFindingsDropped = 0;
+  let runnerBlockersRecorded = 0;
+  let runnerFindingsDispositionSuppressed = 0;
+  const runnerFindingsDeliveredIds = [];
+  for (const pending of pendingRunnerFindings) {
+    const result = pending.result;
+    if (!result)
+      continue;
+    recordRunner(pending.filePath, pending.runnerId, result.status, result.diagnostics.length, Date.now() - pending.markedAtMs, pending.writeIndex);
+    if (result.status === "failed" && !hasUsableResult(result)) {
+      runnerFindingsFailed += 1;
+      const detail = result.failureMessage ? `: ${result.failureMessage}` : "";
+      const failedNote = `❌ Deferred runner ${pending.runnerId} failed (${result.failureKind ?? "unknown"})${detail}`;
+      deliveryHolds.push({
+        part: failedNote,
+        onHeld: () => requeueRunnerFindings({
+          ...pending,
+          result: { ...result, diagnostics: [] }
+        })
+      });
+      advisoryParts.push(failedNote);
+    }
+    const verdict = judgeDeferredRunnerFindings(pending, cwd);
+    runnerFindingsStale += verdict.stale;
+    if (verdict.stale > 0) {
+      dropStaleRunnerFindings(pending);
+      runnerFindingsDropped += 1;
+    }
+    if (verdict.live === 0)
+      continue;
+    const displayPath = toRunnerDisplayPath(cwd, pending.filePath);
+    const runnerKept = verdict.kept;
+    runnerFindingsDispositionSuppressed += verdict.suppressed;
+    if (runnerKept.length === 0) {
+      continue;
+    }
+    runnerFindingsDelivered += runnerKept.length;
+    runnerBlockersRecorded += recordDeferredRunnerBlockers(runtime, pending, runnerKept, verdict.bytes);
+    for (const finding of runnerKept) {
+      if (runnerFindingsDeliveredIds.length < 50) {
+        runnerFindingsDeliveredIds.push(finding.id);
+      }
+    }
+    const advisoryKept = runnerKept.flatMap((finding) => finding.semantic === "blocking" ? [] : [finding]);
+    if (advisoryKept.length === 0)
+      continue;
+    const lines = advisoryKept.map((finding) => `  ${displayPath}:${finding.line ?? 1}:${finding.column ?? 1} [${finding.rule ?? finding.id}] ${finding.message}`);
+    const runnerSuppressedNote = verdict.suppressed > 0 ? `; suppressed by disposition: ${verdict.suppressed} finding(s)` : "";
+    const lateRunnerPart = `⏱️ Late runner diagnostics (${pending.runnerId} completed after the edit${runnerSuppressedNote}):
+${lines.join(`
+`)}`;
+    const { failureKind: _kind, failureMessage: _message, ...findingsOnly } = result;
+    deliveryHolds.push({
+      part: lateRunnerPart,
+      onHeld: () => requeueRunnerFindings({
+        ...pending,
+        result: findingsResult(advisoryKept, findingsOnly)
+      })
+    });
+    advisoryParts.push(lateRunnerPart);
+  }
+  logLatency({
+    type: "phase",
+    toolName: "turn_end",
+    filePath: cwd,
+    phase: "late_runner_findings",
+    durationMs: Date.now() - runnerFindingsStart,
+    metadata: {
+      pending: pendingRunnerFindings.length,
+      delivered: runnerFindingsDelivered,
+      stale: runnerFindingsStale,
+      failed: runnerFindingsFailed,
+      dropped: runnerFindingsDropped,
+      blockersRecorded: runnerBlockersRecorded,
+      dispositionSuppressed: runnerFindingsDispositionSuppressed,
+      deliveredIds: runnerFindingsDeliveredIds
+    }
+  });
+  const blockerPastEofStart = Date.now();
+  const blockerPastEof = sweepInlineBlockerPastEof(runtime, cwd);
+  logLatency({
+    type: "phase",
+    toolName: "turn_end",
+    filePath: cwd,
+    phase: "blocker_past_eof_sweep",
+    durationMs: Date.now() - blockerPastEofStart,
+    metadata: {
+      total: blockerPastEof.total,
+      checked: blockerPastEof.checked,
+      demoted: blockerPastEof.demoted
+    }
+  });
+  let demotedFindingsRetired = 0;
+  const retirePastEofOnDelivery = (bPath, deadLines, displayPath) => () => {
+    if (!runtime.retireDemotedPastEofBlocker(bPath, deadLines))
+      return;
+    runtime.updateGitGuardStatus(false, "");
+    demotedFindingsRetired += 1;
+    incrementDegradationCount({
+      kind: "demoted-finding-retired",
+      subject: `inline-blocker:${displayPath}`,
+      reason: `file shrank past cited line(s) ${deadLines.join(", ")}; retired after one degraded delivery`
+    });
+  };
+  const countDriftDeliveryOnDelivery = (bPath, displayPath) => () => {
+    const deliveryCount = runtime.incrementInlineBlockerStaleDelivery(bPath);
+    if (deliveryCount < DEPENDENCY_DRIFT_MAX_DELIVERIES)
+      return;
+    if (!runtime.retireDemotedDependencyDriftBlocker(bPath))
+      return;
+    runtime.updateGitGuardStatus(false, "");
+    demotedFindingsRetired += 1;
+    incrementDegradationCount({
+      kind: "demoted-finding-retired",
+      subject: `inline-blocker:${displayPath}`,
+      reason: `capped after ${deliveryCount} deliveries with no re-run; re-run can still confirm`
+    });
+  };
+  const blockerFreshnessStart = Date.now();
+  const blockerFreshness = await sweepInlineBlockerFreshness(runtime, cwd, {
+    ...deps.signal === undefined ? {} : { signal: deps.signal },
+    additionalEntries: getWidgetBlockingFilesForSweep().map((row) => ({
+      filePath: row.filePath,
+      recordedAtMs: row.recordedAtMs,
+      demote: () => markWidgetFileBlockersStale(row.filePath, "dependency-drift")
+    }))
+  });
+  logLatency({
+    type: "phase",
+    toolName: "turn_end",
+    filePath: cwd,
+    phase: "blocker_freshness_sweep",
+    durationMs: Date.now() - blockerFreshnessStart,
+    metadata: {
+      total: blockerFreshness.total,
+      kept: blockerFreshness.kept,
+      revalidated: blockerFreshness.revalidated,
+      alreadyStale: blockerFreshness.alreadyStale,
+      truncatedImports: blockerFreshness.truncatedImports,
+      selfHealed: blockerFreshness.selfHealed,
+      selfUnverifiable: blockerFreshness.selfUnverifiable,
+      hashBudgetExhausted: blockerFreshness.hashBudgetExhausted
+    }
+  });
+  const unresolvedBlockers = runtime.getInlineBlockersSnapshot();
+  const inlinePolicyEntries = [];
+  const policySuppressedPaths = [];
+  const inlinePolicyStart = Date.now();
+  for (const record of unresolvedBlockers) {
+    const { filePath: bPath, summary, stale, staleReason } = record;
+    const displayPath = toRunnerDisplayPath(cwd, bPath);
+    const tally = { displayPath, sources: record.sources };
+    if (stale) {
+      inlinePolicyEntries.push({ ...tally, stale: true });
+      const deadLines = blockerPastEof.deadLinesByPath.get(bPath) ?? [];
+      const degraded = degradeDemotedFindingBody(summary, { deadLines });
+      const retires = runtime.wouldRetireDemotedPastEofBlocker(bPath, deadLines);
+      let retirementNote;
+      if (retires) {
+        retirementNote = formatRetirementNote(deadLines);
+      } else if (staleReason === "dependency-drift") {
+        const tentativeCount = runtime.peekInlineBlockerStaleDeliveryCount(bPath) + 1;
+        if (tentativeCount >= DEPENDENCY_DRIFT_MAX_DELIVERIES) {
+          retirementNote = formatDeliveryCapNote(tentativeCount);
+        }
+      }
+      const advisoryPart = `${STALE_LINE_MARKER} ${displayPath}:
+${degraded.body}` + (retirementNote ? `
+${retirementNote}` : "");
+      advisoryParts.push(advisoryPart);
+      if (retires) {
+        deliveryHolds.push({
+          part: advisoryPart,
+          onDelivered: retirePastEofOnDelivery(bPath, deadLines, displayPath)
+        });
+      } else if (staleReason === "dependency-drift") {
+        deliveryHolds.push({
+          part: advisoryPart,
+          onDelivered: countDriftDeliveryOnDelivery(bPath, displayPath),
+          skipOnSuppressed: true
+        });
+      }
+    } else {
+      const policy = applyInlineBlockerPolicy(record, cwd);
+      inlinePolicyEntries.push({ ...tally, stale: false, outcome: policy });
+      if (policy.body === undefined) {
+        policySuppressedPaths.push(bPath);
+        continue;
+      }
+      const suppressedNote = policy.suppressed > 0 ? ` (suppressed by disposition: ${policy.suppressed} finding(s))` : "";
+      blockerParts.push(`Unresolved from this turn — ${displayPath}${suppressedNote}:
+${policy.body}`);
+    }
+  }
+  const guardLatchBefore = runtime.gitGuardHasBlockers;
+  resyncGitGuardAfterInlinePolicy({
+    runtime,
+    suppressedFilePaths: policySuppressedPaths
+  });
+  if (inlinePolicyEntries.length > 0) {
+    logLatency({
+      type: "phase",
+      toolName: "turn_end",
+      filePath: cwd,
+      phase: "inline_blocker_policy",
+      durationMs: Date.now() - inlinePolicyStart,
+      metadata: {
+        ...summarizeInlineBlockerPolicy(inlinePolicyEntries),
+        guardFilesSuppressed: policySuppressedPaths.length,
+        guardLatchCleared: guardLatchBefore && !runtime.gitGuardHasBlockers
+      }
+    });
+  }
+  const cascadeSettleStart = Date.now();
+  const cascadeSettleSignal = deps.signal;
+  const { settled, timedOut } = await bounded(runtime.settleCascadeRuns(cascadeSettleWaitMs(), {
+    trackTurnEndClock: true,
+    generation: holdScope
+  }), {
+    ms: HOOK_WALL_BUDGET_MS.turn_end,
+    signal: cascadeSettleSignal,
+    hook: "turn_end",
+    label: "settleCascadeRuns"
+  }) ?? { settled: 0, timedOut: 0 };
+  logLatency({
+    type: "phase",
+    toolName: "turn_end",
+    filePath: cwd,
+    phase: "cascade_settle_wait",
+    durationMs: Date.now() - cascadeSettleStart,
+    metadata: { settled, timedOut }
+  });
+  const t0 = Date.now();
+  const cascadeRuns = (holdScope.guardedWrite("turn-end:cascade-runs", () => runtime.consumeCascadeRuns()) ?? []).filter((run) => {
+    const originSeq = run.origin?.projectSeq;
+    const originTurn = run.origin?.turnSeq;
+    if (originSeq !== undefined) {
+      const changedSince = runtime.getFilesChangedSince(originSeq);
+      if (changedSince.length > 0) {
+        const changedSet = new Set(changedSince);
+        const primaryKey = normalizeMapKey(path.resolve(run.filePath));
+        const neighborKeys = [
+          ...(run.result?.neighbors ?? []).map((n) => n.filePath),
+          ...run.selectedNeighborPaths ?? []
+        ].map((filePath) => normalizeMapKey(path.resolve(filePath)));
+        const supersededByOwnFile = changedSet.has(primaryKey) || neighborKeys.some((k) => changedSet.has(k));
+        if (supersededByOwnFile) {
+          logCascade({
+            phase: "cascade_carry_over_drop",
+            filePath: run.filePath,
+            neighborCount: run.neighborCount,
+            diagnosticCount: run.diagnosticCount,
+            reason: "superseded_by_later_write",
+            metadata: {
+              originProjectSeq: originSeq,
+              projectSeq: runtime.projectSeq,
+              originTurnSeq: originTurn,
+              turnIndex: runtime.turnIndex,
+              carriedTurns: run.carriedTurns,
+              changedFiles: changedSince
+            }
+          });
+          return false;
+        }
+      }
+    }
+    return true;
+  });
+  const cascadeResults = cascadeRuns.flatMap((r) => r.result ? [r.result] : []);
+  let carriedRunsRendered = 0;
+  let labeledAdvisories = 0;
+  const carriedMetaByResult = new Map;
+  const runByResult = new Map;
+  for (const r of cascadeRuns) {
+    if (r.result)
+      runByResult.set(r.result, r);
+    if (r.result && (r.carriedTurns ?? 0) > 0 && r.carriedTurns !== undefined) {
+      carriedMetaByResult.set(r.result, {
+        carriedTurns: r.carriedTurns,
+        observedAt: r.observedAt
+      });
+    }
+  }
+  const cascadeLogFilePath = cascadeResults[0]?.filePath ?? files[0] ?? cwd;
+  if (cascadeResults.length > 0) {
+    const seen = new Map;
+    for (const result of cascadeResults) {
+      seen.set(normalizeMapKey(result.filePath), result);
+    }
+    const neighborOwner = new Map;
+    for (const result of [...seen.values()].reverse()) {
+      const pk = normalizeMapKey(result.filePath);
+      for (const n of result.neighbors) {
+        const nk = normalizeMapKey(n.filePath);
+        if (!neighborOwner.has(nk))
+          neighborOwner.set(nk, pk);
+      }
+    }
+    const parts = [];
+    const sectionRuns = [];
+    let injectedNeighborCount = 0;
+    let injectedDiagnosticCount = 0;
+    let suppressedByOwnership = 0;
+    for (const result of seen.values()) {
+      const pk = normalizeMapKey(result.filePath);
+      const ownsAny = result.neighbors.some((n) => neighborOwner.get(normalizeMapKey(n.filePath)) === pk);
+      if (ownsAny && result.formatted) {
+        const carryMeta = carriedMetaByResult.get(result);
+        const carrySuffix = cascadeCarrySuffix(carryMeta?.carriedTurns, carryMeta?.observedAt);
+        parts.push(carrySuffix ? `${result.formatted}
+${carrySuffix}` : result.formatted);
+        if (carrySuffix)
+          carriedRunsRendered += 1;
+        const sectionRun = runByResult.get(result);
+        if (sectionRun)
+          sectionRuns.push(sectionRun);
+        injectedNeighborCount += result.neighbors.length;
+        injectedDiagnosticCount += result.neighbors.reduce((s, n) => s + n.diagnostics.length, 0);
+      } else if (!ownsAny && result.formatted) {
+        suppressedByOwnership++;
+      }
+    }
+    const neighborFilesWithErrors = cascadeResults.flatMap((r) => r.neighbors).filter((n) => n.diagnostics.length > 0).map((n) => n.filePath);
+    const uniqueNeighborFiles = [...new Set(neighborFilesWithErrors)];
+    let testSuggestionCount = 0;
+    if (uniqueNeighborFiles.length > 0 && typeof testRunnerClient.suggestTestFiles === "function") {
+      const testSuggestions = testRunnerClient.suggestTestFiles(uniqueNeighborFiles, cwd);
+      testSuggestionCount = testSuggestions.length;
+      logCascade({
+        phase: "cascade_test_targets",
+        filePath: cascadeLogFilePath,
+        neighborCount: uniqueNeighborFiles.length,
+        metadata: {
+          neighborFiles: uniqueNeighborFiles.slice(0, 10),
+          suggestedTestFiles: testSuggestions.slice(0, 10).map((s) => s.testFile),
+          runner: testSuggestions[0]?.runner,
+          truncated: testSuggestions.length > 10,
+          zeroSuggestions: testSuggestions.length === 0
+        }
+      });
+      if (testSuggestions.length > 0) {
+        const testLines = testSuggestions.slice(0, 5).map((s) => `  ${toRunnerDisplayPath(cwd, s.testFile)} (${s.runner})`);
+        let testSection = `\uD83E\uDDEA Likely tests for affected neighbors:
+${testLines.join(`
+`)}`;
+        if (testSuggestions.length > 5) {
+          testSection += `
+  ... and ${testSuggestions.length - 5} more`;
+        }
+        parts.push(testSection);
+      }
+    }
+    if (parts.length > 0) {
+      const section = parts.join(`
+
+`);
+      blockerParts.push(section);
+      deliveryHolds.push({
+        part: section,
+        onHeld: () => {
+          for (const run of sectionRuns)
+            runtime.appendCascadeRun(run);
+        }
+      });
+      logCascade({
+        phase: "cascade_injected",
+        filePath: cascadeLogFilePath,
+        neighborCount: injectedNeighborCount,
+        diagnosticCount: injectedDiagnosticCount,
+        metadata: {
+          sectionChars: section.length,
+          testSuggestionCount,
+          suppressedByOwnership
+        }
+      });
+    }
+    logCascade({
+      phase: "cascade_turn_end",
+      filePath: cascadeLogFilePath,
+      neighborCount: cascadeResults.reduce((s, r) => s + r.neighbors.length, 0),
+      diagnosticCount: cascadeResults.reduce((s, r) => s + r.neighbors.reduce((ns, n) => ns + n.diagnostics.length, 0), 0),
+      metadata: {
+        fileCount: cascadeResults.length,
+        mergedResults: seen.size
+      }
+    });
+  }
+  const indeterminateRuns = cascadeRuns.filter((r) => r.indeterminate);
+  if (indeterminateRuns.length > 0) {
+    const buildAdvisory = (runs, frame) => {
+      if (runs.length === 0)
+        return;
+      const byDetail = new Map;
+      for (const r of runs) {
+        const detail = r.indeterminate?.detail ?? frame.fallbackDetail(r);
+        const files = byDetail.get(detail) ?? [];
+        files.push(toRunnerDisplayPath(cwd, r.filePath));
+        byDetail.set(detail, files);
+      }
+      const lines = [];
+      for (const [detail, filesRaw] of byDetail) {
+        const files = [...new Set(filesRaw)];
+        const shown = files.slice(0, 5).join(", ");
+        const more = files.length > 5 ? ` (+${files.length - 5} more)` : "";
+        lines.push(`  • ${detail}: ${shown}${more}`);
+      }
+      const fileCount = new Set(runs.map((r) => normalizeMapKey(r.filePath))).size;
+      const reasons = [...byDetail.keys()].join("; ");
+      return `${frame.lead(fileCount, reasons)}
+${lines.join(`
+`)}`;
+    };
+    const graphRuns = indeterminateRuns.filter((r) => r.indeterminate?.reason !== "lsp_binding_rejected" && r.indeterminate?.reason !== "excluded_by_role" && r.indeterminate?.reason !== "budget_truncated" && r.indeterminate?.budget === undefined);
+    const bindingRuns = indeterminateRuns.filter((r) => r.indeterminate?.reason === "lsp_binding_rejected" && r.indeterminate?.budget === undefined);
+    const budgetRuns = indeterminateRuns.filter((r) => r.indeterminate?.reason === "budget_truncated" || r.indeterminate?.budget !== undefined);
+    const withCarryLabel = (advisory, runs) => {
+      if (advisory === undefined)
+        return;
+      const carried = runs.filter((r) => (r.carriedTurns ?? 0) > 0);
+      if (carried.length === 0 || carried.length !== runs.length) {
+        return advisory;
+      }
+      const stamps = carried.map((r) => r.observedAt);
+      const observedAt = stamps.every((s) => s !== undefined) ? Math.min(...stamps) : undefined;
+      const suffix = cascadeCarrySuffix(carried[0]?.carriedTurns, observedAt);
+      if (!suffix)
+        return advisory;
+      labeledAdvisories += 1;
+      return `${advisory}
+${suffix}`;
+    };
+    const holdAdvisory = (advisory, runs) => {
+      if (advisory === undefined)
+        return;
+      deliveryHolds.push({
+        part: advisory,
+        onHeld: () => {
+          for (const run of runs)
+            runtime.appendCascadeRun({ ...run, result: undefined });
+        }
+      });
+    };
+    const graphAdvisory = withCarryLabel(buildAdvisory(graphRuns, {
+      lead: (fileCount, reasons) => `Cascade could not compute downstream impact for ${fileCount} edited file(s) this turn — ` + `the review graph was unavailable (${reasons}), so their dependents were not ` + `cascade-checked and a clean cascade result does not cover them.`,
+      fallbackDetail: (r) => r.indeterminate?.reason === "missing_node" ? "changed file not in the review graph" : "review graph unavailable"
+    }), graphRuns);
+    if (graphAdvisory)
+      advisoryParts.push(graphAdvisory);
+    holdAdvisory(graphAdvisory, graphRuns);
+    const bindingAdvisory = withCarryLabel(buildAdvisory(bindingRuns, {
+      lead: (fileCount, reasons) => `Cascade identified dependents for ${fileCount} edited file(s) this turn, but their ` + `diagnostics could not be freshly confirmed (${reasons}) and were withheld — a clean ` + `cascade result does not cover them.`,
+      fallbackDetail: () => "cascade diagnostics withheld (binding rejected)"
+    }), bindingRuns);
+    if (bindingAdvisory)
+      advisoryParts.push(bindingAdvisory);
+    holdAdvisory(bindingAdvisory, bindingRuns);
+    const budgetAdvisory = withCarryLabel(buildAdvisory(budgetRuns, {
+      lead: (fileCount, reasons) => `Cascade checked the selected neighbors for ${fileCount} edited file(s) this turn, ` + `but some eligible dependents were not checked because the cascade budget ` + `was exhausted (${reasons}); a clean cascade result does not cover them.`,
+      fallbackDetail: (r) => {
+        const budget = r.indeterminate?.budget;
+        if (!budget)
+          return "cascade budget omitted eligible dependents";
+        const detail = `cascade budget checked ${budget.selectedCount} of ${budget.eligibleCount} eligible dependents (${budget.truncatedCount} omitted)`;
+        return budget.transitiveTruncated ? `${detail}; transitive expansion was capped before all eligible dependents were enumerated` : detail;
+      }
+    }), budgetRuns);
+    if (budgetAdvisory)
+      advisoryParts.push(budgetAdvisory);
+    holdAdvisory(budgetAdvisory, budgetRuns);
+    const fileCount = new Set(indeterminateRuns.map((r) => normalizeMapKey(r.filePath))).size;
+    const byFile = indeterminateRuns.map((r) => ({
+      file: toRunnerDisplayPath(cwd, r.filePath),
+      reason: r.indeterminate?.reason,
+      ...r.indeterminate?.detail && { detail: r.indeterminate.detail },
+      ...r.indeterminate?.budget && { budget: r.indeterminate.budget },
+      ...r.indeterminate?.diagnostic && {
+        diagnostic: r.indeterminate.diagnostic
+      }
+    }));
+    logCascade({
+      phase: "cascade_indeterminate",
+      filePath: indeterminateRuns[0]?.filePath ?? files[0] ?? cwd,
+      metadata: {
+        fileCount,
+        reasons: indeterminateRuns.map((r) => r.indeterminate?.reason),
+        byFile: byFile.slice(0, 20),
+        ...byFile.length > 20 && { byFileTruncated: byFile.length - 20 }
+      }
+    });
+  }
+  if (carriedRunsRendered > 0 || labeledAdvisories > 0) {
+    logCascade({
+      phase: "cascade_carry_rendered",
+      filePath: cascadeLogFilePath,
+      metadata: { carriedRunsRendered, labeledAdvisories }
+    });
+  }
+  const cascadeSkipped = {
+    blockers: 0,
+    non_code: 0,
+    no_neighbors: 0,
+    clean: 0,
+    indeterminate: 0,
+    error: 0
+  };
+  for (const r of cascadeRuns) {
+    if (r.skipReason)
+      cascadeSkipped[r.skipReason] = (cascadeSkipped[r.skipReason] ?? 0) + 1;
+  }
+  logLatency({
+    type: "phase",
+    toolName: "turn_end",
+    filePath: cwd,
+    phase: "cascade_merge",
+    durationMs: Date.now() - t0,
+    metadata: {
+      runsTotal: cascadeRuns.length,
+      resultCount: cascadeResults.length,
+      neighborCount: cascadeRuns.reduce((s, r) => s + r.neighborCount, 0),
+      diagnosticCount: cascadeRuns.reduce((s, r) => s + r.diagnosticCount, 0),
+      skipped: cascadeSkipped
+    }
+  });
+  const knipScan = resolveKnipScanRoots(cwd, files);
+  for (const root of knipScan.overCap) {
+    incrementDegradationCount({
+      kind: "turn-end-knip-root-skipped",
+      subject: "root-cap",
+      reason: `${toRunnerDisplayPath(cwd, root)} not scanned: more than ${MAX_KNIP_ROOTS_PER_TURN} checkouts edited this turn`
+    });
+  }
+  const KNOWN_SLOW_KNIP_GRACE_MS = 1;
+  const KNIP_MAX_SHOWN = 5;
+  const applyKnipResult = (scanRoot, prevKnip, knipResult, rowNow) => {
+    const knipWouldPoison = wouldPoisonCache(rowNow, knipResult);
+    if (knipWouldPoison) {
+      dbg(`turn_end: keeping last good knip cache; this run failed: ${knipResult.summary}`);
+    } else {
+      cacheManager.writeCache("knip", knipResult, scanRoot);
+    }
+    const knipMeta = {
+      execution: knipResult.execution ?? "executed",
+      success: knipResult.success,
+      totalIssues: knipResult.issues.length,
+      newIssues: 0,
+      blockerIssues: 0,
+      dispositionSuppressed: 0,
+      ...!knipResult.success && { reason: knipResult.summary },
+      ...knipResult.failureKind && { failureKind: knipResult.failureKind },
+      ...knipResult.nestedWorktrees !== undefined && {
+        nestedWorktrees: knipResult.nestedWorktrees,
+        nestedFilesDropped: knipResult.nestedFilesDropped
+      },
+      ...knipWouldPoison && { cacheKept: true }
+    };
+    const knipBlockerLane = carryLane("knip", scanRoot, "blocker");
+    const knipAdvisoryLane = carryLane("knip", scanRoot, "advisory");
+    const parkedKnip = knipResult.success ? [
+      ...takeParked(knipBlockerLane),
+      ...takeParked(knipAdvisoryLane)
+    ] : [];
+    if (knipResult.success && knipResult.issues.length > 0) {
+      const issueKey = (i) => stableFindingKey(i.type, i.file, i.name, i.package);
+      const prevKeys = new Set((prevKnip?.data?.issues ?? []).map(issueKey));
+      const modifiedSet = new Set(files.map((f) => resolveRunnerPath(cwd, f)));
+      const newIssues = knipResult.issues.filter((issue) => {
+        if (prevKeys.has(issueKey(issue)))
+          return false;
+        if (!issue.file)
+          return false;
+        const abs = resolveRunnerPath(scanRoot, issue.file);
+        return modifiedSet.has(abs);
+      });
+      knipMeta.newIssues = newIssues.length;
+      const reOffered = stillReportedParked(parkedKnip, knipResult.issues, issueKey, new Set(newIssues.map(issueKey)));
+      const reOfferedKeys = new Set(reOffered.map(issueKey));
+      if (reOffered.length > 0)
+        knipMeta.reOffered = reOffered.length;
+      if (newIssues.length > 0) {
+        projectDiagnosticsDelta.push(...knipIssuesToProjectDiagnostics(scanRoot, newIssues));
+        projectDiagnosticsSources.add("knip");
+      }
+      const knipPaired = [...newIssues, ...reOffered].flatMap((issue) => knipIssuesToProjectDiagnostics(scanRoot, [issue]).map((diagnostic) => ({
+        issue,
+        diagnostic
+      })));
+      const knipFiltered = filterFindingsByDisposition(knipPaired, cwd, (pair) => pair.diagnostic);
+      const knipDeliverable = {
+        kept: knipFiltered.kept.map((pair) => pair.issue),
+        suppressed: knipFiltered.suppressed
+      };
+      knipMeta.dispositionSuppressed = knipDeliverable.suppressed;
+      const displayPath = (issue) => issue.file ? toRunnerDisplayPath(cwd, resolveRunnerPath(scanRoot, issue.file)) : "(unknown)";
+      const blockerIssues = knipDeliverable.kept.filter((i) => i.type === "unlisted" || i.type === "bin");
+      knipMeta.blockerIssues = blockerIssues.length;
+      if (blockerIssues.length > 0) {
+        let report = `\uD83D\uDD34 New unresolved imports/deps in modified code (Knip):
+`;
+        let firstPath = null;
+        for (const issue of blockerIssues.slice(0, KNIP_MAX_SHOWN)) {
+          const display = displayPath(issue);
+          if (!firstPath && display !== "(unknown)")
+            firstPath = display;
+          report += `  ${display}${issue.line ? `:${issue.line}` : ""} — ${issue.type}: ${issue.name}
+`;
+        }
+        if (firstPath) {
+          report += `  First location: ${firstPath}
+`;
+        }
+        blockerParts.push(report);
+        deliveryHolds.push(cutAdvisoryHold("knip", knipBlockerLane, report, blockerIssues.slice(0, KNIP_MAX_SHOWN), (issue) => reOfferedKeys.has(issueKey(issue))));
+      }
+      const unusedExportDelta = knipDeliverable.kept.filter((i) => i.type === "export" || i.type === "enumMember");
+      if (unusedExportDelta.length > 0) {
+        let report = `⚠️ Newly unused exports in files you edited — check if callers need updating (Knip):
+`;
+        for (const issue of unusedExportDelta.slice(0, KNIP_MAX_SHOWN)) {
+          const display = displayPath(issue);
+          report += `  ${display}${issue.line ? `:${issue.line}` : ""} — ${issue.name}
+`;
+        }
+        advisoryParts.push(report);
+        deliveryHolds.push(cutAdvisoryHold("knip", knipAdvisoryLane, report, unusedExportDelta.slice(0, KNIP_MAX_SHOWN), (issue) => reOfferedKeys.has(issueKey(issue))));
+      }
+    }
+    return knipMeta;
+  };
+  const logKnipRow = (root, startedAt, metadata) => logLatency({
+    type: "phase",
+    toolName: "turn_end",
+    filePath: root,
+    phase: "knip",
+    durationMs: Date.now() - startedAt,
+    metadata
+  });
+  if (runtime.isStartupScanInFlight("knip")) {
+    dbg("turn_end: skipping knip (startup scan still in flight)");
+    logKnipRow(cwd, Date.now(), { skipped: true });
+  } else {
+    let budgetSpent = false;
+    for (const scanRoot of knipScan.roots) {
+      if (budgetSpent) {
+        incrementDegradationCount({
+          kind: "turn-end-knip-root-skipped",
+          subject: "budget",
+          reason: `${toRunnerDisplayPath(cwd, scanRoot)} not scanned: an earlier knip scan spent the turn_end budget`
+        });
+        continue;
+      }
+      const startedAt = Date.now();
+      const prevKnip = cacheManager.readCache("knip", scanRoot);
+      const previousFailedHard = prevKnip && !prevKnip.data.success && !prevKnip.data.failureKind && isHardFailureSummary(prevKnip.data.summary);
+      const abandonedFailure = previousFailedHard ? null : knipClient.recentHardFailure?.(scanRoot) ?? null;
+      let metadata;
+      if (previousFailedHard || abandonedFailure !== null) {
+        const reason = previousFailedHard ? prevKnip.data.summary : abandonedFailure ?? "";
+        dbg(`turn_end: skipping knip after recent failure: ${reason}`);
+        metadata = { skipped: true, reason };
+      } else {
+        const remainingMs = Math.max(0, HOOK_WALL_BUDGET_MS.turn_end - (Date.now() - turnEndStart));
+        const scanFloorMs = knipClient.scanFloorMs?.(scanRoot);
+        const knownSlow = scanFloorMs !== undefined && scanFloorMs > remainingMs;
+        const scanned = await bounded(withRowForFailureWrite(knipClient.analyze(scanRoot, getKnipIgnorePatterns(), {
+          projectSeq: runtime.projectSeq
+        }), cacheManager, "knip", scanRoot, prevKnip), {
+          ms: knownSlow ? KNOWN_SLOW_KNIP_GRACE_MS : remainingMs,
+          signal: deps.signal,
+          hook: "turn_end",
+          label: "knip"
+        });
+        if (scanned === undefined) {
+          dbg(`turn_end: knip for ${scanRoot} outlived the turn_end budget`);
+          const aborted = deps.signal?.aborted === true;
+          const nestedWorktrees = knipClient.nestedWorktrees?.(scanRoot) ?? 0;
+          metadata = {
+            execution: "deferred",
+            aborted,
+            ...knownSlow && {
+              reason: "scan-exceeds-budget",
+              scanFloorMs
+            },
+            ...nestedWorktrees > 0 && { nestedWorktrees }
+          };
+          if (nestedWorktrees > 0 && !aborted) {
+            incrementDegradationCount({
+              kind: "turn-end-knip-nested-worktrees",
+              subject: toRunnerDisplayPath(cwd, scanRoot),
+              reason: `${nestedWorktrees} linked worktree(s) nested under the scan root: knip walks them as project files and the scan did not fit the turn_end budget; add their directory (for example /.worktrees/) to .gitignore to drop the cost`
+            });
+          }
+        } else {
+          metadata = applyKnipResult(scanRoot, prevKnip, scanned.result, scanned.row);
+        }
+      }
+      budgetSpent = metadata.execution === "deferred" && (metadata.scanFloorMs === undefined || metadata.aborted === true);
+      logKnipRow(scanRoot, startedAt, metadata);
+    }
+  }
+  const tDeadCode = Date.now();
+  const deadCodeMeta = {};
+  if (runtime.isStartupScanInFlight("dead-code")) {
+    dbg("turn_end: skipping dead-code (startup scan still in flight)");
+    deadCodeMeta.skipped = true;
+    deadCodeMeta.reason = "startup_scan_in_flight";
+  } else if (deadCodeClients.length === 0) {
+    deadCodeMeta.reason = "no_clients";
+  } else {
+    let modifiedSet = null;
+    const modifiedFiles = () => modifiedSet ??= new Set(files.map((f) => resolveRunnerPath(cwd, f)));
+    let newIssueTotal = 0;
+    let deadCodeDispositionSuppressed = 0;
+    const reasons = [];
+    const deliverDeadCodeDelta = (client, sources) => {
+      const latest = sources.at(-1);
+      if (latest === undefined)
+        return;
+      const result = latest.result;
+      const deadCodeLane = carryLane("dead-code", client.id);
+      const parkedDeadCode = takeParked(deadCodeLane);
+      deadCodeMeta.totalIssues = (deadCodeMeta.totalIssues ?? 0) + deadCodeIssues(result).length;
+      if (!sources.some((source) => source.previousScan?.success)) {
+        reasons.push(`${client.id}:no_previous_scan`);
+        return;
+      }
+      const newIssues = [];
+      for (const source of sources) {
+        if (!source.previousScan?.success)
+          continue;
+        const prevKeys = new Set(deadCodeIssues(source.previousScan).map(deadCodeIssueKey));
+        for (const issue of deadCodeIssues(source.result)) {
+          if (prevKeys.has(deadCodeIssueKey(issue)) || !issue.file)
+            continue;
+          if (source.modified.has(resolveRunnerPath(cwd, issue.file))) {
+            newIssues.push(issue);
+          }
+        }
+      }
+      const reOffered = stillReportedParked(parkedDeadCode, deadCodeIssues(result), deadCodeIssueKey, new Set(newIssues.map(deadCodeIssueKey)));
+      if (newIssues.length === 0 && reOffered.length === 0) {
+        reasons.push(`${client.id}:clean`);
+        return;
+      }
+      newIssueTotal += newIssues.length;
+      if (newIssues.length > 0) {
+        projectDiagnosticsDelta.push(...newIssues.map((issue) => deadCodeIssueToProjectDiagnostic(cwd, issue, result.language)));
+        projectDiagnosticsSources.add("dead-code");
+      }
+      const deadCodeDeliverable = filterFindingsByDisposition([...newIssues, ...reOffered], cwd, (issue) => deadCodeIssueToProjectDiagnostic(cwd, issue, result.language));
+      deadCodeDispositionSuppressed += deadCodeDeliverable.suppressed;
+      if (deadCodeDeliverable.kept.length === 0) {
+        reasons.push(`${client.id}:all_disposed`);
+        return;
+      }
+      const deadCodePart = formatDeadCodeDelta(deadCodeDeliverable.kept, result.language);
+      advisoryParts.push(deadCodePart);
+      const reOfferedKeys = new Set(reOffered.map(deadCodeIssueKey));
+      deliveryHolds.push(cutAdvisoryHold("dead-code", deadCodeLane, deadCodePart, deadCodeDeliverable.kept.slice(0, DEAD_CODE_DELTA_MAX_SHOWN), (issue) => reOfferedKeys.has(deadCodeIssueKey(issue))));
+    };
+    try {
+      const lateScans = lateDeadCodeScansOf(turnScope);
+      for (const client of deadCodeClients) {
+        if (!client.detect(cwd)) {
+          reasons.push(`${client.id}:not_detected`);
+          continue;
+        }
+        const cacheKey = `dead-code-${client.id}`;
+        const lateKey = lateDeadCodeScanKey(client, cwd);
+        const sources = [];
+        const late = lateScans.get(lateKey);
+        let carried = new Set;
+        if (late?.settled) {
+          lateScans.delete(lateKey);
+          sources.push({
+            result: late.settled,
+            previousScan: late.previousScan,
+            modified: late.files
+          });
+          carried = late.carry;
+          reasons.push(`${client.id}:late_scan`);
+          if (joinedEarlierScan(late.settled, late.askedAt)) {
+            carried = new Set([...late.carry, ...late.files]);
+            reasons.push(`${client.id}:joined`);
+          }
+        }
+        try {
+          if (late && !late.settled) {
+            for (const file of modifiedFiles())
+              late.carry.add(file);
+            reasons.push(`${client.id}:in_flight`);
+            continue;
+          }
+          const scanFiles = new Set([...modifiedFiles(), ...carried]);
+          if (![...scanFiles].some((f) => client.owns(f))) {
+            reasons.push(`${client.id}:no_owned_files`);
+            continue;
+          }
+          const prev = cacheManager.readCache(cacheKey, cwd);
+          const previousFailedHard = prev && !prev.data.success && isHardFailureSummary(prev.data.summary);
+          const abandonedFailure = previousFailedHard ? null : client.recentHardFailure?.(cwd) ?? null;
+          if (previousFailedHard || abandonedFailure !== null) {
+            const failure = previousFailedHard ? prev.data.summary : abandonedFailure ?? "";
+            dbg(`turn_end: skipping dead-code after failure: ${failure}`);
+            deadCodeMeta.skipped = true;
+            reasons.push(`${client.id}:backoff:${failure}`);
+            continue;
+          }
+          const startMs = Date.now();
+          const scan = client.analyze(cwd);
+          const settled = await bounded(withRowForFailureWrite(scan, cacheManager, cacheKey, cwd, prev), {
+            signal: deps.signal,
+            hook: "turn_end",
+            label: "dead-code",
+            ms: Math.max(0, HOOK_WALL_BUDGET_MS.turn_end - (Date.now() - turnEndStart))
+          });
+          const joined = settled !== undefined && joinedEarlierScan(settled.result, startMs);
+          if (settled === undefined || joined) {
+            if (joined) {
+              reasons.push(`${client.id}:joined`);
+            } else {
+              dbg(`turn_end: dead-code(${client.id}) outlived the budget`);
+              deadCodeMeta.execution = "deferred";
+              deadCodeMeta.aborted = deps.signal?.aborted === true;
+              reasons.push(`${client.id}:deferred`);
+            }
+            parkLateDeadCodeScan({
+              scope: turnScope,
+              cacheManager,
+              client,
+              cwd,
+              cacheKey,
+              scan,
+              startedAt: startMs,
+              files: scanFiles,
+              previousScan: prev?.data
+            });
+            if (joined)
+              continue;
+            break;
+          }
+          const { result } = settled;
+          const durationMs = Date.now() - startMs;
+          if (wouldPoisonCache(settled.row, result)) {
+            dbg(`turn_end: keeping last good dead-code(${client.id}) cache; this run failed: ${result.summary}`);
+            deadCodeMeta.cacheKept = true;
+          } else {
+            cacheManager.writeCache(cacheKey, result, cwd, {
+              scanDurationMs: durationMs
+            });
+          }
+          logDeadCodeScan(deadCodeScanEvent(client, cwd, result, durationMs));
+          deadCodeMeta.success = result.success;
+          if (result.excludedWorktrees !== undefined) {
+            deadCodeMeta.excludedWorktrees = (deadCodeMeta.excludedWorktrees ?? 0) + result.excludedWorktrees;
+          }
+          if (!result.success) {
+            reasons.push(`${client.id}:scan_failed:${result.summary}`);
+            continue;
+          }
+          sources.push({
+            result,
+            previousScan: prev?.data,
+            modified: scanFiles
+          });
+        } catch (err) {
+          dbg(`turn_end: dead-code(${client.id}) failed: ${err}`);
+          reasons.push(`${client.id}:threw`);
+        } finally {
+          try {
+            deliverDeadCodeDelta(client, sources);
+          } catch (err) {
+            dbg(`turn_end: dead-code(${client.id}) delivery failed: ${err}`);
+            reasons.push(`${client.id}:threw`);
+          }
+        }
+      }
+    } catch (err) {
+      dbg(`turn_end: dead-code block failed: ${err}`);
+      reasons.push("block_threw");
+    }
+    deadCodeMeta.newIssues = newIssueTotal;
+    deadCodeMeta.dispositionSuppressed = deadCodeDispositionSuppressed;
+    if (reasons.length > 0)
+      deadCodeMeta.reason = reasons.join(",");
+  }
+  logLatency({
+    type: "phase",
+    toolName: "turn_end",
+    filePath: cwd,
+    phase: "dead-code",
+    durationMs: Date.now() - tDeadCode,
+    metadata: deadCodeMeta
+  });
+  let dispositionSuppressedTotal = 0;
+  const dispositionSuppressedByLane = {};
+  function recordDispositionSuppressed(lane, count) {
+    if (count <= 0)
+      return;
+    dispositionSuppressedTotal += count;
+    dispositionSuppressedByLane[lane] = (dispositionSuppressedByLane[lane] ?? 0) + count;
+  }
+  const scannerCacheReads = new Map;
+  const scannerStoresUnread = [];
+  function readScannerCache(scanner) {
+    let pending = scannerCacheReads.get(scanner);
+    if (pending === undefined) {
+      pending = deps.signal?.aborted ? Promise.resolve(null) : bounded(cacheManager.readCacheAsync(scanner, cwd), {
+        ms: HOOK_WALL_BUDGET_MS.turn_end,
+        signal: deps.signal,
+        hook: "turn_end",
+        label: `readScannerCache:${scanner}`
+      }).then((entry) => {
+        if (entry === undefined)
+          scannerStoresUnread.push(scanner);
+        return entry ?? null;
+      });
+      scannerCacheReads.set(scanner, pending);
+    }
+    return pending;
+  }
+  const laneCtx = {
+    cwd,
+    signal: deps.signal,
+    readScannerCache,
+    peekActionableWarnings: () => runtime.peekActionableWarnings(sessionId)
+  };
+  const govSources = await govulncheckLane.collect(laneCtx);
+  const trivyCacheEntry = await readScannerCache("trivy");
+  const secretsSources = await secretsLane.collect(laneCtx);
+  if (scannerStoresUnread.length > 0) {
+    logLatency({
+      type: "phase",
+      toolName: "turn_end",
+      filePath: cwd,
+      phase: "scanner_cache_read_abandoned",
+      durationMs: 0,
+      metadata: {
+        stores: scannerStoresUnread.join("+"),
+        aborted: deps.signal?.aborted === true
+      }
+    });
+  }
+  const scannerGates = gateFindingsByPathFreshness({
+    cwd,
+    sources: {
+      ...govSources,
+      ...secretsSources
+    }
+  });
+  const govGate = scannerGates.govulncheck;
+  const gitleaksGate = scannerGates.gitleaks;
+  const trivySecretsGate = scannerGates["trivy-secrets"];
+  const govDelivery = allowProjectWideFindings ? govulncheckLane.render(govulncheckLane.gate({ govulncheck: govGate }, laneCtx), laneCtx) : {};
+  for (const [store, count] of Object.entries(govDelivery.dispositionSuppressed ?? {})) {
+    recordDispositionSuppressed(store, count);
+  }
+  advisoryParts.push(...govDelivery.advisoryParts ?? []);
+  const secretsDelivery = allowProjectWideFindings ? secretsLane.render(secretsLane.gate({
+    gitleaks: gitleaksGate,
+    "trivy-secrets": trivySecretsGate
+  }, laneCtx), laneCtx) : {};
+  for (const [store, count] of Object.entries(secretsDelivery.dispositionSuppressed ?? {})) {
+    recordDispositionSuppressed(store, count);
+  }
+  const secretBlockedLocations = secretsDelivery.deliveredLocationKeys ?? new Set;
+  blockerParts.push(...secretsDelivery.blockerParts ?? []);
+  staleSecretParts.push(...secretsDelivery.staleSecretParts ?? []);
+  const trivyAgeLabel = formatCacheAgeLabel(trivyCacheEntry?.data?.scannedAt);
+  const trivyFindingsFiltered = filterFindingsByDisposition(trivyCacheEntry?.data?.findings ?? [], cwd, (f) => trivyFindingToProjectDiagnostic(cwd, f));
+  recordDispositionSuppressed("trivy", trivyFindingsFiltered.suppressed);
+  if (trivyFindingsFiltered.kept.length) {
+    const all = trivyFindingsFiltered.kept;
+    const critical = all.filter((f) => f.severity === "CRITICAL");
+    const advisory = all.filter((f) => f.severity !== "CRITICAL");
+    const fmt = (f) => {
+      const pkg = f.installedVersion ? `${f.pkgName}@${f.installedVersion}` : f.pkgName;
+      const fix = f.fixedVersion ? ` — upgrade to ${f.fixedVersion} or later` : " — no fix yet, track upstream";
+      return `  ${f.vulnerabilityId} (${pkg})${fix}
+`;
+    };
+    if (critical.length) {
+      const shown = critical.slice(0, 5);
+      let report = `\uD83D\uDD34 STOP — CRITICAL dependency CVEs (trivy, ${trivyAgeLabel}). Upgrade before shipping:
+`;
+      for (const f of shown)
+        report += fmt(f);
+      if (critical.length > shown.length) {
+        report += `  … and ${critical.length - shown.length} more
+`;
+      }
+      blockerParts.push(report);
+    }
+    if (advisory.length) {
+      const shown = advisory.slice(0, 5);
+      let report = `\uD83D\uDEE1️ Dependency CVEs (trivy, ${trivyAgeLabel}) — upgrade where possible:
+`;
+      for (const f of shown)
+        report += fmt(f);
+      if (advisory.length > shown.length) {
+        report += `  … and ${advisory.length - shown.length} more
+`;
+      }
+      advisoryParts.push(report);
+    }
+  }
+  const licenses = trivyCacheEntry?.data?.licenses ?? [];
+  if (licenses.length) {
+    const shown = licenses.slice(0, 5);
+    let report = `\uD83D\uDCDC Dependency license risk (trivy, ${trivyAgeLabel}) — review for compliance:
+`;
+    for (const l of shown) {
+      const cat = l.category ? `, ${l.category}` : "";
+      report += `  ${l.pkgName} — ${l.license} (${l.severity}${cat})
+`;
+    }
+    if (licenses.length > shown.length) {
+      report += `  … and ${licenses.length - shown.length} more
+`;
+    }
+    advisoryParts.push(report);
+  }
+  if (dispositionSuppressedTotal > 0) {
+    const byLane = Object.entries(dispositionSuppressedByLane).map(([lane, count]) => `${lane} ${count}`).join(", ");
+    advisoryParts.push(`suppressed by disposition: ${dispositionSuppressedTotal} finding(s) ` + `dropped from this turn's gitleaks/govulncheck/trivy sections (${byLane}) ` + "(marked false-positive or won't-fix).");
+  }
+  const t3 = Date.now();
+  let madgeStats;
+  const madgeAvailabilitySignal = deps.signal;
+  if (getFlag("lens-turn-end-madge") && await bounded(depChecker.ensureAvailable(), {
+    ms: HOOK_WALL_BUDGET_MS.turn_end,
+    signal: madgeAvailabilitySignal,
+    hook: "turn_end",
+    label: "madge.ensureAvailable"
+  })) {
+    const madgeFiles = cacheManager.getFilesForMadge(cwd, turnStateSessionId);
+    if (madgeFiles.length > 0) {
+      dbg(`turn_end: madge checking ${madgeFiles.length} file(s) for circular deps`);
+      const absFiles = madgeFiles.map((file) => path.resolve(cwd, file));
+      const batch = await depChecker.checkFilesBatch(absFiles, cwd);
+      const depResults = batch.results;
+      madgeStats = batch.stats;
+      for (const file of madgeFiles) {
+        const absPath = path.resolve(cwd, file);
+        const depResult = depResults.get(absPath);
+        if (!depResult)
+          continue;
+        if (depResult.hasCircular && depResult.circular.length > 0) {
+          dbg(`turn_end: circular dependency note for ${file} (suppressed in blockers-only mode)`);
+        }
+      }
+    }
+  }
+  logLatency({
+    type: "phase",
+    toolName: "turn_end",
+    filePath: cwd,
+    phase: "madge",
+    durationMs: Date.now() - t3,
+    metadata: madgeStats ?? { skipped: true }
+  });
+  if (!getFlag("no-tests") && files.length > 0) {
+    const seen = new Set;
+    const targets = [];
+    const testRootFor = createTurnEndTestRoots(cwd);
+    const candidates = [];
+    const seenCandidateKeys = new Set;
+    for (const file of files) {
+      const abs = resolveRunnerPath(cwd, file);
+      const key = normalizeMapKey(abs);
+      if (seenCandidateKeys.has(key))
+        continue;
+      seenCandidateKeys.add(key);
+      candidates.push({ display: file, abs, isNeighbor: false });
+    }
+    for (const result of cascadeResults) {
+      for (const neighbor of result.neighbors) {
+        const abs = path.isAbsolute(neighbor.filePath) ? neighbor.filePath : resolveRunnerPath(cwd, neighbor.filePath);
+        const key = normalizeMapKey(abs);
+        if (seenCandidateKeys.has(key))
+          continue;
+        seenCandidateKeys.add(key);
+        candidates.push({ display: neighbor.filePath, abs, isNeighbor: true });
+      }
+    }
+    const priorTestCache = cacheManager.readCache("test-runner-findings", cwd)?.data;
+    const carriedDeferred = priorTestCache?.deferredTargets ?? [];
+    const turnSessionId = sessionId ?? runtime.telemetrySessionId;
+    const isThisSession = (entry) => entry.sessionId === turnSessionId;
+    const entryPathKey = (entry) => normalizeMapKey(path.resolve(cwd, entry.testFile));
+    const retiredCarry = (priorTestCache?.retiredTargets ?? []).filter(isThisSession);
+    const retiredKeys = new Set(retiredCarry.map(entryPathKey));
+    const resolvedDeferralKeys = new Set;
+    const heldDeferred = [];
+    const boundPersisted = (entries, label) => {
+      const bounded = boundDeferredTargets(entries, TEST_RUNNER_MAX_PERSISTED_TARGETS, isThisSession);
+      if (bounded.length !== entries.length) {
+        dbg(`turn_end: ${label} test target list held ${entries.length} entries, bounded to the newest ${TEST_RUNNER_MAX_PERSISTED_TARGETS} (oldest foreign-session rows dropped)`);
+      }
+      return bounded;
+    };
+    const writeTestFindings = (record, ownDeferred) => {
+      const live = cacheManager.readCache("test-runner-findings", cwd)?.data;
+      const own = mergeDeferredTargets(heldDeferred, ownDeferred);
+      const ownKeys = new Set(own.map(entryPathKey));
+      const merged = mergeDeferredTargets(live?.deferredTargets ?? [], own).filter((entry) => {
+        if (!isThisSession(entry))
+          return true;
+        const key = entryPathKey(entry);
+        return !resolvedDeferralKeys.has(key) || ownKeys.has(key);
+      });
+      cacheManager.writeCache("test-runner-findings", {
+        ...record,
+        deferredTargets: boundPersisted(merged, "deferred"),
+        retiredTargets: boundPersisted(mergeDeferredTargets(live?.retiredTargets ?? [], retiredCarry), "retired")
+      }, cwd);
+    };
+    let deadDeferred = 0;
+    let heldOverCap = 0;
+    let foreignDeferred = 0;
+    let redispatchedDeferred = 0;
+    let retiredThisTurn = 0;
+    for (const carried of carriedDeferred) {
+      const testFile = path.resolve(cwd, carried.testFile);
+      const carriedKey = normalizeMapKey(testFile);
+      if (!isThisSession(carried)) {
+        foreignDeferred++;
+        continue;
+      }
+      if (seen.has(carriedKey)) {
+        resolvedDeferralKeys.add(carriedKey);
+        continue;
+      }
+      const attempts = carried.attempts ?? 0;
+      if (attempts >= TEST_RUNNER_MAX_DEFERRALS) {
+        resolvedDeferralKeys.add(carriedKey);
+        if (!retiredKeys.has(carriedKey)) {
+          retiredKeys.add(carriedKey);
+          retiredThisTurn++;
+          retiredCarry.push({
+            testFile,
+            runner: carried.runner,
+            attempts,
+            sessionId: turnSessionId
+          });
+          incrementDegradationCount({
+            kind: "test-runner-batch-capped",
+            subject: `${cwd}:deferral-exhausted`,
+            reason: `test target was cut after ${attempts} turn(s) at the turn-end budget and is retired for this session — too slow for a per-turn batch; run it explicitly (target: ${path.relative(cwd, testFile)})`
+          });
+          dbg(`turn_end: retiring deferred test target ${path.relative(cwd, testFile)} after ${attempts} cut batch(es) — too slow for the turn-end budget, run it explicitly`);
+        }
+        continue;
+      }
+      const config = RUNNERS[carried.runner];
+      const carriedRoot = testRootFor(testFile);
+      if (!config || isExcludedTestTarget(testFile, carriedRoot) || !fs.existsSync(testFile)) {
+        resolvedDeferralKeys.add(carriedKey);
+        deadDeferred++;
+        continue;
+      }
+      if (targets.length >= TEST_RUNNER_MAX_TARGETS) {
+        heldOverCap++;
+        heldDeferred.push({
+          testFile,
+          runner: carried.runner,
+          sourceFile: carried.sourceFile ?? testFile,
+          attempts,
+          sessionId: turnSessionId
+        });
+        continue;
+      }
+      resolvedDeferralKeys.add(carriedKey);
+      seen.add(carriedKey);
+      redispatchedDeferred++;
+      targets.push({
+        testFile,
+        sourceFile: carried.sourceFile ?? testFile,
+        runner: carried.runner,
+        config,
+        strategy: "deferred",
+        testRoot: carriedRoot,
+        deferralAttempts: attempts
+      });
+      dbg(`turn_end: re-running deferred test target ${path.relative(cwd, testFile)} (${carried.runner}) from the previous turn's cut batch`);
+    }
+    if (deadDeferred > 0) {
+      dbg(`turn_end: dropped ${deadDeferred} deferred test target(s) that no longer resolve (missing file, excluded, or unknown runner)`);
+    }
+    if (heldOverCap > 0) {
+      dbg(`turn_end: held ${heldOverCap} deferred test target(s) over the per-turn cap of ${TEST_RUNNER_MAX_TARGETS} — kept on the deferral list for the next turn, attempts unchanged`);
+    }
+    if (foreignDeferred > 0) {
+      dbg(`turn_end: ignored ${foreignDeferred} deferred test target(s) belonging to another session — left on the record for the session that cut them`);
+    }
+    if (carriedDeferred.length > 0) {
+      logLatency({
+        type: "phase",
+        toolName: "turn_end",
+        filePath: cwd,
+        phase: "test_runner_deferral",
+        durationMs: 0,
+        metadata: {
+          carried: carriedDeferred.length,
+          redispatched: redispatchedDeferred,
+          heldOverCap,
+          retired: retiredThisTurn,
+          dropped: deadDeferred,
+          foreignSession: foreignDeferred,
+          sessionId: turnSessionId
+        }
+      });
+    }
+    let overCapTargets = 0;
+    let missingTargetFiles = 0;
+    let excludedTargets = 0;
+    let retiredSkips = 0;
+    let noTestFile = 0;
+    const candidatesByRoot = new Map;
+    for (const { display, abs, isNeighbor } of candidates) {
+      const testRoot = testRootFor(abs);
+      candidatesByRoot.set(testRoot, (candidatesByRoot.get(testRoot) ?? 0) + 1);
+      const target = testRunnerClient.getTestRunTarget(abs, testRoot, runtime.turnIndex);
+      const targetKey = target ? normalizeMapKey(target.testFile) : "";
+      if (target && !seen.has(targetKey)) {
+        seen.add(targetKey);
+        if (retiredKeys.has(targetKey)) {
+          retiredSkips++;
+          dbg(`turn_end: ${display} → test target retired earlier this session (outran the turn-end batch budget), skipping spawn (${path.relative(cwd, target.testFile)})`);
+          continue;
+        }
+        if (isExcludedTestTarget(target.testFile, testRoot)) {
+          excludedTargets++;
+          dbg(`turn_end: ${display} → test target excluded by the built-in turn-end policy, skipping spawn (${path.relative(cwd, target.testFile)})`);
+          continue;
+        }
+        if (!fs.existsSync(target.testFile)) {
+          missingTargetFiles++;
+          dbg(`turn_end: ${display} → test file missing, skipping spawn (${path.relative(cwd, target.testFile)})`);
+          continue;
+        }
+        if (targets.length >= TEST_RUNNER_MAX_TARGETS) {
+          overCapTargets++;
+          continue;
+        }
+        targets.push({ ...target, sourceFile: abs, testRoot });
+        dbg(`turn_end: ${display} → test ${target.runner} ${path.relative(cwd, target.testFile)} (${target.strategy}${isNeighbor ? ", cascade-neighbor" : ""})`);
+      } else if (!target) {
+        noTestFile++;
+        dbg(`turn_end: ${display} → no test file found${isNeighbor ? " (cascade-neighbor)" : ""}`);
+      }
+    }
+    if (excludedTargets > 0) {
+      dbg(`turn_end: excluded ${excludedTargets} test target(s) by the built-in turn-end policy`);
+    }
+    if (retiredSkips > 0) {
+      dbg(`turn_end: skipped ${retiredSkips} test target(s) retired earlier this session for outrunning the turn-end batch budget`);
+    }
+    if (missingTargetFiles > 0) {
+      dbg(`turn_end: skipped ${missingTargetFiles} test target(s) whose file no longer exists`);
+    }
+    if (overCapTargets > 0) {
+      recordDegradationOnce({
+        kind: "test-runner-batch-capped",
+        subject: cwd,
+        reason: `turn touched more test targets than one turn may fire; ran ${TEST_RUNNER_MAX_TARGETS}, skipped ${overCapTargets} — re-run the remainder with lens_diagnostics or edit them in a smaller batch`
+      });
+      dbg(`turn_end: test target count capped at ${TEST_RUNNER_MAX_TARGETS}, ${overCapTargets} skipped`);
+    }
+    if (candidates.length > 0) {
+      const selectedByRoot = new Map;
+      for (const target of targets) {
+        selectedByRoot.set(target.testRoot, (selectedByRoot.get(target.testRoot) ?? 0) + 1);
+      }
+      const roots = [...candidatesByRoot.entries()].map(([root, candidateCount]) => ({
+        root: root === cwd ? "." : toRunnerDisplayPath(cwd, root),
+        candidates: candidateCount,
+        selected: selectedByRoot.get(root) ?? 0
+      }));
+      emitBounded("turn_end_test_selection", `${cwd}:turn:${runtime.turnIndex}`, {
+        filePath: cwd,
+        durationMs: 0,
+        metadata: {
+          sessionId: turnSessionId,
+          candidates: candidates.length,
+          selected: targets.length,
+          noTestFile,
+          excluded: excludedTargets,
+          missing: missingTargetFiles,
+          overCap: overCapTargets,
+          retired: retiredSkips,
+          roots: roots.slice(0, TURN_END_SELECTION_ROOT_ROWS),
+          rootsOmitted: Math.max(0, roots.length - TURN_END_SELECTION_ROOT_ROWS)
+        }
+      });
+    }
+    if (targets.length > 0) {
+      for (const target of targets) {
+        target.fileSeqAtRun = runtime.getFileSeq(target.sourceFile);
+      }
+      dbg(`turn_end: firing ${targets.length} test target(s) async (non-blocking, max ${TEST_RUNNER_BATCH_CONCURRENCY} concurrent)`);
+      const firedAtTurn = runtime.turnIndex;
+      const firedSessionId = turnSessionId;
+      const testRunGeneration = (priorTestCache?.testRunGeneration ?? 0) + 1;
+      const provenanceFiles = [
+        ...candidates.map((candidate) => ({
+          path: candidate.abs,
+          role: "source"
+        })),
+        ...targets.map((target) => ({
+          path: target.testFile,
+          role: "test"
+        }))
+      ];
+      const launchedFrom = snapshotAdvisoryProvenance({
+        cwd,
+        runtime,
+        generation: testRunGeneration,
+        files: provenanceFiles
+      });
+      writeTestFindings({
+        ...priorTestCache ?? { content: "" },
+        testRunGeneration
+      }, []);
+      runTestTargetsBounded({
+        targets,
+        concurrency: TEST_RUNNER_BATCH_CONCURRENCY,
+        budgetMs: TEST_RUNNER_BATCH_BUDGET_MS,
+        signal: getAmbientAbortSignal(),
+        run: (t, batchSignal) => testRunnerClient.runTestFileAsync(t.testFile, t.testRoot, {
+          runner: t.runner,
+          config: t.config,
+          turnIndex: firedAtTurn,
+          signal: batchSignal,
+          displayRoot: cwd,
+          requireOwnInstall: t.testRoot !== cwd
+        })
+      }).then(({ results: batchResults, deferred, stopReason }) => {
+        const settledResults = batchResults;
+        const results = [];
+        for (const result of settledResults) {
+          if (!("value" in result) || !result.value.notRun) {
+            results.push(result);
+            continue;
+          }
+          const skippedRoot = targets.find((candidate) => candidate.testFile === result.value.file)?.testRoot ?? cwd;
+          const ambientNote = result.value.runner === "pytest" && hasAmbientPythonEnvironment() ? "; ambient Python environments outside this checkout were not borrowed" : "";
+          incrementDegradationCount({
+            kind: "turn-end-test-root-skipped",
+            subject: result.value.notRun,
+            reason: `${toRunnerDisplayPath(cwd, skippedRoot)} has no ${result.value.runner} install of its own${ambientNote}; its tests were skipped rather than fetched through npx or run in another environment`
+          });
+          dbg(`turn_end: skipped ${toRunnerDisplayPath(cwd, result.value.file)}: ${result.value.notRun} in ${toRunnerDisplayPath(cwd, skippedRoot)}`);
+        }
+        const verdicts = results.flatMap((result) => {
+          if (result.status === "rejected")
+            return [];
+          const target = targets.find((candidate) => candidate.testFile === result.value.file);
+          return target ? [
+            {
+              file: result.value.file,
+              sourceFile: target.sourceFile,
+              runner: target.runner,
+              fileSeq: target.fileSeqAtRun === undefined ? {
+                state: "unknown",
+                reason: "sequence-unavailable"
+              } : {
+                state: "known",
+                value: target.fileSeqAtRun
+              }
+            }
+          ] : [];
+        });
+        const deferredTargets = deferred.map((t) => ({
+          testFile: t.testFile,
+          sourceFile: t.sourceFile,
+          runner: t.runner,
+          attempts: (t.deferralAttempts ?? 0) + 1,
+          sessionId: firedSessionId
+        }));
+        if (deferred.length > 0) {
+          incrementDegradationCount({
+            kind: "test-runner-batch-capped",
+            subject: `${cwd}:${stopReason ?? "incomplete"}`,
+            reason: `test batch stopped early (${stopReason ?? "incomplete"}); ${deferred.length} target(s) killed or never dispatched, deferred to the next turn`
+          });
+          dbg(`turn_end: test batch stopped early (${stopReason ?? "incomplete"}), ${deferred.length} target(s) deferred to the next turn`);
+        }
+        const deferralNote = deferred.length > 0 ? `${deferred.length} test target(s) did not finish within the turn-end batch budget and are deferred to the next turn (they run first): ${deferredTargets.map((t) => path.relative(cwd, t.testFile)).join(", ")}` : "";
+        const supersededByNewerGeneration = (label) => {
+          const current = cacheManager.readCache("test-runner-findings", cwd)?.data;
+          const currentGeneration = current?.testRunGeneration;
+          if (currentGeneration !== undefined && currentGeneration > testRunGeneration) {
+            dbg(`turn_end: ${label}test generation ${testRunGeneration} superseded by ${currentGeneration}`);
+            if (deferredTargets.length > 0) {
+              writeTestFindings({ ...current ?? { content: "" } }, deferredTargets);
+              dbg(`turn_end: ${label}carried ${deferredTargets.length} cut target(s) into the newer generation's deferral set`);
+            }
+            return true;
+          }
+          return false;
+        };
+        const publishedAgainst = snapshotAdvisoryProvenance({
+          cwd,
+          runtime,
+          generation: testRunGeneration,
+          files: provenanceFiles
+        });
+        const superseded = launchedFrom.revision.sessionId !== publishedAgainst.revision.sessionId || launchedFrom.revision.projectSeq !== publishedAgainst.revision.projectSeq || launchedFrom.revision.turnIndex !== publishedAgainst.revision.turnIndex || launchedFrom.files.some((file, index) => publishedAgainst.files[index]?.sha256 !== file.sha256 || publishedAgainst.files[index]?.path !== file.path);
+        const stale = runtime.turnIndex !== firedAtTurn;
+        const failures = [];
+        const resultValues = [];
+        let rejectedCount = 0;
+        let hasRealFailure = false;
+        for (const r of results) {
+          if (r.status === "rejected") {
+            rejectedCount++;
+            emitBounded("test_runner_delivery", `${cwd}:generation:${testRunGeneration}:rejected`, {
+              filePath: cwd,
+              durationMs: 0,
+              metadata: {
+                outcome: "runner-promise-rejected",
+                sessionId: firedSessionId,
+                generation: testRunGeneration,
+                targetCount: targets.length,
+                droppedDetailCount: 0,
+                reason: String(r.reason).slice(0, 500)
+              }
+            }, {
+              ledgerKind: "test-runner-delivery",
+              reason: "test runner promise rejected",
+              capPerTurn: { limit: 8, turnIndex: firedAtTurn }
+            });
+            dbg(`turn_end: test run rejected — ${r.reason}`);
+            continue;
+          }
+          resultValues.push(r.value);
+          const { file, runner, passed, failed, duration, error } = r.value;
+          if (failed > 0)
+            hasRealFailure = true;
+          const shortFile = path.basename(file);
+          const elapsed = formatRunDurationMs(duration);
+          const verdict = failed > 0 ? "FAIL" : "PASS";
+          const summary = isRunnerErrorResult(r.value) ? passed > 0 ? `error: ${error} (${passed} passed before)` : `error: ${error}` : `${verdict} ${passed}p/${failed}f (${elapsed})`;
+          dbg(`turn_end: ${stale ? "[stale] " : ""}test ${runner} ${shortFile} → ${summary}`);
+          if (failed > 0 || error) {
+            if (error && String(r.value?.error ?? "").includes("Test file not found")) {
+              continue;
+            }
+            const formatted = testRunnerClient.formatResult(r.value);
+            if (formatted)
+              failures.push(formatted);
+          }
+        }
+        if (rejectedCount > 0) {
+          failures.push(`Test runner rejected ${rejectedCount} promise(s) before producing a structured result.`);
+        }
+        if (failures.length > 0) {
+          if (supersededByNewerGeneration(""))
+            return;
+          const content = [
+            stale ? "[from a prior turn — the edit that triggered this run had already been superseded by the time results came back]" : "",
+            failures.join(`
+
+`),
+            deferralNote
+          ].filter(Boolean).join(`
+
+`);
+          const runnerErrorOnly = !hasRealFailure;
+          writeTestFindings({
+            content,
+            stale,
+            results: resultValues,
+            verdicts,
+            testRunGeneration,
+            launchedFrom,
+            publishedAgainst,
+            provenance: publishedAgainst,
+            superseded,
+            runnerErrorOnly
+          }, deferredTargets);
+          try {
+            deps.onTestRunnerComplete?.({
+              cwd,
+              sessionId: firedSessionId,
+              generation: testRunGeneration,
+              targetCount: targets.length,
+              hasFindings: true
+            });
+          } catch (deliveryErr) {
+            dbg(`turn_end: test delivery staging failed — ${deliveryErr}`);
+          }
+          if (getFlag("lens-guard") && firedSessionId === runtime.telemetrySessionId) {
+            const cleanFiles = resultValues.filter((value) => value.failed === 0 && !value.error).map((value) => value.file);
+            if (cleanFiles.length > 0) {
+              clearGitGuardTestFailure(cacheManager, cwd, runtime, cleanFiles);
+            }
+            if (!runnerErrorOnly) {
+              mergeGitGuardTestFailure(cacheManager, cwd, runtime, content, resultValues.filter((value) => value.failed > 0).map((value) => value.file));
+            } else {
+              emitBounded("test_runner_delivery", `${cwd}:generation:${testRunGeneration}:runner-error-only`, {
+                filePath: cwd,
+                durationMs: 0,
+                metadata: {
+                  outcome: "runner-error-only-not-blocking",
+                  sessionId: firedSessionId,
+                  generation: testRunGeneration,
+                  targetCount: targets.length,
+                  droppedDetailCount: 0
+                }
+              }, {
+                ledgerKind: "test-runner-delivery",
+                reason: "runner-error-only batch kept off the --lens-guard blocker",
+                capPerTurn: { limit: 8, turnIndex: firedAtTurn }
+              });
+            }
+          }
+          dbg(`turn_end: ${failures.length} test failure(s) cached for pull diagnostics and post-agent delivery${stale ? " (stale — turn advanced while tests ran)" : ""}`);
+        } else if (deferred.length > 0) {
+          if (supersededByNewerGeneration("deferred "))
+            return;
+          writeTestFindings({
+            content: deferralNote,
+            stale,
+            results: resultValues,
+            verdicts,
+            testRunGeneration,
+            launchedFrom,
+            publishedAgainst,
+            provenance: publishedAgainst,
+            superseded,
+            runnerErrorOnly: true
+          }, deferredTargets);
+          try {
+            deps.onTestRunnerComplete?.({
+              cwd,
+              sessionId: firedSessionId,
+              generation: testRunGeneration,
+              targetCount: targets.length,
+              hasFindings: true
+            });
+          } catch (deliveryErr) {
+            dbg(`turn_end: test delivery staging failed — ${deliveryErr}`);
+          }
+          dbg(`turn_end: partial test batch — ${results.length} target(s) settled, ${deferred.length} deferred to the next turn; NOT recorded as a clean run`);
+        } else if (results.length > 0) {
+          if (supersededByNewerGeneration("clean "))
+            return;
+          writeTestFindings({
+            ...priorTestCache ?? { content: "" },
+            content: "",
+            stale: false,
+            results: resultValues,
+            testRunGeneration,
+            launchedFrom,
+            publishedAgainst,
+            provenance: publishedAgainst,
+            superseded
+          }, []);
+          try {
+            deps.onTestRunnerComplete?.({
+              cwd,
+              sessionId: firedSessionId,
+              generation: testRunGeneration,
+              targetCount: targets.length,
+              hasFindings: false
+            });
+          } catch (deliveryErr) {
+            dbg(`turn_end: test delivery staging failed — ${deliveryErr}`);
+          }
+          if (getFlag("lens-guard") && firedSessionId === runtime.telemetrySessionId) {
+            clearGitGuardTestFailure(cacheManager, cwd, runtime, resultValues.map((value) => value.file));
+          }
+          dbg(`turn_end: all tests passed${stale ? " (stale — turn advanced while tests ran)" : ""}`);
+        }
+      }).catch(() => {});
+    } else if (carriedDeferred.length > 0) {
+      writeTestFindings({ ...priorTestCache ?? { content: "" } }, []);
+    }
+  }
+  if (runtime.errorDebtBaseline && files.length > 0) {
+    dbg("turn_end: marking error debt check for next session");
+    cacheManager.writeCache("errorDebt", {
+      pendingCheck: true,
+      baselineTestsPassed: runtime.errorDebtBaseline.testsPassed
+    }, cwd);
+  }
+  if (runtime.callGraph && files.length > 0) {
+    const coverage = runtime.callGraph.coverage;
+    if (!coverage || coverage.complete !== true) {
+      advisoryParts.push("Call-graph impact was not emitted because call-graph extraction coverage is incomplete; " + "the affected files may have unreported callers.");
+    } else {
+      const callGraphStart = Date.now();
+      try {
+        const { impact, formatImpact, parseSymbolKey } = await import("./call-graph.js");
+        const { callGraphImpactToProjectDiagnostics } = await import("./project-diagnostics/runner-adapters/call-graph-impact.js");
+        const impactLines = [];
+        let callGraphDispositionSuppressed = 0;
+        const impactFindings = [];
+        const impactFiles = files.slice(0, 5);
+        const impactFileKeys = new Set(impactFiles.map((file) => normalizeMapKey(resolveRunnerPath(cwd, file))));
+        const reOfferedImpactFiles = takeParked(carryLane("call-graph")).filter((file) => !impactFileKeys.has(normalizeMapKey(resolveRunnerPath(cwd, file))));
+        const shownImpactFiles = [];
+        for (const filePath of [...impactFiles, ...reOfferedImpactFiles]) {
+          const linesBefore = impactLines.length;
+          const changedFileKey = normalizeMapKey(resolveRunnerPath(cwd, filePath));
+          const fileCallerKeys = [...runtime.callGraph.callers.keys()].filter((k) => {
+            const graphFilePath = parseSymbolKey(k).filePath;
+            return normalizeMapKey(resolveRunnerPath(cwd, graphFilePath)) === changedFileKey;
+          });
+          for (const calleeKey of fileCallerKeys.slice(0, 3)) {
+            const results = impact(runtime.callGraph, calleeKey).filter((r) => {
+              const callerFile = parseSymbolKey(r.symbolKey).filePath;
+              return !callerFile || !isTestRoleCollateral(resolveRunnerPath(cwd, callerFile));
+            });
+            if (results.length > 0) {
+              impactFindings.push({ calleeKey, results });
+              const markable = results.flatMap((result) => callGraphImpactToProjectDiagnostics(cwd, [
+                { calleeKey, results: [result] }
+              ]).map((diagnostic) => ({ result, diagnostic })));
+              const filtered = filterFindingsByDisposition(markable, cwd, (entry) => entry.diagnostic);
+              callGraphDispositionSuppressed += filtered.suppressed;
+              const keptEntries = new Set(filtered.kept);
+              const dropped = new Set(markable.filter((entry) => !keptEntries.has(entry)).map((entry) => entry.result));
+              const survivors = dropped.size === 0 ? results : results.filter((r) => !dropped.has(r));
+              const summary = survivors.length > 0 ? formatImpact(survivors, cwd) : "";
+              if (summary)
+                impactLines.push(`  ${parseSymbolKey(calleeKey).symbolName ?? calleeKey}: ${summary}`);
+            }
+          }
+          if (impactLines.length > linesBefore)
+            shownImpactFiles.push(filePath);
+        }
+        if (impactLines.length > 0) {
+          const impactPart = `\uD83D\uDCCA Call-graph impact (changed symbols have callers):
+${impactLines.join(`
+`)}`;
+          advisoryParts.push(impactPart);
+          deliveryHolds.push(cutAdvisoryHold("call-graph", carryLane("call-graph"), impactPart, shownImpactFiles, (file) => !impactFiles.includes(file)));
+        }
+        if (impactFindings.length > 0) {
+          const impactDiagnostics = callGraphImpactToProjectDiagnostics(cwd, impactFindings);
+          if (impactDiagnostics.length > 0) {
+            projectDiagnosticsDelta.push(...impactDiagnostics);
+            projectDiagnosticsSources.add("call-graph");
+          }
+        }
+        if (impactFindings.length > 0 || callGraphDispositionSuppressed > 0) {
+          logLatency({
+            type: "phase",
+            toolName: "turn_end",
+            filePath: cwd,
+            phase: "call_graph_impact",
+            durationMs: Date.now() - callGraphStart,
+            metadata: {
+              callees: impactFindings.length,
+              lines: impactLines.length,
+              dispositionSuppressed: callGraphDispositionSuppressed
+            }
+          });
+        }
+      } catch {}
+    }
+  }
+  if (projectDiagnosticsDelta.length > 0) {
+    writeProjectDiagnosticsDeltaReport(cwd, {
+      version: PROJECT_DIAGNOSTICS_CACHE_VERSION,
+      cwd,
+      generatedAt: new Date().toISOString(),
+      sessionId: runtime.telemetrySessionId,
+      turnIndex: runtime.turnIndex,
+      projectSeqStart: runtime.turnStartProjectSeq,
+      projectSeqEnd: runtime.projectSeq,
+      diagnostics: projectDiagnosticsDelta,
+      sources: [...projectDiagnosticsSources].sort((a, b) => a.localeCompare(b))
+    });
+  }
+  const t4 = Date.now();
+  const modifiedRangesByFile = new Map(Object.entries(turnState.files).map(([file, state]) => [
+    normalizeMapKey(resolveRunnerPath(cwd, file)),
+    state.modifiedRanges
+  ]));
+  const getFileSeq = runtime.getFileSeq;
+  const fileSeqByPath = new Map;
+  if (getFileSeq) {
+    for (const file of files) {
+      const filePath = normalizeMapKey(resolveRunnerPath(cwd, file));
+      fileSeqByPath.set(filePath, getFileSeq.call(runtime, filePath));
+    }
+  }
+  let reverify;
+  if (getFlag("lens-actionable-warnings")) {
+    const persistedReport = cacheManager.readCache("actionable-warnings", cwd, Number.MAX_SAFE_INTEGER)?.data;
+    if (persistedReport?.files?.some((entry) => entry.origin === "deferred")) {
+      const reverifyLspService = getLSPService();
+      if (reverifyLspService) {
+        reverify = await bounded(runPersistentReverify({
+          report: persistedReport,
+          cwd,
+          lspService: reverifyLspService,
+          signal: getAmbientAbortSignal()
+        }), {
+          ms: HOOK_WALL_BUDGET_MS.turn_end,
+          signal: getAmbientAbortSignal(),
+          hook: "turn_end",
+          label: "persistent_reverify"
+        });
+      }
+    }
+    try {
+      const report = await buildActionableWarningsReport({
+        cwd,
+        sessionId: runtime.telemetrySessionId,
+        turnIndex: runtime.turnIndex,
+        files,
+        modifiedRangesByFile,
+        dispatchWarnings: runtime.peekActionableWarnings(sessionId),
+        includeLspCodeActions: !!getFlag("lens-actionable-warning-actions"),
+        projectSeqStart: runtime.turnStartProjectSeq,
+        projectSeqEnd: runtime.projectSeq,
+        branchEpoch: runtime.readGuard.currentBranchEpoch,
+        branchScope: runtime.readGuard.lineageKey,
+        fileSeqByPath,
+        deltaOnly: !getFlag("lens-actionable-warning-all"),
+        dbg,
+        signal: getAmbientAbortSignal(),
+        onDeferredReport: (deferred) => {
+          try {
+            writeDeferredActionableWarningsReport({
+              cacheManager,
+              cwd,
+              report: deferred,
+              getFileSeq: getFileSeq ? (filePath) => getFileSeq.call(runtime, filePath) : undefined,
+              dbg
+            });
+          } catch (deferErr) {
+            dbg(`turn_end: deferred actionable-warnings write failed — ${deferErr}`);
+          }
+        }
+      });
+      if (reverify?.replacementFiles.length) {
+        const replacementByPath = new Map(reverify.replacementFiles.map((file) => [
+          normalizeMapKey(file.filePath),
+          file
+        ]));
+        const files = (report.files ?? []).map((file) => replacementByPath.get(normalizeMapKey(file.filePath)) ?? file);
+        for (const replacement of reverify.replacementFiles) {
+          if (!files.some((file) => normalizeMapKey(file.filePath) === normalizeMapKey(replacement.filePath))) {
+            files.push(replacement);
+          }
+        }
+        report.files = files;
+      }
+      const publishResult = publishActionableWarningsReport(cacheManager, cwd, report, {
+        origin: "in-band",
+        getFileSeq: getFileSeq ? (filePath) => getFileSeq.call(runtime, filePath) : undefined,
+        dbg
+      });
+      const advisory = formatActionableWarningsAdvisory(publishResult.report, cwd, host, (report) => {
+        let dispositionSuppressed = 0;
+        const files = report.files.map((file) => {
+          const policy = filterFindingsByDisposition(file.warnings, cwd, (warning) => {
+            const { line, column, rule, code } = warning;
+            return {
+              filePath: warning.filePath,
+              severity: warning.severity,
+              semantic: "warning",
+              tool: warning.tool,
+              runner: warning.tool,
+              message: warning.message,
+              source: warning.origin === "lsp" ? "lsp" : "dispatch",
+              ...line === undefined ? {} : { line: warning.line },
+              ...column === undefined ? {} : { column: warning.column },
+              ...rule === undefined ? {} : { rule: warning.rule },
+              ...code === undefined ? {} : { code }
+            };
+          });
+          dispositionSuppressed += policy.suppressed;
+          const kept = policy.kept.filter((warning) => !(isSecretWarning(warning) && typeof warning.line === "number" && secretBlockedLocations.has(secretLocationKey(warning.filePath, warning.line))));
+          return kept.length > 0 ? { ...file, warnings: kept } : undefined;
+        }).filter((file) => file !== undefined);
+        recordDispositionSuppressed("actionable-warnings", dispositionSuppressed);
+        return { files, suppressed: dispositionSuppressed };
+      });
+      if (advisory)
+        advisoryParts.push(advisory);
+      logActionableWarningsEvent({
+        event: advisory ? "advisory_injected" : "advisory_skipped",
+        sessionId: runtime.telemetrySessionId,
+        metadata: {
+          turnIndex: runtime.turnIndex,
+          unsuppressed: publishResult.report.summary.unsuppressed
+        }
+      });
+      logLatency({
+        type: "phase",
+        toolName: "turn_end",
+        filePath: cwd,
+        phase: "actionable_warnings_report",
+        durationMs: Date.now() - t4,
+        metadata: report.summary
+      });
+    } catch (err) {
+      dbg(`turn_end: actionable warning report failed: ${err}`);
+      logLatency({
+        type: "phase",
+        toolName: "turn_end",
+        filePath: cwd,
+        phase: "actionable_warnings_report",
+        durationMs: Date.now() - t4,
+        metadata: {
+          failed: true,
+          error: err instanceof Error ? err.message : String(err)
+        }
+      });
+    }
+  }
+  const t5 = Date.now();
+  try {
+    const qualityWarningsByFile = new Map;
+    for (const warning of runtime.peekCodeQualityWarnings(sessionId)) {
+      const group = qualityWarningsByFile.get(warning.filePath);
+      if (group)
+        group.push(warning);
+      else
+        qualityWarningsByFile.set(warning.filePath, [warning]);
+    }
+    const qualityWarnings = [];
+    let qualityDispositionSuppressed = 0;
+    for (const [filePath, group] of qualityWarningsByFile) {
+      let content;
+      try {
+        content = fs.readFileSync(filePath, "utf-8");
+      } catch {
+        content = undefined;
+      }
+      const { kept, suppressed } = applyPushedFindingPolicy(group, {
+        cwd,
+        filePath,
+        content
+      });
+      qualityWarnings.push(...kept);
+      qualityDispositionSuppressed += suppressed;
+    }
+    const qualityReport = buildCodeQualityWarningsReport({
+      cwd,
+      sessionId: runtime.telemetrySessionId,
+      turnIndex: runtime.turnIndex,
+      warnings: qualityWarnings,
+      modifiedRangesByFile,
+      projectSeqStart: runtime.turnStartProjectSeq,
+      projectSeqEnd: runtime.projectSeq,
+      fileSeqByPath
+    });
+    writeCodeQualityWarningsReport(cacheManager, cwd, qualityReport);
+    appendCodeQualityWarningsHistory(cwd, qualityReport);
+    const advisory = formatCodeQualityWarningsAdvisory(qualityReport, cwd, host);
+    if (advisory)
+      advisoryParts.push(advisory);
+    logLatency({
+      type: "phase",
+      toolName: "turn_end",
+      filePath: cwd,
+      phase: "code_quality_warnings_report",
+      durationMs: Date.now() - t5,
+      metadata: {
+        ...qualityReport.summary,
+        dispositionSuppressed: qualityDispositionSuppressed
+      }
+    });
+  } catch (err) {
+    dbg(`turn_end: code quality warning report failed: ${err}`);
+    logLatency({
+      type: "phase",
+      toolName: "turn_end",
+      filePath: cwd,
+      phase: "code_quality_warnings_report",
+      durationMs: Date.now() - t5,
+      metadata: {
+        failed: true,
+        error: err instanceof Error ? err.message : String(err)
+      }
+    });
+  }
+  cacheManager.incrementTurnCycle(cwd, currentOwner, turnStateSessionId);
+  const lateAuxStart = Date.now();
+  const lateAuxDrain = isSecondarySession ? {
+    drainedPairs: drainPendingAuxiliaryCoverage(),
+    lateAuxCapEvicted: drainPendingAuxCapEvictedCount()
+  } : holdScope.guardedWrite("turn-end:late-aux", () => ({
+    drainedPairs: drainPendingAuxiliaryCoverage(),
+    lateAuxCapEvicted: drainPendingAuxCapEvictedCount()
+  })) ?? { drainedPairs: [], lateAuxCapEvicted: 0 };
+  const { drainedPairs, lateAuxCapEvicted } = lateAuxDrain;
+  const rearmLateAux = (pair) => isSecondarySession ? (rearmPendingAuxiliaryCoverage(pair), true) : holdScope.guardedWrite("turn-end:late-aux-rearm", () => {
+    rearmPendingAuxiliaryCoverage(pair);
+    return true;
+  }) === true;
+  let lateAuxDelivered = 0;
+  let lateAuxStale = 0;
+  let lateAuxMissing = 0;
+  let lateAuxRearmed = 0;
+  let lateAuxBacklogPending = 0;
+  let lateAuxClientGone = 0;
+  let lateAuxProbeFailed = 0;
+  let lateAuxCleanConfirmed = 0;
+  let lateAuxExpired = 0;
+  let lateAuxCeilingExhausted = 0;
+  let lateAuxAnswered = 0;
+  let lateAuxNotifyStallDemoted = 0;
+  let lateAuxHoldRearmed = 0;
+  let lateAuxHoldExpired = 0;
+  let lateAuxHoldCeiling = 0;
+  let lateAuxDispositionSuppressed = 0;
+  let lateAuxAuxSuppressed = 0;
+  const lateAuxCoverageGapPairs = [];
+  let lateAuxCoverageGapDetailCount = 0;
+  let lateAuxCoverageGapDropCount = 0;
+  const lateAuxStuckPairs = [];
+  if (drainedPairs.length > 0) {
+    const lateObserverDeadline = Date.now() + HOOK_WALL_BUDGET_MS.turn_end;
+    const byFile = new Map;
+    for (const pair of drainedPairs) {
+      const list = byFile.get(pair.filePath);
+      if (list)
+        list.push(pair);
+      else
+        byFile.set(pair.filePath, [pair]);
+    }
+    try {
+      const service = getLSPService();
+      for (const [lateAuxPath, pairs] of byFile) {
+        let cached;
+        try {
+          cached = await service.readCachedDiagnosticsForServers(lateAuxPath, new Set(pairs.map((p) => p.serverId)));
+        } catch {
+          lateAuxProbeFailed += pairs.length;
+          for (const pair of pairs) {
+            if (canRearmPendingAuxiliary(pair)) {
+              if (rearmLateAux(pair))
+                lateAuxRearmed += 1;
+            } else if (isPendingAuxiliaryPastRearmTtl(pair)) {
+              lateAuxExpired += 1;
+            } else {
+              lateAuxCeilingExhausted += 1;
+            }
+          }
+          continue;
+        }
+        const displayLateAuxPath = toRunnerDisplayPath(cwd, lateAuxPath);
+        let lateAuxContentRead = false;
+        let lateAuxContentValue;
+        const readLateAuxContent = () => {
+          if (!lateAuxContentRead) {
+            lateAuxContentRead = true;
+            try {
+              lateAuxContentValue = fs.readFileSync(lateAuxPath, "utf-8");
+            } catch {
+              lateAuxContentValue = undefined;
+            }
+          }
+          return lateAuxContentValue;
+        };
+        for (const pair of pairs) {
+          const cachedEntry = cached.get(pair.serverId);
+          if (cachedEntry === undefined) {
+            lateAuxClientGone += 1;
+            continue;
+          }
+          if (cachedEntry.notifyStallDemoted) {
+            if (cachedEntry.demotedAt === undefined || pair.markedAtMs > cachedEntry.demotedAt) {
+              lateAuxClientGone += 1;
+              continue;
+            }
+            lateAuxNotifyStallDemoted += 1;
+            const pastTtl = isPendingAuxiliaryPastRearmTtl(pair);
+            const atCeiling = (pair.rearmCount ?? 0) >= MAX_LATE_AUX_REARMS;
+            if (!pastTtl && !atCeiling) {
+              if (rearmLateAux(pair)) {
+                lateAuxRearmed += 1;
+                if (lateAuxStuckPairs.length < 20)
+                  lateAuxStuckPairs.push({
+                    filePath: pair.filePath,
+                    serverId: pair.serverId
+                  });
+              }
+            } else {
+              if (pastTtl)
+                lateAuxExpired += 1;
+              else
+                lateAuxCeilingExhausted += 1;
+              lateAuxCoverageGapPairs.push({
+                filePath: pair.filePath,
+                serverId: pair.serverId
+              });
+            }
+            continue;
+          }
+          const rawDiags = cachedEntry.diags;
+          const backlogPending = !isAuxBacklogPublished(pair);
+          if (backlogPending)
+            lateAuxBacklogPending += 1;
+          if (cachedEntry.publishedAt === undefined || cachedEntry.publishedAt <= pair.markedAtMs || backlogPending) {
+            if (canRearmPendingAuxiliary(pair)) {
+              if (rearmLateAux(pair)) {
+                lateAuxRearmed += 1;
+                if (lateAuxStuckPairs.length < 20)
+                  lateAuxStuckPairs.push({
+                    filePath: pair.filePath,
+                    serverId: pair.serverId
+                  });
+              }
+            } else {
+              if (isPendingAuxiliaryPastRearmTtl(pair))
+                lateAuxExpired += 1;
+              else
+                lateAuxCeilingExhausted += 1;
+            }
+            continue;
+          }
+          if (typeof service.observeLateAuxiliaryAnswer === "function") {
+            await bounded(service.observeLateAuxiliaryAnswer(lateAuxPath, pair.serverId, cachedEntry.publishedAt - pair.markedAtMs), {
+              ms: Math.max(1, lateObserverDeadline - Date.now()),
+              signal: deps.signal,
+              hook: "turn_end",
+              label: "observeLateAuxiliaryAnswer"
+            });
+          }
+          if (rawDiags.length === 0) {
+            lateAuxCleanConfirmed += 1;
+            continue;
+          }
+          const anchored = rawDiags.filter((d) => d.range?.start?.line !== undefined);
+          if (anchored.length === 0) {
+            lateAuxMissing += rawDiags.length;
+            lateAuxAnswered += 1;
+            continue;
+          }
+          const lateAuxContent = readLateAuxContent();
+          const converted = convertLspDiagnostics(anchored, lateAuxPath);
+          const retained = retagAuxiliaryDiagnostics(converted, anchored, lateAuxContent ?? "", { cwd, fileRole: detectFileRole(lateAuxPath, lateAuxContent) });
+          lateAuxAuxSuppressed += converted.length - retained.length;
+          if (retained.length === 0) {
+            lateAuxAnswered += 1;
+            continue;
+          }
+          const { "late-auxiliary-findings": gate } = gateFindingsByPathFreshness({
+            cwd,
+            sources: {
+              "late-auxiliary-findings": {
+                findings: retained,
+                scannedAt: pair.markedAtMs,
+                citedPath: () => lateAuxPath
+              }
+            }
+          });
+          lateAuxStale += gate.stale.length;
+          lateAuxMissing += retained.length - gate.live.length - gate.stale.length;
+          if (gate.live.length === 0) {
+            if (gate.stale.length > 0) {
+              if (canRearmPendingAuxiliary(pair)) {
+                if (rearmLateAux(pair))
+                  lateAuxRearmed += 1;
+              } else if (isPendingAuxiliaryPastRearmTtl(pair)) {
+                lateAuxExpired += 1;
+              } else {
+                lateAuxCeilingExhausted += 1;
+              }
+            } else {
+              lateAuxAnswered += 1;
+            }
+            continue;
+          }
+          const { kept: lateAuxKept, suppressed: lateAuxSuppressedHere } = applyPushedFindingPolicy(gate.live, {
+            cwd,
+            filePath: lateAuxPath,
+            content: lateAuxContent
+          });
+          lateAuxDispositionSuppressed += lateAuxSuppressedHere;
+          if (lateAuxKept.length === 0) {
+            lateAuxAnswered += 1;
+            continue;
+          }
+          const lines = lateAuxKept.map((f) => `  ${displayLateAuxPath}:${f.line}:${f.column} [${f.rule}] ${f.message}`);
+          lateAuxDelivered += lateAuxKept.length;
+          lateAuxAnswered += 1;
+          const lateAuxSuppressedNote = lateAuxSuppressedHere > 0 ? `; suppressed by disposition: ${lateAuxSuppressedHere} finding(s)` : "";
+          const lateAuxPart = `\uD83D\uDD50 Late auxiliary diagnostics (${pair.serverId} answered after its grace window${lateAuxSuppressedNote}):
+${lines.join(`
+`)}`;
+          advisoryParts.push(lateAuxPart);
+          deliveryHolds.push({
+            part: lateAuxPart,
+            canHold: () => canRearmPendingAuxiliary(pair),
+            onHeld: () => {
+              rearmPendingAuxiliaryCoverage(pair);
+              lateAuxHoldRearmed += 1;
+            },
+            onDropped: () => {
+              if (isPendingAuxiliaryPastRearmTtl(pair))
+                lateAuxHoldExpired += 1;
+              else
+                lateAuxHoldCeiling += 1;
+              incrementDegradationCount({
+                kind: "late-auxiliary-held-dropped",
+                subject: `late-auxiliary:${pair.serverId}`,
+                reason: "cut by the turn-end cap and past its re-arm bound, so not re-armed"
+              });
+            }
+          });
+        }
+      }
+    } catch (err) {
+      dbg(`turn_end: late-auxiliary probe failed: ${err}`);
+    }
+    for (const pair of lateAuxCoverageGapPairs) {
+      const normalizedPairPath = normalizeMapKey(pair.filePath);
+      const emitted = emitBounded("lsp_scanner_coverage_gap", `${pair.serverId}:${normalizedPairPath}`, {
+        filePath: normalizedPairPath,
+        durationMs: 0,
+        metadata: {
+          source: "late-auxiliary",
+          serverIds: [pair.serverId],
+          reason: "notify-stall-replacement-unavailable",
+          reRaised: true
+        }
+      }, {
+        ledgerKind: "lsp-scanner-coverage-gap",
+        reason: "notify-stall replacement was not available before late-coverage ceiling",
+        capPerTurn: {
+          limit: LATE_AUX_COVERAGE_GAP_DETAIL_CAP_PER_TURN,
+          turnIndex: runtime.turnIndex
+        }
+      });
+      if (emitted)
+        lateAuxCoverageGapDetailCount += 1;
+      else
+        lateAuxCoverageGapDropCount += 1;
+    }
+    logLatency({
+      type: "phase",
+      toolName: "turn_end",
+      filePath: cwd,
+      phase: "late_auxiliary_findings",
+      durationMs: Date.now() - lateAuxStart,
+      metadata: {
+        pending: drainedPairs.length,
+        pairCreated: drainedPairs.length + lateAuxCapEvicted,
+        pendingAfter: pendingAuxiliaryCoverageSize(),
+        delivered: lateAuxDelivered,
+        stale: lateAuxStale,
+        missing: lateAuxMissing,
+        rearmed: lateAuxRearmed,
+        backlogPending: lateAuxBacklogPending,
+        clientGone: lateAuxClientGone,
+        probeFailed: lateAuxProbeFailed,
+        cleanConfirmed: lateAuxCleanConfirmed,
+        expired: lateAuxExpired,
+        ceilingExhausted: lateAuxCeilingExhausted,
+        answered: lateAuxAnswered,
+        dispositionSuppressed: lateAuxDispositionSuppressed,
+        auxSuppressed: lateAuxAuxSuppressed,
+        notifyStallDemoted: lateAuxNotifyStallDemoted,
+        coverageGapReRaised: lateAuxCoverageGapPairs.length,
+        coverageGapReRaisedDetailed: lateAuxCoverageGapDetailCount,
+        coverageGapReRaisedDropped: lateAuxCoverageGapDropCount,
+        capEvicted: lateAuxCapEvicted,
+        stuckPairs: lateAuxStuckPairs
+      }
+    });
+  }
+  const unresolvedKeys = new Set(unresolvedBlockers.map((record) => normalizeMapKey(path.resolve(record.filePath))));
+  const formatResolvedTail = (dropped) => `… and ${dropped} more`;
+  const resolvedTailMax = formatResolvedTail(Number.MAX_SAFE_INTEGER).length;
+  const resolvedShareChars = Math.floor(RUNTIME_CONFIG.turnEnd.maxChars * RESOLVED_SHARE_OF_CHARS) - resolvedTailMax;
+  const formatResolvedLine = (entry) => {
+    const clause = entry.confirmedClean ? " confirmed clean" : entry.writeIndex === undefined ? "" : ` cleared by the ${formatWriteOrdinal(entry.writeIndex)} write`;
+    const label = entry.turnIndex === runtime.turnIndex ? "Resolved this turn" : "Resolved since the last report";
+    const head = `${label}: `;
+    const tail = ` (${entry.blockerCount} blocker(s)${clause})`;
+    let display = toRunnerDisplayPath(cwd, entry.filePath);
+    const room = resolvedShareChars - 1 - head.length - tail.length;
+    if (display.length > room) {
+      const keepHead = Math.ceil((room - 1) / 2);
+      display = `${sliceAtCodePointBoundaries(display, 0, keepHead)}…${sliceAtCodePointBoundaries(display, display.length - (room - 1 - keepHead), display.length)}`;
+    }
+    return `${head}${display}${tail}`;
+  };
+  const blockerText = blockerParts.join(`
+
+`);
+  const blockerChars = blockerParts.length > 0 ? blockerText.length + 2 : 0;
+  const blockerLines = blockerParts.length > 0 ? blockerText.split(`
+`).length + 1 : 0;
+  const resolvedCharBudget = Math.min(resolvedShareChars, RUNTIME_CONFIG.turnEnd.maxChars - blockerChars - resolvedTailMax);
+  const resolvedLineBudget = Math.min(RESOLVED_MAX_LINES, RUNTIME_CONFIG.turnEnd.maxLines - blockerLines) - 1;
+  let resolvedChars = 0;
+  let resolvedCount = 0;
+  const { files: resolvedBlockerFileList, dropped: resolvedBlockerFilesDropped } = runtime.consumeResolvedBlockerFiles((entry) => {
+    if (unresolvedKeys.has(normalizeMapKey(path.resolve(entry.filePath))))
+      return true;
+    const cost = formatResolvedLine(entry).length + 1;
+    if (resolvedCount > 0 && (resolvedCount >= resolvedLineBudget || resolvedChars + cost > resolvedCharBudget))
+      return true;
+    resolvedChars += cost;
+    resolvedCount += 1;
+    return false;
+  });
+  const resolvedLines = resolvedBlockerFileList.map(formatResolvedLine);
+  if (resolvedBlockerFilesDropped > 0) {
+    resolvedLines.push(formatResolvedTail(resolvedBlockerFilesDropped));
+  }
+  const resolvedParts = resolvedLines.length > 0 ? [resolvedLines.join(`
+`)] : [];
+  const asIs = (raw) => ({ raw, text: raw });
+  const composedParts = [
+    ...resolvedParts.map(asIs),
+    ...blockerParts.map(asIs),
+    ...staleSecretParts.map(asIs),
+    ...advisoryParts.map((raw) => ({
+      raw,
+      text: `ℹ️ Advisory — no action required this turn:
+${raw}`
+    }))
+  ];
+  const findingParts = composedParts.map((part) => part.text);
+  let heldSections = 0;
+  if (findingParts.length > 0) {
+    dbg(`turn_end: ${blockerParts.length} blocker section(s), ${advisoryParts.length} advisory section(s) found, persisting for next context`);
+    const joined = findingParts.join(`
+
+`);
+    const holdPlan = planDeliveryHolds({
+      holds: deliveryHolds,
+      parts: composedParts,
+      keptChars: turnEndKeptChars(joined),
+      separatorLength: `
+
+`.length
+    });
+    const settleHolds = (suppressed) => {
+      const outcome = holdPlan.settle({
+        suppressed,
+        isCurrentSession: () => holdScope.isCurrent(),
+        onFault: (cause) => dbg(`turn_end: delivery hold failed: ${cause}`)
+      });
+      heldSections = outcome.held;
+      if (lateAuxHoldRearmed + lateAuxHoldExpired + lateAuxHoldCeiling > 0) {
+        logLatency({
+          type: "phase",
+          toolName: "turn_end",
+          filePath: cwd,
+          phase: "late_auxiliary_holds",
+          durationMs: 0,
+          metadata: {
+            rearmed: lateAuxHoldRearmed,
+            expired: lateAuxHoldExpired,
+            ceilingExhausted: lateAuxHoldCeiling,
+            pendingAfter: pendingAuxiliaryCoverageSize()
+          }
+        });
+      }
+      if (outcome.held > 0) {
+        incrementDegradationCount({
+          kind: "turn-end-sections-held",
+          subject: "turn-end",
+          reason: `${outcome.held} one-shot section(s) cut by the turn-end cap, kept pending for the next turn`
+        });
+      }
+    };
+    const content = capTurnEndMessage(joined, holdPlan.heldCount);
+    const signature = `${files.slice().sort((a, b) => compareOrdinal(a, b)).join("|")}::${content}`;
+    const last = cacheManager.readCache("turn-end-findings-last", cwd);
+    if (last?.data?.signature === signature && last?.data?.sessionId === runtime.telemetrySessionId && resolvedBlockerFileList.length === 0) {
+      dbg("turn_end: duplicate findings detected (same session), suppressing re-prompt");
+      if (getFlag("lens-guard")) {
+        const existingGuard = cacheManager.readCache("turn-end-findings", cwd)?.data;
+        if (existingGuard) {
+          writeGitGuardRecord(cacheManager, runtime, cwd, {
+            ...existingGuard,
+            content,
+            blockerContent: blockerParts.length > 0 ? capTurnEndMessage(blockerParts.join(`
+
+`)) : undefined,
+            hasBlockers: blockerParts.length > 0 || existingGuard.testFailures === true,
+            blockingFiles: blockerParts.length > 0 ? existingGuard.affectedFiles : undefined,
+            projectSeqStart: runtime.turnStartProjectSeq,
+            projectSeqEnd: runtime.projectSeq,
+            fileSeqByPath: Object.fromEntries(runtime.getFileSeqEntries().map(([filePath, seq]) => [
+              normalizeMapKey(path.resolve(filePath)),
+              seq
+            ])),
+            fileContentHashes: {},
+            consumed: false
+          });
+        }
+      }
+      settleHolds(true);
+      clearOwnedTurnState();
+      runtime.fixedThisTurn.clear();
+      resetFormatService();
+      return;
+    }
+    settleHolds(false);
+    const fileSeqByPath = {};
+    for (const [filePath, seq] of runtime.getFileSeqEntries()) {
+      fileSeqByPath[normalizeMapKey(path.resolve(filePath))] = seq;
+    }
+    if (getFlag("lens-guard")) {
+      const existingGuard = cacheManager.readCache("turn-end-findings", cwd)?.data;
+      const blockingContent = blockerParts.length > 0 ? capTurnEndMessage(blockerParts.join(`
+
+`)) : undefined;
+      const affectedFiles = [
+        ...existingGuard?.affectedFiles ?? [],
+        ...files.map((file) => resolveRunnerPath(cwd, file)),
+        ...cascadeResults.flatMap((result) => result.neighbors.filter((neighbor) => neighbor.diagnostics.length > 0).map((neighbor) => resolveRunnerPath(cwd, neighbor.filePath)))
+      ];
+      writeGitGuardRecord(cacheManager, runtime, cwd, {
+        content: [content, existingGuard?.testFailureContent].filter((value) => !!value).join(`
+
+`),
+        blockerContent: blockingContent,
+        blockingFiles: blockerParts.length > 0 ? affectedFiles : undefined,
+        hasBlockers: !!blockingContent || existingGuard?.testFailures === true,
+        affectedFiles,
+        sessionId: runtime.telemetrySessionId,
+        projectSeqStart: runtime.turnStartProjectSeq,
+        projectSeqEnd: runtime.projectSeq,
+        fileSeqByPath,
+        fileContentHashes: {},
+        consumed: false,
+        testFailures: existingGuard?.testFailures,
+        testFailureContent: existingGuard?.testFailureContent,
+        testFailureFiles: existingGuard?.testFailureFiles
+      });
+    } else {
+      const allAffectedFiles = [
+        ...files.map((file) => resolveRunnerPath(cwd, file)),
+        ...cascadeResults.flatMap((result) => result.neighbors.filter((neighbor) => neighbor.diagnostics.length > 0).map((neighbor) => resolveRunnerPath(cwd, neighbor.filePath)))
+      ];
+      const affectedFiles = [...new Set(allAffectedFiles)].slice(0, MAX_ADVISORY_AFFECTED_FILES);
+      const affectedFilesTruncated = new Set(allAffectedFiles).size > affectedFiles.length;
+      cacheManager.writeCache("turn-end-findings", {
+        content,
+        affectedFiles,
+        affectedFilesTruncated,
+        provenance: snapshotAdvisoryProvenance({
+          cwd,
+          runtime,
+          generation: 0,
+          files: affectedFiles.map((file) => ({
+            path: file,
+            role: "affected"
+          })),
+          truncated: affectedFilesTruncated
+        })
+      }, cwd);
+    }
+    cacheManager.writeCache("turn-end-findings-last", {
+      signature,
+      sessionId: runtime.telemetrySessionId,
+      projectSeqStart: runtime.turnStartProjectSeq,
+      projectSeqEnd: runtime.projectSeq
+    }, cwd);
+    emitLensTurnFindings({
+      cwd,
+      filePaths: files.map((file) => resolveRunnerPath(cwd, file)),
+      sessionId: runtime.telemetrySessionId,
+      turnIndex: runtime.turnIndex,
+      blockerSections: blockerParts.length,
+      advisorySections: advisoryParts.length,
+      content
+    });
+  }
+  if (blockerParts.length === 0) {
+    clearOwnedTurnState();
+    if (getFlag("lens-guard") && advisoryParts.length === 0 && staleSecretParts.length === 0 && resolvedParts.length === 0 && !runtime.gitGuardHasBlockers) {
+      const guardRecord = cacheManager.readCache("turn-end-findings", cwd)?.data;
+      if (guardRecord?.sessionId === runtime.telemetrySessionId && guardRecord.testFailures !== true) {
+        cacheManager.clearCache("turn-end-findings", cwd);
+      }
+    }
+  }
+  runtime.fixedThisTurn.clear();
+  runtime.clearActionableWarnings(sessionId);
+  runtime.clearCodeQualityWarnings(sessionId);
+  if (demotedFindingsRetired > 0) {
+    cacheManager.clearCache("turn-end-findings-last", cwd);
+  }
+  logLatency({
+    type: "tool_result",
+    toolName: "turn_end",
+    filePath: cwd,
+    durationMs: Date.now() - turnEndStart,
+    result: blockerParts.length > 0 ? "blockers_found" : staleSecretParts.length > 0 ? "stale_secrets_pending" : "clean",
+    metadata: {
+      fileCount: files.length,
+      blockerSections: blockerParts.length,
+      staleSecretSections: staleSecretParts.length,
+      advisorySections: advisoryParts.length,
+      resolvedBlockerFiles: resolvedBlockerFileList.length,
+      resolvedBlockerFilesDropped,
+      heldSections,
+      demotedFindingsRetired,
+      widgetDemotedFindingsRetired
+    }
+  });
+  resetFormatService();
+}