@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/clients/turn-end/lanes/govulncheck.js

@@ -1,112 +0,0 @@
-/**
- * The turn-end GOVULNCHECK lane (#1892): the session_start-cached Go CVE
- * store, rendered as ONE advisory tier.
- *
- * One lane, one store, one tier — the straight second extraction against the
- * `TurnEndLane` interface, and the first lane that renders an ADVISORY
- * section (see `TurnEndLaneParts.advisoryParts` and ADR 0008's amendment for
- * why that field arrives with this lane rather than with the interface).
- *
- * Registered surface (`clients/finding-delivery-gate.ts`):
- * `runtime-turn:govulncheck-advisory` — mode `gated`, evidence
- * `scannerGates.govulncheck` (the composer's own binding of the shared pass's
- * result, unchanged by this extraction).
- *
- * History this file must not lose (each line below is a shipped defect or a
- * review finding):
- *
- * - #1622 sibling sweep: govulncheck renders a call site as `file:line` off a
- *   session_start snapshot — the same stale-line shape as gitleaks, one tier
- *   lower. A file edited after the scan keeps its CVE and loses its line,
- *   plus the `STALE_LINE_MARKER`.
- * - #1622 review H1: a CVE is pinned by `go.mod`, NOT by the call site, so a
- *   DELETED traced file may not drop it — `onMissing: "demote"` routes a
- *   vanished path into the same arm as an edited one. The first cut dropped
- *   it, and `citedPath` reads only the FIRST filename frame, so one deleted
- *   file in a long trace silently killed a CVE go.mod still pins.
- * - #1694 F1: these findings pass through `filterFindingsByDisposition` with
- *   the SAME `ProjectDiagnostic` identity `lens_diagnostics mode=full`
- *   surfaces, over BOTH freshness arms — a mark made against what the agent
- *   was SHOWN is honoured here too.
- * - #1627 + #1625 review: the post-gate row guard and the post-disposition
- *   row guard are the SAME guard — `render` tests the list it is about to
- *   print, never the raw cache length, or the header prints with zero rows
- *   beneath it whenever either filter empties the list.
- */
-import { filterFindingsByDisposition } from "../../dispatch/finding-policy.js";
-import { toRunnerDisplayPath } from "../../dispatch/runner-context.js";
-import { govulncheckFindingToProjectDiagnostic } from "../../project-diagnostics/runner-adapters/govulncheck.js";
-import { STALE_LINE_MARKER } from "../../stale-marker.js";
-/**
- * #1622 H1: `onMissing: "demote"`, not the default `"drop"`. A Go CVE is
- * pinned by `go.mod`; the traced call site is only where it is reachable
- * FROM, so a deleted trace file means "the line is unusable", never "the
- * vulnerability is gone". `citedPath` reads the first filename frame, which
- * is also the frame `render` prints — the path the verdict is about is the
- * path the agent is shown.
- */
-async function collect(ctx) {
-    const data = (await ctx.readScannerCache("govulncheck"))
-        ?.data;
-    return {
-        govulncheck: {
-            findings: data?.findings ?? [],
-            scannedAt: data?.scannedAt,
-            citedPath: (finding) => finding.trace.find((frame) => frame.filename)?.filename,
-            onMissing: "demote",
-        },
-    };
-}
-/**
- * #1694 F1/#1625 review round: the freshness gate runs FIRST, so the
- * disposition anchor is derived from each finding's post-demotion identity —
- * this list is already the gate's live+stale partition, never the raw
- * pre-gate cache.
- */
-function gate(gates, ctx) {
-    const stale = new Set(gates.govulncheck.stale);
-    const filtered = filterFindingsByDisposition([...gates.govulncheck.live, ...gates.govulncheck.stale], ctx.cwd, (f) => govulncheckFindingToProjectDiagnostic(ctx.cwd, f));
-    return {
-        findings: filtered.kept,
-        stale,
-        suppressed: filtered.suppressed,
-    };
-}
-function render(kept, ctx) {
-    // Lane-local accumulator, deliberately NOT named after the turn's tier:
-    // `advisoryParts` is the composer's array, and a lane that pushed into one
-    // would be a render seam the `@delivery-surface:` tag scan cannot see
-    // (`tests/config/turn-end-lane-boundaries.test.ts`).
-    const advisorySections = [];
-    // #1627/#1625: guard the list that is about to be printed, never the raw
-    // cache length — the header must not print with zero rows beneath it.
-    if (kept.findings.length) {
-        const findings = kept.findings.slice(0, 5);
-        let report = "🛡️ Go CVEs reachable from this code (govulncheck) — upgrade where possible:\n";
-        for (const f of findings) {
-            const callSite = f.trace.find((t) => t.filename);
-            const stale = kept.stale.has(f);
-            const where = callSite?.filename
-                ? `${toRunnerDisplayPath(ctx.cwd, callSite.filename)}${!stale && callSite.line ? `:${callSite.line}` : ""}${stale ? ` ${STALE_LINE_MARKER}` : ""}`
-                : (f.module ?? f.packageName ?? "(module)");
-            const fix = f.fixedVersion
-                ? ` — upgrade to ${f.fixedVersion} or later`
-                : " — no fix yet, track upstream";
-            report += `  ${f.osv} (${where})${fix}\n`;
-        }
-        if (kept.findings.length > findings.length) {
-            report += `  … and ${kept.findings.length - findings.length} more\n`;
-        }
-        advisorySections.push(report);
-    }
-    return {
-        advisoryParts: advisorySections,
-        dispositionSuppressed: { govulncheck: kept.suppressed },
-    };
-}
-/** The lane. Stateless — one object, no per-turn state to reset. */
-export const govulncheckLane = {
-    collect,
-    gate,
-    render,
-};

