@herbertgao/pi-extensions 2026.9.1 → 2026.9.3

package/node_modules/pi-lens/dist/clients/tool-cwd.js

@@ -0,0 +1,299 @@
+import * as os from "node:os";
+import { existsSync, readdirSync } from "node:fs";
+import * as path from "node:path";
+import { logExtension } from "./extension-log.js";
+import { isRealGitMarker, isAtOrAboveHomeDir, isUnderDir, isWindowsPath, nameMatchesMarkerGlob, normalizeEphemeralMapKey, } from "./path-utils.js";
+import { getDegradationLedgerGeneration, recordDegradationOnce, } from "./degradation-ledger.js";
+import { createGenerationMap, createGenerationSource, } from "./generation-guard.js";
+export const FORMATTER_MARKERS = {
+    biome: ["biome.json", "biome.jsonc", "package.json", ".gitignore"],
+    prettier: [
+        ".prettierrc",
+        ".prettierrc.json",
+        ".prettierrc.yaml",
+        ".prettierrc.yml",
+        ".prettierrc.js",
+        ".prettierrc.cjs",
+        ".prettierrc.mjs",
+        "prettier.config.js",
+        "prettier.config.cjs",
+        "prettier.config.mjs",
+        ".prettierignore",
+        "package.json",
+        ".gitignore",
+    ],
+    ruff: ["pyproject.toml", "ruff.toml", ".ruff.toml", ".gitignore"],
+    black: ["pyproject.toml", "black.toml", ".black", ".gitignore"],
+    "php-cs-fixer": [".php-cs-fixer.php", ".php-cs-fixer.dist.php", ".gitignore"],
+    sqlfluff: [".sqlfluff", "pyproject.toml", "setup.cfg", ".gitignore"],
+    oxfmt: [
+        "oxfmt.toml",
+        ".oxfmtrc.json",
+        "vite-plus.json",
+        "package.json",
+        ".gitignore",
+    ],
+    rustfmt: ["rustfmt.toml", ".rustfmt.toml", "Cargo.toml", ".gitignore"],
+    rubocop: [".rubocop.yml", ".rubocop.yaml", ".gitignore"],
+    standardrb: [".standard.yml", ".standard.yaml", ".gitignore"],
+    "clang-format": [".clang-format", "_clang-format", ".gitignore"],
+    stylua: ["stylua.toml", ".stylua.toml", ".gitignore"],
+    ocamlformat: [".ocamlformat", ".gitignore"],
+    "google-java-format": [".google-java-format", ".editorconfig", ".gitignore"],
+    cljfmt: [".cljfmt.edn", "cljfmt.edn", ".cljfmt", ".gitignore"],
+    "cmake-format": [
+        ".cmake-format",
+        ".cmake-format.yaml",
+        ".cmake-format.yml",
+        ".cmake-format.json",
+        ".cmake-format.py",
+        "cmake-format.yaml",
+        "cmake-format.yml",
+        ".editorconfig",
+        ".gitignore",
+    ],
+    "psscriptanalyzer-format": [
+        "PSScriptAnalyzerSettings.psd1",
+        "ScriptAnalyzerSettings.psd1",
+        ".gitignore",
+    ],
+    csharpier: [
+        ".csharpierrc",
+        ".csharpierrc.json",
+        ".csharpierrc.yaml",
+        ".csharpierrc.yml",
+        ".gitignore",
+    ],
+    ormolu: [".ormolu", ".gitignore"],
+    taplo: ["taplo.toml", ".taplo.toml", ".gitignore"],
+    terraform: [".terraform.lock.hcl", ".gitignore"],
+    swiftformat: [".swiftformat", ".gitignore"],
+    fantomas: [".fantomasignore", ".editorconfig", ".gitignore"],
+    mix: [".formatter.exs", ".gitignore"],
+    shfmt: [".editorconfig", ".gitignore"],
+    ktlint: [".editorconfig", ".gitignore"],
+    ktfmt: [
+        ".editorconfig",
+        ".ktfmt",
+        ".ktfmt.kts",
+        "build.gradle",
+        "build.gradle.kts",
+        "settings.gradle",
+        "settings.gradle.kts",
+        ".gitignore",
+    ],
+};
+const RUNNER_MARKERS = {
+    yamllint: [".yamllint", "yamllint.yaml", "yamllint.yml", "pyproject.toml"],
+    ruff: ["pyproject.toml", "ruff.toml", ".ruff.toml"],
+    "spellcheck/typos": ["_typos.toml", "typos.toml"],
+    biome: ["biome.json", "biome.jsonc", "package.json"],
+    oxlint: [".oxlintrc.json", "oxlint.config.js", "package.json"],
+    sqlfluff: [".sqlfluff", "pyproject.toml", "setup.cfg"],
+    prettier: [".prettierignore", "package.json"],
+    // #2894: cargo must run at the package root. This is the marker walk
+    // `rust-clippy.ts` used to do for itself with `findNearestContaining`.
+    "rust-clippy": ["Cargo.toml"],
+};
+const toolCwdGeneration = createGenerationSource("tool-cwd");
+const logged = createGenerationMap("tool-cwd-resolution-log");
+const markerWalks = new Map();
+const markerWalkGenerations = createGenerationMap("tool-cwd-marker-walks");
+let markerWalkCount = 0;
+/** Pure key seam for ephemeral tool-cwd memo and log identity. */
+export function _toolCwdEphemeralKey(parts) {
+    return parts.map(normalizeEphemeralMapKey).join("\0");
+}
+/** Test probe for the per-generation walk memo; not part of runtime behavior. */
+export function _getToolCwdMarkerWalkCount() {
+    return markerWalkCount;
+}
+function syncGeneration() {
+    if (toolCwdGeneration.current() === getDegradationLedgerGeneration())
+        return;
+    markerWalks.clear();
+    markerWalkGenerations.clear();
+    logged.clear();
+    while (toolCwdGeneration.current() < getDegradationLedgerGeneration()) {
+        toolCwdGeneration.bump();
+    }
+}
+function findMarkerRoot(startDir, markers, homeDir) {
+    syncGeneration();
+    const key = _toolCwdEphemeralKey([
+        path.resolve(startDir),
+        ...markers,
+        path.resolve(homeDir),
+    ]);
+    const cached = markerWalks.get(key);
+    if (cached && markerWalkGenerations.current(key) !== 0) {
+        // A negative walk is not stable: a project marker can be created after
+        // the first resolution, so do not cache absence across calls. Positive
+        // results remain memoized and are still revalidated when their marker is
+        // deleted (#2894).
+        if (!cached.marker || !cached.root) {
+            markerWalks.delete(key);
+            markerWalkGenerations.forget(key);
+        }
+        else {
+            // #2777: a marker can disappear during a session; do not reuse a stale root.
+            if (existsSync(path.join(cached.root, cached.marker)))
+                return cached;
+            markerWalks.delete(key);
+            markerWalkGenerations.forget(key);
+        }
+    }
+    markerWalkCount++;
+    let current = path.resolve(startDir);
+    let result = { root: null };
+    for (let depth = 0; depth < 64; depth++) {
+        if (isAtOrAboveHomeDir(current, homeDir))
+            break;
+        for (const marker of markers) {
+            const slash = marker.replace(/\\/g, "/").lastIndexOf("/");
+            const parent = slash >= 0 ? marker.slice(0, slash) : "";
+            const basename = slash >= 0 ? marker.slice(slash + 1) : marker;
+            const target = parent
+                ? path.join(current, ...parent.split("/").filter(Boolean))
+                : current;
+            let found = false;
+            if (basename.includes("*")) {
+                try {
+                    found = readdirSync(target, { withFileTypes: true }).some((entry) => (entry.isFile() || entry.isSymbolicLink()) &&
+                        nameMatchesMarkerGlob(entry.name, basename));
+                }
+                catch {
+                    found = false;
+                }
+            }
+            else {
+                found = existsSync(path.join(target, basename));
+            }
+            if (found) {
+                result = { root: current, marker };
+                markerWalks.set(key, result);
+                markerWalkGenerations.bump(key);
+                return result;
+            }
+        }
+        const parentDir = path.dirname(current);
+        if (parentDir === current)
+            break;
+        current = parentDir;
+    }
+    markerWalks.set(key, result);
+    markerWalkGenerations.bump(key);
+    return result;
+}
+function markersFor(kind, tool, ctx) {
+    if (kind === "lsp")
+        return ctx.rootMarkers ?? [];
+    // #2871: caller-supplied markers count for runners too. `RUNNER_MARKERS`
+    // covers the linter/formatter-shaped runners this module has always known;
+    // a caller that owns its own marker table — the test runner, whose
+    // `RUNNERS[x].configFiles` IS that table — passes it here rather than
+    // registering a second copy of the same data in this file.
+    if (kind === "runner")
+        return ctx.rootMarkers ?? RUNNER_MARKERS[tool] ?? [];
+    return FORMATTER_MARKERS[tool] ?? [".gitignore"];
+}
+function emitResolution(kind, tool, cwd, reason) {
+    syncGeneration();
+    const key = _toolCwdEphemeralKey([kind, tool, cwd, reason]);
+    if (logged.current(key) !== 0)
+        return;
+    logged.bump(key);
+    logExtension({
+        subsystem: "tool-cwd",
+        level: "debug",
+        message: `cwd ${kind} ${tool} cwd=${cwd} reason=${reason}`,
+    });
+}
+/**
+ * Emit a constant runner advisory once per (tool, resolved root) per session
+ * (#2811): the yamllint/stylelint/sqlfluff "no config detected" lines and
+ * markdownlint's spawn-timeout cooldown notice logged once PER FILE at error
+ * level — 17 lines in one session for one tool. The throttle shares the
+ * resolution-log map and its ledger-generation reset, so `session_start`
+ * re-arms it like every once-latch in this module. The message rides
+ * `ctx.log` at debug level so the dispatch seam stays the one sink for
+ * runner lines, with its own filePath/kind metadata.
+ */
+export function logRunnerAdvisoryOnce(ctx, tool, root, message) {
+    syncGeneration();
+    const key = _toolCwdEphemeralKey(["runner-advisory", tool, root]);
+    if (logged.current(key) !== 0)
+        return;
+    logged.bump(key);
+    ctx.log(message, "debug");
+}
+/** Resolve every child process cwd/root through one bounded, synchronous seam. */
+export function resolveToolCwd(kind, tool, file, ctx) {
+    const dispatchRoot = path.resolve(ctx.cwd ?? process.cwd());
+    const absoluteFile = path.resolve(file);
+    const fileDir = path.dirname(absoluteFile);
+    const homeDir = ctx.homeDir ?? os.homedir();
+    const insideDispatch = isUnderDir(absoluteFile, dispatchRoot);
+    if (ctx.serverRoot) {
+        const rootPath = isWindowsPath(ctx.serverRoot) ? path.win32 : path;
+        const serverRoot = rootPath.resolve(ctx.serverRoot);
+        if (!ctx.suppressTelemetry)
+            emitResolution(kind, tool, serverRoot, "server-root");
+        return serverRoot;
+    }
+    const markers = markersFor(kind, tool, ctx);
+    const markerResult = markers.length
+        ? findMarkerRoot(fileDir, markers, ctx.allowHomeMarker ? path.parse(homeDir).root : homeDir)
+        : { root: null };
+    const markerRoot = markerResult.root;
+    if (markerRoot &&
+        (insideDispatch ? isUnderDir(markerRoot, dispatchRoot) : true)) {
+        const finalReason = `marker:${markerResult.marker ?? markers[0]}`;
+        if (!ctx.suppressTelemetry)
+            emitResolution(kind, tool, markerRoot, finalReason);
+        return markerRoot;
+    }
+    const gitResult = findMarkerRoot(fileDir, [".git"], homeDir);
+    const gitRoot = gitResult.root && isRealGitMarker(path.join(gitResult.root, ".git"))
+        ? gitResult.root
+        : null;
+    if (gitRoot && (insideDispatch ? isUnderDir(gitRoot, dispatchRoot) : true)) {
+        if (!ctx.suppressTelemetry)
+            emitResolution(kind, tool, gitRoot, "git-root");
+        return gitRoot;
+    }
+    if (insideDispatch) {
+        if (kind === "formatter") {
+            if (!ctx.suppressTelemetry)
+                emitResolution(kind, tool, fileDir, "file-dir-fallback");
+            if (!ctx.suppressTelemetry && !isUnderDir(fileDir, homeDir)) {
+                recordDegradationOnce({
+                    kind: "tool-cwd-resolution",
+                    subject: tool,
+                    reason: `${kind}:home-cap:${absoluteFile}`,
+                });
+            }
+            return fileDir;
+        }
+        if (!ctx.suppressTelemetry)
+            emitResolution(kind, tool, dispatchRoot, "dispatch-root");
+        return dispatchRoot;
+    }
+    const reason = isUnderDir(fileDir, homeDir)
+        ? "file-dir-fallback"
+        : "home-cap";
+    const fallback = isUnderDir(fileDir, homeDir) ? fileDir : homeDir;
+    if (!ctx.suppressTelemetry)
+        recordDegradationOnce({
+            kind: "tool-cwd-resolution",
+            subject: tool,
+            reason: `${kind}:${reason}:${absoluteFile}`,
+        });
+    if (!ctx.suppressTelemetry)
+        emitResolution(kind, tool, fallback, reason);
+    return fallback;
+}
+/** Runner-shaped adapter kept at the same seam for every runner consumer. */
+export function resolveRunnerCwd(ctx, tool) {
+    return resolveToolCwd("runner", tool, ctx.filePath, ctx);
+}

