@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

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

@@ -22,13 +22,23 @@ import {
 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 { formatCacheAgeLabel } from "./finding-delivery-gate.js";
+import {
+  admitsProjectWideFindings,
+  formatCacheAgeLabel
+} from "./finding-delivery-gate.js";
 import {
   getFullScanWallClockMs,
   isWorkspaceSweepActive,
@@ -40,12 +50,23 @@ 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
@@ -53,6 +74,7 @@ import {
 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,
@@ -68,6 +90,7 @@ import {
   isRunnerErrorResult,
   RUNNERS
 } from "./test-runner-client.js";
+import { createTurnEndTestRoots } from "./test-target-roots.js";
 import {
   MAX_ADVISORY_AFFECTED_FILES,
   gateFindingsByPathFreshness,
@@ -78,17 +101,20 @@ import {
   sweepInlineBlockerFreshness
 } from "./blocker-freshness.js";
 import { sweepInlineBlockerPastEof } from "./blocker-past-eof.js";
-import { getLSPService } from "./lsp/index.js";
+import { getLSPService } from "./lsp/capabilities.js";
 import {
   drainPendingAuxCapEvictedCount,
   drainPendingAuxiliaryCoverage,
+  isAuxBacklogPublished,
   isPendingAuxiliaryPastRearmTtl,
   rearmPendingAuxiliaryCoverage,
   MAX_LATE_AUX_REARMS,
-  pendingAuxiliaryCoverageSize
+  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";
@@ -98,6 +124,10 @@ import {
   filterFindingsByDisposition
 } from "./dispatch/finding-policy.js";
 import { detectFileRole } from "./file-role.js";
+import {
+  judgeDeferredRunnerFindings,
+  recordDeferredRunnerBlockers
+} from "./deferred-runner-blockers.js";
 import {
   applyInlineBlockerPolicy,
   summarizeInlineBlockerPolicy
@@ -105,7 +135,8 @@ import {
 import {
   drainPendingRunnerFindings,
   dropStaleRunnerFindings,
-  pendingRunnerFindingsSize
+  pendingRunnerFindingsSize,
+  requeueRunnerFindings
 } from "./dispatch/pending-runner-findings.js";
 import {
   incrementDegradationCount,
@@ -134,23 +165,9 @@ import {
 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 const TEST_RUNNER_MAX_PERSISTED_TARGETS = 64;
-function deferralEntryKey(entry) {
-  return `${entry.sessionId ?? ""}\x00${normalizeMapKey(path.resolve(entry.testFile))}`;
-}
-function mergeDeferredTargets(existing, incoming) {
-  const byKey = new Map;
-  for (const entry of [...existing, ...incoming]) {
-    const key = deferralEntryKey(entry);
-    const prior = byKey.get(key);
-    if (prior && (prior.attempts ?? 0) >= (entry.attempts ?? 0))
-      continue;
-    byKey.set(key, entry);
-  }
-  return [...byKey.values()];
-}
 export async function runTestTargetsBounded(args) {
   const results = [];
   if (args.targets.length === 0)
@@ -224,6 +241,79 @@ export async function runTestTargetsBounded(args) {
 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) {
@@ -297,22 +387,66 @@ export function cancelLSPIdleReset() {
     pendingSweepRearm = null;
   }
 }
-function capTurnEndMessage(content) {
+function capTurnEndMessage(content, held = 0) {
   const maxLines = RUNTIME_CONFIG.turnEnd.maxLines;
   const maxChars = RUNTIME_CONFIG.turnEnd.maxChars;
-  let out = content;
-  const lines = out.split(`
+  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) {
-    out = `${lines.slice(0, maxLines).join(`
-`)}
-... (truncated)`;
+    kept = lines.slice(0, maxLines).join(`
+`);
+    cut = true;
+  }
+  if (kept.length > maxChars) {
+    kept = sliceAtCodePointBoundaries(kept, 0, maxChars);
+    cut = true;
   }
-  if (out.length > maxChars) {
-    out = `${out.slice(0, maxChars)}
-... (truncated)`;
+  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`;
   }
-  return out;
 }
 export async function handleTurnEnd(deps) {
   const {
@@ -337,21 +471,25 @@ export async function handleTurnEnd(deps) {
       dbg(`turn_end: retaining newer turn state (dispatch=${turnIndexAtDispatch}, current=${runtime.turnIndex})`);
       return;
     }
-    cacheManager.clearTurnState(cwd, currentOwner);
+    cacheManager.clearTurnState(cwd, currentOwner, isSecondarySession ? sessionId : undefined);
   };
   updateHeartbeat().catch(() => {});
   const cwd = ctxCwd ?? process.cwd();
-  let turnState = cacheManager.readTurnState(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: runtime.telemetrySessionId,
+      id: sessionId ?? runtime.telemetrySessionId,
       pid: process.pid,
       lastSeen: new Date().toISOString()
     },
     sessionStartedAt: owner?.sessionStartedAt ?? runtime.sessionStartedAt
   };
-  const access = cacheManager.getTurnStateAccess(cwd, currentOwner);
+  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) {
@@ -361,9 +499,10 @@ export async function handleTurnEnd(deps) {
   if (access === "available" && (turnState.files || turnState.owner || turnState.sessionId)) {
     dbg("turn_end: evicting stale turn-state owner");
     clearOwnedTurnState();
-    turnState = cacheManager.readTurnState(cwd);
+    turnState = cacheManager.readTurnState(cwd, turnStateSessionId);
   }
-  const files = Object.keys(turnState.files);
+  const ownFiles = Object.keys(turnState.files);
+  const files = ownFiles;
   let widgetDemotedFindingsRetired = 0;
   for (const wPath of drainRenderedDependencyDriftFilePaths()) {
     const deliveryCount = incrementWidgetDependencyDriftDelivery(wPath);
@@ -379,7 +518,7 @@ export async function handleTurnEnd(deps) {
       }
     }
   }
-  if (files.length === 0 && !runtime.hasCascadeRuns()) {
+  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) {
@@ -400,7 +539,7 @@ export async function handleTurnEnd(deps) {
       });
     }
     resetFormatService();
-    if (pendingRunnerFindingsSize() === 0)
+    if (pendingRunnerFindingsSize() === 0 && !runtime.hasResolvedBlockerFiles())
       return;
   }
   if (files.length > 0 && (lspIdleResetTimeout || pendingSweepRearm)) {
@@ -408,7 +547,7 @@ export async function handleTurnEnd(deps) {
     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)) {
+  if (cacheManager.isMaxCyclesExceeded(cwd, turnStateSessionId)) {
     dbg("turn_end: max cycles exceeded, clearing state and forcing through");
     clearOwnedTurnState();
     runtime.fixedThisTurn.clear();
@@ -419,8 +558,131 @@ export async function handleTurnEnd(deps) {
   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({
@@ -435,6 +697,32 @@ export async function handleTurnEnd(deps) {
       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 },
@@ -462,8 +750,6 @@ export async function handleTurnEnd(deps) {
     }
   });
   const unresolvedBlockers = runtime.getInlineBlockersSnapshot();
-  let demotedFindingsRetired = 0;
-  const pendingDependencyDriftDeliveries = [];
   const inlinePolicyEntries = [];
   const policySuppressedPaths = [];
   const inlinePolicyStart = Date.now();
@@ -475,39 +761,32 @@ export async function handleTurnEnd(deps) {
       inlinePolicyEntries.push({ ...tally, stale: true });
       const deadLines = blockerPastEof.deadLinesByPath.get(bPath) ?? [];
       const degraded = degradeDemotedFindingBody(summary, { deadLines });
-      const retired = runtime.retireDemotedPastEofBlocker(bPath, deadLines);
+      const retires = runtime.wouldRetireDemotedPastEofBlocker(bPath, deadLines);
       let retirementNote;
-      if (retired) {
-        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`
-        });
+      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);
         }
-        pendingDependencyDriftDeliveries.push(() => {
-          const deliveryCount = runtime.incrementInlineBlockerStaleDelivery(bPath);
-          if (deliveryCount >= DEPENDENCY_DRIFT_MAX_DELIVERIES) {
-            const capRetired = runtime.retireDemotedDependencyDriftBlocker(bPath);
-            if (capRetired) {
-              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`
-              });
-            }
-          }
-        });
       }
-      advisoryParts.push(`${STALE_LINE_MARKER} ${displayPath}:
+      const advisoryPart = `${STALE_LINE_MARKER} ${displayPath}:
 ${degraded.body}` + (retirementNote ? `
-${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 });
@@ -540,7 +819,16 @@ ${policy.body}`);
     });
   }
   const cascadeSettleStart = Date.now();
-  const { settled, timedOut } = await runtime.settleCascadeRuns(cascadeSettleWaitMs(), { trackTurnEndClock: true });
+  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",
@@ -550,7 +838,7 @@ ${policy.body}`);
     metadata: { settled, timedOut }
   });
   const t0 = Date.now();
-  const cascadeRuns = runtime.consumeCascadeRuns().filter((run) => {
+  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) {
@@ -589,7 +877,10 @@ ${policy.body}`);
   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,
@@ -613,6 +904,7 @@ ${policy.body}`);
       }
     }
     const parts = [];
+    const sectionRuns = [];
     let injectedNeighborCount = 0;
     let injectedDiagnosticCount = 0;
     let suppressedByOwnership = 0;
@@ -626,6 +918,9 @@ ${policy.body}`);
 ${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) {
@@ -667,6 +962,13 @@ ${testLines.join(`
 
 `);
       blockerParts.push(section);
+      deliveryHolds.push({
+        part: section,
+        onHeld: () => {
+          for (const run of sectionRuns)
+            runtime.appendCascadeRun(run);
+        }
+      });
       logCascade({
         phase: "cascade_injected",
         filePath: cascadeLogFilePath,
@@ -734,18 +1036,31 @@ ${lines.join(`
       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) => {
@@ -758,6 +1073,7 @@ ${suffix}`;
     }), 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),
@@ -812,106 +1128,182 @@ ${suffix}`;
       skipped: cascadeSkipped
     }
   });