package/node_modules/pi-lens/dist/clients/turn-end/lanes/secrets.js

@@ -1,204 +0,0 @@
-/**
- * The turn-end SECRETS lane (#1892): the gitleaks and trivy-secrets stores,
- * their live 🔴 blocker tier and their demoted 🔑 tier.
- *
- * One lane, two stores, on purpose. The two secret scanners do not have a
- * section each: #131 Mode 3 collapses them (and ast-grep's hardcoded-secret
- * rules) BY LOCATION into one report with combined provenance, because a
- * credential flagged by two tools needs rotating once, not twice — and the
- * demoted tier merges the same two stores for the same reason. So "gitleaks"
- * is not a separable delivery lane: splitting it out would leave every
- * rendering rule (the dedupe, the ast-grep enrichment, the cap, both
- * preambles) in the composer, which is the opposite of the extraction. The
- * lane is the delivery contract; the stores are its sources.
- *
- * Registered surfaces (`clients/finding-delivery-gate.ts`):
- * `runtime-turn:secrets-gitleaks`, `runtime-turn:secrets-trivy`,
- * `runtime-turn:stale-secrets-tier`.
- *
- * History this file must not lose (each line below is a shipped defect):
- *
- * - #1617: these findings never passed through `applyDispositions`, so an
- *   agent-marked false-positive re-reported as a 🔴 STOP blocker every turn.
- * - #1625 review: the disposition filter runs AFTER the freshness gate, over
- *   BOTH arms — an fp-marked finding that later goes stale must not reappear
- *   in the demoted tier.
- * - #1622 review M1: a demoted secret keeps its rule id and source; only the
- *   line is withheld. An agent triages `aws-access-token` differently from a
- *   low-confidence `generic-api-key`, and cannot do that from a bare path.
- * - #1622 review M2: the demoted tier is its OWN tier, never `advisoryParts`
- *   ("no action required this turn" directly above copy telling the agent to
- *   re-scan).
- */
-import { recordDegradationOnce } from "../../degradation-ledger.js";
-import { bounded } from "../../deadline-utils.js";
-import { filterFindingsByDisposition } from "../../dispatch/finding-policy.js";
-import { toRunnerDisplayPath } from "../../dispatch/runner-context.js";
-import { classifyAndFilterFindings, } from "../../gitleaks-client.js";
-import { HOOK_WALL_BUDGET_MS } from "../../hook-budgets.js";
-import { gitleaksFindingToProjectDiagnostic } from "../../project-diagnostics/runner-adapters/gitleaks.js";
-import { trivySecretFindingToProjectDiagnostic } from "../../project-diagnostics/runner-adapters/trivy.js";
-import { dedupeSecretFindings, fromAstGrepWarnings, fromGitleaks, fromTrivySecrets, isSecretWarning, secretLocationKey, } from "../../secret-findings.js";
-import { STALE_LINE_MARKER } from "../../stale-marker.js";
-/**
- * Gitleaks deliberately scans gitignored local files and nested repositories
- * so an explicit security audit can still inspect them. The adapter is the
- * source of truth for whether a finding belongs in a blocking delivery lane;
- * filter here before freshness handling so demoted findings cannot leak into
- * either the blocker or the stale-secret turn context.
- */
-async function blockingGitleaksFindings(data, ctx) {
-    const classification = await bounded(classifyAndFilterFindings(data?.findings ?? [], ctx.cwd), {
-        ms: HOOK_WALL_BUDGET_MS.turn_end,
-        signal: ctx.signal,
-        hook: "turn_end",
-        label: "classifyAndFilterFindings",
-    });
-    if (classification === undefined) {
-        recordDegradationOnce({
-            kind: "gitleaks_classification_timeout",
-            subject: ctx.cwd,
-            reason: "gitleaks classification exceeded the turn_end budget; retained raw findings to fail open",
-        });
-    }
-    return (classification ?? data?.findings ?? []).filter((finding) => gitleaksFindingToProjectDiagnostic(ctx.cwd, finding).semantic ===
-        "blocking");
-}
-/**
- * #1460/#1622: the gitleaks cache is TTL-only, so a finding for a file deleted
- * after the scan was served as a 🔴 blocker for the rest of the 30-minute
- * window — 119 of 126 findings in pi-lens's own cache. This lane is the single
- * agent-facing consumer of that store (session_start's read only decides
- * whether to re-scan; the project-diagnostics path re-scans fresh and
- * reconciles at load), so the drop belongs here, before the findings enter the
- * shared secret pipeline. A cited file EDITED after the scan keeps its finding
- * but loses its line number: the credential may still be there, just not where
- * the snapshot says. Dropping instead would let any edit — malicious or
- * accidental — mute a real secret. Both stores take the default
- * `onMissing: "drop"`: the finding IS the deleted file's content.
- */
-async function collect(ctx) {
-    // One await for both stores: the two reads are independent, and the memo
-    // hands each of them the same promise the composer's own trivy read shares.
-    const [gitleaksEntry, trivyEntry] = await Promise.all([
-        ctx.readScannerCache("gitleaks"),
-        ctx.readScannerCache("trivy"),
-    ]);
-    const gitleaksData = gitleaksEntry?.data;
-    const trivyData = trivyEntry?.data;
-    return {
-        gitleaks: {
-            findings: await blockingGitleaksFindings(gitleaksData, ctx),
-            citedPath: (finding) => finding.file,
-            scannedAt: gitleaksData?.scannedAt,
-        },
-        "trivy-secrets": {
-            findings: trivyData?.secrets ?? [],
-            citedPath: (finding) => finding.file,
-            scannedAt: trivyData?.scannedAt,
-        },
-    };
-}
-/**
- * #1617/#1625/#1628: filter through the SAME `ProjectDiagnostic` identity
- * `lens_diagnostics mode=full` surfaces (tool="gitleaks",
- * rule="gitleaks:<ruleId>" / tool="trivy", rule="trivy-secret:<ruleId>"), so a
- * mark made against what the agent was SHOWN is honored here too — and over
- * both arms, never live-only.
- *
- * ast-grep secret findings need no filtering here: they already went through
- * dispatch's `applyDispositions` before reaching `peekActionableWarnings()`.
- */
-function gate(gates, ctx) {
-    const gitleaksLive = filterFindingsByDisposition(gates.gitleaks.live, ctx.cwd, (f) => gitleaksFindingToProjectDiagnostic(ctx.cwd, f));
-    const gitleaksStale = filterFindingsByDisposition(gates.gitleaks.stale, ctx.cwd, (f) => gitleaksFindingToProjectDiagnostic(ctx.cwd, f));
-    const trivyLive = filterFindingsByDisposition(gates["trivy-secrets"].live, ctx.cwd, (f) => trivySecretFindingToProjectDiagnostic(ctx.cwd, f));
-    const trivyStale = filterFindingsByDisposition(gates["trivy-secrets"].stale, ctx.cwd, (f) => trivySecretFindingToProjectDiagnostic(ctx.cwd, f));
-    return {
-        gitleaksLive: gitleaksLive.kept,
-        gitleaksStale: gitleaksStale.kept,
-        trivyLive: trivyLive.kept,
-        trivyStale: trivyStale.kept,
-        suppressed: {
-            gitleaks: gitleaksLive.suppressed + gitleaksStale.suppressed,
-            "trivy-secrets": trivyLive.suppressed + trivyStale.suppressed,
-        },
-    };
-}
-function render(kept, ctx) {
-    const sessionSecrets = dedupeSecretFindings([
-        ...fromGitleaks(kept.gitleaksLive),
-        ...fromTrivySecrets(kept.trivyLive),
-    ]);
-    // Locations already surfaced as session-scan secret blockers — used to
-    // enrich provenance where ast-grep agrees, and handed back so the
-    // actionable-warnings advisory can suppress its duplicate ast-grep copy.
-    const deliveredLocationKeys = new Set(sessionSecrets.map((f) => secretLocationKey(f.file, f.line)));
-    // Lane-local accumulators, deliberately NOT named after the turn's tiers:
-    // `blockerParts`/`staleSecretParts` are the composer's arrays, and a lane
-    // that pushed into one would be a render seam the `@delivery-surface:` tag
-    // scan cannot see (`tests/config/turn-end-lane-boundaries.test.ts`).
-    const blockerSections = [];
-    if (sessionSecrets.length) {
-        // Fold in ast-grep provenance ONLY where it coincides with a session
-        // secret — don't promote ast-grep-only findings out of their advisory
-        // tier.
-        const enriched = dedupeSecretFindings([
-            ...sessionSecrets,
-            ...fromAstGrepWarnings(ctx.peekActionableWarnings().filter(isSecretWarning)).filter((a) => deliveredLocationKeys.has(secretLocationKey(a.file, a.line))),
-        ]);
-        const shown = enriched.slice(0, 5);
-        let report = "🔴 STOP — hardcoded secrets detected. Rotate the credentials and remove them from source:\n";
-        for (const f of shown) {
-            const where = `${toRunnerDisplayPath(ctx.cwd, f.file)}:${f.line}`;
-            report += `  ${where} — ${f.rule} [${f.sources.join(" + ")}]${f.description ? `: ${f.description}` : ""}\n`;
-        }
-        if (enriched.length > shown.length) {
-            report += `  … and ${enriched.length - shown.length} more\n`;
-        }
-        blockerSections.push(report);
-    }
-    // Demoted secrets are addressed by FILE, never by line — the line is the one
-    // field the edit invalidated. Deduped on file+rule+source so a file with
-    // twenty stale hits of one rule is named once.
-    const staleSecretEntries = [
-        ...kept.gitleaksStale.map((f) => ({
-            file: toRunnerDisplayPath(ctx.cwd, f.file),
-            rule: f.ruleId,
-            source: "gitleaks",
-        })),
-        ...kept.trivyStale.map((f) => ({
-            file: toRunnerDisplayPath(ctx.cwd, f.file),
-            rule: f.ruleId,
-            source: "trivy",
-        })),
-    ];
-    const staleSecrets = [
-        ...new Map(staleSecretEntries.map((e) => [`${e.file}|${e.rule}|${e.source}`, e])).values(),
-    ];
-    const staleSections = [];
-    if (staleSecrets.length) {
-        const shown = staleSecrets.slice(0, 5);
-        let report = `🔑 ACTION NEEDED — secrets were flagged in files that changed after the scan. ${STALE_LINE_MARKER}\n` +
-            "The cached line numbers are no longer trustworthy, so they are withheld. Re-run a secrets scan to confirm or clear these:\n";
-        for (const entry of shown) {
-            report += `  ${entry.file} — ${entry.rule} [${entry.source}]\n`;
-        }
-        if (staleSecrets.length > shown.length) {
-            report += `  … and ${staleSecrets.length - shown.length} more\n`;
-        }
-        staleSections.push(report);
-    }
-    return {
-        blockerParts: blockerSections,
-        staleSecretParts: staleSections,
-        dispositionSuppressed: kept.suppressed,
-        deliveredLocationKeys,
-    };
-}
-/** The lane. Stateless — one object, no per-turn state to reset. */
-export const secretsLane = {
-    collect,
-    gate,
-    render,
-};