package/node_modules/pi-lens/dist/clients/tool-policy.js

@@ -756,7 +756,7 @@ const FORMATTER_POLICY_BY_FILENAME = new Map(TERRAGRUNT_FILENAMES.map((name) =>
 // lines don't fall at the head of the pre-existing lookup-table duplication and
 // get counted as new duplicated code. Bindings are live, so position is safe.
 export { AUTO_INSTALLABLE_DEFAULT_FORMATTERS, FORMATTER_POLICY_BY_EXTENSION, FORMATTER_POLICY_BY_FILENAME, };
-export function getFormatterPolicyForExtension(ext) {
+function getFormatterPolicyForExtension(ext) {
     return FORMATTER_POLICY_BY_EXTENSION.get(ext.toLowerCase());
 }
 export function getFormatterPolicyForFile(filePath) {

package/node_modules/pi-lens/dist/clients/tool-probe.js

@@ -0,0 +1,53 @@
+/**
+ * The tool-probe spawn seam (#2894).
+ *
+ * A sibling of `tool-cwd.ts`: that module owns where a child that READS A
+ * PROJECT starts, this one owns the fact that a child which reads no project
+ * starts nowhere in particular.
+ *
+ * It is a module of its own rather than another export on `safe-spawn.ts`
+ * deliberately. Every availability test in this repo fakes the process
+ * boundary with `vi.mock("clients/safe-spawn.js", … { safeSpawnAsync })`, and
+ * a same-module helper would call the module's own unmocked binding — the
+ * probe would spawn for real while the test believed it had the boundary. One
+ * module hop keeps every existing double production-faithful.
+ */
+import { safeSpawnAsync } from "./safe-spawn.js";
+/**
+ * Run a tool's own presence/version invocation — `<tool> --version`, `cl`,
+ * `go version`, `which <pm>`, `Get-Module -ListAvailable …` — and hand back
+ * the raw spawn result for the caller's availability policy to classify.
+ *
+ * ## The contract: a probe never gets a `cwd`
+ *
+ * A probe asks whether a binary exists and what it calls itself. The answer
+ * does not depend on the directory the child starts in, so this seam passes
+ * NONE — the child inherits the host's directory and nothing it reports is
+ * read out of a project. That is why the sweep in
+ * `tests/clients/dispatch/runners/runner-spawn-cwd-sweep.test.ts` admits ONE
+ * cwd-less spawn here instead of the 23 it admitted before: every one of those
+ * sites re-decided the same thing in its own words, and 23 sentences a
+ * reviewer has to re-read one at a time is how an admission table stops being
+ * auditable (#2872 round 3 shipped 127 rows carrying two canned sentences,
+ * four of them false where they were read).
+ *
+ * `cwd` is STRIPPED rather than merely left out of {@link ProbeSpawnOptions}:
+ * the type stops an object literal from carrying one, and the destructure
+ * below removes one that arrived inside an already-typed options object a
+ * caller widened or spread. Both halves are guarded — deleting the
+ * destructure changes this call's text, which retires the sweep's admission
+ * row, and `tests/clients/probe-and-root-spawn-cwd.test.ts` reds on the
+ * smuggled cwd reaching the child. A probe that genuinely needs to
+ * run somewhere — `mix credo --version` needs a mix project, `cargo clippy
+ * --version` needs a package, `eslint --version` resolves a project-local
+ * binary — must call `safeSpawnAsync` directly and be admitted by that sweep
+ * on its own reason.
+ */
+export async function probeToolAsync(command, args, options) {
+    // Destructured away rather than overwritten with `undefined`: the key is
+    // then genuinely ABSENT from what reaches the spawn, which is both what the
+    // contract says and what `exactOptionalPropertyTypes` wants (a present
+    // `cwd: undefined` is a strictness spike the `tests/config` ratchet counts).
+    const { cwd: _strippedCwd, ...rest } = (options ?? {});
+    return safeSpawnAsync(command, [...args], { ...rest });
+}

package/node_modules/pi-lens/dist/clients/tool-set-policy.js

@@ -1,4 +1,46 @@
 import { logLatency } from "./latency-logger.js";
+import { BoundedFifoMap } from "./bounded-cache.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+// pi re-runs the extension factory for session rebuilds, but imports this
+// module once per process. Keep conversation activation memory here, keyed by
+// pi's session file rather than by a factory closure or process-wide session.
+export const REMEMBERED_LAZY_TOOLS_MAX_SESSIONS = 128;
+const rememberedLazyToolsBySessionFile = new BoundedFifoMap(REMEMBERED_LAZY_TOOLS_MAX_SESSIONS);
+export function rememberLazyTools(sessionFile, names) {
+    if (!sessionFile) {
+        recordDegradationOnce({
+            kind: "tool-set-session-file-unavailable",
+            subject: "activation",
+            reason: "session-file identity unavailable; activation memory is inert",
+        });
+        return;
+    }
+    const remembered = rememberedLazyToolsBySessionFile.get(sessionFile) ?? new Set();
+    for (const name of names)
+        remembered.add(name);
+    rememberedLazyToolsBySessionFile.set(sessionFile, remembered);
+}
+export function getRememberedLazyTools(sessionFile) {
+    return sessionFile
+        ? (rememberedLazyToolsBySessionFile.get(sessionFile) ?? new Set())
+        : new Set();
+}
+export function clearRememberedLazyTools(sessionFile) {
+    if (sessionFile)
+        rememberedLazyToolsBySessionFile.delete(sessionFile);
+}
+export function inheritRememberedLazyTools(parentSessionFile, childSessionFile) {
+    if (!parentSessionFile ||
+        !childSessionFile ||
+        parentSessionFile === childSessionFile)
+        return;
+    const remembered = rememberedLazyToolsBySessionFile.get(parentSessionFile);
+    if (remembered)
+        rememberedLazyToolsBySessionFile.set(childSessionFile, new Set(remembered));
+}
+export function resetRememberedLazyToolsForTests() {
+    rememberedLazyToolsBySessionFile.clear();
+}
 /**
  * Whether the host will send this model deferred (searchable) tool
  * definitions rather than the full inline list.

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

@@ -80,7 +80,7 @@ function grammarFileStamp(filePath) {
         return undefined;
     }
 }
-export function isTreeSitterWasmAbortError(error) {
+function isTreeSitterWasmAbortError(error) {
     const message = error instanceof Error ? error.message : String(error);
     return message.includes("Aborted") || message.includes("abort()");
 }
@@ -4012,54 +4012,3 @@ export class TreeSitterClient {
     }
 }
 // --- Simplified Pattern Search (regex fallback) ---
-/**
- * Fallback structural search using regex when tree-sitter unavailable
- * Less accurate but works without WASM dependencies
- */
-export function regexStructuralSearch(pattern, files, options = {}) {
-    const matches = [];
-    const maxResults = options.maxResults ?? 50;
-    // Extract pattern structure for regex
-    // "console.log($MSG)" -> /console\.log\(([^)]+)\)/
-    const regexPattern = pattern
-        .replace(/\\/g, "\\\\")
-        .replace(/\./g, "\\.")
-        .replace(/\$\$\$[A-Z_][A-Z0-9_]*/g, "(.*?)") // variadic - non-greedy
-        .replace(/\$[A-Z_][A-Z0-9_]*/g, "([^,)]+)"); // single - capture group
-    try {
-        const regex = new RegExp(regexPattern, "g");
-        for (const file of files) {
-            if (matches.length >= maxResults)
-                break;
-            try {
-                const content = fs.readFileSync(file, "utf-8");
-                const lines = content.split("\n");
-                for (let i = 0; i < lines.length; i++) {
-                    regex.lastIndex = 0;
-                    const match = regex.exec(lines[i]);
-                    if (match) {
-                        const captures = {};
-                        // Extract captures
-                        for (let j = 1; j < match.length; j++) {
-                            captures[`$${j}`] = match[j];
-                        }
-                        matches.push({
-                            file,
-                            line: i + 1,
-                            column: match.index + 1,
-                            matchedText: match[0],
-                            captures,
-                        });
-                        if (matches.length >= maxResults)
-                            break;
-                    }
-                }
-            }
-            catch { }
-        }
-    }
-    catch {
-        // Invalid regex
-    }
-    return matches;
-}

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

@@ -272,7 +272,15 @@ export class TrivyClient extends SecurityScanClient {
             const findings = parseTrivyReport(raw);
             const secrets = parseTrivySecrets(raw);
             const licenses = parseTrivyLicenses(raw);
-            return { success: true, findings, secrets, licenses, scannedAt };
+            // #2154: the one trivy site that parsed a scan of this root.
+            return {
+                success: true,
+                analyzed: true,
+                findings,
+                secrets,
+                licenses,
+                scannedAt,
+            };
         }
         catch (err) {
             return {

package/node_modules/pi-lens/dist/clients/tui-fit.js

@@ -18,10 +18,6 @@
 import { truncateToWidth } from "./deps/pi-tui.js";
 const ELLIPSIS_KIND = { "…": 0, "...": 1, "": 2 };
 let truncateIsNative = null;
-/** Test-only: reset the signature probe between test cases. */
-export function _resetTruncateProbeForTests() {
-    truncateIsNative = null;
-}
 export function fitLine(s, maxWidth, ellipsis = "...") {
     const w = Math.max(0, maxWidth);
     const fn = truncateToWidth;

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

@@ -0,0 +1,52 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { getProcessSingleton } from "./process-singletons.js";
+const FAMILY = "turn-context";
+const VERSION = 2;
+function state() {
+    return getProcessSingleton(FAMILY, VERSION, () => ({
+        sessions: new Map(),
+        activeSession: new AsyncLocalStorage(),
+    }));
+}
+function sessionState(sessionId) {
+    const current = state();
+    let session = current.sessions.get(sessionId);
+    if (!session) {
+        session = { turnId: `${sessionId}:0`, turnIndex: 0 };
+        current.sessions.set(sessionId, session);
+    }
+    return session;
+}
+/** Reset the emit identity before a new session can publish rows. */
+export function resetTurnContext(sessionId) {
+    const current = state();
+    if (sessionId === undefined)
+        return;
+    current.sessions.set(sessionId, { turnId: `${sessionId}:0`, turnIndex: 0 });
+}
+/** Ensure a stable host session has a counter without changing detached identity. */
+export function setTurnContextSession(sessionId) {
+    const stableSessionId = sessionId?.trim();
+    if (stableSessionId !== undefined && stableSessionId !== "")
+        sessionState(stableSessionId);
+}
+/** Mint the one id shared by every row emitted during this turn. */
+export function beginTurnContext(sessionId) {
+    const session = sessionState(sessionId);
+    session.turnIndex += 1;
+    session.turnId = `${sessionId}:${session.turnIndex}`;
+    return session.turnId;
+}
+/** Run a host event with the session identity that owns its writes. */
+export function runWithTurnContext(sessionId, fn) {
+    if (sessionId === undefined)
+        return fn();
+    return state().activeSession.run(sessionId, fn);
+}
+export function getTurnId() {
+    const current = state();
+    const sessionId = current.activeSession.getStore();
+    if (sessionId === undefined)
+        return "turn:0";
+    return sessionState(sessionId).turnId;
+}

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

@@ -32,10 +32,6 @@ export function wireUserNotifier(portsOrGetter) {
 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

package/node_modules/pi-lens/dist/clients/widget-state.js

@@ -358,7 +358,7 @@ observedAt) {
     // #555 guard.
     const key = fileMapKey(filePath);
     if (!diagnosticsWriteGuard.shouldWrite(key, writeIndex))
-        return;
+        return false;
     // Keep runner state ordered with the final diagnostic replacement. The
     // guards are deliberately advanced in both directions because either verb
     // may be the first completion from a pipeline.
@@ -369,6 +369,7 @@ observedAt) {
     const observedTs = observedAt ?? Date.now();
     const rec = getOrCreate(filePath, key);
     commitDiagnostics(rec, filePath, normalizeDiagnostics(filePath, diagnostics, observedTs), observedTs, key);
+    return true;
 }
 /** Map the raw diagnostic shape callers pass into stored {@link WidgetDiagnostic}s.
  * Every produced entry is stamped with `observedTs` (#1186) — the time THIS batch
@@ -605,8 +606,8 @@ export function reconcileCascadeNeighborLspErrors(filePath, lspErrorDiagnostics,
  */
 export function reconcileScanDiagnostics(filePath, diagnostics, confirmed, writeIndex, observedAt) {
     if (!confirmed)
-        return;
-    recordDiagnostics(filePath, diagnostics, writeIndex, observedAt);
+        return false;
+    return recordDiagnostics(filePath, diagnostics, writeIndex, observedAt);
 }
 /**
  * Commit the already-correlated result of a full diagnostics scan.

package/node_modules/pi-lens/dist/clients/word-index-logger.js

@@ -47,10 +47,3 @@ export function logWordIndex(entry) {
         cwd: normalizeFilePath(entry.cwd),
     });
 }
-export function getWordIndexLogPath() {
-    return WORD_INDEX_LOG_FILE;
-}
-/** Resolve once all enqueued word-index writes are on disk (tests/shutdown). */
-export function flushWordIndexLog() {
-    return writer.flush();
-}

package/node_modules/pi-lens/dist/clients/word-index-store.js

@@ -30,8 +30,8 @@ import { createDeadline, yieldIfOverBudget, } from "./cooperative-budget.js";
 /**
  * Bytes of backing store per posting entry: one `fileId` lane and one `line`
  * lane, both `Int32`. This is the constant #2069's acceptance criterion is
- * written against, and {@link estimatePostingListBytes} is the arithmetic the
- * memory-sample record and the regression test both read.
+ * written against, and the arithmetic the memory-sample record and the
+ * regression test both read.
  */
 export const WORD_POSTING_ENTRY_BYTES = 8;
 /**
@@ -189,10 +189,6 @@ export class WordPostingList {
         return list;
     }
 }
-/** Estimated bytes one posting list holds, backing store plus fixed headers. */
-export function estimatePostingListBytes(list) {
-    return list.byteLength + WORD_POSTING_LIST_OVERHEAD_BYTES;
-}
 /**
  * Re-home every posting list into ONE shared `ArrayBuffer`, exactly sized.
  *
@@ -405,7 +401,7 @@ export class WordForwardEntry {
  * Bytes per forward entry: one pointer-compressed slot for the shared token
  * string and one `Int32` count lane.
  */
-export const WORD_FORWARD_ENTRY_BYTES = 8;
+const WORD_FORWARD_ENTRY_BYTES = 8;
 /**
  * The word index's dense file-id space: canonical path key → integer id →
  * display path.