@herbertgao/pi-extensions 2026.8.7 → 2026.8.9

package/node_modules/pi-lens/dist/index.js

@@ -2678,6 +2678,23 @@ function isLegacyGlobalState(value) {
 function getRegisteredLogFiles() {
   return registeredLogFiles;
 }
+function getSinkWriteFailures() {
+  if (!ndjsonGlobalState)
+    return [];
+  const result = [];
+  for (const state2 of ndjsonGlobalState.writers.values()) {
+    if (state2.writeFailures > 0) {
+      result.push({ file: state2.file, droppedCount: state2.writeFailures });
+    }
+  }
+  return result;
+}
+function resetSinkWriteFailures() {
+  if (!ndjsonGlobalState)
+    return;
+  for (const state2 of ndjsonGlobalState.writers.values())
+    state2.writeFailures = 0;
+}
 function requireCurrentGlobalState() {
   if (ndjsonGlobalState)
     return ndjsonGlobalState;
@@ -2703,16 +2720,28 @@ function assertCompatibleWriterOptions(existing, maxBytes, backupPath) {
     return;
   throw new Error(`createNdjsonLogger: incompatible options for shared path ${existing.file}; the first writer's maxBytes/backupPath must be reused`);
 }
+function writeQueueItemSync(state2, item) {
+  if (item.kind === "truncate") {
+    fs.writeFileSync(state2.file, "");
+  } else {
+    rotateIfNeeded(state2);
+    fs.appendFileSync(state2.file, item.line);
+  }
+}
 function applyQueueItemSync(state2, item) {
   ensureDirSync(state2);
-  runBestEffort(() => {
-    if (item.kind === "truncate") {
-      fs.writeFileSync(state2.file, "");
-    } else {
-      rotateIfNeeded(state2);
-      fs.appendFileSync(state2.file, item.line);
-    }
-  });
+  try {
+    writeQueueItemSync(state2, item);
+    return;
+  } catch {
+  }
+  state2.ensuredDir = false;
+  ensureDirSync(state2);
+  try {
+    writeQueueItemSync(state2, item);
+  } catch {
+    state2.writeFailures += 1;
+  }
 }
 function flushStateSync(state2) {
   const inFlight2 = state2.inFlightBatch;
@@ -2735,6 +2764,8 @@ function createWriterState(file, maxBytes, backupPath) {
     assertCompatibleWriterOptions(existing, maxBytes, backupPath);
     if (!exitFlushers.has(existing.exitFlusher))
       registerWriter(existing);
+    if (typeof existing.writeFailures !== "number")
+      existing.writeFailures = 0;
     return existing;
   }
   const state2 = {};
@@ -2747,6 +2778,7 @@ function createWriterState(file, maxBytes, backupPath) {
   state2.syncRepairItems = null;
   state2.ensuredDir = false;
   state2.exitFlusher = () => flushStateSync(state2);
+  state2.writeFailures = 0;
   globalState2.writers.set(file, state2);
   registerWriter(state2);
   return state2;
@@ -2781,17 +2813,28 @@ function rotateIfNeeded(state2) {
   } catch {
   }
 }
+async function writeQueueItemAsync(state2, item) {
+  if (item.kind === "truncate") {
+    await fs.promises.writeFile(state2.file, "");
+  } else {
+    rotateIfNeeded(state2);
+    await fs.promises.appendFile(state2.file, item.line);
+  }
+}
 async function applyQueueItemAsync(state2, item) {
   await ensureDirAsync(state2);
   try {
-    if (item.kind === "truncate") {
-      await fs.promises.writeFile(state2.file, "");
-    } else {
-      rotateIfNeeded(state2);
-      await fs.promises.appendFile(state2.file, item.line);
-    }
+    await writeQueueItemAsync(state2, item);
+    return;
   } catch {
   }
+  state2.ensuredDir = false;
+  await ensureDirAsync(state2);
+  try {
+    await writeQueueItemAsync(state2, item);
+  } catch {
+    state2.writeFailures += 1;
+  }
 }
 async function drainLoop(state2) {
   while (state2.queue.length > 0) {
@@ -2801,14 +2844,24 @@ async function drainLoop(state2) {
     const pendingEnd = truncateIndex === -1 ? state2.queue.length : truncateIndex;
     const pending = item.kind === "truncate" ? [item] : state2.queue.slice(0, pendingEnd);
     state2.inFlightBatch = pending;
-    try {
+    const writeBatch = async () => {
       if (item.kind === "truncate") {
         await fs.promises.writeFile(state2.file, "");
       } else {
         rotateIfNeeded(state2);
         await fs.promises.appendFile(state2.file, pending.map((queued) => queued.line).join(""));
       }
+    };
+    try {
+      await writeBatch();
     } catch {
+      state2.ensuredDir = false;
+      await ensureDirAsync(state2);
+      try {
+        await writeBatch();
+      } catch {
+        state2.writeFailures += pending.length;
+      }
     }
     for (const written of pending) {
       if (state2.queue[0] !== written)
@@ -3315,12 +3368,25 @@ function boundedKind(value) {
   return groups.size < MAX_DISTINCT_KINDS - 1 ? kind : OVERFLOW_KIND;
 }
 function getDegradationSummary() {
-  return [...groups.entries()].map(([kind, group]) => ({
+  const summary = [...groups.entries()].map(([kind, group]) => ({
     kind,
     count: group.count,
     droppedCount: group.count - group.entries.length,
     latestReasons: group.entries.map((entry) => ({ ...entry }))
   }));
+  const sinkFailures = getSinkWriteFailures();
+  if (sinkFailures.length > 0) {
+    summary.push({
+      kind: "log-sink-write-failure",
+      count: sinkFailures.reduce((total, sink) => total + sink.droppedCount, 0),
+      droppedCount: 0,
+      latestReasons: sinkFailures.map((sink) => ({
+        subject: truncateForLedger(sink.file),
+        reason: truncateForLedger(`${sink.droppedCount} dropped write(s) after reopen-retry failed`)
+      }))
+    });
+  }
+  return summary;
 }
 function debugLedgerFailure(operation, error) {
   try {
@@ -3337,6 +3403,7 @@ function resetDegradationLedger() {
   onceKeys.clear();
   tallies.clear();
   ledgerGeneration++;
+  resetSinkWriteFailures();
 }
 var ENTRIES_PER_KIND, MAX_DISTINCT_KINDS, OVERFLOW_KIND, groups, onceKeys, tallies, ledgerGeneration;
 var init_degradation_ledger = __esm({
@@ -3345,6 +3412,7 @@ var init_degradation_ledger = __esm({
     init_extension_log();
     init_ledger_bounds();
     init_latency_logger();
+    init_ndjson_logger();
     ENTRIES_PER_KIND = 20;
     MAX_DISTINCT_KINDS = 32;
     OVERFLOW_KIND = "other";
@@ -22617,11 +22685,11 @@ function classifyEntry(entry, fullPath, cfg, probeCache, skipCounters) {
     return { recurseInto: fullPath };
   }
   if (entry.isFile()) {
-    if (ignoreMatcher.isIgnored(fullPath, false))
-      return {};
     const ext2 = path38.extname(entry.name).toLowerCase();
     if (!extensions.has(ext2))
       return {};
+    if (ignoreMatcher.isIgnored(fullPath, false))
+      return {};
     if (isBuildArtifact(fullPath, probeCache)) {
       if (skipCounters)
         skipCounters.buildArtifactSkips += 1;
@@ -28510,6 +28578,46 @@ function skipUnlessToolRan(tool, input, fields) {
   });
   return { status: "skipped", diagnostics: [], semantic: "none" };
 }
+function recordParsedNothing(input) {
+  const { tool, status, output, parsedCount } = input;
+  if (parsedCount > 0)
+    return false;
+  if (!status)
+    return false;
+  const text = output ?? "";
+  if (!text.trim())
+    return false;
+  const entries = Object.entries(input.fields ?? {}).filter(([, value]) => value !== void 0 && value !== "");
+  const identity = entries.length ? `${tool} (${entries.map(([key2, value]) => `${key2}=${value}`).join(", ")})` : tool;
+  incrementDegradationCount({
+    kind: "runner-parsed-nothing",
+    subject: tool,
+    reason: truncateForLedger(`${identity} exited ${status} with ${text.length} chars of output but the parser read 0 diagnostics: ${firstOutputLine(text) || "no first line"}`)
+  });
+  return true;
+}
+function parseToolRun(tool, input, parse6, options = {}) {
+  const skipped = skipUnlessToolRan(tool, input, options.fields);
+  if (skipped)
+    return { skipped, diagnostics: [], parsedNothing: false };
+  const output = options.parseOutput ?? input.output ?? input.result.stdout ?? "";
+  const diagnostics = [...parse6(output)];
+  const parsedNothing = recordParsedNothing({
+    tool,
+    status: input.result.status ?? null,
+    output,
+    parsedCount: diagnostics.length,
+    fields: options.fields
+  });
+  if (parsedNothing && options.skipWhenParsedNothing) {
+    return {
+      skipped: { status: "skipped", diagnostics: [], semantic: "none" },
+      diagnostics: [],
+      parsedNothing
+    };
+  }
+  return { skipped: null, diagnostics, parsedNothing };
+}
 var init_tool_failure = __esm({
   "dist/clients/dispatch/runners/utils/tool-failure.js"() {
     "use strict";
@@ -29413,11 +29521,11 @@ var init_jscpd_client = __esm({
           }
           if (!entry.isFile())
             return "skip";
-          if (ignoreMatcher.isIgnored(fullPath, false))
-            return "skip";
           if (/\.(ts|tsx|js|jsx|mjs|cjs|py|pyi|java|go|rs|rb|php|swift|kt|kts|dart|lua|scala|c|h|cpp|cc|cxx|hpp|hxx|cs|m|mm)$/.test(entry.name)) {
             if (entry.name.endsWith(".d.ts"))
               return "skip";
+            if (ignoreMatcher.isIgnored(fullPath, false))
+              return "skip";
             return "stop";
           }
           return "skip";
@@ -31609,7 +31717,8 @@ function logTreeSitterCacheStats(options) {
         maxSize: options.stats.maxSize,
         totalBytes: options.stats.totalBytes,
         totalLines: options.stats.totalLines
-      }
+      },
+      ...options.astGrep ? { astGrep: options.astGrep } : {}
     }
   });
 }
@@ -38909,7 +39018,11 @@ function shouldLogEvent(event) {
     return LOG_ALLOWED_EDITS;
   if (event === "range_snapshot_validation")
     return LOG_SNAPSHOT_VALIDATION;
-  return event === "edit_blocked" || event === "edit_warned" || event === "exemption_added" || event === "oldtext_not_found" || event === "oldtext_duplicate" || event === "oldtext_indent_autopatched" || event === "oldtext_trailing_ws_autopatched" || event === "oldtext_escape_autopatched" || event === "edit_range_relocated" || event === "edit_preflight_blocked" || event === "edit_partial_apply" || event === "edit_partial_apply_skipped" || event === "edit_post_edit_pipeline_failed" || event === "edit_batch_summary" || event === "edit_batch_summary_overflow" || event === "touched_lines_missing";
+  return event === "edit_blocked" || event === "edit_warned" || event === "exemption_added" || event === "oldtext_not_found" || event === "oldtext_duplicate" || event === "oldtext_indent_autopatched" || event === "oldtext_trailing_ws_autopatched" || event === "oldtext_escape_autopatched" || event === "edit_range_relocated" || event === "edit_preflight_blocked" || event === "edit_partial_apply" || event === "edit_partial_apply_skipped" || event === "edit_post_edit_pipeline_failed" || event === "edit_batch_summary" || event === "edit_batch_summary_overflow" || event === "touched_lines_missing" || // #1913: read-guard record-cap evictions are rare by construction (only
+  // READ_GUARD_MAX_RECORDS_PER_FILE overflow triggers one), so this trim
+  // record bypasses the per-read verbosity gate — a live eviction
+  // regression must be visible without PI_LENS_READ_GUARD_VERBOSE=1.
+  event === "read_cap_trimmed";
 }
 function boundTelemetryValue(value, pathName, depth) {
   if (typeof value === "string") {
@@ -39700,11 +39813,11 @@ function getModuleSourceFiles(moduleRoot, maxFiles = 20) {
       }
       if (!entry.isFile())
         continue;
+      if (!SOURCE_EXTS.has(path72.extname(entry.name).toLowerCase()))
+        continue;
       if (ignoreMatcher.isIgnored(fullPath, false))
         continue;
-      if (SOURCE_EXTS.has(path72.extname(entry.name).toLowerCase())) {
-        files2.push(normalizeMapKey(fullPath));
-      }
+      files2.push(normalizeMapKey(fullPath));
     }
   };
   visit2(root, 0);
@@ -41834,12 +41947,26 @@ var init_bounded_telemetry = __esm({
       "lsp_client_skipped_broken",
       /** #1743 review: the same skip, for a temporarily unavailable command. */
       "lsp_client_skipped_unavailable_command",
+      /**
+       * #1934: `getWarmClientForFile` found no live client for a file that has at
+       * least one language server with a resolvable root. Its callers run per
+       * file (the cascade quiet window, read expansion, `hasWarmLSP`), so it is
+       * rising-edge per candidate (server, root) set, with the ledger holding the
+       * exact count.
+       */
+      "lsp_warm_client_missing",
       /**
        * #1723: an event-loop block at or above the floor. Not a degradation, so
        * no ledger kind; bounded by call cadence (one `turn_end` runs it once per
        * turn) rather than by an option here.
        */
-      "loop_block"
+      "loop_block",
+      /**
+       * #1925: a session event skipped because its ctx was invalidated by a
+       * session replacement or reload. A replaced session can drain a whole
+       * queue of them, so it is rising-edge per event name.
+       */
+      "session_event_stale_ctx_skip"
     ];
     REGISTERED_PHASES = new Set(BOUNDED_TELEMETRY_PHASES);
     turnCounts = /* @__PURE__ */ new Map();
@@ -48819,6 +48946,19 @@ function setupConnectionLifecycle(state2, recentStderr) {
       });
     }
   });
+  state2.lspProcess.process.on("close", (code, signal) => {
+    if (state2.shutdownRequested)
+      return;
+    try {
+      const stderrTail = recentStderr(20);
+      incrementDegradationCount({
+        kind: "lsp-server-unexpected-close",
+        subject: state2.serverId,
+        reason: `closed unprompted: code=${code ?? "none"} signal=${signal ?? "none"} stderr=${stderrTail.length > 0 ? `present(${stderrTail.length}b)` : "empty"} root=${state2.root}`
+      });
+    } catch {
+    }
+  });
 }
 async function clientRequestPullDiagnostics(state2, filePath, budgetMs = PULL_REQUEST_TIMEOUT_MS) {
   if (!isClientAlive(state2))
@@ -49590,13 +49730,58 @@ function armNavLateAnswerTelemetry(args) {
   }, () => {
   });
 }
+function chooseLivenessProbe(state2) {
+  if (state2.operationSupport?.workspaceSymbol === true) {
+    return {
+      method: "workspace/symbol",
+      params: { query: LIVENESS_PING_QUERY }
+    };
+  }
+  const openUri = firstOpenDocumentUri(state2);
+  if (openUri === void 0)
+    return void 0;
+  if (state2.operationSupport?.documentSymbol === true) {
+    return {
+      method: "textDocument/documentSymbol",
+      params: { textDocument: { uri: openUri } }
+    };
+  }
+  if (state2.operationSupport?.hover === true) {
+    return {
+      method: "textDocument/hover",
+      params: {
+        textDocument: { uri: openUri },
+        position: { line: 0, character: 0 }
+      }
+    };
+  }
+  return void 0;
+}
+function firstOpenDocumentUri(state2) {
+  for (const normalizedPath of state2.openDocuments) {
+    const uri = state2.openDocumentUris?.get(normalizedPath);
+    if (uri !== void 0)
+      return uri;
+  }
+  return void 0;
+}
 async function clientPingLiveness(state2, timeoutMs = LIVENESS_PING_TIMEOUT_MS) {
   if (!isClientAlive(state2))
     return false;
+  const probe = chooseLivenessProbe(state2);
+  if (probe === void 0) {
+    try {
+      incrementDegradationCount({
+        kind: "lsp-liveness-probe-unsupported",
+        subject: state2.serverId,
+        reason: "no advertised request method to probe with (no workspaceSymbolProvider, and no open document with documentSymbolProvider or hoverProvider); liveness from process and connection state only"
+      });
+    } catch {
+    }
+    return isClientAlive(state2);
+  }
   try {
-    await withTimeout(safeSendRequest(state2.connection, "workspace/symbol", {
-      query: LIVENESS_PING_QUERY
-    }), timeoutMs);
+    await withTimeout(safeSendRequest(state2.connection, probe.method, probe.params), timeoutMs);
   } catch (err) {
     if (err instanceof Error && err.message.startsWith("Timeout after")) {
       return false;
@@ -49872,6 +50057,7 @@ async function createLSPClient(options) {
       initializationOptions: initialization
     }), initializeTimeoutMs);
   } catch (err) {
+    state2.shutdownRequested = true;
     const pid = lspProcess.pid;
     void killProcessTree(lspProcess.process, pid);
     void removeLspChild(pid, extractSpawnMarker(lspProcess.args)).catch((err2) => {
@@ -51533,7 +51719,14 @@ async function collectWorkspaceDiagnosticFiles(root, maxFiles = getMaxWorkspaceD
         if (ignoreMatcher.isIgnored(full, true))
           continue;
         await walk2(full);
-      } else if (entry.isFile() && !ignoreMatcher.isIgnored(full, false) && getServersForFileWithConfig(full).length > 0) {
+      } else if (
+        // #1974: the getServersForFileWithConfig lookup (an in-memory
+        // extension/pathFilter match against the registered LSP servers) is
+        // cheap relative to isIgnored's per-call minimatch pattern compile,
+        // so it gates first — the same order-independent shape as the four
+        // walkers fixed for #1974.
+        entry.isFile() && getServersForFileWithConfig(full).length > 0 && !ignoreMatcher.isIgnored(full, false)
+      ) {
         files2.push(full);
       }
     }
@@ -51647,6 +51840,21 @@ var init_lsp = __esm({
       /** Server/root pairs that already emitted unavailable for the current occurrence. */
       unavailableLogged = /* @__PURE__ */ new Set();
       optionalDisabled = /* @__PURE__ */ new Set();
+      /**
+       * #1934 review F1: what the last COMPLETED `spawnClient` call for a
+       * (server, root) key decided, written by that call at every point it
+       * returns without a client. This is a direct signal, deliberately NOT an
+       * inference from breaker state: the "binary unavailable while installs are
+       * disabled" branch sets a cooldown yet is a POLICY decline by its own
+       * comment, so reading the cooldown mislabels it as a server failure.
+       *
+       * Not a latch, and nothing re-arms it at `session_start`. Every read sits
+       * in the same microtask as the `await` of the spawn promise that just
+       * wrote it, so a stale entry is unreachable: a read is always preceded by
+       * its own attempt's write. Cardinality matches `state.clients` — one entry
+       * per (server, root) — and a successful spawn deletes its entry.
+       */
+      lastSpawnVerdict = /* @__PURE__ */ new Map();
       /** Consecutive failure counts for exponential backoff circuit breaker */
       failureCounts = /* @__PURE__ */ new Map();
       /**
@@ -52558,8 +52766,14 @@ var init_lsp = __esm({
         const withBudget2 = async () => {
           if (servers.length === 0)
             return void 0;
+          let erroredServerId;
           for (const server of servers) {
-            const spawned = await this.ensureClientForServer(filePath, server, resolvedRoots, noteSpawnInFlight);
+            const acquisition = {
+              outcome: "declined"
+            };
+            const spawned = await this.ensureClientForServer(filePath, server, resolvedRoots, noteSpawnInFlight, (reported) => {
+              acquisition.outcome = reported;
+            });
             if (spawned) {
               logLatency({
                 type: "phase",
@@ -52568,11 +52782,32 @@ var init_lsp = __esm({
                 durationMs: 0,
                 metadata: {
                   serverId: server.id,
-                  candidateCount: servers.length
+                  candidateCount: servers.length,
+                  // Emitted RAW, never coerced to a "safe" value: a served
+                  // client always reports `warm-reuse` or `cold-spawn`, so a
+                  // `declined` here would be a real reporting bug and must be
+                  // visible in the log rather than laundered into a lie.
+                  outcome: acquisition.outcome
                 }
               });
               return spawned;
             }
+            if (acquisition.outcome === "spawn-failure") {
+              erroredServerId ??= server.id;
+            }
+          }
+          if (erroredServerId !== void 0) {
+            logLatency({
+              type: "phase",
+              phase: "lsp_client_selected",
+              filePath,
+              durationMs: 0,
+              metadata: {
+                serverId: erroredServerId,
+                candidateCount: servers.length,
+                outcome: "spawn-failure"
+              }
+            });
           }
           const unavailable = (await Promise.all(servers.map(async (server) => {
             const root = await server.root(filePath);
@@ -52697,6 +52932,7 @@ var init_lsp = __esm({
         if (this.checkDestroyed())
           return void 0;
         const servers = getServersForFileWithConfig(filePath);
+        const missed = [];
         for (const server of servers) {
           const root = await this.resolveServerRoot(server, filePath);
           if (!root)
@@ -52706,6 +52942,21 @@ var init_lsp = __esm({
           if (existing?.isAlive()) {
             return { client: existing, info: server };
           }
+          missed.push(key2);
+        }
+        if (missed.length > 0) {
+          emitBounded("lsp_warm_client_missing", missed.join(","), {
+            filePath,
+            durationMs: 0,
+            metadata: {
+              serverIds: missed.map((key2) => key2.slice(0, key2.indexOf(":"))),
+              roots: missed.map((key2) => key2.slice(key2.indexOf(":") + 1))
+            }
+          }, {
+            ledgerKind: "lsp-warm-client-missing",
+            risingEdgePer: "identity",
+            reason: `no warm client for ${missed.join(",")}`
+          });
         }
         return void 0;
       }
@@ -52881,7 +53132,22 @@ var init_lsp = __esm({
         }
         this.documentDrift.recordSynced(filePath, content, at);
       }
-      async ensureClientForServer(filePath, server, resolvedRoots, onSpawnInFlight) {
+      /**
+       * #1934 review F1: record what a `spawnClient` call decided, at the point
+       * it decides it. Called on EVERY path that returns without a client, so
+       * "no verdict" cannot silently mean "failed".
+       *
+       * `"failed"` is a server failure: the spawn or the initialize handshake
+       * went wrong. `"declined"` is policy or lifecycle: host trust refused the
+       * binary, the service shut down mid-spawn, or the binary is absent while
+       * installs are disabled. That last one sets a breaker cooldown but is NOT
+       * a failure, which is exactly why the outcome cannot be inferred from
+       * breaker state.
+       */
+      noteSpawnVerdict(key2, verdict) {
+        this.lastSpawnVerdict.set(key2, verdict);
+      }
+      async ensureClientForServer(filePath, server, resolvedRoots, onSpawnInFlight, onOutcome) {
         const handoff = this.generationHandoff;
         if (handoff) {
           await handoff;
@@ -52944,6 +53210,7 @@ var init_lsp = __esm({
               logSessionStart(`lsp warm-start ${server.id}: reused root=${root} file=${filePath}`);
               this.warmStartLogged.add(key2);
             }
+            onOutcome?.("warm-reuse");
             return { client: existing, info: server };
           }
           const spawnedAt = this.state.clientSpawnedAt.get(key2);
@@ -53051,7 +53318,12 @@ var init_lsp = __esm({
         }
         onSpawnInFlight?.(server.id);
         try {
-          return await spawnPromise;
+          const spawned = await spawnPromise;
+          onOutcome?.(spawned ? "cold-spawn" : this.lastSpawnVerdict.get(key2) === "failed" ? "spawn-failure" : "declined");
+          return spawned;
+        } catch (err) {
+          onOutcome?.("spawn-failure");
+          throw err;
         } finally {
           if (this.state.inFlight.get(key2) === spawnPromise) {
             this.state.inFlight.delete(key2);
@@ -53069,6 +53341,7 @@ var init_lsp = __esm({
       async spawnClient(server, root, key2, filePath, allowInstall) {
         if (!isLspSpawnAllowedByTrust()) {
           logSessionStart(`lsp spawn ${server.id}: refused \u2014 ${projectTrustDenialReason()}`);
+          this.noteSpawnVerdict(key2, "declined");
           return void 0;
         }
         const isOptionalServer = OPTIONAL_LSP_SERVER_IDS.has(server.id);
@@ -53083,6 +53356,7 @@ var init_lsp = __esm({
             } catch {
             }
             logSessionStart(`lsp spawn ${server.id}: aborted (service shut down mid-spawn)`);
+            this.noteSpawnVerdict(key2, "declined");
             return void 0;
           }
           if (!spawned) {
@@ -53091,6 +53365,7 @@ var init_lsp = __esm({
             if (!allowInstall) {
               logSessionStart(`lsp spawn ${server.id}: unavailable with install disabled; temporary cooldown only`);
               this.state.broken.set(key2, Date.now() + BROKEN_BASE_COOLDOWN_MS);
+              this.noteSpawnVerdict(key2, "declined");
               return void 0;
             }
             const uCount = (this.failureCounts.get(key2) ?? 0) + 1;
@@ -53102,6 +53377,7 @@ var init_lsp = __esm({
               this.recordBreaker(key2, `permanently disabled after ${uCount} unavailable spawns`);
               logSessionStart(`lsp spawn ${server.id}: permanently disabled after ${uCount} failures`);
             }
+            this.noteSpawnVerdict(key2, "failed");
             return void 0;
           }
           const override = getServerInitOverride(server.id, filePath);
@@ -53118,6 +53394,7 @@ var init_lsp = __esm({
             client.shutdown({ fast: true }).catch(() => {
             });
             logSessionStart(`lsp spawn ${server.id}: aborted (service shut down mid-initialize)`);
+            this.noteSpawnVerdict(key2, "declined");
             return void 0;
           }
           const wsDiag = typeof client.getWorkspaceDiagnosticsSupport === "function" ? client.getWorkspaceDiagnosticsSupport() : {
@@ -53127,6 +53404,7 @@ var init_lsp = __esm({
           };
           this.state.clients.set(key2, client);
           this.unavailableLogged.delete(key2);
+          this.lastSpawnVerdict.delete(key2);
           this.state.clientSpawnedAt.set(key2, Date.now());
           this.clientLastUsedAt.set(key2, Date.now());
           this.scheduleTypeScriptIdleEviction(key2);
@@ -53164,6 +53442,7 @@ var init_lsp = __esm({
           if (isOptionalServer) {
             this.optionalDisabled.add(key2);
           }
+          this.noteSpawnVerdict(key2, "failed");
           return void 0;
         }
       }
@@ -55714,6 +55993,7 @@ var init_lsp = __esm({
         });
         this.state.clients.clear();
         this.state.broken.clear();
+        this.lastSpawnVerdict.clear();
         this.outstandingAuxNotifyWrites.clear();
         this.auxNotifyInflight.clear();
         this.documentDrift.clear();
@@ -56933,12 +57213,15 @@ Please read the file again before modifying it.`, absolutePath, "modified");
 import * as fs72 from "node:fs";
 function enforceRecordCapForFile(records) {
   if (records.length <= READ_GUARD_MAX_RECORDS_PER_FILE)
-    return 0;
+    return NO_TRIM;
   const excess = records.length - READ_GUARD_MAX_RECORDS_PER_FILE;
   const evicted = /* @__PURE__ */ new Set();
+  let evictedCreditCount = 0;
   for (let i = 0; i < records.length && evicted.size < excess; i++) {
-    if (records[i].searchCredit !== void 0)
+    if (records[i].searchCredit !== void 0) {
       evicted.add(i);
+      evictedCreditCount++;
+    }
   }
   for (let i = 0; i < records.length && evicted.size < excess; i++) {
     evicted.add(i);
@@ -56947,7 +57230,11 @@ function enforceRecordCapForFile(records) {
   records.length = 0;
   for (const record2 of kept)
     records.push(record2);
-  return excess;
+  return {
+    evictedCount: excess,
+    evictedCreditCount,
+    evictedGenuineCount: excess - evictedCreditCount
+  };
 }
 function captureReadContentBinding(filePath, offset, limit) {
   try {
@@ -57090,10 +57377,11 @@ function mapVerdictAction(action) {
       return "warned";
   }
 }
-var READ_GUARD_STATE_VERSION, DEFAULT_CONFIG, OWN_EDIT_STALE_GRACE_MS, READ_HASH_MAX_LINES, READ_BINDING_MAX_BYTES, READ_GUARD_MAX_FILES, READ_GUARD_MAX_RECORDS_PER_FILE, READ_GUARD_MAX_EDITS_PER_FILE, READ_GUARD_MAX_UNCONSUMED_FILES, READ_GUARD_IDLE_EVICT_MS_DEFAULT, currentContentMatchesBinding, RELOCATION_WINDOW_MIN, RELOCATION_WINDOW_PER_EDIT, RELOCATION_WINDOW_MAX, ReadGuard;
+var READ_GUARD_STATE_VERSION, DEFAULT_CONFIG, OWN_EDIT_STALE_GRACE_MS, READ_HASH_MAX_LINES, READ_BINDING_MAX_BYTES, READ_GUARD_MAX_FILES, READ_GUARD_MAX_RECORDS_PER_FILE, NO_TRIM, READ_GUARD_MAX_EDITS_PER_FILE, READ_GUARD_MAX_UNCONSUMED_FILES, READ_GUARD_IDLE_EVICT_MS_DEFAULT, currentContentMatchesBinding, RELOCATION_WINDOW_MIN, RELOCATION_WINDOW_PER_EDIT, RELOCATION_WINDOW_MAX, ReadGuard;
 var init_read_guard = __esm({
   "dist/clients/read-guard.js"() {
     "use strict";
+    init_degradation_ledger();
     init_file_time();
     init_diagnostic_binding();
     init_path_utils();
@@ -57114,6 +57402,11 @@ var init_read_guard = __esm({
     READ_BINDING_MAX_BYTES = 4 * 1024 * 1024;
     READ_GUARD_MAX_FILES = 256;
     READ_GUARD_MAX_RECORDS_PER_FILE = 128;
+    NO_TRIM = {
+      evictedCount: 0,
+      evictedCreditCount: 0,
+      evictedGenuineCount: 0
+    };
     READ_GUARD_MAX_EDITS_PER_FILE = 256;
     READ_GUARD_MAX_UNCONSUMED_FILES = 4096;
     READ_GUARD_IDLE_EVICT_MS_DEFAULT = 30 * 6e4;
@@ -57155,6 +57448,8 @@ var init_read_guard = __esm({
       // happened to the file since. Pruned inside `evictFile` so it never
       // outlives the record it points at.
       knownPathIndex = /* @__PURE__ */ new Map();
+      /** Running per-file record-cap trim totals for this session (#1913 F1). */
+      trimAccumulators = /* @__PURE__ */ new Map();
       sessionId;
       sessionStartMs;
       constructor(sessionId, config = {}) {
@@ -57247,7 +57542,7 @@ var init_read_guard = __esm({
         arr.push(storedRecord);
         this.reads.set(storedRecord.filePath, arr);
         const rawReadCountForFile = arr.length;
-        const evictedRecordCount = enforceRecordCapForFile(arr);
+        const { evictedCount: evictedRecordCount, evictedCreditCount, evictedGenuineCount } = enforceRecordCapForFile(arr);
         this.touchFile(storedRecord.filePath);
         this.enforceFileCap();
         logReadGuardEvent({
@@ -57282,6 +57577,39 @@ var init_read_guard = __esm({
             }
           }
         });
+        if (evictedRecordCount > 0) {
+          const key2 = storedRecord.filePath;
+          const acc = this.trimAccumulators.get(key2) ?? {
+            totalEvicted: 0,
+            evictedCreditCount: 0,
+            evictedGenuineCount: 0,
+            trimEventCount: 0
+          };
+          acc.totalEvicted += evictedRecordCount;
+          acc.evictedCreditCount += evictedCreditCount;
+          acc.evictedGenuineCount += evictedGenuineCount;
+          acc.trimEventCount += 1;
+          this.trimAccumulators.set(key2, acc);
+          const isRisingEdge = incrementDegradationCount({
+            kind: "read-guard-record-cap-trim",
+            subject: key2,
+            reason: `trim #${acc.trimEventCount}: evicted ${evictedRecordCount} (credit ${evictedCreditCount}, genuine ${evictedGenuineCount})`
+          });
+          if (isRisingEdge) {
+            logReadGuardEvent({
+              event: "read_cap_trimmed",
+              sessionId: this.sessionId,
+              filePath: storedRecord.filePath,
+              metadata: {
+                trimEventCount: acc.trimEventCount,
+                evictedRecordCount: acc.totalEvicted,
+                evictedCreditCount: acc.evictedCreditCount,
+                evictedGenuineCount: acc.evictedGenuineCount,
+                rawReadCountForFile
+              }
+            });
+          }
+        }
         this.fileTime.read(storedRecord.filePath);
       }
       /**
@@ -57641,6 +57969,18 @@ Re-read the relevant section, then retry the edit using the current line range/c
           this.touchFile(key2);
         return this.reads.get(key2) ?? [];
       }
+      /**
+       * Session-lifetime record-cap trim totals for a file (#1913 review F1).
+       * `recordRead` only writes ONE `read_cap_trimmed` read-guard.log line per
+       * file per session (on the first trim), so this is the running-totals
+       * surface for everything after that — the exact split this class already
+       * computes on every trim, not re-derivable from `getReadHistory` alone
+       * (which only shows the SURVIVING records, not what was evicted).
+       */
+      getTrimStats(filePath) {
+        const stats = this.trimAccumulators.get(this.key(filePath));
+        return stats ? { ...stats } : void 0;
+      }
       /**
        * Snapshot the read-set for persistence across a session resume (#1041).
        * Mirrors widget-state's `exportWidgetState`: the Map is emitted as
@@ -58437,11 +58777,11 @@ async function collectSourceFilesForWarmup(rootDir, maxFiles = MAX_WARMUP_SOURCE
         }
         stack.push(fullPath);
       } else if (entry.isFile()) {
-        if (ignoreMatcher.isIgnored(fullPath, false))
-          continue;
         const ext2 = path90.extname(entry.name).toLowerCase();
         if (!WARMUP_SOURCE_EXTS.has(ext2))
           continue;
+        if (ignoreMatcher.isIgnored(fullPath, false))
+          continue;
         matchedSeen += 1;
         const bucket = WARMUP_CODE_EXTS.has(ext2) ? codeOut : nonCodeOut;
         if (bucket.length < maxFiles)
@@ -61302,6 +61642,11 @@ function recordOutstandingCascadeTouch(entry) {
     });
   }
 }
+function resetCascadeTierSessionState() {
+  _outstandingTouches.clear();
+  _expiredSinceLastSweep = 0;
+  _evictedSinceLastSweep = 0;
+}
 async function reconcileOutstandingCascadeTouches(lspService) {
   const outcomes = [];
   pruneExpiredOutstandingTouches(Date.now());
@@ -62555,6 +62900,16 @@ var init_git_identity = __esm({
   }
 });
 
+// dist/clients/review-graph/revision-drift.js
+function formatReviewGraphRevisionDriftNote(drift) {
+  return `Graph was built at commit ${drift.stampedHead.slice(0, 8)}; HEAD is now ${drift.currentHead.slice(0, 8)}. Results below reflect the earlier revision \u2014 run pilens_rebuild or re-analyze to refresh.`;
+}
+var init_revision_drift = __esm({
+  "dist/clients/review-graph/revision-drift.js"() {
+    "use strict";
+  }
+});
+
 // dist/clients/review-graph/symbol-id.js
 function buildSymbolId(filePath, name, kind, startLine) {
   return `${filePath}:${name}:${kind}:${startLine}`;
@@ -63190,6 +63545,7 @@ __export(builder_exports, {
   flushReviewGraphPersist: () => flushReviewGraphPersist,
   flushReviewGraphPersistsForExitForTests: () => flushReviewGraphPersistsForExitForTests,
   flushReviewGraphPersistsForTests: () => flushReviewGraphPersistsForTests,
+  formatReviewGraphRevisionDriftNote: () => formatReviewGraphRevisionDriftNote,
   getCachedReviewGraph: () => getCachedReviewGraph,
   getCheckpointOffloadCountForTests: () => getCheckpointOffloadCountForTests,
   getGraphBuildInfoForGraph: () => getGraphBuildInfoForGraph,
@@ -63199,10 +63555,12 @@ __export(builder_exports, {
   getLastReviewGraphBuildAttempt: () => getLastReviewGraphBuildAttempt,
   getReviewGraphCacheIdentity: () => getReviewGraphCacheIdentity,
   getReviewGraphMaxFiles: () => getReviewGraphMaxFiles,
+  getReviewGraphRevisionDrift: () => getReviewGraphRevisionDrift,
   getReviewGraphSizeSkipVerdict: () => getReviewGraphSizeSkipVerdict,
   getReviewGraphWorkerFallbackReasonForTests: () => getReviewGraphWorkerFallbackReasonForTests,
   getReviewGraphWorkspaceCacheSnapshot: () => getReviewGraphWorkspaceCacheSnapshot,
   graphBuildInfoIsTrustworthy: () => graphBuildInfoIsTrustworthy,
+  isGraphBuildInFlight: () => isGraphBuildInFlight,
   isReviewGraphMigrationNeeded: () => isReviewGraphMigrationNeeded,
   resetReviewGraphPersistWorkerForTests: () => resetReviewGraphPersistWorkerForTests,
   reviewGraphCachePath: () => reviewGraphCachePath,
@@ -63227,13 +63585,20 @@ function clearWorkspaceGraphTimer(entry) {
     clearTimeout(entry.idleTimer);
   entry.idleTimer = void 0;
 }
+function buildCacheWorkspaceKey(cwd) {
+  return normalizeMapKey(path104.resolve(cwd));
+}
+function buildCacheKeyWorkspace(buildKey) {
+  const separator = buildKey.indexOf("|");
+  return separator >= 0 ? buildKey.slice(0, separator) : void 0;
+}
 function evictWorkspaceGraph(key2, entry) {
   if (_workspaceGraphCache.get(key2) !== entry)
     return;
   clearWorkspaceGraphTimer(entry);
+  const buildWorkspace = buildCacheWorkspaceKey(key2);
   for (const buildKey of _buildCache.keys()) {
-    const separator = buildKey.indexOf("|");
-    if (separator >= 0 && normalizeMapKey(buildKey.slice(0, separator)) === key2) {
+    if (buildCacheKeyWorkspace(buildKey) === buildWorkspace) {
       _buildCache.delete(buildKey);
     }
   }
@@ -63308,8 +63673,9 @@ function clearReviewGraphWorkspaceCache(cwd) {
     _sizeSkipVerdicts.clear();
   } else {
     const normalized = normalizeMapKey(cwd);
+    const buildWorkspace = buildCacheWorkspaceKey(cwd);
     for (const key2 of _buildCache.keys()) {
-      if (normalizeMapKey(key2).startsWith(`${normalized}|`)) {
+      if (buildCacheKeyWorkspace(key2) === buildWorkspace) {
         _buildCache.delete(key2);
       }
     }
@@ -63415,7 +63781,7 @@ function getCachedReviewGraph(cwd) {
     return cached.graph;
   }
   const disk = loadPersistedGraph(cwd, {
-    verifyGitStamp: true,
+    verifyWorktreeIdentity: true,
     allowPartial: true
   });
   if (!disk)
@@ -63424,10 +63790,23 @@ function getCachedReviewGraph(cwd) {
     signature: disk.signature,
     fileSignatures: disk.fileSignatures,
     fileHashes: disk.fileHashes,
-    graph: disk.graph
+    graph: disk.graph,
+    // Durable half of the drift fact. The current-HEAD half is never cached
+    // beside it — see getReviewGraphRevisionDrift (#1961 review F3).
+    ...disk.stampedHead ? { snapshotStampedHead: disk.stampedHead } : {}
   });
   return disk.graph;
 }
+function getReviewGraphRevisionDrift(cwd) {
+  const entry = _workspaceGraphCache.get(normalizeMapKey(cwd));
+  const stampedHead = entry?.snapshotStampedHead;
+  if (!stampedHead)
+    return void 0;
+  const current = resolveGitIdentity(cwd);
+  if (!current || current.headCommit === stampedHead)
+    return void 0;
+  return { stampedHead, currentHead: current.headCommit };
+}
 function makeCtx(filePath, cwd, facts) {
   return {
     filePath,
@@ -63724,6 +64103,19 @@ function rebuildIndexes(graph) {
     graph.edgesByTo.set(edge.to, to);
   }
 }
+function logSnapshotReadVerdict(cwd, phase, reason) {
+  const verdict = phase === "snapshot_read_dropped" ? "dropped" : "drifted";
+  const isRisingEdge = incrementDegradationCount({
+    kind: "review-graph-snapshot-read",
+    // Subject keeps BOTH discriminators, so aggregation still answers which
+    // workspace and which verdict after the detailed records stop.
+    subject: `${verdict}:${normalizeMapKey(cwd)}`,
+    reason
+  });
+  if (!isRisingEdge)
+    return;
+  logReviewGraph({ cwd, phase, reason });
+}
 function loadPersistedGraph(cwd, opts) {
   const cacheDir = path104.join(getProjectDataDir(cwd), "cache");
   const cachePath3 = path104.join(cacheDir, GRAPH_CACHE_FILENAME);
@@ -63735,11 +64127,17 @@ function loadPersistedGraph(cwd, opts) {
       return null;
     if (data.coverage?.partial && !opts?.allowPartial)
       return null;
-    if (opts?.verifyGitStamp && data.gitStamp) {
+    let stampedHead;
+    if (opts?.verifyWorktreeIdentity && data.gitStamp) {
       const current = resolveGitIdentity(cwd);
-      if (current && (current.headCommit !== data.gitStamp.headCommit || current.worktreeRoot !== data.gitStamp.worktreeRoot)) {
+      if (current && current.worktreeRoot !== data.gitStamp.worktreeRoot) {
+        logSnapshotReadVerdict(cwd, "snapshot_read_dropped", "worktree_mismatch");
         return null;
       }
+      if (current && current.headCommit !== data.gitStamp.headCommit) {
+        stampedHead = data.gitStamp.headCommit;
+        logSnapshotReadVerdict(cwd, "snapshot_read_drifted", "head_moved");
+      }
     }
     const graph = {
       version: data.version,
@@ -63758,7 +64156,8 @@ function loadPersistedGraph(cwd, opts) {
       signature: data.signature,
       fileSignatures: new Map(data.fileSignatures ?? []),
       fileHashes: new Map(data.fileHashes ?? []),
-      graph
+      graph,
+      ...stampedHead ? { stampedHead } : {}
     };
   } catch {
     return null;
@@ -64543,11 +64942,11 @@ function loadReviewGraphCheckpoint(cwd) {
   }
   if (data.gitStamp) {
     const current = resolveGitIdentity(cwd);
-    if (current && (current.headCommit !== data.gitStamp.headCommit || current.worktreeRoot !== data.gitStamp.worktreeRoot)) {
+    if (current && current.worktreeRoot !== data.gitStamp.worktreeRoot) {
       logReviewGraph({
         cwd,
         phase: "checkpoint_discarded",
-        reason: "git_stamp_mismatch"
+        reason: "worktree_mismatch"
       });
       deleteReviewGraphCheckpoint(cwd);
       return null;
@@ -66038,6 +66437,7 @@ async function _doBuildGraph(cwd, changedFiles, facts, seqHint, buildId) {
   const graph = resumed?.graph ?? createEmptyGraph();
   const filesToExtract = resumed?.remaining ?? filesToBuild;
   const treeSitterClient = getSharedTreeSitterClient();
+  treeSitterClient?.ensureTreeCacheCapacity(filesToExtract.length);
   const extractionStartedAt = Date.now();
   const fileHashes = resumed?.fileHashes ?? /* @__PURE__ */ new Map();
   const checkpointEvery = graphCheckpointEveryFiles();
@@ -66145,8 +66545,14 @@ async function _doBuildGraph(cwd, changedFiles, facts, seqHint, buildId) {
   facts.setSessionFact("session.reviewGraph", graph);
   return graph;
 }
+function buildCacheKey(cwd, changedFiles) {
+  return `${buildCacheWorkspaceKey(cwd)}|${[...changedFiles].sort((a, b) => a.localeCompare(b)).join(",")}`;
+}
+function isGraphBuildInFlight(cwd, changedFiles = []) {
+  return _buildCache.has(buildCacheKey(cwd, changedFiles));
+}
 function buildOrUpdateGraph(cwd, changedFiles, facts, seqHint) {
-  const cacheKey = `${cwd}|${[...changedFiles].sort((a, b) => a.localeCompare(b)).join(",")}`;
+  const cacheKey = buildCacheKey(cwd, changedFiles);
   const cached = _buildCache.get(cacheKey);
   if (cached)
     return cached;
@@ -66212,7 +66618,6 @@ function buildOrUpdateGraph(cwd, changedFiles, facts, seqHint) {
     }
     return graph;
   }).catch((err) => {
-    _buildCache.delete(cacheKey);
     const reason = err instanceof Error ? err.message : String(err);
     recordBuildAttempt(cwd, "failed", reason, buildId);
     logReviewGraph({
@@ -66233,6 +66638,11 @@ function buildOrUpdateGraph(cwd, changedFiles, facts, seqHint) {
     throw err;
   });
   _buildCache.set(cacheKey, promise);
+  const release = () => {
+    if (_buildCache.get(cacheKey) === promise)
+      _buildCache.delete(cacheKey);
+  };
+  promise.then(release, release);
   return promise;
 }
 function extractSymbolsAndRefsFromGraph(graph) {
@@ -66389,7 +66799,9 @@ var init_builder = __esm({
     init_tree_sitter_shared();
     init_tree_sitter_symbol_extractor();
     init_tree_sitter_shared();
+    init_degradation_ledger();
     init_git_identity();
+    init_revision_drift();
     init_symbol_id();
     init_shared_extraction_ir();
     REVIEW_GRAPH_VERSION = "v8";
@@ -68003,7 +68415,7 @@ var init_detekt = __esm({
     init_tool_policy();
     init_priorities();
     init_runner_helpers();
-    init_spawn_outcome();
+    init_tool_failure();
     detekt = createAvailabilityChecker("detekt", ".bat");
     DETEKT_CONFIG_CANDIDATES = [
       "detekt.yml",
@@ -68096,10 +68508,10 @@ var init_detekt = __esm({
         const absPath = path112.resolve(cwd, ctx.filePath);
         const result = await safeSpawnAsync(cmd, ["--input", absPath, "--config", configPath], { cwd, timeout: 6e4 });
         const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-        if (spawnFailedWithNoOutput(result, raw)) {
-          return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseDetektOutput(raw, ctx.filePath);
+        const run = parseToolRun("detekt", { result, output: raw }, (out) => parseDetektOutput(out, ctx.filePath));
+        if (run.skipped)
+          return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
           return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
@@ -68998,7 +69410,7 @@ var init_hadolint = __esm({
     init_tool_policy();
     init_priorities();
     init_runner_helpers();
-    init_spawn_outcome();
+    init_tool_failure();
     hadolint = createAvailabilityChecker("hadolint", ".exe");
     hadolintRunner = {
       id: "hadolint",
@@ -69022,11 +69434,10 @@ var init_hadolint = __esm({
           return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const result = await safeSpawnAsync(cmd, ["--format", "json", "--no-fail", path116.resolve(cwd, ctx.filePath)], { cwd });
-        if (spawnFailedWithNoOutput(result)) {
-          return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const output = result.stdout || "";
-        const diagnostics = parseHadolintOutput(output, ctx.filePath);
+        const run = parseToolRun("hadolint", { result }, (out) => parseHadolintOutput(out, ctx.filePath));
+        if (run.skipped)
+          return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
           return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
@@ -69825,7 +70236,7 @@ var init_htmlhint = __esm({
     init_tool_policy();
     init_priorities();
     init_runner_helpers();
-    init_spawn_outcome();
+    init_tool_failure();
     htmlhint = createAvailabilityChecker("htmlhint");
     HTMLHINT_RULES = {
       "tag-pair": true,
@@ -69865,10 +70276,10 @@ var init_htmlhint = __esm({
           path119.resolve(cwd, ctx.filePath)
         ], { cwd });
         const output = result.stdout || result.stderr || "";
-        if (spawnFailedWithNoOutput(result, output)) {
-          return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseHtmlhintOutput(output, ctx.filePath);
+        const run = parseToolRun("htmlhint", { result, output }, (out) => parseHtmlhintOutput(out, ctx.filePath));
+        if (run.skipped)
+          return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
           return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
@@ -70558,14 +70969,10 @@ var init_markdownlint = __esm({
           cwd
         });
         const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-        const skipped = skipUnlessToolRan("markdownlint", {
-          result,
-          output: raw,
-          exitCodes: MARKDOWNLINT_EXIT_CODES
-        });
-        if (skipped)
-          return skipped;
-        const diagnostics = parseMarkdownlintOutput(raw, ctx.filePath);
+        const run = parseToolRun("markdownlint", { result, output: raw, exitCodes: MARKDOWNLINT_EXIT_CODES }, (out) => parseMarkdownlintOutput(out, ctx.filePath));
+        if (run.skipped)
+          return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
           return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
@@ -70637,14 +71044,10 @@ var init_mypy = __esm({
           return { status: "skipped", diagnostics: [], semantic: "none" };
         const result = await safeSpawnAsync(cmd, ["--no-error-summary", "--show-column-numbers", ctx.filePath], { timeout: 3e4, cwd });
         const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-        const skipped = skipUnlessToolRan("mypy", {
-          result,
-          output: result.stdout,
-          exitCodes: MYPY_EXIT_CODES
-        });
-        if (skipped)
-          return skipped;
-        const diagnostics = parseMypyOutput(raw, ctx.filePath, cwd);
+        const run = parseToolRun("mypy", { result, output: result.stdout, exitCodes: MYPY_EXIT_CODES }, (out) => parseMypyOutput(out, ctx.filePath, cwd), { parseOutput: raw });
+        if (run.skipped)
+          return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
           return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
@@ -70794,9 +71197,6 @@ var init_oxlint = __esm({
         const result = await safeSpawnAsync(cmd, args, {
           timeout: 3e4
         });
-        if (result.status === 0) {
-          return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
         const stdout = result.stdout ?? "";
         const stderr = result.stderr ?? "";
         let diagnostics = parseOxlintJson(stdout, ctx.filePath);
@@ -70808,7 +71208,7 @@ var init_oxlint = __esm({
         }
         const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
         return {
-          status: "failed",
+          status: !hasBlocking && result.status === 0 ? "succeeded" : "failed",
           diagnostics,
           semantic: hasBlocking ? "blocking" : "warning"
         };
@@ -70896,7 +71296,7 @@ function parsePhpstanJson(raw, fallbackPath, cwd) {
     const diagnostics = [];
     for (const [file, fileErrors] of Object.entries(output.files ?? {})) {
       const filePath = file && file.trim() ? path126.isAbsolute(file) ? file : path126.resolve(cwd, file) : fallbackPath;
-      for (const err of fileErrors.errors ?? []) {
+      for (const err of fileErrors?.messages ?? []) {
         diagnostics.push({
           id: `phpstan:${err.line ?? 1}:${err.message.slice(0, 40)}`,
           message: err.message,
@@ -70906,11 +71306,27 @@ function parsePhpstanJson(raw, fallbackPath, cwd) {
           severity: "error",
           semantic: "blocking",
           tool: "phpstan",
-          rule: "phpstan",
+          rule: err.identifier || "phpstan",
           fixable: false
         });
       }
     }
+    for (const message of output.errors ?? []) {
+      if (typeof message !== "string" || !message.trim())
+        continue;
+      diagnostics.push({
+        id: `phpstan:global:${message.slice(0, 40)}`,
+        message,
+        filePath: fallbackPath,
+        line: 1,
+        column: 1,
+        severity: "error",
+        semantic: "blocking",
+        tool: "phpstan",
+        rule: "phpstan/analysis",
+        fixable: false
+      });
+    }
     return diagnostics;
   } catch {
     return [];
@@ -70921,7 +71337,7 @@ async function resolvePhpstan(cwd) {
     return phpstan.getCommand(cwd);
   return resolveVendorToolCommand(cwd, "phpstan", ".bat");
 }
-var phpstan, phpstanRunner, phpstan_default;
+var PHPSTAN_EXIT_CODES, phpstan, phpstanRunner, phpstan_default;
 var init_phpstan = __esm({
   "dist/clients/dispatch/runners/phpstan.js"() {
     "use strict";
@@ -70929,6 +71345,8 @@ var init_phpstan = __esm({
     init_tool_policy();
     init_priorities();
     init_runner_helpers();
+    init_tool_failure();
+    PHPSTAN_EXIT_CODES = { ran: [1] };
     phpstan = createAvailabilityChecker("phpstan", ".phar");
     phpstanRunner = {
       id: "phpstan",
@@ -70950,13 +71368,10 @@ var init_phpstan = __esm({
           return { status: "skipped", diagnostics: [], semantic: "none" };
         const absPath = path126.resolve(cwd, ctx.filePath);
         const result = await safeSpawnAsync(cmd, ["analyse", "--error-format=json", "--no-progress", absPath], { timeout: 3e4, cwd });
-        if (result.status === 2 || result.error) {
-          return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        if (result.status === 0) {
-          return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parsePhpstanJson(result.stdout ?? "", ctx.filePath, cwd);
+        const run = parseToolRun("phpstan", { result, exitCodes: PHPSTAN_EXIT_CODES }, (out) => parsePhpstanJson(out, ctx.filePath, cwd), { parseOutput: result.stdout ?? "" });
+        if (run.skipped)
+          return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
           return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
@@ -72470,10 +72885,10 @@ var typos, TYPOS_EXIT_CODES, spellcheckRunner, spellcheck_default;
 var init_spellcheck = __esm({
   "dist/clients/dispatch/runners/spellcheck.js"() {
     "use strict";
-    init_tool_failure();
     init_safe_spawn();
     init_priorities();
     init_runner_helpers();
+    init_tool_failure();
     typos = createAvailabilityChecker("typos", ".exe");
     TYPOS_EXIT_CODES = { ran: [2] };
     spellcheckRunner = {
@@ -72491,18 +72906,10 @@ var init_spellcheck = __esm({
         const result = await safeSpawnAsync(typos.getCommand(ctx.cwd || process.cwd()), args, {
           timeout: 15e3
         });
-        const skipped = skipUnlessToolRan("spellcheck", {
-          result,
-          exitCodes: TYPOS_EXIT_CODES
-        });
-        if (skipped)
-          return skipped;
-        const hasTypos = result.status === 2 || result.stdout?.trim();
-        if (!hasTypos) {
-          return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const raw = result.stdout + result.stderr;
-        const diagnostics = parseTyposOutput(raw, ctx.filePath);
+        const run = parseToolRun("spellcheck", { result, exitCodes: TYPOS_EXIT_CODES }, (out) => parseTyposOutput(out, ctx.filePath), { parseOutput: `${result.stdout ?? ""}${result.stderr ?? ""}` });
+        if (run.skipped)
+          return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
           return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
@@ -72631,21 +73038,19 @@ var init_sqlfluff = __esm({
         }
         if (!cmd)
           return { status: "skipped", diagnostics: [], semantic: "none" };
-        const args = ["lint", "--format", "json", ctx.filePath];
+        const args = ["lint", "--format", "json"];
         if (!hasConfig) {
-          args.splice(2, 0, "--dialect", "ansi");
+          args.push("--dialect", "ansi");
         }
+        args.push(ctx.filePath);
         const result = await safeSpawnAsync(cmd, args, {
           timeout: 2e4,
           cwd
         });
-        const skipped = skipUnlessToolRan("sqlfluff", {
-          result,
-          exitCodes: SQLFLUFF_EXIT_CODES
-        });
-        if (skipped)
-          return skipped;
-        const diagnostics = parseSqlfluffOutput(result.stdout ?? "", ctx.filePath);
+        const run = parseToolRun("sqlfluff", { result, exitCodes: SQLFLUFF_EXIT_CODES }, (out) => parseSqlfluffOutput(out, ctx.filePath), { parseOutput: result.stdout ?? "" });
+        if (run.skipped)
+          return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
           return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
@@ -72662,6 +73067,13 @@ var init_sqlfluff = __esm({
 
 // dist/clients/dispatch/runners/stylelint.js
 import * as path132 from "node:path";
+function stylelintReport(stdout, stderr) {
+  for (const stream of [stdout, stderr]) {
+    if (stream?.trimStart().startsWith("["))
+      return stream;
+  }
+  return "";
+}
 function parseStylelintJson(raw, filePath) {
   try {
     const results = JSON.parse(raw);
@@ -72758,14 +73170,11 @@ var init_stylelint = __esm({
         if (!cmd)
           return { status: "skipped", diagnostics: [], semantic: "none" };
         const result = await safeSpawnAsync(cmd, ["--formatter", "json", ctx.filePath], { timeout: 2e4, cwd });
-        const skipped = skipUnlessToolRan("stylelint", {
-          result,
-          exitCodes: STYLELINT_EXIT_CODES
-        });
-        if (skipped)
-          return skipped;
-        const raw = result.stdout ?? "";
-        const diagnostics = parseStylelintJson(raw, ctx.filePath);
+        const raw = stylelintReport(result.stdout, result.stderr);
+        const run = parseToolRun("stylelint", { result, output: raw, exitCodes: STYLELINT_EXIT_CODES }, (out) => parseStylelintJson(out, ctx.filePath));
+        if (run.skipped)
+          return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
           return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
@@ -72905,11 +73314,10 @@ var init_swiftlint = __esm({
         if (!cmd)
           return { status: "skipped", diagnostics: [], semantic: "none" };
         const result = await safeSpawnAsync(cmd, ["--reporter", "json", path133.resolve(cwd, ctx.filePath)], { cwd, timeout: 15e3 });
-        const skipped = skipUnlessToolRan("swiftlint", { result });
-        if (skipped)
-          return skipped;
-        const raw = result.stdout || "";
-        const diagnostics = parseSwiftLintOutput(raw, ctx.filePath);
+        const run = parseToolRun("swiftlint", { result }, (out) => parseSwiftLintOutput(out, ctx.filePath));
+        if (run.skipped)
+          return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
           return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
@@ -72928,26 +73336,47 @@ var init_swiftlint = __esm({
 // dist/clients/dispatch/runners/taplo.js
 import * as path134 from "node:path";
 function parseTaploOutput(raw, filePath) {
-  try {
-    const parsed = JSON.parse(raw);
-    const errors = parsed.errors ?? [];
-    return errors.map((err, idx) => ({
-      id: `taplo-${err.kind}-${err.range?.start.line ?? idx}`,
-      message: `[${err.kind}] ${err.message}`,
+  const diagnostics = [];
+  const lines = (raw ?? "").split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const header = HEADER_PATTERN.exec(lines[i].trimEnd());
+    if (!header)
+      continue;
+    const severityWord = header[1];
+    const summary = header[2].trim();
+    if (!summary)
+      continue;
+    let line = null;
+    let column = 1;
+    for (let j = i + 1; j < Math.min(i + 4, lines.length); j++) {
+      if (!lines[j].includes(LOCATION_LEAD))
+        continue;
+      const location = LOCATION_PATTERN.exec(lines[j].trimEnd());
+      if (!location)
+        continue;
+      line = Number.parseInt(location[1], 10) || 1;
+      column = Number.parseInt(location[2], 10) || 1;
+      break;
+    }
+    if (line === null)
+      continue;
+    const severity = severityWord === "warning" ? "warning" : "error";
+    diagnostics.push({
+      id: `taplo-${severity}-${line}-${column}`,
+      message: summary,
       filePath,
-      line: (err.range?.start.line ?? 0) + 1,
-      column: (err.range?.start.col ?? 0) + 1,
-      severity: "error",
-      semantic: "blocking",
+      line,
+      column,
+      severity,
+      semantic: severity === "error" ? "blocking" : "warning",
       tool: "taplo",
-      rule: err.kind,
+      rule: `taplo/${severity}`,
       fixable: false
-    }));
-  } catch {
-    return [];
+    });
   }
+  return diagnostics;
 }
-var taplo, taploRunner, taplo_default;
+var taplo, TAPLO_EXIT_CODES, HEADER_PATTERN, LOCATION_LEAD, LOCATION_PATTERN, taploRunner, taplo_default;
 var init_taplo = __esm({
   "dist/clients/dispatch/runners/taplo.js"() {
     "use strict";
@@ -72956,8 +73385,12 @@ var init_taplo = __esm({
     init_tool_policy();
     init_priorities();
     init_runner_helpers();
-    init_spawn_outcome();
+    init_tool_failure();
     taplo = createAvailabilityChecker("taplo", ".exe");
+    TAPLO_EXIT_CODES = { ran: [1] };
+    HEADER_PATTERN = /^\s*(error|warning):(.*)$/;
+    LOCATION_LEAD = "\u250C\u2500";
+    LOCATION_PATTERN = /:(\d+):(\d+)$/;
     taploRunner = {
       id: "taplo",
       appliesTo: ["toml"],
@@ -72984,11 +73417,12 @@ var init_taplo = __esm({
         if (!cmd)
           return { status: "skipped", diagnostics: [], semantic: "none" };
         const absPath = path134.resolve(cwd, ctx.filePath);
-        const result = await safeSpawnAsync(cmd, ["check", "--output=json", absPath], { cwd, timeout: 15e3 });
-        if (spawnFailedWithNoOutput(result)) {
-          return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseTaploOutput(result.stdout || "", ctx.filePath);
+        const result = await safeSpawnAsync(cmd, ["check", "--colors", "never", absPath], { cwd, timeout: 15e3 });
+        const raw = result.stderr?.trim() ? result.stderr : result.stdout ?? "";
+        const run = parseToolRun("taplo", { result, output: raw, exitCodes: TAPLO_EXIT_CODES }, (out) => parseTaploOutput(out, ctx.filePath), { skipWhenParsedNothing: true });
+        if (run.skipped)
+          return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
           return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
@@ -73150,9 +73584,9 @@ var init_tflint = __esm({
     init_safe_spawn();
     init_tool_policy();
     init_workspace_topology();
-    init_runner_helpers();
-    init_spawn_outcome();
     init_priorities();
+    init_runner_helpers();
+    init_tool_failure();
     tflint = createAvailabilityChecker("tflint", ".exe");
     TFLINT_CONFIG = ".tflint.hcl";
     tflintRunner = {
@@ -73191,10 +73625,10 @@ var init_tflint = __esm({
           cwd: fileDir,
           timeout: 3e4
         });
-        if (spawnFailedWithNoOutput(result)) {
-          return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseTflintOutput(result.stdout || "", ctx.filePath);
+        const run = parseToolRun("tflint", { result }, (out) => parseTflintOutput(out, ctx.filePath));
+        if (run.skipped)
+          return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
           return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
@@ -73404,13 +73838,12 @@ function parseValeOutput(raw, filePath) {
     return diagnostics;
   try {
     const parsed = JSON.parse(raw);
-    const files2 = parsed?.Data?.Files;
-    if (!files2)
+    if (!parsed || typeof parsed !== "object")
       return diagnostics;
-    for (const file of files2) {
-      if (!file.Alerts)
+    for (const alerts of Object.values(parsed)) {
+      if (!Array.isArray(alerts))
         continue;
-      for (const alert of file.Alerts) {
+      for (const alert of alerts) {
         if (!alert.Message)
           continue;
         const severityMap = {
@@ -73425,7 +73858,7 @@ function parseValeOutput(raw, filePath) {
           message: `[${alert.Check ?? "vale"}] ${alert.Message}`,
           filePath,
           line: alert.Line ?? 1,
-          column: alert.Column ?? 1,
+          column: alert.Span?.[0] ?? 1,
           severity,
           semantic: severity === "error" ? "blocking" : "warning",
           tool: "vale",
@@ -73468,11 +73901,10 @@ var init_vale = __esm({
         if (!cmd)
           return { status: "skipped", diagnostics: [], semantic: "none" };
         const result = await safeSpawnAsync(cmd, ["--output", "JSON", ctx.filePath], { cwd, timeout: 15e3 });
-        const skipped = skipUnlessToolRan("vale", { result });
-        if (skipped)
-          return skipped;
-        const raw = result.stdout || "";
-        const diagnostics = parseValeOutput(raw, ctx.filePath);
+        const run = parseToolRun("vale", { result }, (raw) => parseValeOutput(raw, ctx.filePath));
+        if (run.skipped)
+          return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
           return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
@@ -74194,13 +74626,10 @@ var init_yamllint = __esm({
           timeout: 15e3
         });
         const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-        const skipped = skipUnlessToolRan("yamllint", {
-          result,
-          output: result.stdout
-        });
-        if (skipped)
-          return skipped;
-        const diagnostics = parseYamllintParsable(raw, ctx.filePath);
+        const run = parseToolRun("yamllint", { result, output: result.stdout }, (out) => parseYamllintParsable(out, ctx.filePath), { parseOutput: raw });
+        if (run.skipped)
+          return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
           return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
@@ -77975,7 +78404,7 @@ function makeSourceCountVisitor(state2, ignoreMatcher, limit, maxEntries) {
       }
       return recurse ? "recurse" : "skip";
     }
-    if (entry.isFile() && !ignoreMatcher.isIgnored(fullPath, false) && SOURCE_FILE_PATTERN.test(entry.name)) {
+    if (entry.isFile() && SOURCE_FILE_PATTERN.test(entry.name) && !ignoreMatcher.isIgnored(fullPath, false)) {
       state2.count += 1;
       if (state2.count > limit)
         return "stop";
@@ -83501,10 +83930,10 @@ function tokenizeShellCommand(command) {
     word = "";
     atTokenStart = true;
   };
-  const flushSegment = () => {
+  const flushSegment = (terminator) => {
     flushWord();
     if (tokens.length > 0 || unsupported)
-      segments.push({ tokens, unsupported });
+      segments.push({ tokens, unsupported, terminator });
     tokens = [];
     unsupported = false;
     atTokenStart = true;
@@ -83569,13 +83998,17 @@ function tokenizeShellCommand(command) {
     }
     if (ch === ";" || ch === "\n" || ch === "|" || ch === "&") {
       flushWord();
+      let terminator;
       if (ch === "|" && next === "|")
         i++;
       else if (ch === "&" && next === "&")
         i++;
-      else if (ch === "|" || ch === "&")
+      else if (ch === "|") {
+        unsupported = true;
+        terminator = "pipe";
+      } else if (ch === "&")
         unsupported = true;
-      flushSegment();
+      flushSegment(terminator);
       continue;
     }
     if (ch === "<" || ch === ">") {
@@ -83926,11 +84359,44 @@ function parseGrepLineWithoutFile(line, file) {
     return void 0;
   return { file, startLine: lineNumber, endLine: lineNumber };
 }
+var LINE_DROPPING_TAIL_VERBS = /* @__PURE__ */ new Set(["head", "tail", "uniq"]);
+function isSedQuitCommand(args) {
+  for (const arg of args) {
+    const token = stripQuotes(arg);
+    if (token.startsWith("-"))
+      continue;
+    if (/(^|[;\n])\s*(\d+|\$)?\s*q\b/.test(token))
+      return true;
+  }
+  return false;
+}
+function isLineDroppingTailCommand(tokens) {
+  const verb = path69.basename(stripQuotes(tokens[0] ?? ""));
+  if (LINE_DROPPING_TAIL_VERBS.has(verb))
+    return true;
+  if (verb === "sed")
+    return isSedQuitCommand(tokens.slice(1));
+  return false;
+}
+function grepPipesIntoTruncatingTail(segments, index) {
+  if (segments[index]?.terminator !== "pipe")
+    return false;
+  for (let j = index + 1; j < segments.length; j++) {
+    if (isLineDroppingTailCommand(segments[j].tokens))
+      return true;
+    if (segments[j].terminator !== "pipe")
+      return false;
+  }
+  return false;
+}
 function collectGrepCommandFiles(command, cwd) {
   const files2 = /* @__PURE__ */ new Set();
   let hasLineNumberGrep = false;
   let context;
-  for (const tokens of commandSegments(command)) {
+  let truncated = false;
+  const segments = tokenizeShellCommand(command);
+  for (let i = 0; i < segments.length; i++) {
+    const tokens = segments[i].tokens;
     const verb = path69.basename(stripQuotes(tokens[0] ?? ""));
     if (verb !== "grep" && verb !== "egrep" && verb !== "fgrep")
       continue;
@@ -83945,11 +84411,13 @@ function collectGrepCommandFiles(command, cwd) {
     } : segmentContext;
     for (const file of extractGrepSearchFiles(args, cwd))
       files2.add(file);
+    if (grepPipesIntoTruncatingTail(segments, i))
+      truncated = true;
   }
   return {
     hasLineNumberGrep,
     files: files2,
-    context: context ?? { before: 0, after: 0 }
+    context: truncated ? { before: 0, after: 0 } : context ?? { before: 0, after: 0 }
   };
 }
 function dedupePushSearchRead(out, seen, loc) {
@@ -89534,6 +90002,47 @@ var RuntimeCoordinator = class {
     });
     return true;
   }
+  /**
+   * #1944: retire a past-EOF demotion after its ONE degraded delivery.
+   *
+   * The past-EOF gate demotes and re-arms, but nothing ever retired the
+   * record, so a blocker whose file shrank past the cited lines re-served on
+   * every turn end for the rest of the session — measured live at 80+
+   * minutes on session 01a0234c. The re-serve is unbounded, not the six
+   * turns the first evidence window suggested.
+   *
+   * It is unbounded because the record cannot resolve itself. The two
+   * clearing events (`clearInlineBlockers` on a later dispatch of the same
+   * path, `retireInlineBlockerOnConfirmedClean` on a fresh clean verdict)
+   * both need the file to be looked at again, and the agent has no reason to
+   * look: the coordinates it was handed do not exist. "Re-run to confirm" is
+   * an instruction this record makes impossible to follow.
+   *
+   * So the delivery surface retires it after serving it once, degraded. That
+   * is a DROP, which #1419's demote-not-drop rule normally forbids; the
+   * exception is narrow and stated here. The finding was already delivered
+   * this turn with its dead coordinates annotated, and what remains is a
+   * message pinned to a line the file does not have. `deadLines` is required
+   * and must be non-empty, so a record stale for any OTHER reason, or
+   * past-EOF with no identified dead line, still stands.
+   *
+   * @returns true when an entry was retired — the caller records it, so the
+   * suppression is never silent (#1432 Gap 1).
+   */
+  retireDemotedPastEofBlocker(filePath, deadLines) {
+    if (deadLines.length === 0)
+      return false;
+    const key2 = path152.resolve(filePath);
+    const existing = this._pendingInlineBlockers.get(key2);
+    if (!existing)
+      return false;
+    if (!existing.stale)
+      return false;
+    if ((existing.staleReason ?? "past-eof") !== "past-eof")
+      return false;
+    this._pendingInlineBlockers.delete(key2);
+    return true;
+  }
   /**
    * Retire a file's inline blocker because a FRESH, content-bound diagnostic
    * verdict proved it gone (#1561).
@@ -89926,6 +90435,7 @@ init_language_policy();
 init_language_profile();
 init_latency_logger();
 init_log_cleanup();
+init_cascade_tier();
 init_config();
 init_workspace_diagnostics_session();
 init_server();
@@ -91079,6 +91589,7 @@ async function handleSessionStart(deps) {
   resetSmellsSessionState();
   resetWorkspaceDiagnosticsCacheSession(sessionStartMs);
   knipClient.resetSessionState?.();
+  resetCascadeTierSessionState();
   runtime2.resetForSession(sessionStartMs);
   logLatency({
     type: "phase",
@@ -91218,6 +91729,32 @@ async function handleSessionStart(deps) {
     log2(`Active tools: ${quickTools.join(", ")}`);
     dbg2(`session_start tools: ${quickTools.join(", ") || "deferred (quick mode)"}`);
     dbg2("session_start: quick mode active - skipping slow tool probes, language profiling, preinstall, scans, and error debt baseline");
+    logLatency({
+      type: "phase",
+      phase: "session_start_skipped_steps",
+      filePath: cwd,
+      durationMs: 0,
+      metadata: {
+        mode: startupMode,
+        reason: deps.sessionReason,
+        // #1911 review F3: this `if (quickMode)` branch is an early return —
+        // the whole quick path — so there is no enumerable list of "steps
+        // run vs. skipped" this array could be derived from mechanically. It
+        // is DESCRIPTIVE documentation of what the early return skips,
+        // matching the `dbg()` line above word for word; keep both in sync by
+        // hand if either changes. It also does NOT narrow under
+        // `getFlag("no-lsp")` — quick mode skips the same five steps either
+        // way; the LSP flag instead affects `quickTools` above, a separate
+        // record.
+        steps: [
+          "slow_tool_probes",
+          "language_profiling",
+          "tool_preinstall",
+          "startup_scans",
+          "error_debt_baseline"
+        ]
+      }
+    });
     const totalDurationMs2 = Date.now() - sessionStartMs;
     dbg2(`session_start total: ${totalDurationMs2}ms (interactive path)`);
     logLatency({
@@ -93655,6 +94192,61 @@ ${partial.postEditOutput}`;
   }
 }
 
+// dist/clients/session-event-guard.js
+init_bounded_telemetry();
+init_session_lifecycle();
+function isStaleExtensionCtxError(err) {
+  return err instanceof Error && err.message.includes("stale after session replacement or reload");
+}
+function recordStaleSkip(eventName, detectedAt) {
+  emitBounded("session_event_stale_ctx_skip", eventName, {
+    durationMs: 0,
+    metadata: { event: eventName, detectedAt }
+  }, {
+    ledgerKind: "extension-ctx-stale",
+    risingEdgePer: "identity",
+    reason: `${eventName} skipped: extension ctx is stale (${detectedAt})`
+  });
+}
+function isThenable(value) {
+  return typeof value?.then === "function";
+}
+function guardSessionEvent(eventName, handler, onStaleResult, options) {
+  const skip = (event, detectedAt) => {
+    recordStaleSkip(eventName, detectedAt);
+    try {
+      options.dbg?.(`${eventName} skipped: extension ctx is stale after session replacement or reload`);
+    } catch {
+    }
+    return onStaleResult(event);
+  };
+  return (event, ctx) => {
+    if (probeCtxActive(ctx) === false)
+      return skip(event, "pre-dispatch");
+    try {
+      const result = handler(event, ctx);
+      if (isThenable(result)) {
+        return Promise.resolve(result).catch((err) => {
+          if (isStaleExtensionCtxError(err))
+            return skip(event, "mid-handler");
+          throw err;
+        });
+      }
+      return result;
+    } catch (err) {
+      if (isStaleExtensionCtxError(err))
+        return skip(event, "mid-handler");
+      throw err;
+    }
+  };
+}
+function wrapSessionEventHandler(eventName, handler, options = {}) {
+  return guardSessionEvent(eventName, handler, () => void 0, options);
+}
+function wrapSessionEventHandlerWithResult(eventName, handler, options) {
+  return guardSessionEvent(eventName, handler, options.onStaleResult, options);
+}
+
 // dist/index.js
 init_session_lifecycle();
 
@@ -94110,7 +94702,7 @@ function sweepInlineBlockerPastEof(runtime2, cwd, options) {
     total: 0,
     checked: 0,
     demoted: 0,
-    healed: 0
+    deadLinesByPath: /* @__PURE__ */ new Map()
   };
   const resync = options?.resync ?? resyncDocumentOnPastEof;
   let entries;
@@ -94141,20 +94733,80 @@ function sweepInlineBlockerPastEof(runtime2, cwd, options) {
         resync
       });
       const isPastEof = diagnostics.some((d) => d.stale);
+      if (isPastEof) {
+        counts.deadLinesByPath.set(entry.filePath, diagnostics.filter((d) => d.stale).map((d) => d.line).filter((line) => typeof line === "number"));
+      }
       const transitioned = runtime2.setInlineBlockerPastEofStale(entry.filePath, isPastEof);
       if (!transitioned)
         continue;
-      if (isPastEof) {
+      if (isPastEof)
         counts.demoted += 1;
-      } else {
-        counts.healed += 1;
-      }
     } catch {
     }
   }
   return counts;
 }
 
+// dist/clients/runtime-turn.js
+init_degradation_ledger();
+
+// dist/clients/demoted-finding-render.js
+var DEAD_LINE_ANNOTATION = "(line no longer exists)";
+var AUTHORITY_REWRITES = [
+  [
+    /[^\S\n]*(?:🔴|⛔|❌)?[^\S\n]*STOP[^\S\n]*[—–-][^\S\n]*(\d+)[^\S\n]+issue\(s\)[^\S\n]+must be fixed:?/g,
+    "$1 issue(s) were flagged before this file changed; the coordinates below may no longer exist:"
+  ],
+  [/(?:🔴|⛔|❌)[^\S\n]*STOP\b[^\S\n]*[—–-]?/g, "Previously flagged \u2014"],
+  [/\bSTOP\b/g, "Previously flagged"],
+  [/\bmust be fixed\b/g, "were flagged"]
+];
+var CITED_LINE_RE = /^([^\S\n]*)L(\d+)\b/;
+function splitBannerRegion(lines) {
+  const firstCitedRow = lines.findIndex((line) => CITED_LINE_RE.test(line));
+  if (firstCitedRow !== -1)
+    return { bannerEnd: firstCitedRow };
+  const firstNonBlank = lines.findIndex((line) => line.trim() !== "");
+  return { bannerEnd: firstNonBlank === -1 ? 0 : firstNonBlank + 1 };
+}
+function degradeDemotedFindingBody(summary, options = {}) {
+  const deadLines = new Set(options.deadLines ?? []);
+  let authorityMarkersRemoved = 0;
+  const sourceLines = summary.split("\n");
+  const { bannerEnd } = splitBannerRegion(sourceLines);
+  const degradedLines = sourceLines.map((line, index) => {
+    if (index >= bannerEnd)
+      return line;
+    let rewritten = line;
+    for (const [pattern, replacement] of AUTHORITY_REWRITES) {
+      rewritten = rewritten.replace(pattern, (...args) => {
+        authorityMarkersRemoved += 1;
+        return replacement.replace(/\$(\d)/g, (_, digit) => String(args[Number(digit)] ?? ""));
+      });
+    }
+    return rewritten;
+  });
+  let body = degradedLines.join("\n");
+  const deadLinesAnnotated = [];
+  if (deadLines.size > 0) {
+    body = degradedLines.map((line) => {
+      const hit = CITED_LINE_RE.exec(line);
+      if (!hit)
+        return line;
+      const cited = Number.parseInt(hit[2] ?? "", 10);
+      if (!Number.isFinite(cited) || !deadLines.has(cited))
+        return line;
+      deadLinesAnnotated.push(cited);
+      return `${hit[1] ?? ""}L${cited} ${DEAD_LINE_ANNOTATION}${line.slice(hit[0].length)}`;
+    }).join("\n");
+  }
+  return { body, authorityMarkersRemoved, deadLinesAnnotated };
+}
+function formatRetirementNote(deadLines) {
+  const cited = deadLines.length > 0 ? ` (cited ${deadLines.length === 1 ? "line" : "lines"} ${deadLines.join(", ")})` : "";
+  return `Retired after this delivery${cited}: the file no longer has these lines, so this finding cannot be re-confirmed and will not be served again.`;
+}
+
 // dist/clients/runtime-turn.js
 init_stale_marker();
 init_widget_state();
@@ -94331,8 +94983,10 @@ async function handleTurnEnd(deps) {
     metadata: {
       total: blockerPastEof.total,
       checked: blockerPastEof.checked,
-      demoted: blockerPastEof.demoted,
-      healed: blockerPastEof.healed
+      demoted: blockerPastEof.demoted
+      // #1944 review F3: `healed` is gone. Retirement makes the falling edge
+      // unreachable on this store, so the field could only ever log zero —
+      // see `BlockerPastEofCounts`.
     }
   });
   const blockerFreshnessStart = Date.now();
@@ -94358,11 +95012,24 @@ async function handleTurnEnd(deps) {
     }
   });
   const unresolvedBlockers = runtime2.getInlineBlockersSnapshot();
+  let demotedFindingsRetired = 0;
   for (const { filePath: bPath, summary, stale } of unresolvedBlockers) {
     const displayPath = toRunnerDisplayPath(cwd, bPath);
     if (stale) {
+      const deadLines = blockerPastEof.deadLinesByPath.get(bPath) ?? [];
+      const degraded = degradeDemotedFindingBody(summary, { deadLines });
+      const retired = runtime2.retireDemotedPastEofBlocker(bPath, deadLines);
+      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`
+        });
+      }
       advisoryParts.push(`${STALE_LINE_MARKER} ${displayPath}:
-${summary}`);
+${degraded.body}` + (retired ? `
+${formatRetirementNote(deadLines)}` : ""));
     } else {
       blockerParts.push(`Unresolved from this turn \u2014 ${displayPath}:
 ${summary}`);
@@ -95408,6 +96075,9 @@ ${p}`);
   runtime2.fixedThisTurn.clear();
   runtime2.clearActionableWarnings();
   runtime2.clearCodeQualityWarnings();
+  if (demotedFindingsRetired > 0) {
+    cacheManager.clearCache("turn-end-findings-last", cwd);
+  }
   logLatency({
     type: "tool_result",
     toolName: "turn_end",
@@ -95421,7 +96091,12 @@ ${p}`);
       fileCount: files2.length,
       blockerSections: blockerParts.length,
       staleSecretSections: staleSecretParts.length,
-      advisorySections: advisoryParts.length
+      advisorySections: advisoryParts.length,
+      // #1944 AC3: an empty advisory section on its own cannot say whether
+      // the turn had nothing to report or dropped something. This counter
+      // answers that from latency.log even when the payload is empty, and
+      // the payload itself carries the retirement note when it is not.
+      demotedFindingsRetired
     }
   });
   resetFormatService2();
@@ -96651,17 +97326,15 @@ async function scanFileMajorRules(cwd, files2, signal) {
       // subtract its share so this metric stays comparable to the historical
       // phase-major scans.
       durationMs: Date.now() - startedAt - astGrepDurationMs,
-      stats
-    });
-  });
-  await client.withParseCacheMeasurement(async () => {
-  }, (stats) => {
-    logTreeSitterCacheStats({
-      scope: "project_diagnostics_ast_grep_scan",
-      filePath: cwd,
-      fileCount: astGrepFilesScanned,
-      durationMs: astGrepDurationMs,
-      stats
+      stats,
+      // #1935 review: ast-grep's own cost is often a scan's most expensive
+      // phase (production evidence: 13168ms over 86 files, the single
+      // biggest contributor). Its duration is subtracted above so it stays
+      // comparable to the historical phase-major scans; carry it here too
+      // so it stays visible SOMEWHERE instead of disappearing when the
+      // vacuous `project_diagnostics_ast_grep_scan` cache_stats record
+      // (below) was removed.
+      astGrep: { durationMs: astGrepDurationMs, fileCount: astGrepFilesScanned }
     });
   });
   return { treeSitter, factRules, astGrep, filesScanned, wasmAborted };
@@ -97999,10 +98672,14 @@ async function moduleReport(file, cwd, options) {
   let graph;
   let graphFileCap;
   let callGraphIdentity;
+  let revisionDriftNote;
   try {
-    const { getCachedReviewGraph: getCachedReviewGraph2, getReviewGraphCacheIdentity: getReviewGraphCacheIdentity2, getReviewGraphSizeSkipVerdict: getReviewGraphSizeSkipVerdict2 } = await Promise.resolve().then(() => (init_builder(), builder_exports));
+    const { getCachedReviewGraph: getCachedReviewGraph2, getReviewGraphCacheIdentity: getReviewGraphCacheIdentity2, getReviewGraphSizeSkipVerdict: getReviewGraphSizeSkipVerdict2, getReviewGraphRevisionDrift: getReviewGraphRevisionDrift2, formatReviewGraphRevisionDriftNote: formatReviewGraphRevisionDriftNote2 } = await Promise.resolve().then(() => (init_builder(), builder_exports));
     graph = getCachedReviewGraph2(cwd);
     graphFileCap = getReviewGraphSizeSkipVerdict2(cwd)?.maxFileCount;
+    const drift = graph ? getReviewGraphRevisionDrift2(cwd) : void 0;
+    if (drift)
+      revisionDriftNote = formatReviewGraphRevisionDriftNote2(drift);
     callGraphIdentity = graph ? (() => {
       const identity = getReviewGraphCacheIdentity2(cwd, graph);
       return identity ? {
@@ -98021,6 +98698,8 @@ async function moduleReport(file, cwd, options) {
   const api = topLevel.filter((entry) => entry.exported);
   const internal = topLevel.filter((entry) => !entry.exported);
   const warnings = [...extractionWarnings ?? []];
+  if (revisionDriftNote)
+    warnings.push(revisionDriftNote);
   if (callbackError) {
     warnings.push(`Failed to extract callbacks: ${callbackError}`);
     logLatency({
@@ -98639,6 +99318,7 @@ async function readEnclosing(file, line, cwd, options) {
 // dist/clients/project-report.js
 init_path_utils();
 init_project_snapshot();
+init_revision_drift();
 import * as path179 from "node:path";
 var DEFAULT_LIMIT = 10;
 var STALE_THRESHOLD_MS = 15 * 6e4;
@@ -98691,7 +99371,7 @@ function buildFileDegrees(graph) {
   }
   return { fanIn, fanOut };
 }
-function computeTrust(graph, cwd) {
+function computeTrust(graph, cwd, drift) {
   const filesCovered = graph.fileNodes.size;
   const snapshot = loadProjectSnapshotWithoutWordIndex(cwd);
   const snapshotFileCount = snapshot ? Object.keys(snapshot.files).length : 0;
@@ -98728,6 +99408,8 @@ function computeTrust(graph, cwd) {
   const stale = Number.isFinite(ageMs) && ageMs > STALE_THRESHOLD_MS;
   const lowCoverage = coverage < LOW_COVERAGE_THRESHOLD || graph.persistCoverage?.partial === true;
   const notes = [];
+  if (drift)
+    notes.push(formatReviewGraphRevisionDriftNote(drift));
   if (stale) {
     const ageMin = Math.round(ageMs / 6e4);
     notes.push(`Graph is stale: built ${ageMin}m ago. Sections below may miss recent edits \u2014 run pilens_rebuild or re-analyze to refresh.`);
@@ -98759,6 +99441,7 @@ function computeTrust(graph, cwd) {
       sampleSize
     },
     stale,
+    ...drift ? { revisionDrift: drift } : {},
     lowCoverage,
     persistCoverage: graph.persistCoverage?.partial ? graph.persistCoverage : void 0,
     notes
@@ -99016,28 +99699,22 @@ function computeDeadWeight(graph, degrees, entryPointFiles, cwd, limit) {
   };
 }
 var inFlightGraphBuilds = /* @__PURE__ */ new Set();
-function triggerBackgroundGraphBuild(cwd) {
+function triggerBackgroundGraphBuild(cwd, deps) {
   const key2 = normalizeMapKey(path179.resolve(cwd));
   if (inFlightGraphBuilds.has(key2))
-    return false;
+    return "already_running";
+  const deduped = deps.isGraphBuildInFlight(key2, []);
   inFlightGraphBuilds.add(key2);
-  void (async () => {
-    try {
-      const { buildOrUpdateGraph: buildOrUpdateGraph3 } = await Promise.resolve().then(() => (init_builder(), builder_exports));
-      const { FactStore: FactStore2 } = await Promise.resolve().then(() => (init_fact_store(), fact_store_exports));
-      await buildOrUpdateGraph3(key2, [], new FactStore2());
-    } catch {
-    } finally {
-      inFlightGraphBuilds.delete(key2);
-    }
-  })();
-  return true;
+  const build2 = deps.buildOrUpdateGraph(key2, [], new deps.FactStore()).catch(() => {
+  });
+  void build2.finally(() => inFlightGraphBuilds.delete(key2));
+  return deduped ? "already_running" : "started";
 }
 async function projectReport(cwd, options) {
   const limit = clampLimit(options?.limit);
   const focusTerms = normalizeFocus2(options?.focus);
   const view = options?.view;
-  const { getCachedReviewGraph: getCachedReviewGraph2, getReviewGraphSizeSkipVerdict: getReviewGraphSizeSkipVerdict2, getLastReviewGraphBuildAttempt: getLastReviewGraphBuildAttempt2 } = await Promise.resolve().then(() => (init_builder(), builder_exports));
+  const { getCachedReviewGraph: getCachedReviewGraph2, getReviewGraphSizeSkipVerdict: getReviewGraphSizeSkipVerdict2, getLastReviewGraphBuildAttempt: getLastReviewGraphBuildAttempt2, buildOrUpdateGraph: buildOrUpdateGraph3, isGraphBuildInFlight: isGraphBuildInFlight2, getReviewGraphRevisionDrift: getReviewGraphRevisionDrift2 } = await Promise.resolve().then(() => (init_builder(), builder_exports));
   let graph;
   try {
     graph = getCachedReviewGraph2(cwd);
@@ -99061,17 +99738,25 @@ async function projectReport(cwd, options) {
       };
     }
     const previousAttempt = getLastReviewGraphBuildAttempt2(cwd);
-    const kickedOff = triggerBackgroundGraphBuild(cwd);
-    const lastBuildAttempt2 = previousAttempt ?? getLastReviewGraphBuildAttempt2(cwd);
+    const { FactStore: FactStore2 } = await Promise.resolve().then(() => (init_fact_store(), fact_store_exports));
+    const trigger = triggerBackgroundGraphBuild(cwd, {
+      buildOrUpdateGraph: buildOrUpdateGraph3,
+      isGraphBuildInFlight: isGraphBuildInFlight2,
+      FactStore: FactStore2
+    });
+    const started = trigger === "started";
+    const lastBuildAttempt2 = started ? getLastReviewGraphBuildAttempt2(cwd) ?? previousAttempt : previousAttempt;
+    const terminal = previousAttempt?.outcome === "failed" || previousAttempt?.outcome === "skipped";
+    const cause = terminal ? `Review graph unavailable: ${previousAttempt?.reason ?? previousAttempt?.outcome}. ` : "";
     return {
       available: false,
-      hint: lastBuildAttempt2?.outcome === "failed" || lastBuildAttempt2?.outcome === "skipped" ? `Review graph unavailable: ${lastBuildAttempt2.reason ?? lastBuildAttempt2.outcome}. A retry was ${kickedOff ? "started" : "not started"}.` : kickedOff ? "No review graph cached for this workspace yet \u2014 a build was kicked off in the background; retry this call shortly." : "No review graph cached for this workspace yet \u2014 the background build is still running; retry this call shortly.",
+      hint: started ? terminal ? `${cause}A retry was started.` : "No review graph cached for this workspace yet \u2014 a build was kicked off in the background; retry this call shortly." : `${cause}A build is already running for this workspace; retry this call shortly.`,
       ...lastBuildAttempt2 ? { lastBuildAttempt: lastBuildAttempt2 } : {},
       ...view ? { view } : {}
     };
   }
   const degrees = buildFileDegrees(graph);
-  const trust = computeTrust(graph, cwd);
+  const trust = computeTrust(graph, cwd, getReviewGraphRevisionDrift2(cwd));
   const hubs = await computeHubs(graph, degrees, cwd, limit, focusTerms);
   const { entryPoints, entryPointFiles } = computeEntryPoints(graph, degrees, cwd, limit, focusTerms);
   const subsystems = computeSubsystems(graph, cwd, limit);
@@ -99507,7 +100192,7 @@ function createLensDiagnosticsTool(cacheManager, getCwd, getLspService = getLSPS
   };
 }
 function formatProjectDeltaDiagnostic(diagnostic, stale) {
-  const marker = diagnostic.semantic === "blocking" || diagnostic.severity === "error" ? "\u{1F534}" : "\u2139";
+  const marker = stale ? "\u25CB" : diagnostic.semantic === "blocking" || diagnostic.severity === "error" ? "\u{1F534}" : "\u2139";
   const rule = diagnostic.rule ?? diagnostic.code ?? diagnostic.runner;
   const where = stale ? STALE_LINE_MARKER : `L${diagnostic.line ?? "?"}`;
   return `  ${marker} ${where}  ${rule}  ${diagnostic.message}`;
@@ -104856,6 +105541,7 @@ function recordToolSetMutation(mutation) {
 }
 
 // dist/clients/cache-observability.js
+init_env_utils();
 init_latency_logger();
 import { createHash as createHash15 } from "node:crypto";
 var PROCESS_TURN_SCOPE = "process-global-runtime";
@@ -104866,6 +105552,93 @@ var MAX_REPORTED_MESSAGES = 1e4;
 var MAX_INJECTED_CHARS = 16384;
 var MAX_INJECTED_BYTES = 65536;
 var contextObservationCounter = 0;
+var CHARS_PER_ESTIMATED_TOKEN = 4;
+var DEFAULT_PROVIDER_CACHE_TTL_MS = 6e4;
+var _providerCacheTtl = lazyEnvNumber("PI_LENS_PROVIDER_CACHE_TTL_MS", DEFAULT_PROVIDER_CACHE_TTL_MS);
+var getProviderCacheTtlMs = _providerCacheTtl.get;
+var _resetProviderCacheTtlForTests = _providerCacheTtl._resetForTests;
+var LOW_CACHE_READ_RATIO = 0.5;
+var PARTIAL_EVICTION_INPUT_FACTOR = 4;
+var PARTIAL_EVICTION_MIN_FRESH_TOKENS = 512;
+var MAX_ATTRIBUTION_CHARS = 262144;
+var MAX_ATTRIBUTION_BYTES = 1048576;
+var attributionBySession = /* @__PURE__ */ new Map();
+function newAttributionState() {
+  return {
+    prefixBrokeSinceLastUsage: false,
+    injectedCharsSinceLastUsage: 0,
+    newTranscriptCharsSinceLastUsage: 0,
+    attributionCharsCapped: false
+  };
+}
+function attributionFor(key2) {
+  const existing = attributionBySession.get(key2);
+  const state2 = existing ?? newAttributionState();
+  attributionBySession.delete(key2);
+  attributionBySession.set(key2, state2);
+  while (attributionBySession.size > MAX_TRACKED_SESSIONS) {
+    const oldest = attributionBySession.keys().next().value;
+    if (oldest === void 0)
+      break;
+    attributionBySession.delete(oldest);
+  }
+  return state2;
+}
+function recordContextAttribution(key2, existingMessages, injectedSize) {
+  const state2 = attributionFor(key2);
+  const baseline = Math.min(state2.lastObservedMessageCount ?? existingMessages.length, existingMessages.length);
+  const grown = measureTranscriptGrowth(existingMessages.slice(baseline));
+  state2.injectedCharsSinceLastUsage = Math.min(MAX_ATTRIBUTION_CHARS, state2.injectedCharsSinceLastUsage + injectedSize.chars);
+  state2.newTranscriptCharsSinceLastUsage = Math.min(MAX_ATTRIBUTION_CHARS, state2.newTranscriptCharsSinceLastUsage + grown.chars);
+  if (injectedSize.capped || grown.capped || state2.injectedCharsSinceLastUsage >= MAX_ATTRIBUTION_CHARS || state2.newTranscriptCharsSinceLastUsage >= MAX_ATTRIBUTION_CHARS) {
+    state2.attributionCharsCapped = true;
+  }
+  state2.lastObservedMessageCount = existingMessages.length;
+  state2.lastContextAtMs = Date.now();
+}
+function resolveInterTurnGap(state2, nowMs) {
+  if (state2.lastUsageAtMs === void 0) {
+    return { gapMs: null, basis: "no-prior-turn" };
+  }
+  if (state2.lastContextAtMs !== void 0) {
+    return {
+      gapMs: Math.max(0, state2.lastContextAtMs - state2.lastUsageAtMs),
+      basis: "request-time"
+    };
+  }
+  return {
+    gapMs: Math.max(0, nowMs - state2.lastUsageAtMs),
+    basis: "message-end-fallback"
+  };
+}
+function estimateTokens2(chars) {
+  return Math.ceil(chars / CHARS_PER_ESTIMATED_TOKEN);
+}
+function classifyCacheMiss(args) {
+  const { cacheRead, priorCacheRead } = args;
+  if (typeof cacheRead !== "number" || !Number.isFinite(cacheRead))
+    return null;
+  if (typeof priorCacheRead !== "number" || !Number.isFinite(priorCacheRead)) {
+    return null;
+  }
+  let kind;
+  if (cacheRead === 0) {
+    kind = "zero-read";
+  } else if (priorCacheRead > 0 && cacheRead < priorCacheRead * LOW_CACHE_READ_RATIO) {
+    kind = "low-read";
+  } else {
+    return null;
+  }
+  if (args.prefixBroke)
+    return { kind, cause: "prefix-broke" };
+  if (args.interTurnGapMs !== null && args.interTurnGapMs >= args.ttlMs) {
+    return { kind, cause: "ttl-expired" };
+  }
+  if (kind === "low-read" && !args.attributionCharsCapped && args.input > Math.max(PARTIAL_EVICTION_MIN_FRESH_TOKENS, args.estimatedNewTokens * PARTIAL_EVICTION_INPUT_FACTOR)) {
+    return { kind, cause: "partial-eviction" };
+  }
+  return { kind, cause: "unknown" };
+}
 function boundedHashScalar(value, state2) {
   if (value === null)
     return "null";
@@ -104938,87 +105711,78 @@ function hashMessageSequence(messages) {
     contentTruncated: state2.contentTruncated
   };
 }
-function messageTextSize(content) {
+var INJECTED_LIMITS = {
+  maxChars: MAX_INJECTED_CHARS,
+  maxBytes: MAX_INJECTED_BYTES
+};
+var TRANSCRIPT_LIMITS = {
+  maxChars: MAX_ATTRIBUTION_CHARS,
+  maxBytes: MAX_ATTRIBUTION_BYTES
+};
+function messageTextSize(content, limits) {
   if (typeof content === "string") {
-    const chars = Math.min(content.length, MAX_INJECTED_CHARS);
+    const chars = Math.min(content.length, limits.maxChars);
     return {
       chars,
-      bytes: Math.min(Buffer.byteLength(content.slice(0, chars), "utf8"), MAX_INJECTED_BYTES)
+      bytes: Math.min(Buffer.byteLength(content.slice(0, chars), "utf8"), limits.maxBytes)
     };
   }
   const bounded = boundedHashValue(content);
   return {
-    chars: Math.min(bounded.length, MAX_INJECTED_CHARS),
-    bytes: Math.min(Buffer.byteLength(bounded.slice(0, MAX_INJECTED_CHARS), "utf8"), MAX_INJECTED_BYTES)
+    chars: Math.min(bounded.length, limits.maxChars),
+    bytes: Math.min(Buffer.byteLength(bounded.slice(0, limits.maxChars), "utf8"), limits.maxBytes)
   };
 }
-function measureInjectedMessages(messages) {
+function measureMessages(messages, limits) {
   let chars = 0;
   let bytes = 0;
   const measuredCount = Math.min(messages.length, MAX_REPORTED_MESSAGES);
   for (let i = 0; i < measuredCount; i++) {
     const message = messages[i];
-    const size = messageTextSize(message?.content);
-    chars = Math.min(MAX_INJECTED_CHARS, chars + size.chars);
-    bytes = Math.min(MAX_INJECTED_BYTES, bytes + size.bytes);
-    if (chars === MAX_INJECTED_CHARS || bytes === MAX_INJECTED_BYTES)
+    const size = messageTextSize(message?.content, limits);
+    chars = Math.min(limits.maxChars, chars + size.chars);
+    bytes = Math.min(limits.maxBytes, bytes + size.bytes);
+    if (chars === limits.maxChars || bytes === limits.maxBytes)
       break;
   }
   return {
     chars,
     bytes,
-    capped: chars >= MAX_INJECTED_CHARS || bytes >= MAX_INJECTED_BYTES
+    capped: chars >= limits.maxChars || bytes >= limits.maxBytes
   };
 }
-function sessionKey(sessionId) {
-  return sessionId?.trim() ? sessionId.trim() : NO_SESSION_KEY;
-}
-function prefixLengthForPlacement(placement, messageCount) {
-  if (placement === "insert-before-final") {
-    return Math.max(0, messageCount - 1);
-  }
-  if (placement === "prepend")
-    return 0;
-  return messageCount;
-}
-function resolvePrefixObservation(truncated, observation) {
-  if (truncated)
-    return "unknown";
-  return observation ?? "empty";
+function measureInjectedMessages(messages) {
+  return measureMessages(messages, INJECTED_LIMITS);
 }
-function prefixBaselineForObservation(observation) {
-  if (observation === "baseline")
-    return true;
-  if (observation === "empty" || observation === "unknown")
-    return null;
-  return false;
+function measureTranscriptGrowth(messages) {
+  return measureMessages(messages, TRANSCRIPT_LIMITS);
 }
-function firstMessageChangeFor(truncated, before, after) {
-  if (truncated)
-    return "unknown";
-  return before !== after ? "changed" : "unchanged";
+function sessionKey(sessionId) {
+  return sessionId?.trim() ? sessionId.trim() : NO_SESSION_KEY;
 }
 function observeCacheContext(args) {
   try {
     const existingMessages = args.existingMessages ?? [];
     const resultMessages = args.resultMessages ?? existingMessages;
-    const injectedMessages = args.injectedMessages ?? [];
+    const injectionSlices = (args.injectionSlices ?? []).filter((slice) => slice.messages.length > 0);
+    const injectedMessages = injectionSlices.flatMap((slice) => slice.messages);
     const placement = args.placement ?? "none";
     const beforeSequence = hashMessageSequence(existingMessages);
     const afterSequence = hashMessageSequence(resultMessages);
-    const beforePrefixLength = prefixLengthForPlacement(placement, existingMessages.length);
-    const afterPrefixLength = Math.min(beforePrefixLength, resultMessages.length);
-    const beforePrefix = hashMessageSequence(existingMessages.slice(0, beforePrefixLength));
-    const afterPrefix = hashMessageSequence(resultMessages.slice(0, afterPrefixLength));
-    const beforeFirstSequence = existingMessages.length ? hashMessageSequence([existingMessages[0]]) : void 0;
-    const afterFirstSequence = resultMessages.length ? hashMessageSequence([resultMessages[0]]) : void 0;
-    const beforeFirst = beforeFirstSequence?.hash ?? null;
-    const afterFirst = afterFirstSequence?.hash ?? null;
-    const firstMessageHashTruncated = beforeFirstSequence?.truncated === true || beforeFirstSequence?.contentTruncated === true || afterFirstSequence?.truncated === true || afterFirstSequence?.contentTruncated === true;
-    const prefixHashTruncated = beforePrefix.truncated || afterPrefix.truncated || beforePrefix.contentTruncated || afterPrefix.contentTruncated;
-    const prefixObservation = resolvePrefixObservation(prefixHashTruncated, args.prefixObservation);
     const sizes = measureInjectedMessages(injectedMessages);
+    const sourceBreakdown = injectionSlices.map((slice) => {
+      const sliceSize = measureInjectedMessages(slice.messages);
+      return {
+        source: slice.source,
+        messageCount: Math.min(slice.messages.length, MAX_REPORTED_MESSAGES),
+        chars: sliceSize.chars,
+        bytes: sliceSize.bytes,
+        estimatedTokens: estimateTokens2(sliceSize.chars),
+        countsCapped: sliceSize.capped
+      };
+    });
     const messageCountCapped = existingMessages.length > MAX_REPORTED_MESSAGES || resultMessages.length > MAX_REPORTED_MESSAGES;
+    recordContextAttribution(sessionKey(args.sessionId), existingMessages, sizes);
     logLatency({
       type: "phase",
       filePath: "<pi-lens>",
@@ -105032,34 +105796,25 @@ function observeCacheContext(args) {
         sessionRole: args.sessionRole,
         ...args.sessionRole === "concurrent-secondary" ? { turnScope: SECONDARY_TURN_SCOPE } : { turnIndex: args.turnIndex, turnScope: PROCESS_TURN_SCOPE },
         injectionEnabled: args.injectionEnabled,
-        injectionSources: Array.from(args.injectionSources ?? []),
+        injectionSources: sourceBreakdown.map((entry) => entry.source),
+        injectionSourceBreakdown: sourceBreakdown,
+        injectionOccurred: injectedMessages.length > 0,
         injectedMessageCount: Math.min(injectedMessages.length, MAX_REPORTED_MESSAGES),
         injectedMessageCountCapped: injectedMessages.length > MAX_REPORTED_MESSAGES,
         injectedChars: sizes.chars,
         injectedBytes: sizes.bytes,
+        injectedEstimatedTokens: estimateTokens2(sizes.chars),
+        injectedTokenBasis: "chars-per-token-4-estimate-not-provider-measured",
         injectedCountsCapped: sizes.capped,
         existingMessageCount: Math.min(existingMessages.length, MAX_REPORTED_MESSAGES),
         resultMessageCount: Math.min(resultMessages.length, MAX_REPORTED_MESSAGES),
         messageCountCapped,
         placement,
-        prefixObservation,
-        prefixObservationUnknown: prefixObservation === "unknown",
-        prefixBaseline: prefixBaselineForObservation(prefixObservation),
-        firstMessageChanged: firstMessageHashTruncated ? null : beforeFirst !== afterFirst,
-        firstMessageChange: firstMessageChangeFor(firstMessageHashTruncated, beforeFirst, afterFirst),
-        firstMessageHashTruncated,
-        beforeFirstMessageHash: beforeFirst,
-        afterFirstMessageHash: afterFirst,
         beforeSequenceHash: beforeSequence.hash,
         afterSequenceHash: afterSequence.hash,
-        beforePrefixHash: beforePrefix.hash,
-        afterPrefixHash: afterPrefix.hash,
         sequenceHashTruncated: beforeSequence.truncated || afterSequence.truncated || beforeSequence.contentTruncated || afterSequence.contentTruncated,
         sequenceMessageCountTruncated: beforeSequence.truncated || afterSequence.truncated,
-        sequenceContentHashTruncated: beforeSequence.contentTruncated || afterSequence.contentTruncated,
-        prefixHashTruncated,
-        prefixMessageCountTruncated: beforePrefix.truncated || afterPrefix.truncated,
-        prefixContentHashTruncated: beforePrefix.contentTruncated || afterPrefix.contentTruncated
+        sequenceContentHashTruncated: beforeSequence.contentTruncated || afterSequence.contentTruncated
       }
     });
   } catch (err) {
@@ -105077,6 +105832,34 @@ function logCacheUsage(message, dbg2, context) {
     if (!usage || typeof usage !== "object")
       return;
     const u = usage;
+    const attributionKey = sessionKey(context?.sessionId);
+    const state2 = attributionFor(attributionKey);
+    const nowMs = Date.now();
+    const gap = resolveInterTurnGap(state2, nowMs);
+    const interTurnGapMs = gap.gapMs;
+    const ttlMs = getProviderCacheTtlMs();
+    const estimatedNewTokens = estimateTokens2(state2.injectedCharsSinceLastUsage + state2.newTranscriptCharsSinceLastUsage);
+    const verdict = classifyCacheMiss({
+      cacheRead: u.cacheRead,
+      input: typeof u.input === "number" ? u.input : 0,
+      priorCacheRead: state2.lastCacheRead,
+      interTurnGapMs,
+      ttlMs,
+      prefixBroke: state2.prefixBrokeSinceLastUsage,
+      estimatedNewTokens,
+      attributionCharsCapped: state2.attributionCharsCapped
+    });
+    const priorCacheRead = typeof state2.lastCacheRead === "number" ? state2.lastCacheRead : null;
+    const injectedCharsSinceLastTurn = state2.injectedCharsSinceLastUsage;
+    const newTranscriptCharsSinceLastTurn = state2.newTranscriptCharsSinceLastUsage;
+    const attributionCharsCapped = state2.attributionCharsCapped;
+    state2.lastUsageAtMs = nowMs;
+    state2.lastCacheRead = typeof u.cacheRead === "number" && Number.isFinite(u.cacheRead) ? u.cacheRead : void 0;
+    state2.prefixBrokeSinceLastUsage = false;
+    state2.injectedCharsSinceLastUsage = 0;
+    state2.newTranscriptCharsSinceLastUsage = 0;
+    state2.attributionCharsCapped = false;
+    state2.lastContextAtMs = void 0;
     logLatency({
       type: "phase",
       filePath: "<pi-lens>",
@@ -105091,6 +105874,20 @@ function logCacheUsage(message, dbg2, context) {
         output: u.output,
         // `Usage.cost` is a breakdown object; the total is the headline number.
         cost: u.cost?.total,
+        // Idle milliseconds before this turn's request, or null for the first
+        // record in the session. This is the field the 2026-08-21
+        // investigation had to reconstruct by hand-joining timestamps.
+        interTurnGapMs,
+        gapBasis: gap.basis,
+        // null means "nothing to explain", not "cause unknown"; `unknown` is
+        // the explicit no-local-explanation verdict.
+        cacheMissCause: verdict?.cause ?? null,
+        cacheMissKind: verdict?.kind ?? null,
+        cacheTtlThresholdMs: ttlMs,
+        priorCacheRead,
+        injectedCharsSinceLastTurn,
+        newTranscriptCharsSinceLastTurn,
+        attributionCharsCapped,
         ...context ? {
           // MessageEndEvent has no request/context id in the host API. These
           // fields permit session correlation without inventing an exact
@@ -105158,6 +105955,7 @@ function observeCachePrefix(messages, turnIndex, sessionId, sessionRole, dbg2) {
       return "baseline";
     }
     if (currentHash !== previousHash) {
+      attributionFor(key2).prefixBrokeSinceLastUsage = true;
       logLatency({
         type: "phase",
         filePath: "<pi-lens>",
@@ -105182,6 +105980,7 @@ function observeCachePrefix(messages, turnIndex, sessionId, sessionRole, dbg2) {
 function clearCachePrefixSession(sessionId) {
   const key2 = sessionKey(sessionId);
   prefixHashBySession.delete(key2);
+  attributionBySession.delete(key2);
 }
 
 // dist/clients/startup-timing.js
@@ -105478,9 +106277,6 @@ logLatency({
 });
 function log(_msg) {
 }
-function isStaleExtensionCtxError(err) {
-  return err instanceof Error && err.message.includes("stale after session replacement or reload");
-}
 var runtime = new RuntimeCoordinator();
 var _readBridgeRegistered = false;
 var _readBridgeGetFlag;
@@ -106139,7 +106935,7 @@ ${degradations.map((group) => `  ${group.kind}: ${group.count} (${group.latestRe
       skillPaths: [skillsDir]
     };
   });
-  pi.on("session_start", async (event, ctx) => {
+  pi.on("session_start", wrapSessionEventHandler("session_start", async (event, ctx) => {
     const sessionStartMonotonicAt = performance4.now();
     resetVerifiedPathAttributionGuessCount();
     warmDispatchAtSessionStart();
@@ -106314,10 +107110,12 @@ ${degradations.map((group) => `  ${group.kind}: ${group.count} (${group.latestRe
         mountLensWidget(ctx.ui, readExtensionMode(ctx));
       }
     } catch (sessionErr) {
+      if (isStaleExtensionCtxError(sessionErr))
+        throw sessionErr;
       dbg(`session_start crashed: ${sessionErr}`);
       dbg(`session_start crash stack: ${sessionErr.stack}`);
     }
-  });
+  }, { dbg }));
   pi.on("session_before_fork", () => {
     try {
       pendingForkSnapshot = exportWidgetState();
@@ -106341,7 +107139,7 @@ ${degradations.map((group) => `  ${group.kind}: ${group.count} (${group.latestRe
       resetLSPService
     });
   });
-  pi.on("tool_result", async (event, ctx) => {
+  const onToolResult = async (event, ctx) => {
     rememberOwnEventCtx(ctx);
     if (!lensEnabled)
       return;
@@ -106382,8 +107180,9 @@ ${degradations.map((group) => `  ${group.kind}: ${group.count} (${group.latestRe
     } finally {
       setAmbientAbortSignal(void 0);
     }
-  });
-  pi.on("turn_start", (_event, ctx) => {
+  };
+  pi.on("tool_result", wrapSessionEventHandler("tool_result", onToolResult, { dbg }));
+  const onTurnStart = (_event, ctx) => {
     rememberOwnEventCtx(ctx);
     adoptProjectTrustFromPorts(hostPorts);
     if (lensWidgetVisible && ctx?.ui && (mountedLensWidgetUi === void 0 || mountedLensWidgetUi !== ctx.ui)) {
@@ -106400,7 +107199,8 @@ ${degradations.map((group) => `  ${group.kind}: ${group.count} (${group.latestRe
     }).catch((err) => {
       dbg(`turn_start: cross-process nudge read failed: ${err}`);
     });
-  });
+  };
+  pi.on("turn_start", wrapSessionEventHandler("turn_start", onTurnStart, { dbg }));
   async function runDeferredMutationDrain(ctx) {
     const currentSessionId = getStableSessionId(ctx);
     const emission = classifyCurrentSessionEmission(ctx, currentSessionId);
@@ -106434,25 +107234,28 @@ ${degradations.map((group) => `  ${group.kind}: ${group.count} (${group.latestRe
       updateLspStatus(ctx.ui.setStatus, ctx.ui.theme);
     }
   }
-  pi.on("agent_end", async (_event, ctx) => {
+  const onAgentEnd = async (_event, ctx) => {
     if (!lensEnabled)
       return;
-    setAmbientAbortSignal(ctx?.signal);
     try {
+      setAmbientAbortSignal(ctx?.signal);
       await flushDebouncedToolResults();
       ctx.ui && updateLspStatus(ctx.ui.setStatus, ctx.ui.theme);
     } catch (agentEndErr) {
+      if (isStaleExtensionCtxError(agentEndErr))
+        throw agentEndErr;
       dbg(`agent_end crashed: ${agentEndErr}`);
       dbg(`agent_end crash stack: ${agentEndErr.stack}`);
     } finally {
       setAmbientAbortSignal(void 0);
     }
-  });
-  pi.on("turn_end", async (_event, ctx) => {
+  };
+  pi.on("agent_end", wrapSessionEventHandler("agent_end", onAgentEnd, { dbg }));
+  const onTurnEnd = async (_event, ctx) => {
     if (!lensEnabled)
       return;
-    setAmbientAbortSignal(ctx?.signal);
     try {
+      setAmbientAbortSignal(ctx?.signal);
       const repaintLspStatus = captureLspStatusRepaint(ctx);
       const elStats = getEventLoopStats();
       const loopMaxMs = elStats?.maxMs ?? 0;
@@ -106551,12 +107354,15 @@ ${degradations.map((group) => `  ${group.kind}: ${group.count} (${group.latestRe
         );
       }
     } catch (turnEndErr) {
+      if (isStaleExtensionCtxError(turnEndErr))
+        throw turnEndErr;
       dbg(`turn_end crashed: ${turnEndErr}`);
       dbg(`turn_end crash stack: ${turnEndErr.stack}`);
     } finally {
       setAmbientAbortSignal(void 0);
     }
-  });
+  };
+  pi.on("turn_end", wrapSessionEventHandler("turn_end", onTurnEnd, { dbg }));
   registerBuiltinQuietWindowTasks(() => runtime);
   registerCascadeTierReconcileTask(() => getLSPService(), {
     onResolvedFound: ({ filePath, diagnostics }) => {
@@ -106644,27 +107450,36 @@ ${degradations.map((group) => `  ${group.kind}: ${group.count} (${group.latestRe
       });
     });
   }
-  try {
-    pi.on("agent_settled", async (_event, ctx) => {
-      if (!lensEnabled)
-        return;
+  const onAgentSettled = async (_event, ctx) => {
+    if (!lensEnabled)
+      return;
+    try {
       setAmbientAbortSignal(ctx?.signal);
       try {
         await runDeferredMutationDrain(ctx);
       } catch (drainErr) {
+        if (isStaleExtensionCtxError(drainErr))
+          throw drainErr;
         dbg(`agent_settled deferred_mutation_drain crashed: ${drainErr}`);
       } finally {
         setAmbientAbortSignal(void 0);
       }
+      const cwd = ctx?.cwd;
       void runQuietWindow({
         runtime,
         dbg,
-        cwd: ctx?.cwd
+        cwd
       }).catch((err) => {
         dbg(`quiet_window crashed: ${err}`);
       });
       dumpActiveHandles("agent_settled");
-    });
+    } catch (settledErr) {
+      setAmbientAbortSignal(void 0);
+      throw settledErr;
+    }
+  };
+  try {
+    pi.on("agent_settled", wrapSessionEventHandler("agent_settled", onAgentSettled, { dbg }));
   } catch (registerErr) {
     dbg(`agent_settled registration failed (older pi host?): ${registerErr}`);
   }
@@ -106719,89 +107534,105 @@ ${degradations.map((group) => `  ${group.kind}: ${group.count} (${group.latestRe
       return true;
     return !msg.content.some((block) => typeof block === "object" && block !== null && block.type === "tool_result");
   };
-  pi.on("context", async (event, ctx) => {
-    const existingMessages = event?.messages ?? [];
-    const prefixSessionId = getStableSessionId(ctx);
-    const sessionRole = classifyCurrentSessionEmission(ctx, prefixSessionId);
-    const prefixObservation = observeCachePrefix(existingMessages, runtime.turnIndex, prefixSessionId, sessionRole, dbg);
-    const effectiveInjectionEnabled = lensEnabled && contextInjectionEnabled;
-    let telemetryLogged = false;
-    const logContextObservation = (resultMessages, placement, injectionSources, injectedMessages) => {
-      if (telemetryLogged)
-        return;
-      telemetryLogged = true;
-      observeCacheContext({
-        existingMessages,
-        resultMessages,
-        sessionId: prefixSessionId,
-        sessionRole,
-        turnIndex: runtime.turnIndex,
-        injectionEnabled: effectiveInjectionEnabled,
-        injectionSources,
-        injectedMessages,
-        placement,
-        prefixObservation,
-        dbg
-      });
-    };
-    try {
-      const cwd = ctx.cwd ?? process.cwd();
-      if (!effectiveInjectionEnabled) {
-        logContextObservation(existingMessages, "none", [], []);
-        return;
-      }
-      const turnEndFindings = consumeTurnEndFindings(cacheManager, cwd, runtime);
-      const sessionGuidance = consumeSessionStartGuidance(cacheManager, cwd);
-      const testFindings = consumeTestFindings(cacheManager, cwd, runtime);
-      const agentNudge = consumeAgentNudge(dbg);
-      const sourceMessages = [
-        {
-          source: "session-guidance",
-          messages: sessionGuidance?.messages ?? []
-        },
-        {
-          source: "turn-findings",
-          messages: turnEndFindings?.messages ?? []
-        },
-        {
-          source: "test-findings",
-          messages: testFindings?.messages ?? []
-        },
-        {
-          source: "agent-nudge",
-          messages: agentNudge?.messages ?? []
-        }
-      ].filter((source) => source.messages.length > 0);
-      const injectedMessages = sourceMessages.flatMap((source) => source.messages);
-      const injectionSources = sourceMessages.map((source) => source.source);
-      if (injectedMessages.length === 0) {
-        logContextObservation(existingMessages, "none", [], []);
-        return;
+  pi.on(
+    "context",
+    // #1929: `context` is reachable with a ctx the SDK already invalidated,
+    // exactly like the five handlers #1925 wrapped. It could not use the void
+    // wrapper because the host CONSUMES its return value on the live path, so
+    // it uses the value-returning variant and states its own stale-path answer
+    // below. Before this, a stale ctx surfaced as `context event error: …`,
+    // indistinguishable from a real handler bug, and counted nothing.
+    wrapSessionEventHandlerWithResult("context", async (event, ctx) => {
+      const existingMessages = event?.messages ?? [];
+      const prefixSessionId = getStableSessionId(ctx);
+      const sessionRole = classifyCurrentSessionEmission(ctx, prefixSessionId);
+      observeCachePrefix(existingMessages, runtime.turnIndex, prefixSessionId, sessionRole, dbg);
+      const effectiveInjectionEnabled = lensEnabled && contextInjectionEnabled;
+      let telemetryLogged = false;
+      const logContextObservation = (resultMessages, placement, injectionSlices) => {
+        if (telemetryLogged)
+          return;
+        telemetryLogged = true;
+        observeCacheContext({
+          existingMessages,
+          resultMessages,
+          sessionId: prefixSessionId,
+          sessionRole,
+          turnIndex: runtime.turnIndex,
+          injectionEnabled: effectiveInjectionEnabled,
+          injectionSlices,
+          placement,
+          dbg
+        });
+      };
+      try {
+        const cwd = ctx.cwd ?? process.cwd();
+        if (!effectiveInjectionEnabled) {
+          logContextObservation(existingMessages, "none", []);
+          return;
+        }
+        const turnEndFindings = consumeTurnEndFindings(cacheManager, cwd, runtime);
+        const sessionGuidance = consumeSessionStartGuidance(cacheManager, cwd);
+        const testFindings = consumeTestFindings(cacheManager, cwd, runtime);
+        const agentNudge = consumeAgentNudge(dbg);
+        const sourceMessages = [
+          {
+            source: "session-guidance",
+            messages: sessionGuidance?.messages ?? []
+          },
+          {
+            source: "turn-findings",
+            messages: turnEndFindings?.messages ?? []
+          },
+          {
+            source: "test-findings",
+            messages: testFindings?.messages ?? []
+          },
+          {
+            source: "agent-nudge",
+            messages: agentNudge?.messages ?? []
+          }
+        ].filter((source) => source.messages.length > 0);
+        const injectedMessages = sourceMessages.flatMap((source) => source.messages);
+        if (injectedMessages.length === 0) {
+          logContextObservation(existingMessages, "none", []);
+          return;
+        }
+        if (existingMessages.length === 0) {
+          const resultMessages2 = [...injectedMessages];
+          logContextObservation(resultMessages2, "prepend", sourceMessages);
+          return { messages: resultMessages2 };
+        }
+        const lastMessage = existingMessages[existingMessages.length - 1];
+        if (!isPlainUserPrompt(lastMessage)) {
+          const resultMessages2 = [...existingMessages, ...injectedMessages];
+          logContextObservation(resultMessages2, "append", sourceMessages);
+          return { messages: resultMessages2 };
+        }
+        const resultMessages = [
+          ...existingMessages.slice(0, -1),
+          ...injectedMessages,
+          lastMessage
+        ];
+        logContextObservation(resultMessages, "insert-before-final", sourceMessages);
+        return { messages: resultMessages };
+      } catch (err) {
+        if (isStaleExtensionCtxError(err))
+          throw err;
+        if (!telemetryLogged)
+          logContextObservation(existingMessages, "none", []);
+        dbg(`context event error: ${err}`);
       }
-      if (existingMessages.length === 0) {
-        const resultMessages2 = [...injectedMessages];
-        logContextObservation(resultMessages2, "prepend", injectionSources, injectedMessages);
-        return { messages: resultMessages2 };
-      }
-      const lastMessage = existingMessages[existingMessages.length - 1];
-      if (!isPlainUserPrompt(lastMessage)) {
-        const resultMessages2 = [...existingMessages, ...injectedMessages];
-        logContextObservation(resultMessages2, "append", injectionSources, injectedMessages);
-        return { messages: resultMessages2 };
-      }
-      const resultMessages = [
-        ...existingMessages.slice(0, -1),
-        ...injectedMessages,
-        lastMessage
-      ];
-      logContextObservation(resultMessages, "insert-before-final", injectionSources, injectedMessages);
-      return { messages: resultMessages };
-    } catch (err) {
-      if (!telemetryLogged)
-        logContextObservation(existingMessages, "none", [], []);
-      dbg(`context event error: ${err}`);
-    }
-  });
+    }, {
+      dbg,
+      // #1929: a dead ctx means pi-lens contributes NOTHING to this
+      // request. `undefined` is that answer, and is what the four
+      // non-injecting paths above already return, so the host keeps its
+      // own message list byte-for-byte. Never a half-built injection: the
+      // consume* calls that feed one have side effects and may not have run.
+      onStaleResult: () => void 0
+    })
+  );
 }
 function index_default(pi) {
   return runInConsoleCaptureWindow(() => activateExtension(pi));