package/node_modules/pi-lens/dist/clients/turn-summary-render.js

@@ -1,72 +0,0 @@
-/**
- * Renderer for the #484 turn-summary custom message
- * (`pilens:turn-summary`). Collapsed = one tool-grouped line (pi-lens brand
- * accent). Expanded = file-major: each touched file lists its
- * formats/autofixes/diagnostics with tool + rule id + line.
- *
- * `Component` construction is verified practical from an extension: it is
- * just `@earendil-works/pi-tui`'s `Component` interface —
- * `{ render(width: number): string[] }` — no framework object graph needed.
- * `pi-tui` is already a devDependency (package.json `@earendil-works/pi-tui`).
- */
-import { fitLines } from "./tui-fit.js";
-import { formatTurnSummaryLine, } from "./turn-summary.js";
-function severityColor(theme, severity) {
-    if (severity === "error")
-        return (s) => theme.fg("error", s);
-    if (severity === "warning")
-        return (s) => theme.fg("warning", s);
-    return (s) => theme.fg("dim", s);
-}
-function eventLine(theme, event) {
-    const loc = event.line !== undefined ? `:${event.line}` : "";
-    if (event.kind === "diagnostic") {
-        const color = severityColor(theme, event.severity);
-        const rule = event.ruleId ? ` ${event.ruleId}` : "";
-        const desc = event.description ? ` — ${event.description}` : "";
-        return `    ${color(`[${event.tool}${rule}]`)}${loc}${desc}`;
-    }
-    if (event.kind === "autofix") {
-        const desc = event.description ? ` — ${event.description}` : "";
-        return `    ${theme.fg("success", `[autofix:${event.tool}]`)}${loc}${desc}`;
-    }
-    return `    ${theme.fg("accent", `[format:${event.tool}]`)}`;
-}
-function buildExpandedLines(details, theme) {
-    const lines = [];
-    lines.push(theme.fg("accent", theme.bold("pi-lens turn summary")));
-    const sortedFiles = [...details.files].sort((a, b) => a.displayPath.localeCompare(b.displayPath));
-    for (const file of sortedFiles) {
-        lines.push(`  ${theme.bold(file.displayPath)}`);
-        // File-major: formats, then autofixes, then diagnostics — matches the
-        // order things happen in the write pipeline (format → autofix → lint).
-        const formats = file.events.filter((e) => e.kind === "format");
-        const autofixes = file.events.filter((e) => e.kind === "autofix");
-        const diagnostics = file.events.filter((e) => e.kind === "diagnostic");
-        for (const event of [...formats, ...autofixes, ...diagnostics]) {
-            lines.push(eventLine(theme, event));
-        }
-    }
-    return lines;
-}
-export function renderTurnSummaryMessage(message, options, theme) {
-    const details = message.details;
-    if (!details)
-        return undefined;
-    // pi-tui HARD-CRASHES the host on any rendered line wider than the
-    // terminal, so every line must be fitted to the width the TUI hands us
-    // (#513 — an untruncated collapsed one-liner took down a live session).
-    if (!options.expanded) {
-        const line = formatTurnSummaryLine(details);
-        const text = theme.fg("accent", line);
-        return {
-            render: (width) => fitLines([text], width),
-            invalidate: () => { },
-        };
-    }
-    const lines = buildExpandedLines(details, theme);
-    return {
-        render: (width) => fitLines(lines, width),
-        invalidate: () => { },
-    };
-}

