@herbertgao/pi-extensions 2026.8.4 → 2026.8.6

package/node_modules/pi-lens/dist/clients/tree-sitter-logger.js

@@ -53,6 +53,27 @@ export function logTreeSitterCacheStats(options) {
         },
     });
 }
+/**
+ * The tree-sitter stack's terminal-safe diagnostic sink (#1333).
+ *
+ * pi owns the terminal, so nothing under `clients/` may `console.error`. The
+ * tree-sitter subsystem already owns `tree-sitter.log`, so its diagnostics stay
+ * there rather than moving to the generic `extension.log` — one log per
+ * subsystem, per the AGENTS.md logger invariant.
+ *
+ * `filePath` is optional because several of these fire process-wide (WASM
+ * abort, grammar fetch, rule compile) with no file in hand.
+ */
+export function logTreeSitterDiagnostic(entry) {
+    logTreeSitter({
+        phase: "diagnostic",
+        filePath: entry.filePath ?? "<tree-sitter>",
+        ...(entry.languageId ? { languageId: entry.languageId } : {}),
+        status: entry.level ?? "error",
+        reason: entry.message,
+        metadata: { subsystem: entry.subsystem, ...(entry.metadata ?? {}) },
+    });
+}
 export function getTreeSitterLogPath() {
     return TREE_SITTER_LOG_FILE;
 }

package/node_modules/pi-lens/dist/clients/tree-sitter-query-loader.js

@@ -4,6 +4,7 @@
  * Loads tree-sitter queries from YAML files in rules/tree-sitter-queries/
  * and provides them to the TreeSitterClient.
  */
