pi-lens 3.8.73 → 4.0.0

package/dist/clients/pipeline.js

@@ -19,7 +19,7 @@ import { recordFromCodeQualityDiagnostic, } from "./code-quality-warnings.js";
 import { recordDiagnostics } from "./widget-state.js";
 import { getDiagnosticLogger } from "./diagnostic-logger.js";
 import { getDiagnosticTracker } from "./diagnostic-tracker.js";
-import { computeCascadeForFile, dispatchLintWithResult, } from "./dispatch/integration.js";
+import { loadDispatchIntegration } from "./dispatch/lazy.js";
 import { toRunnerDisplayPath } from "./dispatch/runner-context.js";
 import { createAvailabilityChecker, resolveAvailableOrInstall, resolveCommandArgsWithInstallFallback, resolveToolCommand, resolveToolCommandWithInstallFallback, } from "./dispatch/runners/utils/runner-helpers.js";
 import { findDetektConfig } from "./dispatch/runners/detekt.js";
@@ -29,12 +29,14 @@ import { logLatency } from "./latency-logger.js";
 import { emitLensAnalysisComplete } from "./lens-events.js";
 import { publishFilesTouched } from "./bus-publish.js";
 import { publishDiagnostics, wasPreviouslyReportedDirty, } from "./diagnostics-publish.js";
-import { getLSPService } from "./lsp/index.js";
+import { loadLspService } from "./lsp-lazy.js";
 import { clearGraphCache } from "./review-graph/builder.js";
+import { BoundedLruCache } from "./bounded-cache.js";
 import { RUNTIME_CONFIG } from "./runtime-config.js";
 import { getAmbientAbortSignal, safeSpawnAsync } from "./safe-spawn.js";
 import { combineAbortSignals } from "./deadline-utils.js";
-import { getAutofixPolicyForFile, getPreferredAutofixTools, getRubocopCommand, hasBiomeConfig, hasDetektConfig, hasEslintConfig, hasGolangciConfig, hasKtfmtConfig, hasOxlintConfig, hasRubocopConfig, hasSqlfluffConfig, hasStylelintConfig, } from "./tool-policy.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { getAutofixPolicyForFile, getPreferredAutofixTools, getRubocopCommand, hasBiomeConfig, hasDetektConfig, hasEslintConfig, hasGolangciConfig, hasKtfmtConfig, hasKtlintConfig, hasOxlintConfig, hasRubocopConfig, hasSqlfluffConfig, hasStylelintConfig, markdownlintConfigArgs, } from "./tool-policy.js";
 const LSP_MAX_FILE_BYTES = RUNTIME_CONFIG.pipeline.lspMaxFileBytes;
 const LSP_MAX_FILE_LINES = RUNTIME_CONFIG.pipeline.lspMaxFileLines;
 const LSP_SPAWN_BUDGET_MS = RUNTIME_CONFIG.pipeline.lspSpawnBudgetMs;