-  const t2 = Date.now();
-  let knipMeta = {};
-  if (runtime.isStartupScanInFlight("knip")) {
-    dbg("turn_end: skipping knip (startup scan still in flight)");
-    knipMeta = { skipped: true };
-  } else {
-    const prevKnip = cacheManager.readCache("knip", cwd);
-    const previousFailedHard = prevKnip && !prevKnip.data.success && !prevKnip.data.failureKind && /(timed out|killed|SIGTERM|SIGKILL|SIGABRT)/i.test(prevKnip.data.summary);
-    if (previousFailedHard) {
-      dbg(`turn_end: skipping knip after recent failure: ${prevKnip.data.summary}`);
-      knipMeta = { skipped: true, reason: prevKnip.data.summary };
+  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 {
-      const knipResult = await knipClient.analyze(cwd, getKnipIgnorePatterns(), {
-        projectSeq: runtime.projectSeq
+      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);
       });
-      const knipWouldPoison = wouldPoisonCache(prevKnip, knipResult);
-      if (knipWouldPoison) {
-        dbg(`turn_end: keeping last good knip cache; this run failed: ${knipResult.summary}`);
-      } else {
-        cacheManager.writeCache("knip", knipResult, cwd);
+      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");
       }
-      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 },
-        ...knipWouldPoison && { cacheKept: true }
+      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
       };
