@herbertgao/pi-extensions 2026.8.5 → 2026.8.6

package/node_modules/pi-lens/dist/clients/lsp/cascade-tier.js

@@ -32,6 +32,12 @@
  * NOT tier-3 — the caller keeps today's full in-lane wait. Fail-safe is
  * always "wait like before".
  *
+ * Native TS7 is the cascade-only exception. It is not silent on clean, but
+ * its publication does not settle inside the cold-snapshot budget. Cascade
+ * classifies it as `collect-later`, sends the same no-wait touch, and
+ * reconciles its later per-file push or pull publication. The shared server
+ * policy remains `waits`, so main-lane behavior does not change.
+ *
  * #524/#529/#541/#558: a server id can now be backed by more than one actual
  * binary — "typescript" is classic typescript-language-server OR TS7's
  * native `tsc --lsp --stdio` (PR #526). PR #526 originally routed the
@@ -46,9 +52,11 @@
  * confirmed still silent (`cleanPubs=0(v:0)`) in the same run. This is
  * therefore an EVIDENCE-BASED revert, not the original unverified caution:
  * native-ts7's clean-signal behavior IS known, and it is "publishes, not
- * silent". The snapshot's `launchVariant` marker again routes a native-ts7
- * snapshot through "waits" while the shared `silentOnClean` flag stays
- * `true` for classic. `scripts/probe-clean-signal.mjs`'s drift check no
+ * silent". The shared classifier still routes a native-ts7 snapshot through
+ * `waits`. The cascade-only wrapper routes it through `collect-later` because
+ * the measured publication arrives after the in-lane budget. The shared
+ * `silentOnClean` flag stays `true` for classic.
+ * `scripts/probe-clean-signal.mjs`'s drift check no
  * longer compares native-ts7 rows against the shared marker (it now expects
  * `false` for them explicitly) — see that file's header for the regression
  * watch this sets up for a future TS7 build that becomes silent again.
@@ -57,7 +65,32 @@ import { logCascade } from "../cascade-logger.js";
 import { logLatency } from "../latency-logger.js";
 import { normalizeMapKey } from "../path-utils.js";
 import { registerQuietWindowTask } from "../quiet-window.js";
-export { classifyCascadeWaitTier, classifyServerWaitTier, } from "./wait-policy/classification.js";
+import { classifyCascadeWaitTier as classifySharedCascadeWaitTier, classifyServerWaitTier, resolvePrimaryServerForWaitPolicy, } from "./wait-policy/classification.js";
+export { classifyServerWaitTier };
+/**
+ * The cascade lane's wait tier for `filePath`. DELEGATES to the shared
+ * `wait-policy/classification.ts` rule — this wrapper adds exactly one
+ * cascade-only override on top of it (native TS7's push-only snapshot →
+ * `collect-later`) and never re-implements the classification itself.
+ *
+ * #1444 coverage tradeoff: the no-wait touch this tier selects is
+ * `clientScope: "primary"`, and the tier itself is decided from the PRIMARY
+ * (non-auxiliary) server alone. That tradeoff already existed for
+ * `tier3-silent`; the override enlarges the population it applies to — every
+ * native-TS7 TypeScript neighbour now takes the no-wait path too, so an
+ * auxiliary server configured for those files no longer gets touched in-lane
+ * for them (its findings arrive via the next per-edit dispatch, as they
+ * already did for classic tier-3 files).
+ */
+export function classifyCascadeWaitTier(lspService, filePath, snapshots) {
+    const primary = resolvePrimaryServerForWaitPolicy(filePath, snapshots);
+    if (primary?.serverId === "typescript" &&
+        primary.snapshot?.launchVariant === "native-ts7" &&
+        primary.snapshot.workspaceDiagnosticsSupport?.mode === "push-only") {
+        return "collect-later";
+    }
+    return classifySharedCascadeWaitTier(lspService, filePath, snapshots);
+}
 // --- Kill switch (lazy, memoized — house style per clients/runtime-config.ts /
 // clients/quiet-window.ts's isQuietWindowEnabled) ---
 let _enabledCache;
@@ -158,6 +191,7 @@ export async function reconcileOutstandingCascadeTouches(lspService) {
                 outcome: found ? "resolved-found" : "resolved-clean",
                 ageMs,
                 diagnosticCount: entry.diags.length,
+                publishedAt: entry.ts,
                 // #1023: carry the diagnostics so the task can re-surface them.
                 ...(found && { diagnostics: entry.diags }),
             });