+import { logTreeSitterDiagnostic } from "./tree-sitter-logger.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { resolvePackagePath } from "./package-root.js";
@@ -110,7 +111,12 @@ export class TreeSitterQueryLoader {
     /** Debug logging helper */
     dbg(msg) {
         if (this.verbose) {
-            console.error(`[query-loader] ${msg}`);
+            // #1333: verbose gate preserved, sink moved to tree-sitter.log.
+            logTreeSitterDiagnostic({
+                subsystem: "query-loader",
+                level: "debug",
+                message: msg,
+            });
         }
     }
     /**

package/node_modules/pi-lens/dist/clients/tree-sitter-shared.js

@@ -13,6 +13,7 @@
  * consumer skips further tree-sitter work (previously only the runner tracked this,
  * while the other subsystems kept calling the dead runtime).
  */
+import { notifyUserDegradation } from "./user-notify.js";
 import * as path from "node:path";
 import { TreeSitterClient, } from "./tree-sitter-client.js";
 import { logTreeSitter } from "./tree-sitter-logger.js";
@@ -48,8 +49,12 @@ export function markTreeSitterWasmAborted() {
     _wasmAborted = true;
     _wasmAbortedAt = new Date().toISOString();
     _shared = null;
-    console.error("[pi-lens] tree-sitter WASM runtime aborted; structural analysis is disabled " +
-        "for this process. Restart the pi-lens extension/MCP server to recover.");
+    // HUMAN-audience: structural analysis is dead for the rest of the process
+    // and only a restart recovers it. Reaches the user through the HOST's
+    // render path (#1333); the machine-readable record is the logTreeSitter
+    // `runtime_abort` entry below.
+    notifyUserDegradation("pi-lens: tree-sitter WASM runtime aborted; structural analysis is disabled " +
+        "for this process. Restart the pi-lens extension/MCP server to recover.", "error");
     logTreeSitter({
         phase: "runtime_abort",
         filePath: process.cwd(),

package/node_modules/pi-lens/dist/clients/tree-sitter-symbol-extractor.js

@@ -2,6 +2,7 @@
  * Symbol extraction via tree-sitter queries
  * Extracts definitions and references from source files
  */
+import { logTreeSitterDiagnostic } from "./tree-sitter-logger.js";
 import * as path from "node:path";
 import { loadWebTreeSitter } from "./deps/web-tree-sitter.js";
 // Tree-sitter query patterns for symbol extraction
@@ -505,6 +506,10 @@ SYMBOL_QUERIES.javascript = {
         constructor: (identifier) @newIdent) @newRef
     `,
 };
+/** Language keys with symbol queries; used by fixture drift guards. */
+export function getSymbolQueryLanguages() {
+    return Object.keys(SYMBOL_QUERIES);
+}
 // Per-language import-source extraction (#249). Optional and independent of
 // SYMBOL_QUERIES: a language without an entry simply yields no imports (its
 // symbols still extract). Each query captures the import source text as
@@ -653,7 +658,11 @@ export class TreeSitterSymbolExtractor {
         }
         catch (err) {
             this.client.reportWasmAbort(err);
-            console.error(`[symbol-extractor] Failed to init ${this.languageId}:`, err);
+            logTreeSitterDiagnostic({
+                subsystem: "symbol-extractor",
+                languageId: this.languageId,
+                message: `Failed to init ${this.languageId}: ${err instanceof Error ? err.message : String(err)}`,
+            });
             return false;
         }
     }
@@ -665,7 +674,12 @@ export class TreeSitterSymbolExtractor {
         catch (err) {
             if (this.client.reportWasmAbort(err))
                 throw err;
-            console.error(`[symbol-extractor] ${this.languageId} ${label} query failed: ${err.message}`);
+            logTreeSitterDiagnostic({
+                subsystem: "symbol-extractor",
+                languageId: this.languageId,
+                message: `${this.languageId} ${label} query failed: ${err.message}`,
+                metadata: { query: label },
+            });
             return null;
         }
     }
@@ -704,7 +718,16 @@ export class TreeSitterSymbolExtractor {
                     imports.push(ref);
             }
         }
-        return { symbols, refs, imports };
+        return {
+            symbols,
+            refs,
+            imports,
+            coverage: {
+                definitions: this.defQuery ? "complete" : "unavailable",
+                references: this.refQuery ? "complete" : "unavailable",
+                imports: this.importQuery ? "complete" : "unavailable",
+            },
+        };
     }
     queryMatches(query, rootNode) {
         try {
@@ -1001,26 +1024,40 @@ export class TreeSitterSymbolExtractor {
     parseRefMatch(match, filePath) {
         let name;
         let refNode;
+        let referenceKind = "unknown";
         for (const capture of match.captures) {
-            if (capture.name.endsWith("Ident") ||
-                capture.name.endsWith("Method") ||
-                capture.name.endsWith("Field")) {
+            const captureName = String(capture.name);
+            if (captureName.endsWith("Ident") ||
+                captureName.endsWith("Method") ||
+                captureName.endsWith("Field")) {
                 name = capture.node.text;
                 // biome-ignore lint/suspicious/noExplicitAny: Node type
                 refNode = capture.node;
+                if (captureName.startsWith("type"))
+                    referenceKind = "type";
+                else if (captureName.startsWith("call") || captureName.startsWith("new")) {
+                    referenceKind = "call";
+                }
             }
-            if (capture.name.endsWith("Ref") && !refNode) {
+            if (captureName.endsWith("Ref") && !refNode) {
                 // biome-ignore lint/suspicious/noExplicitAny: Node type
                 refNode = capture.node;
+                if (captureName.startsWith("type"))
+                    referenceKind = "type";
+                else if (captureName.startsWith("call") || captureName.startsWith("new")) {
+                    referenceKind = "call";
+                }
             }
         }
         if (!name || !refNode)
             return null;
         return {
             symbolId: `${filePath}:${name}`, // Will be resolved later
+            symbolName: name,
             filePath,
             line: refNode.startPosition.row + 1,
             column: refNode.startPosition.column + 1,
+            referenceKind,
         };
     }
     // biome-ignore lint/suspicious/noExplicitAny: Node type

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

@@ -0,0 +1,51 @@
+/**
+ * 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.
+ */
+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;
+}
+/** True when a host render path is available (for callers that want to branch). */
+export function hasUserNotifier() {
+    return 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") {
+    try {
+        const notify = notifierGetter?.();
+        notify?.(message, 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

@@ -0,0 +1,57 @@
+/**
+ * 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
+    }
+}

package/node_modules/pi-lens/dist/clients/warm-attach.js

@@ -4,8 +4,9 @@ import * as path from "node:path";
 import { readInstanceRegistry, } from "./instance-registry.js";
 import { realIsPidAlive, STALE_HEARTBEAT_MS, } from "./instance-reaper.js";
 import { logLatency } from "./latency-logger.js";
-import { getLSPService } from "./lsp/index.js";
-import { contentHash, diagnosticsIpcPathForCwd, requestWarmCodeActions, requestWarmDiagnostics, WARM_CODE_ACTION_LOOKUP_LIMIT, WARM_DIAGNOSTICS_SCHEMA_VERSION, } from "./mcp/ipc.js";
+import { touchCoverageGap } from "./lsp/diagnostic-binding.js";
+import { loadLspService } from "./lsp-lazy.js";
+import { contentHash, createWarmIpcLineReader, diagnosticsIpcPathForCwd, requestWarmCodeActions, requestWarmDiagnostics, WARM_CODE_ACTION_LOOKUP_LIMIT, WARM_DIAGNOSTICS_SCHEMA_VERSION, } from "./mcp/ipc.js";
 import { normalizeFilePath } from "./path-utils.js";
 const state = { local: true, servedDiagnosticHashes: new Map() };
 function record(event, cwd, reason, pid, source) {
@@ -41,7 +42,7 @@ async function serveRequest(req) {
                 if (Date.now() > req.deadlineAt) {
                     throw new Error("deadline exceeded");
                 }
-                return getLSPService().codeAction(req.file, range.start.line, range.start.character, range.end.line, range.end.character);
+                return (await loadLspService()).getLSPService().codeAction(req.file, range.start.line, range.start.character, range.end.line, range.end.character);
             }));
             const servedAt = Date.now();
             if (servedAt > req.deadlineAt)
@@ -67,7 +68,7 @@ async function serveRequest(req) {
     if (Date.now() > req.deadlineAt || contentHash(req.content) !== req.contentHash) {
         return { error: "stale request" };
     }
-    const touched = await getLSPService().touchFile(req.file, req.content, {
+    const touched = await (await loadLspService()).getLSPService().touchFile(req.file, req.content, {
         diagnostics: "document",
         collectDiagnostics: true,
         clientScope: "with-auxiliary",
@@ -76,6 +77,11 @@ async function serveRequest(req) {
         source: "warm-attach-incumbent",
     });
     const servedAt = Date.now();
+    // #1470: the coverage gap is read through the shared helper, never re-derived
+    // from `confirmation === "partial"`. The two fields are set together today, so
+    // either test passes — which is exactly the coincidence `touchCoverageGap`'s
+    // own doc comment warns against. One reader, one rule.
+    const coverageGap = touchCoverageGap(touched);
     if (servedAt <= req.deadlineAt && touched !== undefined && !touched.inconclusive) {
         state.servedDiagnosticHashes.set(normalizeFilePath(req.file), req.contentHash);
     }
@@ -83,11 +89,34 @@ async function serveRequest(req) {
         result: {
             route: "diagnostics",
             version: WARM_DIAGNOSTICS_SCHEMA_VERSION,
-            diagnostics: touched ?? [],
+            // #1179: `touchFile` now returns the `{ diags, inconclusive, binding }`
+            // wrapper — take the array off `.diags`. This is the canonical shape-5
+            // serialization boundary: the diagnostics array crosses the IPC socket
+            // and `inconclusive` is re-surfaced below as an EXPLICIT enumerable DTO
+            // field (no side-channel survives `JSON.stringify`).
+            diagnostics: touched?.diags ?? [],
             contentHash: req.contentHash,
             servedAt,
             fresh: servedAt <= req.deadlineAt && touched !== undefined,
             inconclusive: touched?.inconclusive === true,
+            // #1253: carry the touch's own confirmation verdict across the socket
+            // as an explicit enumerable field (same doctrine as `inconclusive`) —
+            // without it, an incumbent-served empty result from a silent-on-clean
+            // server is indistinguishable from "never answered" on the far side.
+            ...(touched?.confirmation === "confirmed"
+                ? { confirmation: "confirmed" }
+                : {}),
+            // #1470: a PARTIAL touch crosses the socket as itself rather than as a
+            // missing key. Omitting it would still fail closed on the far side, but it
+            // would be indistinguishable from an old incumbent that never sent the
+            // field — and the whole point of narrowing is that the reader can tell
+            // which coverage is real.
+            ...(coverageGap.length > 0
+                ? {
+                    confirmation: "partial",
+                    unconfirmedServerIds: [...coverageGap],
+                }
+                : {}),
         },
     };
 }
@@ -104,22 +133,22 @@ function startServer(cwd) {
     }
     const server = net.createServer((socket) => {
         socket.setEncoding("utf8");
-        let buffer = "";
-        socket.on("data", (chunk) => {
-            buffer += chunk;
-            const newline = buffer.indexOf("\n");
-            if (newline === -1)
-                return;
+        // One-shot per connection (#1219 family): the same defect shape as the
+        // MCP warm socket — clients write exactly one request and read one
+        // reply, so a handler that kept re-reading the same buffered line
+        // re-dispatched the request on stray bytes. The shared reader consumes
+        // the line and ignores anything after it.
+        socket.on("data", createWarmIpcLineReader((line) => {
             void (async () => {
                 try {
-                    const req = JSON.parse(buffer.slice(0, newline));
+                    const req = JSON.parse(line);
                     socket.end(`${JSON.stringify(await serveRequest(req))}\n`);
                 }
                 catch (error) {
                     socket.end(`${JSON.stringify({ error: String(error) })}\n`);
                 }
             })();
-        });
+        }));
     });
     server.on("error", (error) => {
         record("listener-error", cwd, String(error));
@@ -202,3 +231,11 @@ export function _setWarmAttachForTests(cwd, incumbentPid) {
     state.incumbentPid = incumbentPid;
     state.local = false;
 }
+/**
+ * The incumbent-side request handler, exposed for tests. The socket wiring
+ * around it (`startServer`) can only be exercised by a test that actually
+ * binds a unix socket, which is not available in every sandbox — this seam
+ * lets the DTO-composition half (notably the #1253 `confirmation` field, whose
+ * absence is what a consumer reads as unconfirmed) be pinned directly.
+ */
+export const _serveWarmRequestForTests = serveRequest;