-      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(cwd, issue.file);
-          return modifiedSet.has(abs);
-        });
-        knipMeta.newIssues = newIssues.length;
-        if (newIssues.length > 0) {
-          projectDiagnosticsDelta.push(...knipIssuesToProjectDiagnostics(cwd, newIssues));
-          projectDiagnosticsSources.add("knip");
-        }
-        const knipPaired = newIssues.flatMap((issue) => knipIssuesToProjectDiagnostics(cwd, [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 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):
+      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, 5)) {
-            const display = issue.file ? toRunnerDisplayPath(cwd, issue.file) : "(unknown)";
-            if (!firstPath && display !== "(unknown)")
-              firstPath = display;
-            report += `  ${display}${issue.line ? `:${issue.line}` : ""} — ${issue.type}: ${issue.name}
+        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}
+        }
+        if (firstPath) {
+          report += `  First location: ${firstPath}
 `;
-          }
-          blockerParts.push(report);
         }
-        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):
+        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, 5)) {
-            const display = issue.file ? toRunnerDisplayPath(cwd, issue.file) : "(unknown)";
-            report += `  ${display}${issue.line ? `:${issue.line}` : ""} — ${issue.name}
+        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);
         }
+        advisoryParts.push(report);
+        deliveryHolds.push(cutAdvisoryHold("knip", knipAdvisoryLane, report, unusedExportDelta.slice(0, KNIP_MAX_SHOWN), (issue) => reOfferedKeys.has(issueKey(issue))));
       }
     }
