@herbertgao/pi-extensions 2026.8.5 → 2026.8.6

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

@@ -13,7 +13,7 @@ import path from "node:path";
 import { getGlobalPiLensDir, getProjectIgnoreGlobs, isPathIgnoredByProject, } from "../file-utils.js";
 import { STAGE_TMP_PATTERN } from "../atomic-write-staging.js";
 import { DOTNET_CSHARP_ROOT_MARKERS, DOTNET_FSHARP_ROOT_MARKERS, KIND_EXTENSIONS, } from "../file-kinds.js";
-import { direntsHaveMarkerGlobMatch, isAtOrAboveHomeDir, isFullyQualified, } from "../path-utils.js";
+import { direntsHaveMarkerGlobMatch, isAtOrAboveHomeDir, isFullyQualified, isWindowsPath, } from "../path-utils.js";
 import { ensureTool, getToolEnvironment, getToolPath, } from "../installer/index.js";
 import { resolveOpengrepConfig } from "../opengrep-config.js";
 import { isZizmorAuditTarget, resolveZizmorGitHubToken } from "../zizmor-config.js";
@@ -78,17 +78,22 @@ const PROJECT_BOUNDARY_MARKERS = [
 // with FALLBACK_PROJECT_MARKERS, the shared fallback root-policy marker set.
 const loggedRootCeilingClamps = new Set();
 function isSameOrWithin(ancestor, candidate) {
-    const relative = path.relative(path.resolve(ancestor), path.resolve(candidate));
-    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+    const windowsShaped = isWindowsPath(ancestor) || isWindowsPath(candidate);
+    const pathApi = windowsShaped ? path.win32 : path;
+    const relative = pathApi.relative(pathApi.resolve(ancestor), pathApi.resolve(candidate));
+    return (relative === "" ||
+        (!relative.startsWith("..") && !pathApi.isAbsolute(relative)));
 }
 /** Enforce the session cwd as the hard boundary for LSP client root selection. */
 export function enforceLspRootCeiling(root, sessionCwd, filePath) {
-    const resolvedRoot = path.resolve(root);
-    const resolvedCwd = path.resolve(sessionCwd);
+    const windowsShaped = isWindowsPath(root) || isWindowsPath(sessionCwd);
+    const pathApi = windowsShaped ? path.win32 : path;
+    const resolvedRoot = pathApi.resolve(root);
+    const resolvedCwd = pathApi.resolve(sessionCwd);
     // Callers may explicitly inspect an out-of-session file (notably isolated
     // tests and API consumers). The cwd ceiling governs roots for files that are
     // actually inside the declared session project.
-    if (filePath && !isSameOrWithin(resolvedCwd, path.resolve(filePath))) {
+    if (filePath && !isSameOrWithin(resolvedCwd, pathApi.resolve(filePath))) {
         return resolvedRoot;
     }
     if (isSameOrWithin(resolvedCwd, resolvedRoot))
@@ -717,6 +722,12 @@ export function NearestRoot(includePatterns, excludePatterns, stopDir) {
     // different servers (e.g. TypeScript vs Go) with different marker sets never
     // share entries. vi.resetModules() in tests resets module state between cases.
     const cache = new Map();
+    // Only cache successful hits. Undefined results are NOT cached so that a
+    // newly-created root marker (e.g. package.json or tsconfig.json scaffolded
+    // mid-session by the agent) is detected on the next call — the absent →
+    // present transition must work without a process restart. The uncached
+    // re-walk cost for configless repos is a known trade-off; bounding the
+    // walk with stopDir for in-cwd files is the tracked optimization (#1412).
     const inFlight = new Map();
     return async (file) => {
         // Cache key is the resolved directory — all files in the same dir share a root.
@@ -774,9 +785,6 @@ export function NearestRoot(includePatterns, excludePatterns, stopDir) {
         inFlight.set(dirKey, promise);
         try {
             const result = await promise;
-            // Only cache successful hits. Undefined results are not cached so that
-            // a newly-created root marker (e.g. package.json added mid-session) is
-            // detected on the next call.
             if (result !== undefined)
                 cache.set(dirKey, result);
             return result;
@@ -829,44 +837,173 @@ export async function tryDotnetToolInstall(tool) {
     return !updateResult.error && updateResult.status === 0;
 }
 /**
- * Locate tsserver.js — tries local project, then pi-lens managed TypeScript.
- * Returns the path to tsserver.js, or undefined if not found.
+ * #1412 M1: walk up from `startDir` (inclusive) looking for a file at
+ * `startDir/<relativeSegments>`, `dirname(startDir)/<relativeSegments>`, and so
+ * on — the same ancestor walk `findNativeTypeScriptLsp` uses, bounded the same
+ * way (`isAtOrAboveHomeDir`). A nested config root (e.g. a `cypress/tsconfig.json`
+ * LSP root inside a repo whose `node_modules` only exists at the repo root) must
+ * still resolve tooling installed at an ancestor, not just directly under the
+ * LSP root — mirrors how node module resolution itself walks up.
  */
-async function findTsserverPath(root, allowInstall) {
+async function findAncestorFile(startDir, ...relativeSegments) {
+    return findAncestorFileAmong(startDir, [relativeSegments]);
+}
+/**
+ * Same ancestor walk as `findAncestorFile`, but checks every candidate
+ * relative-path in `candidateSegmentLists` AT EACH LEVEL before moving up —
+ * so the nearest ancestor wins regardless of which candidate name matched
+ * there, matching normal node_modules resolution priority (nearest install
+ * shadows a further one, never the reverse).
+ */
+async function findAncestorFileAmong(startDir, candidateSegmentLists) {
     const fs = await import("node:fs/promises");
-    const candidates = [
-        path.join(root, "node_modules", "typescript", "lib", "tsserver.js"),
-        path.join(process.cwd(), "node_modules", "typescript", "lib", "tsserver.js"),
+    let currentDir = path.resolve(startDir);
+    while (!isAtOrAboveHomeDir(currentDir)) {
+        for (const segments of candidateSegmentLists) {
+            const candidate = path.join(currentDir, ...segments);
+            try {
+                await fs.access(candidate);
+                return candidate;
+            }
+            catch {
+                /* not found at this level */
+            }
+        }
+        const parent = path.dirname(currentDir);
+        if (parent === currentDir)
+            break;
+        currentDir = parent;
+    }
+    return undefined;
+}
+/**
+ * A failed classic-compiler repair must not repeat. `ensureTool` caches
+ * successful installs, so a repair that works short-circuits later calls on
+ * its own. A repair that fails leaves nothing behind, and `findTsserverPath`
+ * has three call sites (TypeScript, Vue, Svelte). Without this guard an
+ * offline or partial install re-runs a 120 s forced reinstall on every spawn.
+ */
+let classicTsRepairAttempted = false;
+/** Test hook — clears the per-process classic-repair guard. */
+export function _resetClassicTsRepairForTests() {
+    classicTsRepairAttempted = false;
+}
+/**
+ * Directories that may hold the TypeScript package next to a resolved `tsc`
+ * binary: `<bin>/../typescript` (npm-global layout) and
+ * `<bin>/../../typescript` (managed `node_modules/.bin` layout).
+ */
+function typescriptDirsForTsc(tscPath) {
+    const binDir = path.dirname(tscPath);
+    return [
+        path.join(binDir, "..", "typescript"),
+        path.join(binDir, "..", "..", "typescript"),
     ];
-    for (const p of candidates) {
+}
+/**
+ * Read the major version of the TypeScript package that backs a resolved
+ * `tsc` binary. Returns undefined when the version is unknowable: `ensureTool`
+ * returns the bare string `"tsc"` for a PATH hit, and `path.dirname("tsc")` is
+ * `"."`, so the candidates would go cwd-relative. Callers must not repair on
+ * an unknown version — a healthy global TypeScript 5.x would be reinstalled
+ * for nothing.
+ */
+async function typescriptVersionForTsc(tscPath) {
+    if (!path.isAbsolute(tscPath))
+        return undefined;
+    for (const dir of typescriptDirsForTsc(tscPath)) {
+        let manifest;
         try {
-            await fs.access(p);
-            return p;
+            manifest = await readFile(path.join(dir, "package.json"), "utf8");
         }
         catch {
-            /* not found */
+            continue;
+        }
+        let version;
+        try {
+            const parsed = JSON.parse(manifest);
+            if (typeof parsed !== "object" ||
+                parsed === null ||
+                !("version" in parsed) ||
+                typeof parsed.version !== "string") {
+                return undefined;
+            }
+            version = parsed.version;
         }
+        catch {
+            return undefined;
+        }
+        const majorText = version.split(".", 1)[0] ?? "";
+        const major = /^\d+$/.test(majorText) ? Number(majorText) : Number.NaN;
+        if (!Number.isFinite(major))
+            return undefined;
+        return { version, major };
     }
-    // Discover the typescript install (PATH / npm-global) even when install is
-    // disabled; only the download is gated by allowInstall.
-    const tscPath = await ensureTool("typescript", {
-        allowInstall: canInstall(allowInstall),
-    });
-    if (tscPath) {
-        for (const p of [
-            path.join(path.dirname(tscPath), "..", "typescript", "lib", "tsserver.js"),
-            path.join(path.dirname(tscPath), "..", "..", "typescript", "lib", "tsserver.js"),
-        ]) {
+    return undefined;
+}
+/**
+ * Locate tsserver.js — tries local project (walking up from root, #1412 M1),
+ * then process.cwd() as a last-resort fallback, then pi-lens managed
+ * TypeScript. Returns the path to tsserver.js, or undefined if not found.
+ */
+async function findTsserverPath(root, allowInstall) {
+    const fs = await import("node:fs/promises");
+    const ancestorHit = await findAncestorFile(root, "node_modules", "typescript", "lib", "tsserver.js");
+    if (ancestorHit)
+        return ancestorHit;
+    const cwdCandidate = path.join(process.cwd(), "node_modules", "typescript", "lib", "tsserver.js");
+    try {
+        await fs.access(cwdCandidate);
+        return cwdCandidate;
+    }
+    catch {
+        /* not found */
+    }
+    const tsserverForTsc = async (tscPath) => {
+        if (!tscPath)
+            return undefined;
+        for (const dir of typescriptDirsForTsc(tscPath)) {
+            const candidate = path.join(dir, "lib", "tsserver.js");
             try {
-                await fs.access(p);
-                return p;
+                await fs.access(candidate);
+                return candidate;
             }
             catch {
                 /* not found */
             }
         }
+        return undefined;
+    };
+    // Discover the TypeScript install (PATH / npm-global) even when installation
+    // is disabled; only the download is gated by allowInstall.
+    const installAllowed = canInstall(allowInstall);
+    const discoveredTsc = await ensureTool("typescript", {
+        allowInstall: installAllowed,
+    });
+    const discoveredTsserver = await tsserverForTsc(discoveredTsc);
+    if (discoveredTsserver ||
+        !discoveredTsc ||
+        !installAllowed ||
+        classicTsRepairAttempted) {
+        return discoveredTsserver;
     }
-    return undefined;
+    // Repair only a compiler we can prove is TypeScript 7+. TypeScript 7 dropped
+    // lib/tsserver.js, so the classic wrapper cannot start against it. Any other
+    // version — or a version we cannot read, such as a bare PATH `tsc` — is left
+    // alone rather than force-reinstalled.
+    const discoveredVersion = await typescriptVersionForTsc(discoveredTsc);
+    if (!discoveredVersion || discoveredVersion.major < 7)
+        return undefined;
+    // An older managed tree took `latest` before the registry pinned the classic
+    // compiler. Reinstall the pinned version once so that tree self-heals,
+    // without deleting user or project-local TypeScript installations.
+    classicTsRepairAttempted = true;
+    logSessionStart(`lsp typescript: managed compiler resolved to TypeScript ${discoveredVersion.version}, which ships no tsserver.js; reinstalling pinned classic fallback`);
+    const repairedTsc = await ensureTool("typescript", {
+        allowInstall: true,
+        forceReinstall: true,
+    });
+    return tsserverForTsc(repairedTsc);
 }
 /**
  * TypeScript 7+ ships the native typescript-go language server through the
@@ -1046,10 +1183,17 @@ export async function detectPythonVenv(root) {
 }
 // --- Server Definitions ---
 const JS_TS_LSP_EXTENSIONS = KIND_EXTENSIONS["jsts"].filter((ext) => ext !== ".svelte" && ext !== ".vue");
-// Marker set used for both the unbounded TypeScriptProjectRoot walk and the
-// extension-bounded walk below. Kept in one place so both code paths look
-// for the same project signals.
-const TS_PROJECT_MARKERS = [
+// TypeScript identity and tooling discovery deliberately use separate marker
+// families. A governing config wins even when a package directory supplies
+// hoisted binaries. Keep configs out of PROJECT_BOUNDARY_MARKERS: #1373 still
+// coalesces a config-only nested root when an ancestor client was hosted first
+// (nested-config-first remains intentionally open-order-sensitive). #1412
+// accepted risk (M2, not fixed here): honoring nested config roots at all
+// enlarges the population of directories that can independently coalesce or
+// diverge under #1373's open-order sensitivity — the same pre-existing
+// blast-radius, just triggered by more roots than before.
+const TS_CONFIG_MARKERS = ["tsconfig.json", "jsconfig.json"];
+const TS_TOOLING_MARKERS = [
     "package-lock.json",
     "bun.lockb",
     "bun.lock",
@@ -1057,21 +1201,71 @@ const TS_PROJECT_MARKERS = [
     "yarn.lock",
     "package.json",
 ];
-const TypeScriptProjectRoot = IgnoreHomeRoot(createRootDetector([...TS_PROJECT_MARKERS]));
+// #1412 M3: tsserver associates jsconfig.json with JS files only (its identity
+// probe reports a jsconfig-governed .ts file as unassociated) — so a TS-family
+// file under a jsconfig-only directory must NOT root there; keep walking up
+// for a real tsconfig.json. A JS-family file accepts either: tsconfig also
+// governs plain JS via `allowJs`, so accepting tsconfig for a .js file is
+// correct, and jsconfig obviously is too.
+const TS_FAMILY_EXTENSIONS = new Set([".ts", ".tsx", ".mts", ".cts"]);
+function isTsFamilyFile(file) {
+    return TS_FAMILY_EXTENSIONS.has(path.extname(file).toLowerCase());
+}
+function tsConfigMarkersForFile(file) {
+    return isTsFamilyFile(file) ? ["tsconfig.json"] : TS_CONFIG_MARKERS;
+}
+// Two detector instances (not one parameterized by file) so each keeps its own
+// per-directory NearestRoot cache valid for its fixed marker set — a shared
+// cache keyed only by directory would conflate the TS-only and either-config
+// answers for the same directory.
+const TypeScriptConfigRootTsOnly = IgnoreHomeRoot(createRootDetector(["tsconfig.json"]));
+const TypeScriptConfigRootEither = IgnoreHomeRoot(createRootDetector([...TS_CONFIG_MARKERS]));
+const TypeScriptToolingRoot = IgnoreHomeRoot(createRootDetector([...TS_TOOLING_MARKERS]));
+async function findTypeScriptProjectRoot(file) {
+    const configDetector = isTsFamilyFile(file)
+        ? TypeScriptConfigRootTsOnly
+        : TypeScriptConfigRootEither;
+    const [configRoot, toolingRoot] = await Promise.all([
+        configDetector(file),
+        TypeScriptToolingRoot(file),
+    ]);
+    if (!configRoot)
+        return toolingRoot;
+    if (!toolingRoot)
+        return configRoot;
+    // A config inside (or beside) the nearest package governs its files. A
+    // config above a nearer package must not erase that topology boundary.
+    return isSameOrWithin(toolingRoot, configRoot) ? configRoot : toolingRoot;
+}
 /**
- * Walk up from the file's directory looking for a TypeScript project marker,
- * but stop at `extensionRootKey` so we never escape the .pi/agent/extensions
- * boundary into a higher-up project (e.g. ~/.pi/agent/package.json which
- * would pull every extension in the directory into one LSP workspace).
+ * Walk up from the file's directory looking for a TypeScript project marker
+ * (a governing config first, per-directory, per #1412 M3's extension-family
+ * filter; else a tooling/lockfile marker), but stop at `extensionRootKey` so
+ * we never escape the .pi/agent/extensions boundary into a higher-up project
+ * (e.g. ~/.pi/agent/package.json which would pull every extension in the
+ * directory into one LSP workspace).
  *
- * Returns the nearest directory containing a marker, or undefined if none
- * is found between the file and the extensions root inclusive.
+ * #1412 L4: each directory returns immediately on its first match (config or
+ * tooling) — there is no cross-level "nearest tooling root" to carry forward,
+ * since a match always wins on the spot. Returns the nearest directory
+ * containing a marker, or undefined if none is found between the file and the
+ * extensions root inclusive.
  */
 async function findExtensionBoundedRoot(file, extensionRootKey) {
     const startDir = path.resolve(path.dirname(file));
     let currentDir = startDir;
+    const configMarkers = tsConfigMarkersForFile(file);
     while (true) {
-        for (const pattern of TS_PROJECT_MARKERS) {
+        for (const pattern of configMarkers) {
+            try {
+                await stat(path.join(currentDir, pattern));
+                return currentDir;
+            }
+            catch {
+                /* not found, try next marker */
+            }
+        }
+        for (const pattern of TS_TOOLING_MARKERS) {
             try {
                 await stat(path.join(currentDir, pattern));
                 return currentDir;
@@ -1102,7 +1296,7 @@ async function hasAgentLevelProjectMarker(extensionRootKey) {
     const agentDir = path.dirname(extensionRootKey);
     if (!agentDir || agentDir === extensionRootKey)
         return false;
-    for (const pattern of TS_PROJECT_MARKERS) {
+    for (const pattern of [...TS_CONFIG_MARKERS, ...TS_TOOLING_MARKERS]) {
         try {
             await stat(path.join(agentDir, pattern));
             return true;
@@ -1133,7 +1327,7 @@ const TypeScriptRoot = DenoExcludeRoot(async (file) => {
         // analyze a lone .ts file with no package.json above or below).
         return undefined;
     }
-    const projectRoot = await TypeScriptProjectRoot(file);
+    const projectRoot = await findTypeScriptProjectRoot(file);
     if (projectRoot)
         return projectRoot;
     return FileDirRoot(file);
@@ -1159,20 +1353,13 @@ export const TypeScriptServer = {
         let source = "direct";
         // TypeScript <=6 uses typescript-language-server + tsserver.js. Prefer a
         // project-local wrapper, then fall back to discovered/managed tooling.
-        let lspPath;
-        const localLsp = path.join(root, "node_modules", ".bin", "typescript-language-server");
-        const localLspCmd = path.join(root, "node_modules", ".bin", "typescript-language-server.cmd");
-        // Check for local version first (Windows .cmd first, then Unix)
-        for (const checkPath of [localLspCmd, localLsp]) {
-            try {
-                await fs.access(checkPath);
-                lspPath = checkPath;
-                break;
-            }
-            catch {
-                /* not found */
-            }
-        }
+        // #1412 M1: walk up from root (Windows .cmd first, then Unix at each
+        // level) — a nested config root's node_modules/.bin lives at an ancestor,
+        // not necessarily directly under the LSP root.
+        let lspPath = await findAncestorFileAmong(root, [
+            ["node_modules", ".bin", "typescript-language-server.cmd"],
+            ["node_modules", ".bin", "typescript-language-server"],
+        ]);
         // Fall back to a discovered or managed install. ensureTool() runs PATH /
         // npm-global discovery even when install is disabled (only the download is
         // gated by canInstall), so a globally-installed typescript-language-server

package/node_modules/pi-lens/dist/clients/lsp/tsserver-sync.js

@@ -32,10 +32,106 @@
  * `undefined`). The caller must handle `undefined` as "sync path unavailable,
  * fall back to existing unconfirmed/timed-out behavior".
  */
+import { logLatency } from "../latency-logger.js";
+import { normalizeMapKey } from "../path-utils.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
 export const TSSERVER_REQUEST_COMMAND = "typescript.tsserverRequest";
+function classifyProjectInfo(body) {
+    if (!body || typeof body !== "object") {
+        return { projectKind: "unassociated", association: "unassociated" };
+    }
+    const info = body;
+    const configFile = typeof info.configFileName === "string" && info.configFileName.length > 0
+        ? info.configFileName
+        : undefined;
+    const inferred = configFile
+        ? /(?:^|[/\\])inferredProject\d*\*?$/i.test(configFile) ||
+            /inferred[-_ ]?project/i.test(configFile)
+        : false;
+    const projectKind = configFile
+        ? inferred
+            ? "inferred"
+            : /(?:^|[/\\])(?:tsconfig|jsconfig)\.json$/i.test(configFile)
+                ? "configured"
+                : "unassociated"
+        : "unassociated";
+    return {
+        projectKind,
+        ...(configFile ? { configFile } : {}),
+        association: info.languageServiceDisabled === true
+            ? "language-service-disabled"
+            : projectKind === "unassociated"
+                ? "unassociated"
+                : "associated",
+    };
+}
+/**
+ * #1412: after classic TypeScript's first successful didOpen, sample the
+ * tsserver project association without delaying diagnostics. The supplied
+ * executeCommand channel owns the existing bounded anti-deadlock backstop.
+ */
+export async function probeTsserverProjectIdentity(options) {
+    const normalizedFile = options.normalizedFile ?? normalizeMapKey(options.file);
+    const startedAt = Date.now();
+    // Logging starts only once a probe is actually eligible and attempted:
+    // ineligible servers (wrong serverId/launchVariant, no command channel) and
+    // already-probed dedupe are both routine, high-volume, and per-server — a
+    // bare return keeps them out of the telemetry stream entirely instead of
+    // writing an `lsp_typescript_project_identity` row per didOpen on every
+    // server (python, go, opengrep, ...).
+    const logOutcome = (outcome, metadata = {}) => logLatency({
+        type: "phase", phase: "lsp_typescript_project_identity", filePath: normalizedFile,
+        durationMs: Date.now() - startedAt,
+        metadata: { serverId: options.serverId, launchVariant: options.launchVariant, clientRoot: options.clientRoot, outcome, ...metadata },
+    });
+    if (options.serverId !== "typescript" ||
+        options.launchVariant !== "classic" ||
+        typeof options.commandChannel.executeCommand !== "function") {
+        return;
+    }
+    if (options.probedFiles.has(normalizedFile))
+        return;
+    // Claim before yielding so concurrent opens cannot issue duplicate probes.
+    options.probedFiles.add(normalizedFile);
+    try {
+        const outcome = await options.commandChannel.executeCommand(TSSERVER_REQUEST_COMMAND, ["projectInfo", { file: options.file, needFileNameList: false }]);
+        if (!outcome.executed) {
+            logOutcome("not-executed");
+            return;
+        }
+        const response = outcome.result;
+        if (!response) {
+            logOutcome("no-response");
+            return;
+        }
+        if (response.success !== true) {
+            logOutcome("unsuccessful");
+            return;
+        }
+        const identity = classifyProjectInfo(response.body);
+        logLatency({
+            type: "phase",
+            phase: "lsp_typescript_project_identity",
+            filePath: normalizedFile,
+            durationMs: Date.now() - startedAt,
+            metadata: {
+                outcome: "ok",
+                serverId: options.serverId,
+                launchVariant: options.launchVariant,
+                clientRoot: options.clientRoot,
+                projectKind: identity.projectKind,
+                configFile: identity.configFile,
+                association: identity.association,
+            },
+        });
+    }
+    catch {
+        logOutcome("threw");
+        // Best-effort telemetry: command errors/timeouts never reach diagnostics.
+    }
+}
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------

package/node_modules/pi-lens/dist/clients/lsp/wait-policy/classification.js

@@ -26,7 +26,7 @@ export function classifyServerWaitTier(serverId, snapshot) {
         return "pull-capable";
     if (mode !== "push-only")
         return "waits";
-    const strategy = getStrategy(serverId);
+    const strategy = getStrategy(serverId, snapshot.launchVariant);
     if (strategy.silentOnClean !== true)
         return "waits"; // 2*/unknown push-only
     // #524/#529/#541/#558: `silentOnClean` on a server-id-keyed strategy is
@@ -44,6 +44,24 @@ export function classifyServerWaitTier(serverId, snapshot) {
         return "waits";
     return "tier3-silent";
 }
+/**
+ * Resolve `filePath`'s PRIMARY (non-auxiliary) server id and its live
+ * capability snapshot, or `undefined` when the file has no primary server
+ * configured. The single place that decides what "this file's server" means
+ * for wait-policy purposes — shared by {@link classifyCascadeWaitTier} and the
+ * cascade-lane wrapper in `clients/lsp/cascade-tier.ts`, which needs the same
+ * id/snapshot pair to apply its one cascade-only override.
+ */
+export function resolvePrimaryServerForWaitPolicy(filePath, snapshots) {
+    const servers = getServersForFileWithConfig(filePath).filter((s) => s.role !== "auxiliary");
+    const primary = servers[0];
+    if (!primary)
+        return undefined;
+    return {
+        serverId: primary.id,
+        snapshot: snapshots.find((s) => s.serverId === primary.id),
+    };
+}
 /**
  * Classify whether `filePath`'s PRIMARY language server is a cascade-lane
  * Tier-3 (push-only, silent-on-clean) server. Ambiguous or missing capability
@@ -54,10 +72,8 @@ export function classifyServerWaitTier(serverId, snapshot) {
  */
 export function classifyCascadeWaitTier(lspService, filePath, snapshots) {
     void lspService; // kept in the signature for call-site clarity/typing only
-    const servers = getServersForFileWithConfig(filePath).filter((s) => s.role !== "auxiliary");
-    const primary = servers[0];
+    const primary = resolvePrimaryServerForWaitPolicy(filePath, snapshots);
     if (!primary)
         return "waits";
-    const snapshot = snapshots.find((s) => s.serverId === primary.id);
-    return classifyServerWaitTier(primary.id, snapshot);
+    return classifyServerWaitTier(primary.serverId, primary.snapshot);
 }

package/node_modules/pi-lens/dist/clients/lsp/wait-policy/strategies.js

@@ -138,7 +138,8 @@ export const SERVER_DIAGNOSTIC_STRATEGIES = {
     // (#242), so on a 2500ms-capped edit opengrep waits min(2500, 3500)=2500
     // and on uncapped paths it gets its full 3500. 3500 covers warm and most
     // cold; a cold scan that overruns isn't lost — late diagnostics are cached
-    // and surface on the next edit.
+    // and surface on the next unchanged-content read through the content-bound
+    // auxiliary carry-over path.
     opengrep: {
         seedFirstPush: false,
         pullRetryBudgetMs: 0,
@@ -174,7 +175,8 @@ export const SERVER_DIAGNOSTIC_STRATEGIES = {
     // reopen-on-resync. A native single-workflow audit is sub-second offline;
     // online mode may add a GitHub-API round-trip, so 2000ms gives headroom
     // (bounded by the per-edit caller cap as a ceiling, #242), and any late online
-    // finding is cached and surfaces on the next edit.
+    // finding can surface on the next unchanged-content read through the
+    // content-bound auxiliary carry-over path.
     zizmor: {
         seedFirstPush: true,
         pullRetryBudgetMs: 0,
@@ -231,6 +233,16 @@ export const SERVER_DIAGNOSTIC_STRATEGIES = {
         silentOnClean: true,
     },
 };
+/** Native TS7 can publish multiple versionless partial-program snapshots for a
+ * single open. Its first push is therefore provisional; a quiet window, rather
+ * than a protocol-unstable publication count, establishes the settled push. */
+const NATIVE_TS7_DIAGNOSTIC_STRATEGY = {
+    ...SERVER_DIAGNOSTIC_STRATEGIES.typescript,
+    seedFirstPush: false,
+    // Native TS7 demonstrably publishes on clean, so the classic-only marker
+    // must not leak through the shared server id.
+    silentOnClean: false,
+};
 /** Fallback for unknown servers. Conservative defaults. */
 export const DEFAULT_STRATEGY = {
     seedFirstPush: false,
@@ -239,6 +251,9 @@ export const DEFAULT_STRATEGY = {
     aggregateWaitMs: 1500,
     expectSemanticSecondPush: false,
 };
-export function getStrategy(serverId) {
+export function getStrategy(serverId, launchVariant) {
+    if (serverId === "typescript" && launchVariant === "native-ts7") {
+        return NATIVE_TS7_DIAGNOSTIC_STRATEGY;
+    }
     return SERVER_DIAGNOSTIC_STRATEGIES[serverId] ?? DEFAULT_STRATEGY;
 }

package/node_modules/pi-lens/dist/clients/mcp/analyze.js

@@ -239,6 +239,10 @@ export async function analyzeFile(filePath, cwd, options = {}) {
     }
     const reportsBefore = getLatencyReports().length;
     const start = Date.now();
+    // No telemetryModel/telemetryProvider here (#1448): this MCP facade has no
+    // RuntimeCoordinator to hold a host-reported identity (see the module doc
+    // above), so any worklog entries this dispatch produces get a blank
+    // model/provider — that's correct, not a gap.
     const result = await dispatchLintWithResult(absPath, cwd, host, undefined, undefined, {
         blockingOnly: options.blockingOnly ?? false,
     });