@@ -66,7 +68,10 @@ const SNAPSHOT_YIELD_EVERY = 500;
 async function snapshotDirInto(dir, ignoreMatcher, stack, snapshot, counter) {
     let entries;
     try {
-        entries = nodeFs.readdirSync(dir, { withFileTypes: true });
+        // Async (#1137): a synchronous per-directory read blocks the loop for the
+        // whole stall on a slow cloud-backed (OneDrive) directory; fs.promises
+        // keeps this tool_result-path walk off the event loop.
+        entries = await nodeFs.promises.readdir(dir, { withFileTypes: true });
     }
     catch {
         return;
@@ -85,7 +90,7 @@ async function snapshotDirInto(dir, ignoreMatcher, stack, snapshot, counter) {
         if (ignoreMatcher.isIgnored(fullPath, false))
             continue;
         try {
-            const stat = nodeFs.statSync(fullPath);
+            const stat = await nodeFs.promises.stat(fullPath);
             snapshot.set(path.resolve(fullPath), {
                 mtimeMs: stat.mtimeMs,
                 size: stat.size,
@@ -173,7 +178,7 @@ function createPhaseTracker(toolName, filePath) {
 }
 // --- ESLint autofix helpers ---
 export { hasEslintConfig, hasRubocopConfig, hasSqlfluffConfig, hasStylelintConfig, };
-const _eslintCache = new Map();
+const _eslintCache = new BoundedLruCache(32);
 /**
  * Run eslint --fix on a file. Runs a single spawn and diffs the file before/after,
  * same idiom as the other autofix helpers below. Exit code 1 (unfixable problems
@@ -186,7 +191,9 @@ async function tryEslintFix(filePath, cwd) {
     const userHasConfig = hasEslintConfig(cwd);
     if (!userHasConfig)
         return 0;
-    const cacheKey = path.resolve(cwd);
+    // PATH is part of command resolution; include it so an install or PATH
+    // refresh cannot leave a negative eslint result live for the session.
+    const cacheKey = `${path.resolve(cwd)}|${process.env.PATH ?? ""}`;
     let cached = _eslintCache.get(cacheKey);
     if (!cached) {
         const candidate = resolveToolCommand(cwd, "eslint") ?? "eslint";
@@ -274,8 +281,12 @@ async function tryMarkdownlintFix(filePath, cwd) {
     const cmd = await resolveToolCommandWithInstallFallback(cwd, "markdownlint");
     if (!cmd)
         return 0;
+    // Shared config-args seam (#1247): the lint runner consumes the same
+    // builder, so the bare --fix here can never fall back to markdownlint's
+    // default all-rules-on config again (the whole-file CHANGELOG/AGENTS
+    // reformat + `#946` → `# 946` corruption).
     // markdownlint-cli2 --fix exits non-zero when unfixable violations remain.
-    return detectFileChangedAfterCommand(filePath, cmd, ["--fix", filePath], cwd, [1]);
+    return detectFileChangedAfterCommand(filePath, cmd, [...markdownlintConfigArgs(cwd), "--fix", filePath], cwd, [1]);
 }
 async function tryOxlintFix(filePath, cwd) {
     const cmd = await resolveToolCommandWithInstallFallback(cwd, "oxlint");
@@ -356,6 +367,7 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
         hasGolangciConfig: hasGolangciConfig(cwd),
         hasDetektConfig: hasDetektConfig(cwd),
         hasKtfmtConfig: hasKtfmtConfig(cwd),
+        hasKtlintConfig: hasKtlintConfig(cwd),
         hasOxlintConfig: hasOxlintConfig(cwd),
     };
     const autofixPolicy = getAutofixPolicyForFile(filePath, autofixContext);
@@ -396,7 +408,7 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
                 dbg(`autofix: ruff unavailable for ${filePath}`);
                 continue;
             }
-            const result = await ruffClient.fixFileAsync(filePath);
+            const result = await ruffClient.fixFileAsync(filePath, cwd);
             if (result.success && result.fixed > 0) {
                 fixedCount += result.fixed;
                 autofixTools.push(`ruff:${result.fixed}`);
@@ -415,7 +427,7 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
                 dbg(`autofix: biome unavailable or unsupported for ${filePath}`);
                 continue;
             }
-            const result = await biomeClient.fixFileAsync(filePath);
+            const result = await biomeClient.fixFileAsync(filePath, cwd);
             if (result.success && result.fixed > 0) {
                 fixedCount += result.fixed;
                 autofixTools.push(`biome:${result.fixed}`);
@@ -570,7 +582,6 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
                 dbg(`autofix: oxlint --fix fixed ${filePath}`);
                 needsContentRefresh = true;
             }
-            continue;
         }
     }
     if (attemptedTools.length > 0 && autofixTools.length === 0) {
@@ -593,7 +604,7 @@ export async function resyncLspFile(filePath, fileContent, needsContentRefresh,
     if (limitCheck.tooLarge)
         return;
     try {
-        const lspService = getLSPService();
+        const lspService = (await loadLspService()).getLSPService();
         if (lspService.supportsLSP(filePath)) {
             // Push the final post-format/post-fix content through touchFile (not the
             // bare openFile) so it registers in the touch-debounce map via
@@ -704,6 +715,13 @@ export async function runFormatPhase(filePath, getFormatService, dbg) {
         }
         if (!result.allSucceeded) {
             const failures = result.formatters.filter((f) => !f.success);
+            for (const failure of failures) {
+                recordDegradationOnce({
+                    kind: "formatter-failure",
+                    subject: `${failure.name}:${path.basename(filePath)}`,
+                    reason: failure.error ?? "unknown error",
+                });
+            }
             formatFailures.push(...failures.map((f) => `${f.name}: ${f.error ?? "unknown error"}`));
             dbg("autoformat: " +
                 failures
@@ -713,6 +731,11 @@ export async function runFormatPhase(filePath, getFormatService, dbg) {
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
+        recordDegradationOnce({
+            kind: "formatter-failure",
+            subject: `format-service:${path.basename(filePath)}`,
+            reason: message,
+        });
         formatFailures.push(message);
         dbg(`autoformat error: ${err}`);
     }
@@ -871,11 +894,15 @@ export async function runPipeline(ctx, deps) {
     const piApi = {
         getFlag: getFlag,
     };
+    const { dispatchLintWithResult, computeCascadeForFile } = await loadDispatchIntegration();
     const dispatchResult = await dispatchLintWithResult(filePath, cwd, piApi, ctx.modifiedRanges, {
         model: ctx.telemetry?.model ?? "unknown",
         sessionId: ctx.telemetry?.sessionId ?? "unknown",
         turnIndex: ctx.telemetry?.turnIndex ?? 0,
         writeIndex: ctx.telemetry?.writeIndex ?? 0,
+    }, {
+        projectRoot: ctx.projectRoot,
+        writeIndex: ctx.telemetry?.writeIndex,
     });
     recordDiagnostics(filePath, dispatchResult.diagnostics, ctx.telemetry?.writeIndex);
     // #502: emit the write batch's FINAL diagnostic state immediately after
@@ -984,6 +1011,11 @@ export async function runPipeline(ctx, deps) {
     // result is never shown inline — settled (bounded) and surfaced at turn_end.
     // The stored promise must never reject: an unhandled rejection is fatal, so a
     // failing compute resolves to an "error" skip-run instead.
+    const cascadeOrigin = {
+        turnSeq: ctx.telemetry?.turnIndex,
+        writeSeq: ctx.telemetry?.writeIndex,
+        projectSeq: ctx.seqState?.projectSeq(),
+    };
     const cascadePromise = getFlag("no-lsp")
         ? undefined
         : computeCascadeForFile(filePath, cwd, {
@@ -995,14 +1027,23 @@ export async function runPipeline(ctx, deps) {
             fileContent,
             wordIndex: ctx.wordIndex,
             onWordIndexUpdated: ctx.onWordIndexUpdated,
-        }).catch((err) => {
+        }).then((run) => ({ ...run, origin: cascadeOrigin }))
+            .catch((err) => {
             dbg(`cascade compute failed for ${filePath}: ${err}`);
             return {
                 filePath,
+                origin: cascadeOrigin,
                 result: undefined,
                 neighborCount: 0,
                 diagnosticCount: 0,
                 skipReason: "error",
+                // #1023: a thrown compute is ALSO "couldn't compute downstream
+                // impact" — carry an indeterminate marker so turn_end surfaces an
+                // honest advisory instead of the error skip being logs-only.
+                indeterminate: {
+                    reason: "error",
+                    detail: "cascade computation failed",
+                },
             };
         });
     // --- Final timing + all-clear ---

package/dist/clients/print-mode.js

@@ -0,0 +1,21 @@
+/**
+ * One-shot invocation detection, shared across the session_start-scheduled
+ * background work that must NOT run — or retain the process — in print mode
+ * (#1154 quick-mode warmup, #1153 orphan-reaper).
+ *
+ * `pi -p` / `pi --print` is a one-shot: the host computes a single turn and
+ * exits. Work scheduled to warm caches / clean up state for a *future* session
+ * in the same process is pure waste in this mode AND — when it arms a
+ * referenced libuv handle (a non-`unref`'d timer, an LSP child, an fs walk)
+ * with no session_shutdown teardown — keeps the already-settled one-shot
+ * process alive. That is the referenced-handle retention class of
+ * #1097/#1110/#1148/#1149 and the located #1122 hypothesis-A concern.
+ *
+ * argv is read live (not captured at module load) so tests can drive it; the
+ * flag never changes within a real process, and there is no hot-path caller,
+ * so recomputing is free. This mirrors the print detection in
+ * `runtime-session.ts`'s `resolveStartupMode` — keep them a single source.
+ */
+export function isPrintMode(argv = process.argv) {
+    return argv.includes("--print") || argv.includes("-p");
+}

package/dist/clients/project-changes.js

@@ -44,6 +44,31 @@ export function readProjectChanges(cwd) {
         return [];
     }
 }
+/**
+ * Async twin of `readProjectChanges` (#1162). `fs.promises.readFile` — unlike
+ * the sync `readFileSync` above — YIELDS to the event loop, which is what lets
+ * a caller bound it with a `Promise.race` timeout: a `setTimeout` can never
+ * preempt a synchronous blocking read (the thread doesn't return to the event
+ * loop until the OS does), so a bounded read on the session_start hot path
+ * requires the async form. Same parse/error-swallow semantics as the sync
+ * version — a missing/corrupt log is the normal cold-start case, not a
+ * caller-visible error.
+ */
+export async function readProjectChangesAsync(cwd) {
+    const logPath = getProjectChangeLogPath(cwd);
+    try {
+        const content = await fs.promises.readFile(logPath, "utf-8");
+        return content
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map(parseChangeLine)
+            .filter((entry) => Boolean(entry));
+    }
+    catch {
+        return [];
+    }
+}
 export function readChangesSince(cwd, seq, maxEntries = 200) {
     const limit = Math.max(1, maxEntries);
     return readProjectChanges(cwd)
@@ -51,16 +76,104 @@ export function readChangesSince(cwd, seq, maxEntries = 200) {
         .sort((a, b) => a.seq - b.seq)
         .slice(-limit);
 }
-export function readLatestProjectSequence(cwd) {
+// Test-observable count of the EXPENSIVE per-entry folds (each one does a
+// `path.resolve` + `normalizeMapKey`/`realpathSync.native` syscall). Lets the
+// #1019 equivalence tests prove the partial path folds strictly FEWER entries
+// than the full replay for the same log — i.e. that the bound actually holds —
+// without a brittle spy on the path helpers.
+let _sequenceFoldCountForTests = 0;
+export function getSequenceFoldCountForTests() {
+    return _sequenceFoldCountForTests;
+}
+export function resetSequenceFoldCountForTests() {
+    _sequenceFoldCountForTests = 0;
+}
+function foldEntry(entry, fileSeqByPath) {
+    _sequenceFoldCountForTests++;
+    const key = normalizeMapKey(path.resolve(entry.filePath));
+    fileSeqByPath.set(key, Math.max(fileSeqByPath.get(key) ?? 0, entry.fileSeq));
+}
+function fullReplay(entries) {
     let projectSeq = 0;
     const fileSeqByPath = new Map();
-    for (const entry of readProjectChanges(cwd)) {
+    for (const entry of entries) {
+        projectSeq = Math.max(projectSeq, entry.seq);
+        foldEntry(entry, fileSeqByPath);
+    }
+    return { projectSeq, fileSeqByPath };
+}
+/**
+ * Attempt the bounded partial replay: hydrate `base` (pre-normalized keys, no
+ * `realpath` cost) and fold ONLY entries with `seq > base.sinceSeq`. Returns
+ * `null` — signalling the caller to fall back to a full replay — whenever the
+ * base cannot be trusted to be byte-identical to a full replay:
+ *
+ *  - `base.sinceSeq` is AHEAD of the log's max seq (the log was truncated /
+ *    rotated below the snapshot, or the snapshot seq is simply ahead). Serving
+ *    the base would over-report the seq; the full replay reflects the real log.
+ *
+ * The result is provably equal to a full replay under the append-only,
+ * single-writer invariant (`base` == fold of the log up to `sinceSeq`): every
+ * historical file's seq is already in `base`, and folding the strictly-newer
+ * entries with the SAME `Math.max` the full replay uses reproduces the max over
+ * the whole log for both `projectSeq` and each file. `Math.max` makes the fold
+ * order-independent, so gaps / out-of-order entries are handled exactly as the
+ * full replay handles them.
+ */
+function partialReplay(entries, base) {
+    let logMaxSeq = 0;
+    for (const entry of entries) {
+        if (entry.seq > logMaxSeq)
+            logMaxSeq = entry.seq;
+    }
+    // Snapshot ahead of / newer than the log (truncation, rotation, or a stale
+    // log): the base describes a state the log no longer backs — never serve it.
+    if (base.sinceSeq > logMaxSeq)
+        return null;
+    const fileSeqByPath = new Map(base.fileSeqByPath);
+    let projectSeq = Math.max(0, base.projectSeq);
+    for (const entry of entries) {
+        if (entry.seq <= base.sinceSeq)
+            continue; // covered by the base
         projectSeq = Math.max(projectSeq, entry.seq);
-        const key = normalizeMapKey(path.resolve(entry.filePath));
-        fileSeqByPath.set(key, Math.max(fileSeqByPath.get(key) ?? 0, entry.fileSeq));
+        foldEntry(entry, fileSeqByPath);
     }
     return { projectSeq, fileSeqByPath };
 }
+/**
+ * Compute the current `{ projectSeq, fileSeqByPath }` from the append-only
+ * change log. With no `base`, this is a full replay of the entire log. With a
+ * snapshot-embedded `base` (#1019), it folds only entries newer than
+ * `base.sinceSeq` on top of the base — O(changes since snapshot) instead of
+ * O(entire log) — and transparently falls back to a full replay when the base
+ * cannot be trusted (see `partialReplay`). A legacy/stale/missing snapshot
+ * simply passes no `base` (or one the guard rejects), so correctness never
+ * depends on the optimization being applicable.
+ */
+export function readLatestProjectSequence(cwd, base) {
+    const entries = readProjectChanges(cwd);
+    if (base) {
+        const partial = partialReplay(entries, base);
+        if (partial)
+            return partial;
+    }
+    return fullReplay(entries);
+}
+/**
+ * Async twin of `readLatestProjectSequence` (#1162) — same fold logic, but
+ * reads the log via `readProjectChangesAsync` so a caller can bound the wait
+ * with a `Promise.race` timeout (see that function's doc comment for why the
+ * sync form can't be bounded at all).
+ */
+export async function readLatestProjectSequenceAsync(cwd, base) {
+    const entries = await readProjectChangesAsync(cwd);
+    if (base) {
+        const partial = partialReplay(entries, base);
+        if (partial)
+            return partial;
+    }
+    return fullReplay(entries);
+}
 export function appendProjectChange(cwd, entry) {
     const logPath = getProjectChangeLogPath(cwd);
     fs.mkdirSync(path.dirname(logPath), { recursive: true });

package/dist/clients/project-diagnostics/cache.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getProjectDataDir } from "../file-utils.js";
+import { writeFileAtomic } from "../atomic-write.js";
 import { readJsonCache } from "../json-cache-read.js";
 // v2: cheap-tier scan now also runs ast-grep-napi (#308); invalidate older
 // snapshots so a pre-ast-grep cache isn't served as complete via refreshRunners=cached.
@@ -25,7 +26,7 @@ export function loadProjectDiagnosticsSnapshot(cwd) {
 export function saveProjectDiagnosticsSnapshot(cwd, snapshot) {
     const filePath = cachePath(cwd, SNAPSHOT_CACHE_FILE);
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, JSON.stringify(snapshot, null, 2));
+    writeFileAtomic(filePath, JSON.stringify(snapshot, null, 2));
 }
 export function loadProjectDiagnosticsDeltaReport(cwd) {
     return readJsonCache(cachePath(cwd, DELTA_CACHE_FILE), (parsed) => {
@@ -42,7 +43,7 @@ export function loadProjectDiagnosticsDeltaReport(cwd) {
 export function writeProjectDiagnosticsDeltaReport(cwd, report) {
     const filePath = cachePath(cwd, DELTA_CACHE_FILE);
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, JSON.stringify(report, null, 2));
+    writeFileAtomic(filePath, JSON.stringify(report, null, 2));
 }
 /**
  * Drop diagnostics whose underlying file changed on disk after the snapshot was

package/dist/clients/project-diagnostics/extractors.js

@@ -1,83 +1,30 @@
 /**
- * Extractor registry — the single place that turns the heavyweight project
- * analyzers' CACHED results into `ProjectDiagnostic`s for `lens_diagnostics
- * mode=full`.
+ * Provenance metadata for the heavyweight project analyzers surfaced in
+ * `lens_diagnostics mode=full`.
  *
- * Each analyzer (knip, jscpd, madge, gitleaks, …) runs on its own cadence
- * (session-start / turn-end) and writes a result to `cacheManager`. This module
- * READS those caches and adapts them via the pure `runner-adapters/*` functions.
- * It never launches a scan — so mode=full can't relaunch or contend with the
- * background runs. Adding a new analyzer = write one adapter + one registry row.
+ * NOTE (#585 regression cleanup): this module USED to also own
+ * `extractCachedProjectDiagnostics` — a CACHE-ONLY reader that adapted each
+ * analyzer's cached result to `ProjectDiagnostic[]` via a parallel `EXTRACTORS`
+ * registry. #585 replaced that reader in production with
+ * `fetchFreshProjectDiagnostics` (./fresh-fetch.ts), which triggers-or-joins a
+ * fresh run instead of settling for a possibly-hours-stale session_start
+ * snapshot. The old reader lingered here wired only to a test — a SECOND,
+ * dead surfacing path whose registry could (and did) silently diverge from
+ * fresh-fetch's `ANALYZER_IDS`: opengrep was registered here but missing there,
+ * so opengrep scanned+cached yet never reached the agent (the exact #585-class
+ * regression this cleanup removes). The parallel registry is gone; fresh-fetch
+ * is the single source of truth (#883).
+ *
+ * What survives is the honesty metadata (#533): given an analyzer id that
+ * fresh-fetch reported `cold` (not applicable / unavailable this run),
+ * `warmTriggerFor` names what WOULD warm it, so the rendered note is actionable
+ * rather than a bare "not run".
  */
-import { deadCodeResultToProjectDiagnostics } from "./runner-adapters/dead-code.js";
-import { gitleaksResultToProjectDiagnostics } from "./runner-adapters/gitleaks.js";
-import { govulncheckResultToProjectDiagnostics } from "./runner-adapters/govulncheck.js";
-import { jscpdResultToProjectDiagnostics } from "./runner-adapters/jscpd.js";
-import { knipIssuesToProjectDiagnostics } from "./runner-adapters/knip.js";
-import { circularDepsToProjectDiagnostics } from "./runner-adapters/madge.js";
-import { opengrepResultToProjectDiagnostics } from "./runner-adapters/opengrep.js";
-import { testRunnerFindingsToProjectDiagnostics } from "./runner-adapters/runner-findings.js";
-import { trivyResultToProjectDiagnostics } from "./runner-adapters/trivy.js";
-// biome-ignore lint/suspicious/noExplicitAny: heterogeneous result types per row
-const EXTRACTORS = [
-    {
-        id: "knip",
-        cacheKeys: ["knip"],
-        adapt: (cwd, r) => knipIssuesToProjectDiagnostics(cwd, r.issues ?? []),
-    },
-    {
-        id: "jscpd",
-        cacheKeys: ["jscpd-ts", "jscpd"],
-        adapt: (cwd, r) => jscpdResultToProjectDiagnostics(cwd, r),
-    },
-    {
-        id: "madge",
-        cacheKeys: ["madge"],
-        adapt: (cwd, r) => circularDepsToProjectDiagnostics(cwd, r.circular ?? []),
-    },
-    {
-        id: "gitleaks",
-        cacheKeys: ["gitleaks"],
-        adapt: (cwd, r) => gitleaksResultToProjectDiagnostics(cwd, r),
-    },
-    {
-        id: "govulncheck",
-        cacheKeys: ["govulncheck"],
-        adapt: (cwd, r) => govulncheckResultToProjectDiagnostics(cwd, r),
-    },
-    {
-        // #584: opengrep's full-workspace findings, sourced from a single
-        // project-wide CLI scan (`opengrep-client.ts`) instead of the per-file
-        // LSP sweep — see the constant's doc in `clients/lsp/index.ts`.
-        id: "opengrep",
-        cacheKeys: ["opengrep"],
-        adapt: (cwd, r) => opengrepResultToProjectDiagnostics(cwd, r),
-    },
-    {
-        id: "trivy",
-        cacheKeys: ["trivy"],
-        adapt: (cwd, r) => trivyResultToProjectDiagnostics(cwd, r),
-    },
-    {
-        // Per-language cache (`dead-code-<id>`). Only Python (vulture) exists today;
-        // add a key here as each new dead-code language lands.
-        id: "dead-code",
-        cacheKeys: ["dead-code-python"],
-        adapt: (cwd, r) => deadCodeResultToProjectDiagnostics(cwd, r),
-    },
-    {
-        // #628 item 4: per-edit test-runner findings (turn_end, `runtime-turn.ts`).
-        // Cache-only like every row here — never relaunches a test run. `cwd` is
-        // unused (results already carry absolute file paths).
-        id: "test-runner",
-        cacheKeys: ["test-runner-findings"],
-        adapt: (_cwd, r) => testRunnerFindingsToProjectDiagnostics(r),
-    },
-];
 /**
- * #533: which trigger warms each extractor's cache, surfaced in the "cold"
- * honesty note so the note is actionable (names what to do), matching the
- * #511/#514 house shape. Keep in sync with `EXTRACTORS` — one line per id.
+ * #533: which trigger warms each analyzer, surfaced in the "cold" honesty note
+ * so the note is actionable (names what to do), matching the #511/#514 house
+ * shape. Keyed by the ids `fetchFreshProjectDiagnostics` (./fresh-fetch.ts)
+ * reports in its `cold` list — keep in sync with that module's `ANALYZER_IDS`.
  */
 const WARM_TRIGGER = {
     knip: "runs at session-start",
@@ -85,47 +32,11 @@ const WARM_TRIGGER = {
     madge: "runs at session-start",
     gitleaks: "runs at session-start (config opt-in), or on any git repo via mode=full (#608)",
     govulncheck: "runs at session-start (Go projects only)",
+    opengrep: "runs at session-start",
     trivy: "runs at session-start",
     "dead-code": "runs at session-start (Python projects only)",
-    opengrep: "runs at session-start",
     "test-runner": "fires per-edit at turn_end (only after a source file with a discoverable test companion is edited)",
 };
-/** All registered extractor ids, in registry order — exported for tools/tests
- *  that need to enumerate "what could this section include" without reaching
- *  into the private `EXTRACTORS` table. */
-export const PROJECT_DIAGNOSTIC_EXTRACTOR_IDS = EXTRACTORS.map((e) => e.id);
-export function warmTriggerFor(extractorId) {
-    return WARM_TRIGGER[extractorId] ?? "runs at session-start";
-}
-/**
- * Read every registered analyzer's cached result and adapt it to project
- * diagnostics. Returns the merged diagnostics, the ids of the analyzers that
- * actually contributed findings (for the snapshot's `runners` list), and the
- * ids of analyzers with NO cache entry at all yet (`cold`) — distinct from an
- * analyzer that ran and found nothing. Cache-only: no scans.
- */
-export function extractCachedProjectDiagnostics(cacheManager, cwd) {
-    const diagnostics = [];
-    const runners = [];
-    const cold = [];
-    for (const extractor of EXTRACTORS) {
-        let data;
-        for (const key of extractor.cacheKeys) {
-            const entry = cacheManager.readCache(key, cwd);
-            if (entry?.data) {
-                data = entry.data;
-                break;
-            }
-        }
-        if (data === undefined) {
-            cold.push(extractor.id);
-            continue;
-        }
-        const adapted = extractor.adapt(cwd, data);
-        if (adapted.length > 0) {
-            diagnostics.push(...adapted);
-            runners.push(extractor.id);
-        }
-    }
-    return { diagnostics, runners, cold };
+export function warmTriggerFor(analyzerId) {
+    return WARM_TRIGGER[analyzerId] ?? "runs at session-start";
 }