-  }
-  logLatency({
+    return knipMeta;
+  };
+  const logKnipRow = (root, startedAt, metadata) => logLatency({
     type: "phase",
     toolName: "turn_end",
-    filePath: cwd,
+    filePath: root,
     phase: "knip",
-    durationMs: Date.now() - t2,
-    metadata: knipMeta
+    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")) {
@@ -926,29 +1318,136 @@ ${suffix}`;
     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;
         }
-        if (![...modifiedFiles()].some((f) => client.owns(f))) {
-          reasons.push(`${client.id}:no_owned_files`);
-          continue;
-        }
         const cacheKey = `dead-code-${client.id}`;
-        const prev = cacheManager.readCache(cacheKey, cwd);
-        if (prev && !prev.data.success && /(timed out|killed|SIGTERM|SIGKILL|SIGABRT)/i.test(prev.data.summary)) {
-          dbg(`turn_end: skipping dead-code after failure: ${prev.data.summary}`);
-          deadCodeMeta.skipped = true;
-          reasons.push(`${client.id}:backoff:${prev.data.summary}`);
-          continue;
+        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`);
+          }
         }
-        const startMs = Date.now();
         try {
-          const result = await client.analyze(cwd);
+          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(prev, result)) {
+          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 {
@@ -956,53 +1455,30 @@ ${suffix}`;
               scanDurationMs: durationMs
             });
           }
-          logDeadCodeScan({
-            language: client.language,
-            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.success && { reason: result.summary }
-          });
+          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;
           }
-          deadCodeMeta.totalIssues = (deadCodeMeta.totalIssues ?? 0) + deadCodeIssues(result).length;
-          if (!prev?.data.success) {
-            reasons.push(`${client.id}:no_previous_scan`);
-            continue;
-          }
-          const prevKeys = new Set(deadCodeIssues(prev.data).map(deadCodeIssueKey));
-          const modified = modifiedFiles();
-          const newIssues = deadCodeIssues(result).filter((issue) => {
-            if (prevKeys.has(deadCodeIssueKey(issue)))
-              return false;
-            if (!issue.file)
-              return false;
-            return modified.has(resolveRunnerPath(cwd, issue.file));
+          sources.push({
+            result,
+            previousScan: prev?.data,
+            modified: scanFiles
           });
-          if (newIssues.length === 0) {
-            reasons.push(`${client.id}:clean`);
-            continue;
-          }
-          newIssueTotal += newIssues.length;
-          projectDiagnosticsDelta.push(...newIssues.map((issue) => deadCodeIssueToProjectDiagnostic(cwd, issue, result.language)));
-          projectDiagnosticsSources.add("dead-code");
-          const deadCodeDeliverable = filterFindingsByDisposition(newIssues, cwd, (issue) => deadCodeIssueToProjectDiagnostic(cwd, issue, result.language));
-          deadCodeDispositionSuppressed += deadCodeDeliverable.suppressed;
-          if (deadCodeDeliverable.kept.length === 0) {
-            reasons.push(`${client.id}:all_disposed`);
-            continue;
-          }
-          advisoryParts.push(formatDeadCodeDelta(deadCodeDeliverable.kept, result.language));
         } 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) {
@@ -1053,7 +1529,7 @@ ${suffix}`;
     cwd,
     signal: deps.signal,
     readScannerCache,
-    peekActionableWarnings: () => runtime.peekActionableWarnings()
+    peekActionableWarnings: () => runtime.peekActionableWarnings(sessionId)
   };
   const govSources = await govulncheckLane.collect(laneCtx);
   const trivyCacheEntry = await readScannerCache("trivy");
@@ -1081,15 +1557,15 @@ ${suffix}`;
   const govGate = scannerGates.govulncheck;
   const gitleaksGate = scannerGates.gitleaks;
   const trivySecretsGate = scannerGates["trivy-secrets"];
-  const govDelivery = govulncheckLane.render(govulncheckLane.gate({ govulncheck: govGate }, laneCtx), laneCtx);
+  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 = secretsLane.render(secretsLane.gate({
+  const secretsDelivery = allowProjectWideFindings ? secretsLane.render(secretsLane.gate({
     gitleaks: gitleaksGate,
     "trivy-secrets": trivySecretsGate
-  }, laneCtx), laneCtx);
+  }, laneCtx), laneCtx) : {};
   for (const [store, count] of Object.entries(secretsDelivery.dispositionSuppressed ?? {})) {
     recordDispositionSuppressed(store, count);
   }
@@ -1156,8 +1632,14 @@ ${suffix}`;
   }
   const t3 = Date.now();
   let madgeStats;