@@ -199,17 +233,28 @@ export function registerCascadeTierReconcileTask(getLspService, options = {}) {
         if (outcomes.length === 0)
             return;
         // #1023: re-inject each resolved-found neighbor error so it reaches the
-        // agent (previously logs-only). Isolated per-outcome — a throwing callback
-        // must not drop the log line or the sibling re-injections.
+        // agent (previously logs-only). #1444: hand each resolved-CLEAN outcome to
+        // the footer reconcile for the mirror-image case. Isolated per-outcome — a
+        // throwing callback must not drop the log line or the sibling deliveries.
         for (const o of outcomes) {
-            if (o.outcome !== "resolved-found" || !o.diagnostics?.length)
-                continue;
             try {
-                options.onResolvedFound?.({
-                    filePath: o.filePath,
-                    serverId: o.serverId,
-                    diagnostics: o.diagnostics,
-                });
+                if (o.outcome === "resolved-found" && o.diagnostics?.length) {
+                    options.onResolvedFound?.({
+                        filePath: o.filePath,
+                        serverId: o.serverId,
+                        diagnostics: o.diagnostics,
+                    });
+                }
+                else if (o.outcome === "resolved-clean" && o.publishedAt != null) {
+                    // #1444: the stale-footer half of the same honesty problem — the
+                    // neighbour proved clean, but only after the in-lane wait was
+                    // skipped, so nothing has cleared its earlier error entries.
+                    options.onResolvedClean?.({
+                        filePath: o.filePath,
+                        serverId: o.serverId,
+                        publishedAt: o.publishedAt,
+                    });
+                }
             }
             catch {
                 // best-effort surfacing; the log below is the durable record.

package/node_modules/pi-lens/dist/clients/lsp/client.js

@@ -24,6 +24,7 @@ import { newLspMutationCorrelationId, } from "../lsp-mutation.js";
 import { applyWorkspaceEdit, normalizeWorkspaceEditToUtf16, } from "./edits.js";
 import { recordLspChild, removeLspChild } from "../instance-registry.js";
 import { normalizeMapKey, uriToPath } from "./path-utils.js";
+import { probeTsserverProjectIdentity } from "./tsserver-sync.js";
 import { ADVERTISED_POSITION_ENCODINGS, convertCharacterOffset, lineTextAt, negotiatePositionEncoding, } from "./position-encoding.js";
 import { getStrategy } from "./wait-policy/index.js";
 import { WatchedFilesQueue } from "./watch-queue.js";
@@ -151,6 +152,10 @@ const WORKSPACE_PULL_RESULT_CACHE_MAX = 4096;
 // stops a hung server from blocking the caller forever. On timeout the command
 // may still be applying server-side; we surface that rather than pretend it ran.
 const EXECUTE_COMMAND_TIMEOUT_MS = positiveIntFromEnv("PI_LENS_LSP_EXECUTE_COMMAND_TIMEOUT_MS", 30_000);
+// #1412 H1: short ceiling for the read-only tsserver project-identity probe.
+// This is a telemetry sample, not a mutation — it must never hold the door
+// open for anything close to EXECUTE_COMMAND_TIMEOUT_MS.
+const PROBE_COMMAND_TIMEOUT_MS = positiveIntFromEnv("PI_LENS_LSP_PROJECT_IDENTITY_PROBE_TIMEOUT_MS", 2_500);
 const LSP_CRASH_CODES = new Set([
     "ERR_STREAM_DESTROYED",
     "ERR_STREAM_WRITE_AFTER_END",
@@ -434,9 +439,16 @@ function getMergedDiagnosticsForPath(state, normalizedPath) {
     return mergeDiagnosticLists(state.pushDiagnostics?.get(normalizedPath) ??
         legacy.diagnostics?.get(normalizedPath), state.documentPullDiagnostics?.get(normalizedPath));
 }
-function clearDiagnosticsForPath(state, normalizedPath) {
+/** Exported for tests: the quiet-window timer cancel on clear/resync is the
+ * headline #1412 safety property (a stale versionless publication must never
+ * land after the document content changed). */
+export function clearDiagnosticsForPath(state, normalizedPath) {
     const legacy = state;
     state.pushDiagnostics?.delete(normalizedPath);
+    const pending = state.pendingDiagnostics?.get(normalizedPath);
+    if (pending)
+        clearTimeout(pending);
+    state.pendingDiagnostics?.delete(normalizedPath);
     state.pushDiagnosticTimestamps?.delete(normalizedPath);
     state.documentPullDiagnostics?.delete(normalizedPath);
     state.documentPullDiagnosticTimestamps?.delete(normalizedPath);
@@ -454,6 +466,32 @@ function clearDiagnosticsForPath(state, normalizedPath) {
     legacy.diagnostics?.delete(normalizedPath);
     legacy.diagnosticTimestamps?.delete(normalizedPath);
 }
+function logTypeScriptPullSettle(state, normalizedPath) {
+    if (state.serverId !== "typescript")
+        return;
+    const diagnostics = state.documentPullDiagnostics.get(normalizedPath) ?? [];
+    const elapsedSinceDidOpenMs = Math.max(0, Date.now() - (state.documentOpenedAt.get(normalizedPath) ?? Date.now()));
+    const diagnosticCodes = [...new Set(diagnostics
+            .map((diagnostic) => diagnostic.code)
+            .filter((code) => code !== undefined)
+            .map(String))].slice(0, 8);
+    logLatency({
+        type: "phase",
+        phase: "lsp_typescript_diagnostic_sequence",
+        filePath: normalizedPath,
+        durationMs: elapsedSinceDidOpenMs,
+        metadata: {
+            launchVariant: state.launchVariant ?? "unknown",
+            publicationIndex: state.diagnosticPublicationCounts.get(normalizedPath) ?? 0,
+            version: null,
+            diagnosticCount: diagnostics.length,
+            diagnosticCodes,
+            elapsedSinceDidOpenMs,
+            settledReturn: true,
+            settleSource: "pull",
+        },
+    });
+}
 /**
  * #1095: fingerprint the EXACT didOpen/didChange payload text at SEND time and
  * tag it with the document version it was sent as, so a later
@@ -558,7 +596,45 @@ export function setupIncomingHandlers(state, initialization) {
                 message: `server=${state.serverId} pubVersion=${docVersion} docVersion=${state.documentVersions?.get(normalizedPath)} diags=${newDiags.length}`,
             });
         }
-        const strategy = getStrategy(state.serverId);
+        const strategy = getStrategy(state.serverId, state.launchVariant);
+        // Publication counting and code extraction exist only for the
+        // TypeScript diagnostic-sequence telemetry; skip the bookkeeping for
+        // every other push server on this hot receive path.
+        const isTypeScriptTelemetry = state.serverId === "typescript";
+        const publicationIndex = isTypeScriptTelemetry
+            ? (state.diagnosticPublicationCounts.get(normalizedPath) ?? 0) + 1
+            : 0;
+        if (isTypeScriptTelemetry) {
+            state.diagnosticPublicationCounts.set(normalizedPath, publicationIndex);
+        }
+        const diagnosticCodes = isTypeScriptTelemetry
+            ? [...new Set(newDiags
+                    .map((diagnostic) => diagnostic.code)
+                    .filter((code) => code !== undefined)
+                    .map(String))].slice(0, 8)
+            : [];
+        const logSequence = (settledReturn, settleSource) => {
+            if (state.serverId !== "typescript")
+                return;
+            const elapsedSinceDidOpenMs = Math.max(0, Date.now() -
+                (state.documentOpenedAt.get(normalizedPath) ?? Date.now()));
+            logLatency({
+                type: "phase",
+                phase: "lsp_typescript_diagnostic_sequence",
+                filePath: normalizedPath,
+                durationMs: elapsedSinceDidOpenMs,
+                metadata: {
+                    launchVariant: state.launchVariant ?? "unknown",
+                    publicationIndex,
+                    version: docVersion ?? null,
+                    diagnosticCount: newDiags.length,
+                    diagnosticCodes,
+                    elapsedSinceDidOpenMs,
+                    settledReturn,
+                    ...(settleSource && { settleSource }),
+                },
+            });
+        };
         // Record the document version these diagnostics were computed against
         // (when the server reports it) so waitForDiagnostics can reject results
         // that lag behind the latest didChange instead of serving them as fresh.
@@ -624,8 +700,10 @@ export function setupIncomingHandlers(state, initialization) {
             recordDocVersion();
             state.diagnosticsVersion += 1;
             state.diagnosticEmitter.emit("diagnostics", normalizedPath);
+            logSequence(true, "first-push");
             return;
         }
+        logSequence(false);
         const existingTimer = state.pendingDiagnostics.get(normalizedPath);
         if (existingTimer)
             clearTimeout(existingTimer);
@@ -638,6 +716,7 @@ export function setupIncomingHandlers(state, initialization) {
             recordDocVersion();
             state.diagnosticsVersion += 1;
             state.diagnosticEmitter.emit("diagnostics", normalizedPath);
+            logSequence(true, "quiet-window");
         }, strategy.debounceMs);
         state.pendingDiagnostics.set(normalizedPath, timer);
     });
@@ -998,10 +1077,12 @@ export async function clientWaitForDiagnostics(state, filePath, timeoutMs, optio
         // version baseline (`minVersion === undefined`), so a failed pull returned
         // 0 and was read as a fresh clean.
         let outcome = await clientRequestPullDiagnostics(state, filePath, timeoutMs);
-        if (outcome.status === "found")
+        if (outcome.status === "found") {
+            logTypeScriptPullSettle(state, normalizedPath);
             return;
+        }
         let sawClean = outcome.status === "clean";
-        const strategy = getStrategy(state.serverId);
+        const strategy = getStrategy(state.serverId, state.launchVariant);
         const retryBudgetMs = strategy.pullRetryBudgetMs > 0
             ? Math.min(timeoutMs, strategy.pullRetryBudgetMs)
             : 0;
@@ -1016,10 +1097,16 @@ export async function clientWaitForDiagnostics(state, filePath, timeoutMs, optio
             if (outcome.status === "clean")
                 sawClean = true;
         }
-        if (options.pullOnly)
+        if (options.pullOnly) {
+            if (outcome.status === "found" || sawClean) {
+                logTypeScriptPullSettle(state, normalizedPath);
+            }
             return;
-        if (outcome.status === "found" || sawClean)
+        }
+        if (outcome.status === "found" || sawClean) {
+            logTypeScriptPullSettle(state, normalizedPath);
             return;
+        }
     }
     if (hasFreshDiagnostics() &&
         !isVersionStale() &&
@@ -1037,7 +1124,7 @@ export async function clientWaitForDiagnostics(state, filePath, timeoutMs, optio
                 clearTimeout(debounceTimer);
             // Adaptive debounce: use time since last push to compute remaining
             // wait instead of always waiting the full debounce window.
-            const strategy = getStrategy(state.serverId);
+            const strategy = getStrategy(state.serverId, state.launchVariant);
             const hit = state.pushDiagnosticTimestamps.get(normalizedPath);
             const timeSincePush = hit ? Date.now() - hit : Infinity;
             const remaining = Math.max(0, strategy.debounceMs - timeSincePush);
@@ -1080,7 +1167,7 @@ export async function handleNotifyOpen(state, filePath, content, languageId, pre
         // Scanners that only re-scan on a fresh open (opengrep ignores didChange):
         // close + reopen so the re-edit actually triggers a re-scan instead of
         // silently publishing nothing.
-        if (getStrategy(state.serverId).reopenOnResync) {
+        if (getStrategy(state.serverId, state.launchVariant).reopenOnResync) {
             await safeSendNotification(state.connection, "textDocument/didClose", {
                 textDocument: { uri },
             });
@@ -1096,6 +1183,8 @@ export async function handleNotifyOpen(state, filePath, content, languageId, pre
             // for a stale view (worse than "unknown"). Monotonic versions make that
             // late echo strictly older → dropped by isSupersededPush → never bound.
             state.documentVersions.set(normalizedPath, version);
+            state.documentOpenedAt.set(normalizedPath, Date.now());
+            state.diagnosticPublicationCounts.set(normalizedPath, 0);
             if (!isClientAlive(state))
                 return;
             await safeSendNotification(state.connection, "textDocument/didOpen", {
@@ -1115,6 +1204,8 @@ export async function handleNotifyOpen(state, filePath, content, languageId, pre
     }
     state.pendingOpens.add(normalizedPath);
     state.documentVersions.set(normalizedPath, 0);
+    state.documentOpenedAt.set(normalizedPath, Date.now());
+    state.diagnosticPublicationCounts.set(normalizedPath, 0);
     clearDiagnosticsForPath(state, normalizedPath); // always clear for initial open
     // Send workspace notification first (like opencode does).
     // Skipped in silent mode — cascade reads a file for diagnostics,
@@ -1149,6 +1240,24 @@ export async function handleNotifyOpen(state, filePath, content, languageId, pre
     state.openDocuments.add(normalizedPath);
     state.closedDocuments?.delete(normalizedPath);
     state.openDocumentUris?.set(normalizedPath, uri);
+    // Telemetry is deliberately detached after didOpen succeeds.
+    // #1412 H1: routed through runReadOnlyServerCommand, NOT runServerCommand —
+    // the probe must never open the serverEditsAllowed/activeMutationContext
+    // mutation-acceptance window; it is a diagnostic sample, not a mutation, and
+    // carries its own short PROBE_COMMAND_TIMEOUT_MS backstop. The probe itself
+    // is classic-only and swallows every failure.
+    void probeTsserverProjectIdentity({
+        serverId: state.serverId,
+        launchVariant: state.launchVariant,
+        clientRoot: state.root,
+        file: filePath,
+        normalizedFile: normalizedPath,
+        probedFiles: state.projectIdentityProbedFiles ??
+            (state.projectIdentityProbedFiles = new Set()),
+        commandChannel: {
+            executeCommand: (command, args) => runReadOnlyServerCommand(state, command, args),
+        },
+    });
 }
 export async function handleNotifyChange(state, filePath, content) {
     if (!isClientAlive(state))
@@ -1162,6 +1271,8 @@ export async function handleNotifyChange(state, filePath, content) {
             textDocument: { uri, languageId: "plaintext", version: 0, text: content },
         });
         state.documentVersions.set(normalizedPath, 0);
+        state.documentOpenedAt.set(normalizedPath, Date.now());
+        state.diagnosticPublicationCounts.set(normalizedPath, 0);
         recordSentContent(state, normalizedPath, 0, content);
         state.openDocuments.add(normalizedPath);
         state.openDocumentUris?.set(normalizedPath, uri);
@@ -1194,6 +1305,13 @@ export async function closeDocument(state, filePath) {
     state.closedDocuments?.add(normalizedPath);
     state.openDocumentUris?.delete(normalizedPath);
     state.documentVersions.delete(normalizedPath);
+    state.documentOpenedAt.delete(normalizedPath);
+    state.diagnosticPublicationCounts.delete(normalizedPath);
+    // #1412 L1: projectIdentityProbedFiles is a claim-once memo scoped to the
+    // document's open lifetime (re-probing a closed-then-reopened file is
+    // harmless and cheap) — mirror openDocuments' own per-close cleanup so it
+    // doesn't grow unbounded across a long session's worth of open/close churn.
+    state.projectIdentityProbedFiles?.delete(normalizedPath);
     clearDiagnosticsForPath(state, normalizedPath);
 }
 export async function clientShutdown(state, options = {}) {
@@ -1208,6 +1326,9 @@ export async function clientShutdown(state, options = {}) {
     state.pendingOpens.clear();
     state.openDocuments.clear();
     state.openDocumentUris?.clear();
+    // #1412 L1: mirror openDocuments' clear — a shut-down/evicted client's
+    // probe memo is moot along with everything else document-scoped.
+    state.projectIdentityProbedFiles?.clear();
     // #271: drop any pending watched-files batch + its timer (a dying client's
     // queued FS changes are moot, and the timer must not outlive the connection).
     state.watchQueue?.cancel();
@@ -1409,6 +1530,43 @@ export async function runServerCommand(state, command, args, timeoutMs = EXECUTE
             state.activeMutationContext = undefined;
     }
 }
+// #1412 H1/H2: read-only sibling of runServerCommand for telemetry/identity
+// probes that must NOT participate in the mutation-acceptance window. Unlike
+// runServerCommand this never touches serverEditsAllowed, activeMutationDepth,
+// or activeMutationContext — a probe firing mid-flight must leave a concurrent
+// real executeCommand's mutation context untouched, and must not itself open
+// the workspace/applyEdit acceptance window (client.ts's applyEdit handler
+// gates on serverEditsAllowed > 0). Preserves the allowlist-by-advertisement
+// invariant. Short PROBE_COMMAND_TIMEOUT_MS backstop — this is a diagnostic
+// sample, not a mutation, and must never hold anything up for anywhere near
+// EXECUTE_COMMAND_TIMEOUT_MS.
+export async function runReadOnlyServerCommand(state, command, args, timeoutMs = PROBE_COMMAND_TIMEOUT_MS) {
+    if (!isClientAlive(state)) {
+        return { executed: false, reason: "lsp client not alive" };
+    }
+    if (!state.advertisedCommands.has(command)) {
+        return {
+            executed: false,
+            reason: `command "${command}" is not advertised by the ${state.serverId} server`,
+        };
+    }
+    try {
+        const result = await withTimeout(safeSendRequest(state.connection, "workspace/executeCommand", {
+            command,
+            arguments: args ?? [],
+        }), timeoutMs);
+        return { executed: true, result };
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.startsWith("Timeout after")) {
+            return {
+                executed: false,
+                reason: `workspace/executeCommand timed out after ${timeoutMs}ms`,
+            };
+        }
+        throw err;
+    }
+}
 function validateWorkspaceEditVersions(state, edit) {
     for (const change of edit.documentChanges ?? []) {
         if (typeof change !== "object" || change === null || !("textDocument" in change))
@@ -1592,6 +1750,8 @@ export async function createLSPClient(options) {
         documentPullDiagnosticTimestamps: new Map(),
         pullFailureHistory: [],
         pendingDiagnostics: new Map(),
+        diagnosticPublicationCounts: new Map(),
+        documentOpenedAt: new Map(),
         diagnosticEmitter,
         diagnosticsVersion: 0,
         documentVersions: new Map(),
@@ -1604,6 +1764,7 @@ export async function createLSPClient(options) {
         closedDocuments: new Set(),
         openDocumentUris: new Map(),
         pendingOpens: new Set(),
+        projectIdentityProbedFiles: new Set(),
         // these are filled in after initialize — cast to avoid two-phase init
         workspaceDiagnosticsSupport: undefined,
         operationSupport: undefined,

package/node_modules/pi-lens/dist/clients/lsp/diagnostic-binding.js

@@ -2,6 +2,35 @@ import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import { PathKeyedMap } from "../path-keyed-map.js";
 import { normalizeEphemeralMapKey } from "../path-utils.js";
+/**
+ * #1470: the single source of truth for "which servers did this touch NOT hear
+ * from". Read this instead of comparing `confirmation` to a string literal — a
+ * consumer that tests `confirmation === "confirmed"` is correct only by accident
+ * (it happens to fail closed for `"partial"`), and one that tests `!inconclusive`
+ * is outright wrong, because a partially-confirmed touch is deliberately NOT
+ * inconclusive: the primary's answer is still trustworthy and must survive.
+ */
+export function touchCoverageGap(result) {
+    return result?.unconfirmedServerIds ?? [];
+}
+/**
+ * #1470: did this touch complete its configured confirmation policy at all —
+ * `"confirmed"` (for every spawned server) or `"partial"` (for every server
+ * except the named cut-off auxiliaries)?
+ *
+ * This is deliberately NOT `confirmation === "confirmed"`. A consumer asking
+ * "did the PRIMARY confirm?" must answer yes for a partial touch: `partial`
+ * implies neither the notify write nor the diagnostics wait lapsed, so the
+ * silent-clean gates ran to completion exactly as they do for a full
+ * confirmation. Reading `=== "confirmed"` there looks safely fail-closed but
+ * reports "the language server could not confirm clean" when the truth is "the
+ * language server confirmed clean and a scanner was cut off" — the same overclaim
+ * pointing the other way. Pair this with {@link touchCoverageGap}, which names
+ * what the touch does not speak for.
+ */
+export function touchCompletedConfirmationPolicy(result) {
+    return result?.confirmation !== undefined;
+}
 /**
  * Fingerprint the EXACT text handed to didOpen/didChange. sha256 over the raw
  * string — no normalization — so the disk comparison (which reads the file with