package/node_modules/pi-lens/dist/clients/turn-summary.js

@@ -1,132 +0,0 @@
-/**
- * Turn-summary collector (#484).
- *
- * Opt-in, transcript-persistent record of what pi-lens did: diagnostics
- * found, autofixes applied, autoformats applied. Accumulated per-file across
- * the RUN's write/edit pipeline runs + the agent_end deferred-format pass,
- * then emitted as ONE `pi.sendMessage` custom entry at the `agent_settled`
- * quiet window (never per-file, and per-RUN not per-turn — see the #484
- * discussion + PR #500 review). The quiet-window emit point is load-bearing,
- * not cosmetic (verified in the installed pi 0.80.6 SDK):
- *
- *   1. `sendCustomMessage` STEERS the live model conversation when the
- *      session `isStreaming` (dist/core/agent-session.js), and turn_end can
- *      fire mid-stream — a passive summary must never steer a working agent.
- *      At settle the session is idle, so sendMessage takes the safe append
- *      branch (persisted + rendered immediately, no steer).
- *   2. A CustomMessageEntry DOES participate in LLM context: `display` only
- *      controls TUI rendering, and `buildSessionContext` converts every such
- *      entry into a `role: "user"` message on later context builds
- *      (dist/core/session-manager.js). Only `content` reaches the model —
- *      `details` never does — so the entry `content` must stay ONE short
- *      line; the model's exposure is that ~80-char collapsed line, an
- *      accepted residue (largely redundant with the #493 agent nudge).
- *
- * Collapsed rendering is tool-grouped; expanded rendering (from `details`,
- * human-only) is file-major.
- *
- * All map keys go through `normalizeMapKey` — never a hand-rolled path
- * comparison (see the two red CI rounds on PR #491 the raw-key trap cost).
- */
-import { normalizeMapKey } from "./path-utils.js";
-/**
- * Per-RUN accumulator. One instance lives on the runtime coordinator; it
- * survives turn boundaries (NOT cleared in beginTurn) and is cleared only by
- * `consume()` at the quiet-window emit and by `resetForSession()`.
- */
-export class TurnSummaryCollector {
-    filesByKey = new Map();
-    getOrCreate(filePath) {
-        const key = normalizeMapKey(filePath);
-        let entry = this.filesByKey.get(key);
-        if (!entry) {
-            // displayPath is resolved at consume() time (cwd known there); the
-            // accumulation phase only has the absolute path.
-            entry = { filePath, displayPath: filePath, events: [] };
-            this.filesByKey.set(key, entry);
-        }
-        return entry;
-    }
-    record(filePath, event) {
-        this.getOrCreate(filePath).events.push(event);
-    }
-    recordDiagnostic(filePath, args) {
-        this.record(filePath, { kind: "diagnostic", ...args });
-    }
-    recordAutofix(filePath, args) {
-        this.record(filePath, { kind: "autofix", ...args });
-    }
-    recordFormat(filePath, args) {
-        this.record(filePath, { kind: "format", ...args });
-    }
-    isEmpty() {
-        return this.filesByKey.size === 0;
-    }
-    /** Snapshot without clearing — used for tests/observability. */
-    peek() {
-        return [...this.filesByKey.values()];
-    }
-    clear() {
-        this.filesByKey.clear();
-    }
-    /** Consume (snapshot + clear) the run's collection, building the details payload. */
-    consume(turnIndex, toDisplayPath) {
-        const files = [...this.filesByKey.values()].map((entry) => ({
-            ...entry,
-            displayPath: toDisplayPath
-                ? toDisplayPath(entry.filePath)
-                : entry.filePath,
-        }));
-        this.filesByKey.clear();
-        const counts = {
-            diagnostics: 0,
-            autofixes: 0,
-            formats: 0,
-            byTool: { diagnostic: {}, autofix: {}, format: {} },
-        };
-        for (const file of files) {
-            for (const event of file.events) {
-                if (event.kind === "diagnostic")
-                    counts.diagnostics++;
-                else if (event.kind === "autofix")
-                    counts.autofixes++;
-                else
-                    counts.formats++;
-                const bucket = counts.byTool[event.kind];
-                bucket[event.tool] = (bucket[event.tool] ?? 0) + 1;
-            }
-        }
-        return { version: 1, turnIndex, files, counts };
-    }
-}
-function formatToolCounts(byTool) {
-    return Object.entries(byTool)
-        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
-        .map(([tool, count]) => `${tool} ${count}`)
-        .join(", ");
-}
-/**
- * Build the collapsed, tool-grouped one-line fallback text (also used as the
- * plain-text `content` for hosts without the custom renderer).
- * Example: "pi-lens: 3 diagnostics (eslint 2, tsserver 1) · 2 autofixed (ruff) · 1 reformatted (prettier)"
- */
-export function formatTurnSummaryLine(details) {
-    const parts = [];
-    const { counts } = details;
-    if (counts.diagnostics > 0) {
-        const byTool = formatToolCounts(counts.byTool.diagnostic);
-        parts.push(`${counts.diagnostics} diagnostic${counts.diagnostics === 1 ? "" : "s"}${byTool ? ` (${byTool})` : ""}`);
-    }
-    if (counts.autofixes > 0) {
-        const byTool = formatToolCounts(counts.byTool.autofix);
-        parts.push(`${counts.autofixes} autofixed${byTool ? ` (${byTool})` : ""}`);
-    }
-    if (counts.formats > 0) {
-        const byTool = formatToolCounts(counts.byTool.format);
-        parts.push(`${counts.formats} reformatted${byTool ? ` (${byTool})` : ""}`);
-    }
-    if (parts.length === 0)
-        return "pi-lens: turn summary (empty)";
-    return `pi-lens: ${parts.join(" · ")}`;
-}
-export const TURN_SUMMARY_CUSTOM_TYPE = "pilens:turn-summary";