-  if (getFlag("lens-turn-end-madge") && await depChecker.ensureAvailable()) {
-    const madgeFiles = cacheManager.getFilesForMadge(cwd);
+  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));
@@ -1186,6 +1668,7 @@ ${suffix}`;
   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) {
@@ -1216,14 +1699,11 @@ ${suffix}`;
     const resolvedDeferralKeys = new Set;
     const heldDeferred = [];
     const boundPersisted = (entries, label) => {
-      const ordered = [
-        ...entries.filter((entry) => !isThisSession(entry)),
-        ...entries.filter(isThisSession)
-      ];
-      if (ordered.length <= TEST_RUNNER_MAX_PERSISTED_TARGETS)
-        return ordered;
-      dbg(`turn_end: ${label} test target list held ${ordered.length} entries, bounded to the newest ${TEST_RUNNER_MAX_PERSISTED_TARGETS} (oldest foreign-session rows dropped)`);
-      return ordered.slice(-TEST_RUNNER_MAX_PERSISTED_TARGETS);
+      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;
@@ -1272,14 +1752,15 @@ ${suffix}`;
           incrementDegradationCount({
             kind: "test-runner-batch-capped",
             subject: `${cwd}:deferral-exhausted`,
-            reason: `test target ${path.relative(cwd, testFile)} was cut at the turn-end batch budget ${attempts} turn(s) running and is retired from turn-end selection for the rest of this session — too slow for a per-turn batch, run it explicitly`
+            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];
-      if (!config || isExcludedTestTarget(testFile, cwd) || !fs.existsSync(testFile)) {
+      const carriedRoot = testRootFor(testFile);
+      if (!config || isExcludedTestTarget(testFile, carriedRoot) || !fs.existsSync(testFile)) {
         resolvedDeferralKeys.add(carriedKey);
         deadDeferred++;
         continue;
@@ -1304,6 +1785,7 @@ ${suffix}`;
         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`);
@@ -1339,8 +1821,12 @@ ${suffix}`;
     let missingTargetFiles = 0;
     let excludedTargets = 0;
     let retiredSkips = 0;
+    let noTestFile = 0;
+    const candidatesByRoot = new Map;
     for (const { display, abs, isNeighbor } of candidates) {
-      const target = testRunnerClient.getTestRunTarget(abs, cwd, runtime.turnIndex);
+      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);
@@ -1349,9 +1835,9 @@ ${suffix}`;
           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, cwd)) {
+        if (isExcludedTestTarget(target.testFile, testRoot)) {
           excludedTargets++;
-          dbg(`turn_end: ${display} → test target excluded (integration/e2e), skipping spawn (${path.relative(cwd, target.testFile)})`);
+          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)) {
@@ -1363,14 +1849,15 @@ ${suffix}`;
           overCapTargets++;
           continue;
         }
