@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/clients/project-changes.js

@@ -1,181 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getProjectDataDir } from "./file-utils.js";
-import { normalizeMapKey } from "./path-utils.js";
-export function getProjectChangeLogPath(cwd) {
-    return path.join(getProjectDataDir(cwd), "change-log.jsonl");
-}
-function parseChangeLine(line) {
-    try {
-        const parsed = JSON.parse(line);
-        if (typeof parsed.seq !== "number" ||
-            typeof parsed.fileSeq !== "number" ||
-            typeof parsed.filePath !== "string" ||
-            typeof parsed.source !== "string") {
-            return undefined;
-        }
-        return {
-            seq: parsed.seq,
-            timestamp: parsed.timestamp ?? new Date(0).toISOString(),
-            sessionId: parsed.sessionId ?? "unknown",
-            turnIndex: parsed.turnIndex ?? 0,
-            source: parsed.source,
-            filePath: parsed.filePath,
-            fileSeq: parsed.fileSeq,
-            changedRange: parsed.changedRange,
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-export function readProjectChanges(cwd) {
-    const logPath = getProjectChangeLogPath(cwd);
-    try {
-        const content = fs.readFileSync(logPath, "utf-8");
-        return content
-            .split(/\r?\n/)
-            .map((line) => line.trim())
-            .filter(Boolean)
-            .map(parseChangeLine)
-            .filter((entry) => Boolean(entry));
-    }
-    catch {
-        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.
- */
-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)
-        .filter((entry) => entry.seq > seq)
-        .sort((a, b) => a.seq - b.seq)
-        .slice(-limit);
-}
-// 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 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);
-        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 });
-    fs.appendFileSync(logPath, `${JSON.stringify(entry)}\n`, "utf-8");
-}

package/node_modules/pi-lens/dist/clients/project-conventions.js