package/node_modules/pi-lens/dist/clients/typos-config.js

@@ -1,29 +0,0 @@
-import { findLocalToolConfig } from "./path-utils.js";
-/**
- * typos (source-code spell checker) configuration discovery. typos runs as a
- * cross-cutting auxiliary LSP (#283); like Opengrep's local-rules gate and
- * zizmor's `zizmor.yml` gate, the PRESENCE of a repo-local typos config is the
- * project's deliberate opt-in to let spelling findings BLOCK (it carries the
- * team's curated allow-list / `extend-words` / severity). Advisory otherwise.
- *
- * typos discovers its config as `typos.toml`, `_typos.toml`, or `.typos.toml`
- * at the project root (see typos' configuration docs). We only need to know if
- * one EXISTS for the blocking gate — the `typos-lsp` server reads it itself.
- *
- * Note: `files.*` ignore globs in the config have NO effect under the LSP
- * (CLI-only), so a `.typos.toml` does not exclude paths from the LSP scan — it
- * only tunes the dictionary/severity. The blocking gate keys purely on presence.
- */
-export const LOCAL_TYPOS_CONFIG_NAMES = [
-    "typos.toml",
-    "_typos.toml",
-    ".typos.toml",
-];
-// Deliberately UNCEILINGED at $HOME (refs #2472 review round 3, F1): typos
-// discovers `~/typos.toml` as the user's legitimate global config, and
-// `typos-lsp` merges an injected config with its own discovery (injected
-// wins) — a ceilinged search here silently hid the user's config from that
-// merge and let pi-lens's own shipped `_typos.toml` clobber it instead.
-export function findLocalTyposConfig(startDir) {
-    return findLocalToolConfig(startDir, LOCAL_TYPOS_CONFIG_NAMES);
-}