-        targets.push({ ...target, sourceFile: abs });
+        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) under the built-in integration/e2e exclusion list`);
+      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`);
@@ -1386,6 +1873,33 @@ ${suffix}`;
       });
       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);
@@ -1419,15 +1933,32 @@ ${suffix}`;
         concurrency: TEST_RUNNER_BATCH_CONCURRENCY,
         budgetMs: TEST_RUNNER_BATCH_BUDGET_MS,
         signal: getAmbientAbortSignal(),
-        run: (t, batchSignal) => testRunnerClient.runTestFileAsync(t.testFile, cwd, {
+        run: (t, batchSignal) => testRunnerClient.runTestFileAsync(t.testFile, t.testRoot, {
           runner: t.runner,
           config: t.config,
           turnIndex: firedAtTurn,
-          signal: batchSignal
+          signal: batchSignal,
+          displayRoot: cwd,
+          requireOwnInstall: t.testRoot !== cwd
         })
-      }).then(({ results, deferred, stopReason }) => {
-        const settledResults = results;
-        const verdicts = settledResults.flatMap((result) => {
+      }).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);
@@ -1435,6 +1966,7 @@ ${suffix}`;
             {
               file: result.value.file,
               sourceFile: target.sourceFile,
+              runner: target.runner,
               fileSeq: target.fileSeqAtRun === undefined ? {
                 state: "unknown",
                 reason: "sequence-unavailable"
@@ -1672,7 +2204,12 @@ ${suffix}`;
         const impactLines = [];
         let callGraphDispositionSuppressed = 0;
         const impactFindings = [];
-        for (const filePath of files.slice(0, 5)) {
+        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;
@@ -1698,11 +2235,15 @@ ${suffix}`;
                 impactLines.push(`  ${parseSymbolKey(calleeKey).symbolName ?? calleeKey}: ${summary}`);
             }
           }
+          if (impactLines.length > linesBefore)
+            shownImpactFiles.push(filePath);
         }
         if (impactLines.length > 0) {
-          advisoryParts.push(`\uD83D\uDCCA Call-graph impact (changed symbols have callers):
+          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);
@@ -1780,10 +2321,12 @@ ${impactLines.join(`
         turnIndex: runtime.turnIndex,
         files,
         modifiedRangesByFile,
-        dispatchWarnings: runtime.peekActionableWarnings(),
+        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,
@@ -1882,7 +2425,7 @@ ${impactLines.join(`
   const t5 = Date.now();
   try {
     const qualityWarningsByFile = new Map;
-    for (const warning of runtime.peekCodeQualityWarnings()) {
+    for (const warning of runtime.peekCodeQualityWarnings(sessionId)) {
       const group = qualityWarningsByFile.get(warning.filePath);
       if (group)
         group.push(warning);
@@ -1946,97 +2489,25 @@ ${impactLines.join(`
       }
     });
   }
-  cacheManager.incrementTurnCycle(cwd, currentOwner);
-  const runnerFindingsStart = Date.now();
-  const pendingRunnerFindings = await drainPendingRunnerFindings(0);
-  let runnerFindingsDelivered = 0;
-  let runnerFindingsStale = 0;
-  let runnerFindingsFailed = 0;
-  let runnerFindingsDropped = 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") {
-      runnerFindingsFailed += 1;
-      const detail = result.failureMessage ? `: ${result.failureMessage}` : "";
-      advisoryParts.push(`❌ Deferred runner ${pending.runnerId} failed (${result.failureKind ?? "unknown"})${detail}`);
-      continue;
-    }
-    const findings = result.diagnostics;
-    if (findings.length === 0)
-      continue;
-    const { "late-runner-findings": gate } = gateFindingsByPathFreshness({
-      cwd,
-      sources: {
-        "late-runner-findings": {
-          findings,
-          scannedAt: pending.markedAtMs,
-          citedPath: (finding) => finding.filePath
-        }
-      }
-    });
-    runnerFindingsStale += gate.stale.length;
-    if (gate.stale.length > 0) {
-      dropStaleRunnerFindings(pending);
-      runnerFindingsDropped += 1;
-    }
-    if (gate.live.length === 0)
-      continue;
-    const displayPath = toRunnerDisplayPath(cwd, pending.filePath);
-    let runnerContent;
-    try {
-      runnerContent = fs.readFileSync(pending.filePath, "utf-8");
-    } catch {
-      runnerContent = undefined;
-    }
-    const { kept: runnerKept, suppressed: runnerSuppressedHere } = applyPushedFindingPolicy(gate.live, {
-      cwd,
-      filePath: pending.filePath,
-      content: runnerContent
-    });
-    runnerFindingsDispositionSuppressed += runnerSuppressedHere;
-    if (runnerKept.length === 0) {
-      continue;
-    }
-    const lines = runnerKept.map((finding) => `  ${displayPath}:${finding.line ?? 1}:${finding.column ?? 1} [${finding.rule ?? finding.id}] ${finding.message}`);
-    runnerFindingsDelivered += runnerKept.length;
-    for (const finding of runnerKept) {
-      if (runnerFindingsDeliveredIds.length < 50) {
-        runnerFindingsDeliveredIds.push(finding.id);
-      }
-    }
-    const runnerSuppressedNote = runnerSuppressedHere > 0 ? `; suppressed by disposition: ${runnerSuppressedHere} finding(s)` : "";
-    advisoryParts.push(`⏱️ Late runner diagnostics (${pending.runnerId} completed after the edit${runnerSuppressedNote}):
-${lines.join(`
-`)}`);
-  }
-  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,
-      dispositionSuppressed: runnerFindingsDispositionSuppressed,
-      deliveredIds: runnerFindingsDeliveredIds
-    }
-  });
+  cacheManager.incrementTurnCycle(cwd, currentOwner, turnStateSessionId);
   const lateAuxStart = Date.now();
-  const drainedPairs = drainPendingAuxiliaryCoverage();
-  const lateAuxCapEvicted = drainPendingAuxCapEvictedCount();
+  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;
@@ -2044,6 +2515,9 @@ ${lines.join(`
   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 = [];
@@ -2069,9 +2543,9 @@ ${lines.join(`
         } catch {
           lateAuxProbeFailed += pairs.length;
           for (const pair of pairs) {
-            if (!isPendingAuxiliaryPastRearmTtl(pair) && (pair.rearmCount ?? 0) < MAX_LATE_AUX_REARMS) {
-              rearmPendingAuxiliaryCoverage(pair);
-              lateAuxRearmed += 1;
+            if (canRearmPendingAuxiliary(pair)) {
+              if (rearmLateAux(pair))
+                lateAuxRearmed += 1;
             } else if (isPendingAuxiliaryPastRearmTtl(pair)) {
               lateAuxExpired += 1;
             } else {
@@ -2109,13 +2583,14 @@ ${lines.join(`
             const pastTtl = isPendingAuxiliaryPastRearmTtl(pair);
             const atCeiling = (pair.rearmCount ?? 0) >= MAX_LATE_AUX_REARMS;
             if (!pastTtl && !atCeiling) {
-              rearmPendingAuxiliaryCoverage(pair);
-              lateAuxRearmed += 1;
-              if (lateAuxStuckPairs.length < 20)
-                lateAuxStuckPairs.push({
-                  filePath: pair.filePath,
-                  serverId: pair.serverId
-                });
+              if (rearmLateAux(pair)) {
+                lateAuxRearmed += 1;
+                if (lateAuxStuckPairs.length < 20)
+                  lateAuxStuckPairs.push({
+                    filePath: pair.filePath,
+                    serverId: pair.serverId
+                  });
+              }
             } else {
               if (pastTtl)
                 lateAuxExpired += 1;
@@ -2129,15 +2604,19 @@ ${lines.join(`
             continue;
           }
           const rawDiags = cachedEntry.diags;
-          if (cachedEntry.publishedAt === undefined || cachedEntry.publishedAt <= pair.markedAtMs) {
-            if (!isPendingAuxiliaryPastRearmTtl(pair) && (pair.rearmCount ?? 0) < MAX_LATE_AUX_REARMS) {
-              rearmPendingAuxiliaryCoverage(pair);
-              lateAuxRearmed += 1;
-              if (lateAuxStuckPairs.length < 20)
-                lateAuxStuckPairs.push({
-                  filePath: pair.filePath,
-                  serverId: pair.serverId
-                });
+          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;
@@ -2186,9 +2665,9 @@ ${lines.join(`
           lateAuxMissing += retained.length - gate.live.length - gate.stale.length;
           if (gate.live.length === 0) {
             if (gate.stale.length > 0) {
-              if (!isPendingAuxiliaryPastRearmTtl(pair) && (pair.rearmCount ?? 0) < MAX_LATE_AUX_REARMS) {
-                rearmPendingAuxiliaryCoverage(pair, Date.now(), true);
-                lateAuxRearmed += 1;
+              if (canRearmPendingAuxiliary(pair)) {
+                if (rearmLateAux(pair))
+                  lateAuxRearmed += 1;
               } else if (isPendingAuxiliaryPastRearmTtl(pair)) {
                 lateAuxExpired += 1;
               } else {
@@ -2213,9 +2692,29 @@ ${lines.join(`
           lateAuxDelivered += lateAuxKept.length;
           lateAuxAnswered += 1;
           const lateAuxSuppressedNote = lateAuxSuppressedHere > 0 ? `; suppressed by disposition: ${lateAuxSuppressedHere} finding(s)` : "";
-          advisoryParts.push(`\uD83D\uDD50 Late auxiliary diagnostics (${pair.serverId} answered after its grace window${lateAuxSuppressedNote}):
+          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) {
@@ -2259,6 +2758,7 @@ ${lines.join(`
         stale: lateAuxStale,
         missing: lateAuxMissing,
         rearmed: lateAuxRearmed,
+        backlogPending: lateAuxBacklogPending,
         clientGone: lateAuxClientGone,
         probeFailed: lateAuxProbeFailed,
         cleanConfirmed: lateAuxCleanConfirmed,
@@ -2276,21 +2776,112 @@ ${lines.join(`
       }
     });
   }
-  const labeledAdvisoryParts = advisoryParts.map((p) => `ℹ️ Advisory — no action required this turn:
-${p}`);
-  const findingParts = [
-    ...blockerParts,
-    ...staleSecretParts,
-    ...labeledAdvisoryParts
+  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 content = capTurnEndMessage(findingParts.join(`
+    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) {
+    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;
@@ -2314,13 +2905,13 @@ ${p}`);
           });
         }
       }
+      settleHolds(true);
       clearOwnedTurnState();
       runtime.fixedThisTurn.clear();
       resetFormatService();
       return;
     }
-    for (const commit of pendingDependencyDriftDeliveries)
-      commit();
+    settleHolds(false);
     const fileSeqByPath = {};
     for (const [filePath, seq] of runtime.getFileSeqEntries()) {
       fileSeqByPath[normalizeMapKey(path.resolve(filePath))] = seq;
@@ -2394,7 +2985,7 @@ ${p}`);
   }
   if (blockerParts.length === 0) {
     clearOwnedTurnState();
-    if (getFlag("lens-guard") && advisoryParts.length === 0 && staleSecretParts.length === 0 && !runtime.gitGuardHasBlockers) {
+    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);
@@ -2402,8 +2993,8 @@ ${p}`);
     }
   }
   runtime.fixedThisTurn.clear();
-  runtime.clearActionableWarnings();
-  runtime.clearCodeQualityWarnings();
+  runtime.clearActionableWarnings(sessionId);
+  runtime.clearCodeQualityWarnings(sessionId);
   if (demotedFindingsRetired > 0) {
     cacheManager.clearCache("turn-end-findings-last", cwd);
   }
@@ -2418,6 +3009,9 @@ ${p}`);
       blockerSections: blockerParts.length,
       staleSecretSections: staleSecretParts.length,
       advisorySections: advisoryParts.length,
+      resolvedBlockerFiles: resolvedBlockerFileList.length,
+      resolvedBlockerFilesDropped,
+      heldSections,
       demotedFindingsRetired,
       widgetDemotedFindingsRetired
     }