@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/clients/performance-report.js

@@ -1,331 +0,0 @@
-import * as fs from "node:fs";
-import * as readline from "node:readline";
-import { flushLatencyLog, getLatencyLogPath, } from "./latency-logger.js";
-import { getMaxLogSizeMB } from "./log-cleanup.js";
-const DEFAULT_PERF_TOP_N = 5;
-const MAX_PERF_TOP_N = 50;
-export const MAX_PERF_PHASE_SAMPLES = 20_000;
-// Yield cadence for the full-window parse below. Exported so the occupancy
-// guard can count yields against the lines fed instead of measuring a
-// wall-clock block the scheduler can inflate (#2886): the count is a
-// deterministic function of the input, not of worker contention.
-export const PARSE_YIELD_EVERY = 500;
-// The window follows the same threshold that rotates the log out from under it.
-// Exported so a test can size a fixture to the window it means to saturate
-// rather than to a second copy of the default that can drift out of agreement.
-export function resolveLogByteBudget() {
-    return getMaxLogSizeMB() * 1024 * 1024;
-}
-function boundedPositiveInteger(value, maximum, fallback = maximum) {
-    return Number.isFinite(value) && value > 0
-        ? Math.min(maximum, Math.max(1, Math.floor(value)))
-        : fallback;
-}
-function percentile(sorted, quantile) {
-    const position = (sorted.length - 1) * quantile;
-    const lower = Math.floor(position);
-    const upper = Math.ceil(position);
-    return lower === upper
-        ? sorted[lower]
-        : sorted[lower] + (sorted[upper] - sorted[lower]) * (position - lower);
-}
-function roundedMs(value) {
-    return Math.round(value * 10) / 10;
-}
-function isEntryObject(value) {
-    return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function isPhaseRecord(value) {
-    if (!isEntryObject(value))
-        return false;
-    return (value.type === "phase" &&
-        typeof value.phase === "string" &&
-        value.phase.trim().length > 0 &&
-        typeof value.durationMs === "number" &&
-        Number.isFinite(value.durationMs) &&
-        value.durationMs >= 0 &&
-        (value.toolName === undefined || typeof value.toolName === "string") &&
-        (value.ts === undefined || typeof value.ts === "string") &&
-        (value.startedAt === undefined || typeof value.startedAt === "string") &&
-        (value.pid === undefined ||
-            (typeof value.pid === "number" && Number.isFinite(value.pid))));
-}
-function isPhaseSample(value) {
-    return isPhaseRecord(value) && value.durationMs > 0;
-}
-function phaseKey(entry) {
-    const phase = entry.phase?.trim() ?? "";
-    const toolName = entry.toolName?.trim();
-    return toolName ? `${toolName}/${phase}` : phase;
-}
-function isCurrentSessionSample(entry, processId, sessionStartedAt) {
-    if (entry.pid !== processId || typeof entry.ts !== "string")
-        return false;
-    const finishedAt = Date.parse(entry.ts);
-    if (!Number.isFinite(finishedAt) || finishedAt < sessionStartedAt)
-        return false;
-    if (entry.startedAt === undefined)
-        return true;
-    const startedAt = Date.parse(entry.startedAt);
-    return Number.isFinite(startedAt) && startedAt >= sessionStartedAt;
-}
-function createPhaseBuffer(limit) {
-    return { values: [], nextIndex: 0, total: 0, limit };
-}
-function retainEntry(buffer, entry) {
-    buffer.total += 1;
-    if (buffer.values.length < buffer.limit) {
-        buffer.values.push(entry);
-        return;
-    }
-    buffer.values[buffer.nextIndex] = entry;
-    buffer.nextIndex = (buffer.nextIndex + 1) % buffer.limit;
-}
-function orderedEntries(buffer) {
-    return buffer.total > buffer.values.length
-        ? [
-            ...buffer.values.slice(buffer.nextIndex),
-            ...buffer.values.slice(0, buffer.nextIndex),
-        ]
-        : buffer.values;
-}
-export function summarizePhaseLatency(entries, topN = DEFAULT_PERF_TOP_N) {
-    const durationsByPhase = new Map();
-    let oldestTimestamp;
-    let newestTimestamp;
-    let sampleCount = 0;
-    for (const entry of entries) {
-        if (!isPhaseSample(entry))
-            continue;
-        const phase = phaseKey(entry);
-        const durations = durationsByPhase.get(phase) ?? [];
-        durations.push(entry.durationMs);
-        durationsByPhase.set(phase, durations);
-        sampleCount += 1;
-        if (typeof entry.ts === "string") {
-            const ms = Date.parse(entry.ts);
-            if (Number.isFinite(ms)) {
-                if (!oldestTimestamp || ms < oldestTimestamp.ms) {
-                    oldestTimestamp = { ms, iso: entry.ts };
-                }
-                if (!newestTimestamp || ms > newestTimestamp.ms) {
-                    newestTimestamp = { ms, iso: entry.ts };
-                }
-            }
-        }
-    }
-    const summaries = Array.from(durationsByPhase, ([phase, durations]) => {
-        const sorted = [...durations].sort((a, b) => a - b);
-        const p50RawMs = percentile(sorted, 0.5);
-        const p99RawMs = percentile(sorted, 0.99);
-        return {
-            phase,
-            samples: sorted.length,
-            p50Ms: roundedMs(p50RawMs),
-            p99Ms: roundedMs(p99RawMs),
-            p50RawMs,
-            p99RawMs,
-        };
-    });
-    const limit = boundedPositiveInteger(topN, MAX_PERF_TOP_N, DEFAULT_PERF_TOP_N);
-    const tieBreak = (a, b) => b.samples - a.samples || a.phase.localeCompare(b.phase);
-    const toPublic = ({ phase, samples, p50Ms, p99Ms, }) => ({
-        phase,
-        samples,
-        p50Ms,
-        p99Ms,
-    });
-    const rankBy = (primary, secondary) => [...summaries]
-        .sort((a, b) => b[primary] - a[primary] ||
-        b[secondary] - a[secondary] ||
-        tieBreak(a, b))
-        .slice(0, limit)
-        .map(toPublic);
-    return {
-        sampleCount,
-        phaseCount: durationsByPhase.size,
-        oldestTs: oldestTimestamp?.iso,
-        newestTs: newestTimestamp?.iso,
-        slowestByP50: rankBy("p50RawMs", "p99RawMs"),
-        slowestByP99: rankBy("p99RawMs", "p50RawMs"),
-    };
-}
-async function readPhaseLogTail(filePath, windowBytes, maxSamples, processId, sessionStartedAt) {
-    const empty = () => ({
-        logEntries: [],
-        sessionEntries: [],
-        windowTruncated: false,
-        logSamplesTruncated: false,
-        sessionSamplesTruncated: false,
-        totalPhaseSamples: 0,
-        totalSessionPhaseSamples: 0,
-        malformedLines: 0,
-        invalidRecords: 0,
-    });
-    let handle;
-    try {
-        handle = await fs.promises.open(filePath, "r");
-        const stat = await handle.stat();
-        if (!stat.isFile()) {
-            // POSIX rejects opening a directory with EISDIR, but Windows opens it
-            // successfully with size 0 — which would fall into the empty() branch
-            // and conflate "unreadable path" with "no data yet". Throw the same
-            // error POSIX would so both platforms surface the bad path.
-            const notAFile = new Error(`EISDIR: illegal operation on a directory, read '${filePath}'`);
-            notAFile.code = "EISDIR";
-            throw notAFile;
-        }
-        if (stat.size === 0)
-            return empty();
-        const sampleLimit = boundedPositiveInteger(maxSamples, MAX_PERF_PHASE_SAMPLES);
-        const start = Math.max(0, stat.size - windowBytes);
-        let discardPartialFirstLine = false;
-        if (start > 0) {
-            const previousByte = Buffer.alloc(1);
-            const { bytesRead } = await handle.read(previousByte, 0, 1, start - 1);
-            discardPartialFirstLine = bytesRead === 1 && previousByte[0] !== 0x0a;
-        }
-        const stream = handle.createReadStream({
-            start,
-            end: stat.size - 1,
-            autoClose: false,
-            encoding: "utf8",
-        });
-        const lines = readline.createInterface({
-            input: stream,
-            crlfDelay: Infinity,
-        });
-        const logBuffer = createPhaseBuffer(sampleLimit);
-        const sessionBuffer = createPhaseBuffer(sampleLimit);
-        let malformedLines = 0;
-        let invalidRecords = 0;
-        let lineCount = 0;
-        for await (const line of lines) {
-            lineCount += 1;
-            if (lineCount % PARSE_YIELD_EVERY === 0) {
-                await new Promise((resolve) => setImmediate(resolve));
-            }
-            if (discardPartialFirstLine) {
-                discardPartialFirstLine = false;
-                continue;
-            }
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            try {
-                const value = JSON.parse(trimmed);
-                if (isPhaseSample(value)) {
-                    retainEntry(logBuffer, value);
-                    if (isCurrentSessionSample(value, processId, sessionStartedAt)) {
-                        retainEntry(sessionBuffer, value);
-                    }
-                }
-                else if (!isPhaseRecord(value) &&
-                    (!isEntryObject(value) || value.type === "phase")) {
-                    invalidRecords += 1;
-                }
-            }
-            catch {
-                malformedLines += 1;
-            }
-        }
-        return {
-            logEntries: orderedEntries(logBuffer),
-            sessionEntries: orderedEntries(sessionBuffer),
-            windowTruncated: start > 0,
-            logSamplesTruncated: logBuffer.total > sampleLimit,
-            sessionSamplesTruncated: sessionBuffer.total > sampleLimit,
-            totalPhaseSamples: logBuffer.total,
-            totalSessionPhaseSamples: sessionBuffer.total,
-            malformedLines,
-            invalidRecords,
-        };
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return empty();
-        throw error;
-    }
-    finally {
-        await handle?.close().catch(() => { });
-    }
-}
-export async function collectLatencyPerformance(options) {
-    await flushLatencyLog();
-    const logPath = options.logPath ?? getLatencyLogPath();
-    const processId = options.processId ?? process.pid;
-    const topN = boundedPositiveInteger(options.topN ?? DEFAULT_PERF_TOP_N, MAX_PERF_TOP_N, DEFAULT_PERF_TOP_N);
-    const byteBudget = resolveLogByteBudget();
-    const windowBytes = boundedPositiveInteger(options.maxBytes ?? byteBudget, byteBudget);
-    const tail = await readPhaseLogTail(logPath, windowBytes, options.maxSamples ?? MAX_PERF_PHASE_SAMPLES, processId, options.sessionStartedAt);
-    const { logEntries, sessionEntries, ...counters } = tail;
-    return {
-        logPath,
-        topN,
-        windowBytes,
-        ...counters,
-        session: summarizePhaseLatency(sessionEntries, topN),
-        logWindow: summarizePhaseLatency(logEntries, topN),
-    };
-}
-function formatDuration(ms) {
-    if (ms >= 1000)
-        return `${(ms / 1000).toFixed(2)}s`;
-    if (ms > 0 && ms < 1)
-        return `${ms.toFixed(2)}ms`;
-    return `${Number.isInteger(ms) ? ms : ms.toFixed(1)}ms`;
-}
-function formatByteBudget(bytes) {
-    if (bytes >= 1024 * 1024) {
-        return `${Number((bytes / (1024 * 1024)).toFixed(1))}MB`;
-    }
-    if (bytes >= 1024)
-        return `${Number((bytes / 1024).toFixed(1))}KB`;
-    return `${bytes}B`;
-}
-function formatTimestamp(ts) {
-    const parsed = new Date(ts);
-    return Number.isFinite(parsed.getTime())
-        ? `${parsed.toISOString().slice(0, 19).replace("T", " ")}Z`
-        : ts;
-}
-function renderRanking(lines, label, phases) {
-    lines.push(`  ${label}:`);
-    for (const phase of phases) {
-        lines.push(`    ${phase.phase}: p50 ${formatDuration(phase.p50Ms)}, p99 ${formatDuration(phase.p99Ms)}, n=${phase.samples}`);
-    }
-}
-function renderScope(lines, label, scope) {
-    const range = scope.oldestTs && scope.newestTs
-        ? `, ${formatTimestamp(scope.oldestTs)} to ${formatTimestamp(scope.newestTs)}`
-        : "";
-    lines.push("", `${label} (${scope.sampleCount} samples across ${scope.phaseCount} phases${range})`);
-    if (scope.slowestByP99.length === 0) {
-        lines.push("  No phase timings yet.");
-        return;
-    }
-    renderRanking(lines, "Highest p50", scope.slowestByP50);
-    renderRanking(lines, "Highest p99", scope.slowestByP99);
-}
-export function renderLatencyPerformanceReport(report) {
-    const lines = [
-        "⏱️ PI-LENS PERFORMANCE",
-        `Top ${report.topN} sustained and tail latency phases.`,
-    ];
-    renderScope(lines, "Current process session", report.session);
-    renderScope(lines, "Machine-wide active log window", report.logWindow);
-    lines.push("", `Source: ${report.logPath}`);
-    if (report.windowTruncated) {
-        lines.push(`Both scopes use only the newest ${formatByteBudget(report.windowBytes)} of the active log.`);
-    }
-    if (report.sessionSamplesTruncated) {
-        lines.push(`Session percentiles use the newest ${report.session.sampleCount.toLocaleString("en-US")} of ${report.totalSessionPhaseSamples.toLocaleString("en-US")} phase samples.`);
-    }
-    if (report.logSamplesTruncated) {
-        lines.push(`Machine-wide percentiles use the newest ${report.logWindow.sampleCount.toLocaleString("en-US")} of ${report.totalPhaseSamples.toLocaleString("en-US")} phase samples.`);
-    }
-    if (report.malformedLines > 0 || report.invalidRecords > 0) {
-        lines.push(`Skipped ${report.malformedLines} malformed line(s) and ${report.invalidRecords} invalid record(s).`);
-    }
-    return lines.join("\n");
-}

package/node_modules/pi-lens/dist/clients/persist-debounce.js

@@ -1,70 +0,0 @@
-/**
- * Generalized debounced-persist coalescing scheduler (#348 phase 2), factored
- * out of the review graph's #260 circuit-breaker so a second warm cache
- * (the word index) doesn't grow a parallel copy of the same discipline:
- *   1. Coalesce: a burst of edits schedules ONE write after a quiet window,
- *      instead of one write per edit.
- *   2. Best-effort teardown flush: a process-exit hook flushes any pending
- *      writes synchronously so a debounced payload is never silently lost.
- *
- * What stayed OUT of this module (left to each caller, deliberately not
- * generalized): the actual serialize+write. The review graph writes its own
- * cache file (tmp+rename, size-cap check, git-stamp) while the word index
- * merges into the shared project-snapshot file via `saveProjectSnapshot`
- * (preserving unrelated fields, honoring the seq-laundering guard). Those
- * writers are different enough (different files, different merge semantics)
- * that forcing them through one write function would either leak
- * graph-specific concerns into the snapshot path or vice versa. The
- * scheduler only owns "when", never "how".
- */
-/**
- * Build a debounce scheduler over `write(key, payload)`. `debounceMs()` is
- * read fresh on every schedule call (not captured once) so a test that
- * flips its env override mid-run takes effect immediately, same as the
- * graph's `graphPersistDebounceMs()`.
- */
-export function createDebounceScheduler(args) {
-    const { write, debounceMs } = args;
-    const pending = new Map();
-    const timers = new Map();
-    function flush(key) {
-        const payload = pending.get(key);
-        if (payload === undefined)
-            return;
-        pending.delete(key);
-        const timer = timers.get(key);
-        if (timer) {
-            clearTimeout(timer);
-            timers.delete(key);
-        }
-        write(key, payload);
-    }
-    function flushAll() {
-        // Iterates `pending.keys()` live (a `Map` iterator reflects mutation
-        // during iteration): `flush` deletes the current key before calling
-        // `write`, which is safe, but the injected `write` callback must NOT
-        // synchronously call `schedule` again for a key not yet visited — that
-        // would insert into `pending` mid-iteration and the live iterator would
-        // pick it up, flushing a payload the caller expected to survive as
-        // "still pending" after this call returns.
-        for (const key of pending.keys())
-            flush(key);
-    }
-    function schedule(key, payload) {
-        pending.set(key, payload);
-        const debounce = debounceMs();
-        const existing = timers.get(key);
-        if (existing)
-            clearTimeout(existing);
-        if (debounce === 0) {
-            flush(key);
-            return;
-        }
-        const timer = setTimeout(() => flush(key), debounce);
-        // Don't keep the event loop alive solely for a debounced write.
-        if (typeof timer.unref === "function")
-            timer.unref();
-        timers.set(key, timer);
-    }
-    return { schedule, flush, flushAll };
-}

package/node_modules/pi-lens/dist/clients/persistent-reverify.js

@@ -1,271 +0,0 @@
-/**
- * #3170 — the bounded persistent-reverify pass.
- *
- * A finding whose own file is unchanged is re-delivered turn after turn from
- * the persisted actionable-warnings report without ever being re-observed
- * against the live server: the in-band publish carries forward DEFERRED-origin
- * file entries while their file has not moved
- * (`mergeActionableWarningsReports`'s scope guard), and the delta freshness
- * gate passes them because the file's mtime has not moved either. When the
- * root cause was fixed in a DIFFERENT file, the carried finding is stale in
- * fact but fresh by every on-disk axis.
- *
- * This module re-observes those files at turn_end, BEFORE the advisory
- * assembles, and the replacement entries fold into the turn's SINGLE in-band
- * publish (#3176 F1: a separate replacement publish spends the carry marker
- * and the main publish then drops the entries at the scope guard — the
- * blocker the review caught).
- *
- * Review-round contracts (#3176):
- * - **F2**: the fresh observation converts through the PRODUCER's own
- *   pipeline (`enrichFileFromLsp` — severity-2, code-action enrichment,
- *   fixable-only, the per-file caps), fed the touch's collected diagnostics
- *   as the cached arm so no second pull happens. No re-implementation.
- * - **F3**: an empty result is clean ONLY when the touch itself answers
- *   `confirmation: "confirmed"` — the silent-on-clean rule (#240/#533/#1253).
- *   A bare `{diags: []}` (the house double's silent empty, a tier-3 server
- *   still analyzing, a `skipReason`) is UNCONFIRMED: the carried warnings are
- *   kept verbatim and the render labels the gap. `touched.inconclusive` is
- *   `resolveTouchVerdict`'s output computed service-side and is honored
- *   directly.
- * - **F4**: every await is bound-wrapped (`bounded()`); `maxClientWaitMs` is
- *   only the spawn/ready budget, not a request ceiling.
- * - **F6**: no skip guard — every deferred-origin entry re-verifies each
- *   turn (re-arm), per the issue's failure table.
- *
- * Bounds: at most {@link MAX_REVERIFY_FILES} files per turn_end, a wall
- * budget of {@link REVERIFY_BUDGET_MS}, the turn-end abort signal, and no
- * new durable state — candidates come from the persisted report itself,
- * which is what was delivered last turn.
- */
-import * as fs from "node:fs";
-import { enrichFileFromLsp } from "./actionable-warnings.js";
-import { bounded } from "./deadline-utils.js";
-import { logLatency } from "./latency-logger.js";
-import { touchCompletedConfirmationPolicy, } from "./lsp/diagnostic-binding.js";
-import { findAuxiliaryProfileForSource } from "./dispatch/auxiliary-lsp.js";
-/** At most this many files are re-observed per turn_end (the drift backstop's
- * own 4-resyncs-per-pass precedent). */
-export const MAX_REVERIFY_FILES = 4;
-/** Wall-clock budget for the whole pass; a touch that cannot answer inside
- * its remaining slice is recorded unconfirmed, never waited out. */
-export const REVERIFY_BUDGET_MS = 3000;
-/** The touch options the `source=lsp` probe uses, with this pass's source. */
-const TOUCH_SOURCE = "persistent_reverify";
-/**
- * Select the report's re-verify candidates: DEFERRED-origin file entries (the
- * only population the in-band publish carries forward, so the only population
- * that re-serves across turns — F6: with no skip guard, so every carried
- * entry re-verifies each turn) whose file stat is UNCHANGED since the entry's
- * own observation stamp. A file that changed is skipped and counted — the
- * edit path already re-observed it. Missing files are skipped too: the delta
- * freshness gate drops them outright.
- */
-export function selectPersistentReverifyFiles(report, nowMs = Date.now()) {
-    const candidates = [];
-    let skippedChanged = 0;
-    for (const entry of report.files) {
-        if (entry.origin !== "deferred")
-            continue;
-        // F3 (population half): the pass re-observes through a PRIMARY-scope
-        // touch, so an auxiliary-lane finding can never be re-confirmed — an
-        // entry carrying aux-sourced warnings is skipped (kept verbatim),
-        // never scored dropped. The aux lookup is the one shared seam.
-        if (entry.warnings.some((w) => findAuxiliaryProfileForSource(w.source ?? "") !== undefined)) {
-            continue;
-        }
-        const stamp = entry.generatedAt ? Date.parse(entry.generatedAt) : NaN;
-        if (!Number.isFinite(stamp) || stamp > nowMs)
-            continue;
-        let mtimeMs;
-        try {
-            mtimeMs = fs.statSync(entry.filePath).mtimeMs;
-        }
-        catch {
-            continue;
-        }
-        if (mtimeMs > stamp) {
-            skippedChanged += 1;
-            continue;
-        }
-        if (candidates.length < MAX_REVERIFY_FILES)
-            candidates.push(entry);
-    }
-    return { candidates, skippedChanged };
-}
-/**
- * Run the bounded re-verify pass over the report's candidates and build the
- * replacement entries for the caller's single in-band publish. Never throws:
- * an unexpected per-file failure degrades that file to `unconfirmed` (kept
- * verbatim, labeled), which is the shape-48 direction — the harm reaching the
- * user is a hidden real finding, worse than re-delivering a stale one.
- */
-export async function runPersistentReverify(args) {
-    const started = Date.now();
-    const deadlineAt = started + (args.budgetMs ?? REVERIFY_BUDGET_MS);
-    const nowMs = args.nowMs ?? started;
-    const { candidates, skippedChanged } = selectPersistentReverifyFiles(args.report, nowMs);
-    const outcomes = [];
-    const replacementFiles = [];
-    let touched = 0;
-    // F2: the producer's own pipeline (enrichFileFromLsp) — constructed once,
-    // reused per candidate. deltaOnly: false (a re-observation is not gated on
-    // this turn's modified ranges — the file was not edited).
-    const buildArgs = {
-        cwd: args.cwd,
-        sessionId: args.report.sessionId,
-        turnIndex: 0,
-        files: [],
-        modifiedRangesByFile: new Map(),
-        dispatchWarnings: [],
-        includeLspCodeActions: true,
-        deltaOnly: false,
-        ...(args.signal !== undefined ? { signal: args.signal } : {}),
-        lspBudgetMs: REVERIFY_BUDGET_MS,
-        dbg: () => { },
-    };
-    // R3-4: every candidate the budget or the abort cut, so the phase row
-    // distinguishes "the pass ran out of time" from "the server answered
-    // nothing". Counted from what the loop actually reached, never predicted.
-    let processed = 0;
-    for (const entry of candidates) {
-        if (args.signal?.aborted || Date.now() >= deadlineAt)
-            break;
-        processed += 1;
-        let content;
-        try {
-            content = fs.readFileSync(entry.filePath, "utf-8");
-        }
-        catch {
-            outcomes.push({
-                filePath: entry.filePath,
-                displayPath: entry.displayPath,
-                outcome: "unconfirmed",
-                dropped: 0,
-                kept: entry.warnings.length,
-            });
-            replacementFiles.push({ ...entry, reVerifyIncomplete: true });
-            continue;
-        }
-        // F4: the touch is bound-wrapped — `maxClientWaitMs` bounds the
-        // spawn/ready window, `bounded()` is the request ceiling.
-        let touchedResult;
-        try {
-            touchedResult = await bounded(args.lspService.touchFile(entry.filePath, content, {
-                diagnostics: "document",
-                collectDiagnostics: true,
-                source: TOUCH_SOURCE,
-                clientScope: "primary",
-            }), {
-                ms: Math.max(250, deadlineAt - Date.now()),
-                signal: args.signal,
-                hook: "turn_end",
-                label: "persistent_reverify_touch",
-            });
-        }
-        catch {
-            // The never-throws contract: a wedged touch degrades to unconfirmed
-            // (kept verbatim, labeled), never an escaped error.
-            touchedResult = undefined;
-        }
-        // F3 (#3176): an empty result is clean ONLY when the touch COMPLETED
-        // its confirmation policy — the silent-on-clean rule (#240/#533/#1253).
-        // A bare `{diags: []}` (the house double's silent empty, a tier-3
-        // server still analyzing) or a `skipReason` is UNCONFIRMED: the carried
-        // warnings are kept verbatim and the render labels the gap.
-        // `touched.inconclusive` is resolveTouchVerdict's output, computed
-        // service-side, and is honored directly.
-        // R3-3: read the policy through `touchCompletedConfirmationPolicy`, the
-        // #1470 seam, NOT the literal `confirmation !== "confirmed"` that
-        // `diagnostic-binding.ts:274-288` exists to forbid: `partial` means
-        // every server except the named cut-off auxiliaries answered, so the
-        // primary's silent-clean gates ran to completion and its observation is
-        // as trustworthy as a full confirmation. The literal labels a file the
-        // primary fully answered and keeps a finding the touch just re-derived.
-        if (touchedResult === undefined ||
-            touchedResult.inconclusive === true ||
-            touchedResult.skipReason !== undefined ||
-            (touchedResult.diagnosticsUnsupportedServerIds ?? []).length > 0 ||
-            !touchCompletedConfirmationPolicy(touchedResult)) {
-            outcomes.push({
-                filePath: entry.filePath,
-                displayPath: entry.displayPath,
-                outcome: "unconfirmed",
-                dropped: 0,
-                kept: entry.warnings.length,
-            });
-            replacementFiles.push({ ...entry, reVerifyIncomplete: true });
-            continue;
-        }
-        touched += 1;
-        // F2: the touch's collected diagnostics feed the producer's pipeline
-        // as the cached arm — no second pull, the producer's filters and
-        // caps are reused verbatim.
-        // F4: the outer await is bound-wrapped too — the module carries ZERO
-        // syntactic unbounded awaits (#2523 slice-3 worklist), and the hard
-        // ceiling composes with enrichFileFromLsp's own internal deadline.
-        const freshRecords = (await bounded(enrichFileFromLsp(args.cwd, buildArgs, { filePath: entry.filePath, cached: touchedResult.diags }, {
-            lspService: args.lspService,
-            pullTimeoutMs: 2000,
-            deadlineAt,
-            ...(args.signal !== undefined ? { signal: args.signal } : {}),
-            site: { hook: "turn_end", label: "persistent_reverify" },
-        }), {
-            ms: Math.max(250, deadlineAt - Date.now()),
-            signal: args.signal,
-            hook: "turn_end",
-            label: "persistent_reverify_enrich",
-        })) ?? [];
-        let dropped = 0;
-        let kept = 0;
-        for (const warning of entry.warnings) {
-            const stillThere = freshRecords.some((record) => record.rule === warning.rule && record.message === warning.message);
-            if (stillThere)
-                kept += 1;
-            else
-                dropped += 1;
-        }
-        const outcome = freshRecords.length === 0
-            ? "clean"
-            : dropped === 0
-                ? "reconfirmed"
-                : "mixed";
-        outcomes.push({
-            filePath: entry.filePath,
-            displayPath: entry.displayPath,
-            outcome,
-            dropped,
-            kept,
-        });
-        replacementFiles.push({
-            ...entry,
-            warnings: freshRecords,
-            reVerified: true,
-            generatedAt: new Date(nowMs).toISOString(),
-        });
-    }
-    logLatency({
-        type: "phase",
-        toolName: "turn_end",
-        filePath: args.cwd,
-        phase: "persistent_reverify",
-        durationMs: Date.now() - started,
-        metadata: {
-            candidates: candidates.length,
-            touched,
-            clean: outcomes.filter((o) => o.outcome === "clean").length,
-            reconfirmed: outcomes.filter((o) => o.outcome === "reconfirmed").length,
-            mixed: outcomes.filter((o) => o.outcome === "mixed").length,
-            unconfirmed: outcomes.filter((o) => o.outcome === "unconfirmed").length,
-            skippedChanged,
-            skippedBudget: candidates.length - processed,
-        },
-    });
-    return {
-        outcomes,
-        replacementFiles,
-        candidates: candidates.length,
-        touched,
-        skippedChanged,
-    };
-}