package/node_modules/pi-lens/dist/clients/user-notify.js

@@ -1,51 +0,0 @@
-/**
- * The HUMAN channel for degradations discovered deep in `clients/` (#1333).
- *
- * Most of what the migrated `console.*` sites emitted is LOG-audience and
- * belongs in an ndjson sink (`clients/extension-log.ts`). A small set is
- * genuinely user-facing — "the config file you wrote is being ignored", "this
- * language's grammar could not be fetched, so its structural features are
- * degraded", "the WASM runtime aborted; restart to recover". Those must reach
- * the human through the HOST's own render path, never a raw terminal write
- * (pi owns the terminal — see the module doc in `extension-log.ts`).
- *
- * `index.ts` wires a getter at extension init; modules deep in the tree call
- * `notifyUserDegradation` without knowing anything about `ctx`. Per the
- * #338/#798 detached-callback rule the notifier is resolved through a GETTER
- * at delivery time — never captured once, because a session replacement
- * invalidates the previously captured `ctx.ui`.
- *
- * Fail-soft by construction: with no host wired (MCP server, CLI, tests) this
- * is a no-op and the ndjson sink remains the sole destination — the message is
- * never lost, only un-rendered.
- */
-import { withConfigDiagnosticCode, } from "./config-diagnostic-codes.js";
-let notifierGetter;
-/** Called once from the extension entry with a getter over the live `ctx.ui.notify`. */
-export function wireUserNotifier(portsOrGetter) {
-    notifierGetter =
-        typeof portsOrGetter === "function"
-            ? portsOrGetter
-            : () => portsOrGetter.notify.user;
-}
-/** Test/teardown-only: drop the wired host. */
-export function resetUserNotifier() {
-    notifierGetter = undefined;
-}
-/**
- * Best-effort delivery of a user-facing degradation. Never throws — a stale
- * `ctx` after a session replacement must degrade to a no-op, not break the
- * diagnostic path that called it.
- */
-export function notifyUserDegradation(message, level = "warning", options) {
-    try {
-        const notify = notifierGetter?.();
-        const coded = options?.code
-            ? withConfigDiagnosticCode(message, options.code)
-            : message;
-        notify?.(coded, level);
-    }
-    catch {
-        // The ndjson sink already holds this message; a dead host is not an error.
-    }
-}