@@ -1,171 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-function readPackageJson(cwd) {
-    const pkgPath = path.join(cwd, "package.json");
-    try {
-        const raw = fs.readFileSync(pkgPath, "utf-8");
-        return JSON.parse(raw);
-    }
-    catch {
-        return undefined;
-    }
-}
-function hasDep(pkg, name) {
-    if (!pkg)
-        return false;
-    return Boolean(pkg.dependencies?.[name] ??
-        pkg.devDependencies?.[name] ??
-        pkg.peerDependencies?.[name]);
-}
-function fileExists(cwd, ...segments) {
-    try {
-        return fs.existsSync(path.join(cwd, ...segments));
-    }
-    catch {
-        return false;
-    }
-}
-function dirExists(cwd, ...segments) {
-    try {
-        const target = path.join(cwd, ...segments);
-        const stat = fs.statSync(target);
-        return stat.isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-function detectReact(_cwd, pkg) {
-    const signals = [];
-    if (hasDep(pkg, "react"))
-        signals.push("package.json:dependencies.react");
-    if (hasDep(pkg, "react-dom"))
-        signals.push("package.json:dependencies.react-dom");
-    if (hasDep(pkg, "@types/react"))
-        signals.push("package.json:devDependencies.@types/react");
-    if (signals.length === 0)
-        return undefined;
-    const confidence = hasDep(pkg, "react-dom")
-        ? "high"
-        : "medium";
-    return { id: "react", confidence, signals };
-}
-function detectNext(cwd, pkg) {
-    const signals = [];
-    if (hasDep(pkg, "next"))
-        signals.push("package.json:dependencies.next");
-    for (const candidate of [
-        "next.config.js",
-        "next.config.mjs",
-        "next.config.ts",
-    ]) {
-        if (fileExists(cwd, candidate))
-            signals.push(candidate);
-    }
-    if (dirExists(cwd, "src", "pages"))
-        signals.push("src/pages/");
-    else if (dirExists(cwd, "pages"))
-        signals.push("pages/");
-    if (dirExists(cwd, "src", "app"))
-        signals.push("src/app/");
-    else if (dirExists(cwd, "app"))
-        signals.push("app/");
-    if (signals.length === 0)
-        return undefined;
-    const confidence = hasDep(pkg, "next") && signals.some((s) => s.startsWith("next.config."))
-        ? "high"
-        : hasDep(pkg, "next")
-            ? "medium"
-            : "low";
-    return { id: "next", confidence, signals };
-}
-function detectVite(cwd, pkg) {
-    const signals = [];
-    if (hasDep(pkg, "vite"))
-        signals.push("package.json:devDependencies.vite");
-    for (const candidate of [
-        "vite.config.ts",
-        "vite.config.js",
-        "vite.config.mjs",
-        "vite.config.mts",
-    ]) {
-        if (fileExists(cwd, candidate))
-            signals.push(candidate);
-    }
-    if (signals.length === 0)
-        return undefined;
-    const confidence = hasDep(pkg, "vite") && signals.some((s) => s.startsWith("vite.config."))
-        ? "high"
-        : "medium";
-    return { id: "vite", confidence, signals };
-}
-function detectVitest(cwd, pkg) {
-    const signals = [];
-    if (hasDep(pkg, "vitest"))
-        signals.push("package.json:devDependencies.vitest");
-    for (const candidate of [
-        "vitest.config.ts",
-        "vitest.config.js",
-        "vitest.config.mjs",
-        "vitest.config.mts",
-    ]) {
-        if (fileExists(cwd, candidate))
-            signals.push(candidate);
-    }
-    if (signals.length === 0)
-        return undefined;
-    const confidence = hasDep(pkg, "vitest")
-        ? "high"
-        : "medium";
-    return { id: "vitest", confidence, signals };
-}
-const AGENT_DOC_CANDIDATES = [
-    "AGENTS.md",
-    "CLAUDE.md",
-    ".cursorrules",
-];
-function summarizeAgentDocs(cwd) {
-    const docs = [];
-    for (const candidate of AGENT_DOC_CANDIDATES) {
-        const abs = path.join(cwd, candidate);
-        try {
-            const raw = fs.readFileSync(abs, "utf-8");
-            const lineCount = raw.split(/\r?\n/).length;
-            docs.push({ filePath: candidate, lineCount });
-        }
-        catch {
-            // candidate not present
-        }
-    }
-    return docs;
-}
-export function detectProjectConventions(cwd) {
-    let cwdExists = false;
-    try {
-        cwdExists = fs.statSync(cwd).isDirectory();
-    }
-    catch {
-        cwdExists = false;
-    }
-    if (!cwdExists) {
-        return { frameworks: [], testRunners: [], buildTools: [], agentDocs: [] };
-    }
-    const pkg = readPackageJson(cwd);
-    const detectors = [detectReact, detectNext, detectVite, detectVitest];
-    const frameworks = [];
-    for (const detector of detectors) {
-        const detection = detector(cwd, pkg);
-        if (detection)
-            frameworks.push(detection);
-    }
-    const testRunners = [];
-    if (frameworks.some((f) => f.id === "vitest"))
-        testRunners.push("vitest");
-    const buildTools = [];
-    if (frameworks.some((f) => f.id === "vite"))
-        buildTools.push("vite");
-    if (frameworks.some((f) => f.id === "next"))
-        buildTools.push("next");
-    const agentDocs = summarizeAgentDocs(cwd);
-    return { frameworks, testRunners, buildTools, agentDocs };
-}

package/node_modules/pi-lens/dist/clients/project-diagnostics/cache.js

@@ -1,137 +0,0 @@
-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";
-import { freshnessFromMtime } from "../freshness.js";
-import { hashDiagnosticContent } from "../lsp/diagnostic-binding.js";
-// v3 (#2154, #3060 review F1): rows carry `fileFingerprints` — the size and
-// sha256 of the bytes the scan actually read. A v2 snapshot has no content
-// axis at all; its rows can only be judged by `mtime <= scannedAt`, the test
-// that let an edit landing mid-scan read as fresh forever. Every row here is
-// a POSITIVE claim, so v2 records are rejected by the version guard and the
-// project is re-scanned rather than served under the axis that failed — the
-// same clean break `WORKSPACE_DIAGNOSTICS_CACHE_VERSION` v3 (#2776) made.
-// 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.
-export const PROJECT_DIAGNOSTICS_CACHE_VERSION = 3;
-const SNAPSHOT_CACHE_FILE = "project-diagnostics.json";
-const DELTA_CACHE_FILE = "project-diagnostics-delta.json";
-function cachePath(cwd, fileName) {
-    return path.join(getProjectDataDir(cwd), "cache", fileName);
-}
-export function loadProjectDiagnosticsSnapshot(cwd) {
-    return readJsonCache(cachePath(cwd, SNAPSHOT_CACHE_FILE), (parsed) => {
-        if (!parsed || typeof parsed !== "object")
-            return undefined;
-        const snapshot = parsed;
-        if (snapshot.version !== PROJECT_DIAGNOSTICS_CACHE_VERSION)
-            return undefined;
-        if (!Array.isArray(snapshot.diagnostics))
-            return undefined;
-        return snapshot;
-    });
-}
-export function saveProjectDiagnosticsSnapshot(cwd, snapshot) {
-    const filePath = cachePath(cwd, SNAPSHOT_CACHE_FILE);
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    writeFileAtomic(filePath, JSON.stringify(snapshot, null, 2));
-}
-export function loadProjectDiagnosticsDeltaReport(cwd) {
-    return readJsonCache(cachePath(cwd, DELTA_CACHE_FILE), (parsed) => {
-        if (!parsed || typeof parsed !== "object")
-            return undefined;
-        const report = parsed;
-        if (report.version !== PROJECT_DIAGNOSTICS_CACHE_VERSION)
-            return undefined;
-        if (!Array.isArray(report.diagnostics))
-            return undefined;
-        return report;
-    });
-}
-export function writeProjectDiagnosticsDeltaReport(cwd, report) {
-    const filePath = cachePath(cwd, DELTA_CACHE_FILE);
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    writeFileAtomic(filePath, JSON.stringify(report, null, 2));
-}
-/**
- * Drop diagnostics whose underlying file changed on disk after the snapshot was
- * taken (`mtimeMs > scannedAt + MTIME_DRIFT_TOLERANCE_MS`) or no longer
- * exists. The persisted snapshot is a
- * cross-session cache served by `lens_diagnostics mode=full refreshRunners=cached`;
- * without this it replays diagnostics the agent has since fixed or for files that
- * were deleted (#298 — "the cache needs to be cleaned before running diagnostics
- * because it became stale"). This mirrors `reconcileStaleWidgetFiles` for the
- * in-memory widget, applied at the consumer so `loadProjectDiagnosticsSnapshot`
- * stays a pure reader. Synchronous (a `statSync` per *distinct* file, memoised),
- * since the cached full-mode path is already off the typing hot loop.
- *
- * The boundary is `mtime > scannedAt + MTIME_DRIFT_TOLERANCE_MS`
- * (`blocker-freshness.ts`), not a bare `mtime > scannedAt`: #1711 found this
- * consumer's old +1ms slack did not cover the measured Windows host skew
- * between a file's mtime and the `Date.now()` read that produces `scannedAt`
- * (up to ~11.4ms, #1491/#1498) — a same-tick write-then-scan silently
- * dropped a live finding here, worse than `findingPathFreshness`'s sibling
- * gate (#1708) since this arm DROPS rather than demotes. Reusing the shared
- * constant keeps one source of truth for the measured skew.
- *
- * Fail-safe on an unparseable `scannedAt`: return the snapshot untouched rather
- * than risk dropping live findings on a clock/format anomaly.
- */
-export function reconcileProjectDiagnosticsSnapshot(snapshot) {
-    const scannedAtMs = Date.parse(snapshot.scannedAt);
-    if (!Number.isFinite(scannedAtMs))
-        return { snapshot, staleDropped: 0 };
-    const staleByFile = new Map();
-    const isStale = (filePath) => {
-        const cached = staleByFile.get(filePath);
-        if (cached !== undefined)
-            return cached;
-        let stale;
-        let stat;
-        try {
-            stat = fs.statSync(filePath);
-        }
-        catch {
-            stat = undefined; // deleted / unreadable -> indeterminate -> drop
-        }
-        // #2154: when the scan recorded what this file's bytes WERE, that answers
-        // the question directly and the timestamp comparison below cannot — a
-        // file edited while the scan was still running carries an mtime at or
-        // before `scannedAt` while holding bytes no rule here ever saw. Size is
-        // the cheap reject; only a same-size file is read and hashed. An exact
-        // content match is stronger evidence than any mtime ordering, so it
-        // settles the verdict on its own: these are per-file syntax rules, so
-        // identical bytes mean identical findings no matter what the clock says.
-        const fingerprint = snapshot.fileFingerprints?.[filePath];
-        if (fingerprint && stat) {
-            stale = true;
-            if (stat.size === fingerprint.sizeBytes) {
-                try {
-                    stale =
-                        hashDiagnosticContent(fs.readFileSync(filePath, "utf-8")) !==
-                            fingerprint.contentHash;
-                }
-                catch {
-                    stale = true; // unreadable now -> indeterminate -> drop
-                }
-            }
-            staleByFile.set(filePath, stale);
-            return stale;
-        }
-        const verdict = freshnessFromMtime({
-            mtimeMs: stat?.mtimeMs,
-            referenceMs: scannedAtMs,
-        });
-        // Pre-kernel policy: an unreadable/missing file is stale (dropped).
-        stale = verdict.verdict !== "fresh";
-        staleByFile.set(filePath, stale);
-        return stale;
-    };
-    const kept = snapshot.diagnostics.filter((d) => !isStale(d.filePath));
-    if (kept.length === snapshot.diagnostics.length) {
-        return { snapshot, staleDropped: 0 };
-    }
-    const staleDropped = [...staleByFile.values()].filter(Boolean).length;
-    return { snapshot: { ...snapshot, diagnostics: kept }, staleDropped };
-}

package/node_modules/pi-lens/dist/clients/project-diagnostics/extractors.js

@@ -1,109 +0,0 @@
-/**
- * #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",
-    jscpd: "runs at session-start",
-    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)",
-    "test-runner": "fires per-edit at turn_end (only after a source file with a discoverable test companion is edited)",
-};
-function warmTriggerFor(analyzerId) {
-    return WARM_TRIGGER[analyzerId] ?? "runs at session-start";
-}
-/**
- * #1623: single formatter for a "not run" lane entry — reused by every
- * caller that renders `fetchFreshProjectDiagnostics`'s `cold` list (today,
- * `tools/lens-diagnostics.ts`'s mode=full) so the wording can't drift
- * per-caller. Prefers the SPECIFIC reason captured at the decision point
- * (`coldReasons`, ./fresh-fetch.ts) over the generic `warmTriggerFor` guess —
- * the latter only remains a fallback for a `cold` id this map doesn't cover.
- */
-export function formatNotRunEntry(analyzerId, coldReasons) {
-    const reason = coldReasons?.[analyzerId];
-    return reason
-        ? `${analyzerId} — not run (${reason})`
-        : `${analyzerId} — not run (${warmTriggerFor(analyzerId)})`;
-}
-/**
- * #1623: human-readable age, for a lane whose result was served from cache
- * rather than executed fresh this call (see `cachedAgeMs`, ./fresh-fetch.ts).
- * Mirrors the granularity an agent actually needs to judge staleness — exact
- * seconds don't matter, "12m" vs "3h" does.
- */
-export function formatCacheAge(ms) {
-    // #1623 fix-round F4: `CacheManager.readCache` accepts a missing/corrupt
-    // `meta.timestamp` as a HIT (the timestamp only gates staleness, not
-    // validity), so `Date.now() - new Date(badTimestamp).getTime()` reaches
-    // here as NaN. Rendering "NaNh old" is a worse honesty gap than the one
-    // this whole module exists to close — say the age is unknown instead of
-    // fabricating one. Mirrors the sibling `Number.isFinite` guard in
-    // `./cache.ts`'s `reconcileProjectDiagnosticsSnapshot` (fail-safe on an
-    // unparseable timestamp rather than propagate NaN).
-    if (!Number.isFinite(ms))
-        return "age unknown";
-    if (ms < 0)
-        return "0m";
-    const totalMinutes = Math.round(ms / 60_000);
-    if (totalMinutes < 1)
-        return "under 1m";
-    if (totalMinutes < 60)
-        return `${totalMinutes}m`;
-    const hours = Math.floor(totalMinutes / 60);
-    const minutes = totalMinutes % 60;
-    return minutes > 0 ? `${hours}h${minutes}m` : `${hours}h`;
-}
-/**
- * #1623 fix-round F5: the full "<age> old" phrase for a cache-read lane.
- * Every render call site used to append the literal word " old" after
- * `formatCacheAge` itself, so a corrupt/missing timestamp's "age unknown"
- * came out as the ungrammatical "age unknown old" — the exact residual the
- * issue's tracking comment named. "Old" only makes sense once an age is
- * actually known, so this is the single place that decides whether to say
- * it, instead of every caller repeating (and occasionally forgetting) the
- * same guard.
- */
-export function formatCacheAgeOld(ms) {
-    const age = formatCacheAge(ms);
-    return Number.isFinite(ms) ? `${age} old` : age;
-}
-/**
- * #1623 fix-round F1: a "cold" reason for an analyzer whose `ensureAvailable()`
- * returned false, built from the SAME `AvailabilityOutcome`/`AvailabilityCause`
- * taxonomy every dispatch-side unavailability message already uses
- * (`describeUnavailability`, availability-policy.ts) — not a re-guessed
- * "binary unavailable" for every failure shape.
- *
- * `ensureAvailable() === false` collapses at least three distinct causes: a
- * durable absence (`missing`), a transient probe under an active retry
- * cooldown (`transient`), and — for govulncheck specifically — a project-trust
- * install denial the latch never even records (`assertInstallAllowed` returns
- * before touching it, project-trust.ts). fresh-fetch.ts's govulncheck task
- * checks trust denial itself, via `projectTrustDenialReason()`, before
- * falling back to this function. Wording a cooldown as "unavailable" would
- * repeat, one layer up, exactly the dispatch-layer defect #1467 fixed.
- */
-export function reasonFromAvailabilityVerdict(tool, verdict) {
-    if (!verdict || verdict.outcome === null)
-        return `${tool} binary unavailable`;
-    const { outcome, cause } = verdict;
-    if (outcome === "transient") {
-        if (cause === "install-retry-exhausted") {
-            return `${tool} install kept timing out and hit its retry ceiling this session (not reported missing)`;
-        }
-        const remainingMs = verdict.retryAtMs - Date.now();
-        const remainingS = remainingMs > 0 ? Math.round(remainingMs / 1000) : 0;
-        return `${tool} availability probe — retry cooldown (${remainingS}s), not a missing install`;
-    }
-    if (outcome === "non-installable") {
-        return `${tool} unavailable on this host (non-installable)`;
-    }
-    return `${tool} binary unavailable`;
-}