package/node_modules/pi-lens/dist/clients/vanished-instance-marker.js

@@ -1,57 +0,0 @@
-/**
- * Vanished-instance markers (#1123 item 2, first slice — instance health).
- *
- * `deregisterInstance()` (clients/instance-registry.ts) SYNCHRONOUSLY removes
- * a process's own entry from `instances.json` on a clean `session_shutdown`.
- * That means the entry's mere PRESENCE in the registry, combined with a
- * pid-confirmed-dead owner, is already proof the process never reached that
- * shutdown path — no separate "clean shutdown" flag is needed on
- * `InstanceEntry` (the registry already carries `heartbeatAt`/`rssBytes`,
- * which is exactly the "lastSeen"/"rss" pair this marker needs; both are
- * used AS-IS, per the instruction to add fields only if missing).
- *
- * `sweepOrphans()` (clients/instance-reaper.ts) already prunes these exact
- * dead-pid entries out of the registry as part of #472's orphan-LSP reap —
- * so this marker's read MUST happen against a snapshot taken before (or
- * independently of) that prune, or the vanished set will already be empty by
- * the time this runs. `logVanishedInstances` therefore takes the registry
- * snapshot as an argument rather than reading it itself, so the caller
- * controls ordering (see index.ts's session_start wiring, which reads once
- * and passes the same snapshot to both this marker and `sweepOrphans`).
- */
-import { logSessionStart } from "./sessionstart-logger.js";
-import { realIsPidAlive } from "./instance-reaper.js";
-/**
- * PURE: registry entries whose owning pid is confirmed dead. Every such entry
- * is, by construction (see module docstring), one that exited without
- * reaching `deregisterInstance()`. Uses the SAME conservative liveness
- * contract as the reaper (`isPidAlive`, defaulting to `realIsPidAlive`):
- * ESRCH-only-means-dead, any ambiguous signal (EPERM, unknown) stays "alive"
- * — never flag a live-but-unverifiable instance as vanished.
- */
-export function detectVanishedInstances(registry, isPidAlive) {
-    return registry
-        .filter((entry) => !isPidAlive(entry.pid))
-        .map((entry) => ({
-        pid: entry.pid,
-        lastSeenAt: entry.heartbeatAt,
-        rssBytes: entry.rssBytes ?? 0,
-    }));
-}
-/**
- * Log one `sessionstart.log` line per vanished instance found in `registry`.
- * Best-effort (never throws into `session_start`) and read-only — this
- * function never mutates or prunes the registry; that stays the reaper's job.
- */
-export function logVanishedInstances(registry, isPidAlive = realIsPidAlive) {
-    try {
-        const vanished = detectVanishedInstances(registry, isPidAlive);
-        for (const instance of vanished) {
-            const rssMb = Math.round(instance.rssBytes / (1024 * 1024));
-            logSessionStart(`previous instance pid ${instance.pid} last seen ${instance.lastSeenAt} (RSS ${rssMb}MB) exited without shutdown`);
-        }
-    }
-    catch {
-        // best-effort observability — never fail session_start over this
-    }
-}