@herbertgao/pi-extensions 2026.9.1 → 2026.9.3

package/node_modules/pi-lens/dist/clients/lsp/inferred-project.js

@@ -55,7 +55,7 @@ const TYPESCRIPT_DIAGNOSTIC_SOURCES = new Set(["typescript", "ts", "tsserver"]);
 export function isTsProjectFile(filePath) {
     return TS_PROJECT_EXTENSIONS.has(path.extname(filePath).toLowerCase());
 }
-export function isTypeScriptSourcedDiagnostic(d) {
+function isTypeScriptSourcedDiagnostic(d) {
     return TYPESCRIPT_DIAGNOSTIC_SOURCES.has((d.source ?? "").toLowerCase());
 }
 /**

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

@@ -61,11 +61,3 @@ export function getLanguageId(filePath) {
         LANGUAGE_EXTENSIONS[base.toLowerCase()] ??
         getBasenameLanguageId(base));
 }
-/**
- * Get all extensions for a language ID
- */
-export function getExtensionsForLanguage(languageId) {
-    return Object.entries(LANGUAGE_EXTENSIONS)
-        .filter(([, id]) => id === languageId)
-        .map(([ext]) => ext);
-}

package/node_modules/pi-lens/dist/clients/lsp/path-utils.js

@@ -2,4 +2,4 @@
  * Re-export from shared path-utils.
  * Kept as a local module for LSP imports that use relative paths.
  */
-export { isUnderDir, normalizeFilePath, normalizeEphemeralMapKey, normalizeMapKey, pathsEqual, pathToUri, uriToDiskPath, uriToPath, } from "../path-utils.js";
+export { isUnderDir, normalizeEphemeralMapKey, normalizeMapKey, pathsEqual, uriToDiskPath, uriToPath, } from "../path-utils.js";

package/node_modules/pi-lens/dist/clients/lsp/pending-aux-coverage.js

@@ -187,8 +187,6 @@ export function drainPendingAuxiliaryCoverage() {
 export function pendingAuxiliaryCoverageSize() {
     return pending.size;
 }
-/** Test-only alias for the store-size assertion seam. */
-export const pendingAuxiliaryCoverageSizeForTests = pendingAuxiliaryCoverageSize;
 /**
  * Drain (read and reset) the cap-eviction count accumulated since the last
  * drain. Mirrors {@link drainPendingAuxiliaryCoverage}'s consume-once shape

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

@@ -26,6 +26,8 @@ import { logSessionStart } from "../sessionstart-logger.js";
 import { findLocalSgconfig, resolveBaselineSgconfig } from "../sgconfig.js";
 import { findLocalTyposConfig } from "../typos-config.js";
 import { resolvePackagePath } from "../package-root.js";
+import { resolveToolCwd } from "../tool-cwd.js";
+import { recordDegradationOnce } from "../degradation-ledger.js";
 import { hasCargoWorkspaceTable, readCargoWorkspaceExclude, readCargoWorkspaceMembers, readTextFileOrUndefined, } from "../cargo-manifest.js";
 import { resolveAstGrepNativeExe } from "./wait-policy/index.js";
 import { hasSpawnFailureKind, isCommandAvailableAsync, safeSpawnAsync, } from "../safe-spawn.js";
@@ -36,6 +38,48 @@ import { normalizeMapKey } from "./path-utils.js";
 import { getRubyVersionDirNamesSync } from "./ruby-drive-dirs.js";
 import { getProcessSingleton } from "../process-singletons.js";
 import { createGenerationSource, } from "../generation-guard.js";
+function withRootMarkers(root, markers) {
+    root.rootMarkers = markers;
+    return root;
+}
+/** Resolve a server identity cwd through the shared tool-cwd seam. */
+export async function resolveLspServerCwd(server, filePath, sessionCwd, onRootFailure) {
+    const rootMarkers = server.rootMarkers ?? server.root.rootMarkers;
+    let serverRoot;
+    let rootFailed = false;
+    try {
+        serverRoot = await server.root(filePath);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        rootFailed = true;
+        onRootFailure?.(reason);
+    }
+    const isFileDirFallback = serverRoot !== undefined &&
+        rootMarkers?.length &&
+        path.resolve(serverRoot) === path.resolve(path.dirname(filePath));
+    if (!serverRoot || isFileDirFallback) {
+        if (!serverRoot) {
+            recordDegradationOnce({
+                kind: "tool-cwd-resolution",
+                subject: server.id,
+                reason: `lsp:server-root-${rootFailed ? "failed" : "fallback"}:${filePath}`,
+            });
+        }
+        if (!rootMarkers?.length)
+            return undefined;
+        return resolveToolCwd("lsp", server.id, filePath, {
+            cwd: path.dirname(path.resolve(filePath)),
+            rootMarkers,
+        });
+    }
+    const boundedServerRoot = enforceLspRootCeiling(serverRoot, sessionCwd, filePath);
+    return resolveToolCwd("lsp", server.id, filePath, {
+        cwd: sessionCwd,
+        rootMarkers,
+        serverRoot: boundedServerRoot,
+    });
+}
 const FIXTURE_ROOT_SEGMENTS = new Set(["__fixtures__", "testdata"]);
 const FALLBACK_PROJECT_MARKERS = [
     ".git",
@@ -845,12 +889,12 @@ function normalizeRootKey(root) {
 }
 function IgnoreHomeRoot(primary) {
     const homeKey = normalizeRootKey(os.homedir());
-    return async (file) => {
+    return withRootMarkers(async (file) => {
         const root = await primary(file);
         if (!root)
             return undefined;
         return normalizeRootKey(root) === homeKey ? undefined : root;
-    };
+    }, primary.rootMarkers ?? []);
 }
 function rubyBinCandidates(baseName) {
     const candidates = [];
@@ -879,6 +923,7 @@ function createInteractiveServer(spec) {
         name: spec.name,
         extensions: spec.extensions,
         root: spec.root,
+        rootMarkers: spec.root.rootMarkers,
         fallbackFor: spec.fallbackFor,
         availabilityKey: typeof spec.command === "string" && isSimpleCommand(spec.command)
             ? spec.command
@@ -917,29 +962,29 @@ function createInteractiveServer(spec) {
 }
 export function PriorityRoot(markerGroups, excludePatterns, stopDir) {
     const resolvers = markerGroups.map((markers) => NearestRoot(markers, excludePatterns, stopDir));
-    return async (file) => {
+    return withRootMarkers(async (file) => {
         for (const resolve of resolvers) {
             const root = await resolve(file);
             if (root)
                 return root;
         }
         return undefined;
-    };
+    }, markerGroups.flat());
 }
 export const FileDirRoot = async (file) => {
     const candidate = path.resolve(path.dirname(file));
     return nearestNonExcludedFallbackRoot(candidate);
 };
 export function RootWithFallback(primary, fallback = FileDirRoot) {
-    return async (file) => {
+    return withRootMarkers(async (file) => {
         const primaryRoot = await primary(file);
         if (primaryRoot)
             return primaryRoot;
         return fallback(file);
-    };
+    }, primary.rootMarkers ?? []);
 }
 export function WorkspacePriorityRoot(markerGroups, excludePatterns) {
-    return async (file) => PriorityRoot(markerGroups, excludePatterns, process.cwd())(file);
+    return withRootMarkers(async (file) => PriorityRoot(markerGroups, excludePatterns, process.cwd())(file), markerGroups.flat());
 }
 function isPermissionFsError(err) {
     const code = err?.code;
@@ -1010,7 +1055,7 @@ export function NearestRoot(includePatterns, excludePatterns, stopDir) {
     // 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) => {
+    return withRootMarkers(async (file) => {
         // Cache key is the resolved directory — all files in the same dir share a root.
         const startDir = path.resolve(path.dirname(file));
         const dirKey = normalizeMapKey(startDir);
@@ -1052,6 +1097,7 @@ export function NearestRoot(includePatterns, excludePatterns, stopDir) {
                 // glob markers like `*.csproj` match real project filenames (#201).
                 for (const pattern of includePatterns) {
                     if ((await markerExists(currentDir, pattern)) &&
+                        (pattern !== ".git" || currentDir !== os.tmpdir()) &&
                         !(await isExcludedLspRoot(currentDir))) {
                         return enforceLspRootCeiling(currentDir, process.cwd(), file);
                     }
@@ -1073,7 +1119,7 @@ export function NearestRoot(includePatterns, excludePatterns, stopDir) {
         finally {
             inFlight.delete(dirKey);
         }
-    };
+    }, includePatterns);
 }
 /** Alias kept for backward compatibility */
 export const createRootDetector = NearestRoot;
@@ -1579,7 +1625,7 @@ async function hasAgentLevelProjectMarker(extensionRootKey) {
     }
     return false;
 }
-const TypeScriptRoot = DenoExcludeRoot(async (file) => {
+const TypeScriptRoot = withRootMarkers(DenoExcludeRoot(async (file) => {
     const extensionRootKey = piAgentExtensionsRootKey(file);
     if (extensionRootKey) {
         // Bounded walk so we never adopt a parent (e.g. ~/.pi/agent/) as the
@@ -1603,13 +1649,14 @@ const TypeScriptRoot = DenoExcludeRoot(async (file) => {
     if (projectRoot)
         return projectRoot;
     return FileDirRoot(file);
-});
+}), [...TS_CONFIG_MARKERS, ...TS_TOOLING_MARKERS]);
 export const TypeScriptServer = {
     id: "typescript",
     name: "TypeScript Language Server",
     extensions: JS_TS_LSP_EXTENSIONS,
     autoPropagateDiagnostics: true,
     root: TypeScriptRoot,
+    rootMarkers: TypeScriptRoot.rootMarkers,
     async spawn(root, options) {
         const fs = await import("node:fs/promises");
         const nativeLsp = await findNativeTypeScriptLsp(root);
@@ -1919,7 +1966,7 @@ function sessionHoistCeiling(sessionCwd, file) {
 }
 function RustWorkspaceRoot() {
     const crateRoot = createRootDetector(["Cargo.toml", "Cargo.lock"]);
-    return async (file) => {
+    return withRootMarkers(async (file) => {
         const root = await crateRoot(file);
         if (!root)
             return undefined;
@@ -1958,7 +2005,7 @@ function RustWorkspaceRoot() {
             current = parent;
         }
         return root;
-    };
+    }, crateRoot.rootMarkers ?? []);
 }
 /**
  * Resolve whether `parentPomPath`'s <modules> block declares `childDir` as one
@@ -2011,7 +2058,7 @@ function JavaWorkspaceRoot() {
         "build.gradle",
         ".classpath",
     ]);
-    return async (file) => {
+    return withRootMarkers(async (file) => {
         const root = await moduleRoot(file);
         if (!root)
             return undefined;
@@ -2051,7 +2098,7 @@ function JavaWorkspaceRoot() {
             current = parent;
         }
         return enforceLspRootCeiling(lastHop, sessionCwd, file);
-    };
+    }, moduleRoot.rootMarkers ?? []);
 }
 export const RustServer = {
     id: "rust",

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

@@ -16,7 +16,6 @@
  * always sent, so an unrecognized/absent value never regresses `Full`/`None`
  * behavior.
  */
-export const TEXT_DOCUMENT_SYNC_KIND_NONE = 0;
 export const TEXT_DOCUMENT_SYNC_KIND_FULL = 1;
 export const TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL = 2;
 function isSyncKind(value) {

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

@@ -37,7 +37,7 @@ import { normalizeMapKey } from "../path-utils.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
-export const TSSERVER_REQUEST_COMMAND = "typescript.tsserverRequest";
+const TSSERVER_REQUEST_COMMAND = "typescript.tsserverRequest";
 /**
  * tsserver's synthetic inferred-project name, as its own source builds it:
  * `"/dev/null/inferredProject" + counter + "*"`. `/dev/null` is a deliberate
@@ -219,13 +219,13 @@ export async function fetchTsserverProjectIdentity(svc, file) {
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
-export function isTsserverSyncRawDiagnostic(value) {
+function isTsserverSyncRawDiagnostic(value) {
     if (!value || typeof value !== "object")
         return false;
     const v = value;
     return typeof v.message === "string" && typeof v.category === "string";
 }
-export function tsserverSeverityFromCategory(category) {
+function tsserverSeverityFromCategory(category) {
     switch (category) {
         case "error":
             return 1;
@@ -242,7 +242,7 @@ export function tsserverSeverityFromCategory(category) {
  * `LSPDiagnostic`. Both `line`/`offset` are 1-based in tsserver's protocol
  * and 0-based in LSP — this conversion handles that.
  */
-export function tsserverSyncDiagnosticToLsp(d) {
+function tsserverSyncDiagnosticToLsp(d) {
     const startLine = Math.max(0, (d.startLocation?.line ?? 1) - 1);
     const startChar = Math.max(0, (d.startLocation?.offset ?? 1) - 1);
     const endLine = Math.max(0, (d.endLocation?.line ?? d.startLocation?.line ?? 1) - 1);
@@ -265,7 +265,7 @@ export function tsserverSyncDiagnosticToLsp(d) {
  * executed, the response envelope isn't `{success:true, body:[...]}`, or
  * any error is thrown.
  */
-export async function runTsserverSyncCommand(svc, file, command) {
+async function runTsserverSyncCommand(svc, file, command) {
     if (typeof svc.executeCommand !== "function")
         return undefined;
     const outcome = await svc.executeCommand(file, TSSERVER_REQUEST_COMMAND, [

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

@@ -24,6 +24,12 @@ export function classifyServerWaitTier(serverId, snapshot) {
     const mode = snapshot.workspaceDiagnosticsSupport?.mode;
     if (mode === "pull")
         return "pull-capable";
+    if (snapshot.customServer === true &&
+        mode === "push-only" &&
+        snapshot.diagnosticsUnsupported === true &&
+        snapshot.diagnosticsPublished !== true) {
+        return "diagnostics-unsupported";
+    }
     if (mode !== "push-only")
         return "waits";
     const strategy = getStrategy(serverId, snapshot.launchVariant);

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

@@ -73,6 +73,7 @@ export function resolveAstGrepNativeExe(platform = process.platform, arch = proc
         return undefined;
     }
 }
+/** @public — loaded by scripts/probe-clean-signal.mjs through a dynamic import wrapper knip cannot see. */
 export const SERVER_DIAGNOSTIC_STRATEGIES = {
     typescript: {
         seedFirstPush: true,
@@ -287,7 +288,7 @@ const NATIVE_TS7_DIAGNOSTIC_STRATEGY = {
     silentOnClean: false,
 };
 /** Fallback for unknown servers. Conservative defaults. */
-export const DEFAULT_STRATEGY = {
+const DEFAULT_STRATEGY = {
     seedFirstPush: false,
     pullRetryBudgetMs: 250,
     debounceMs: 150,

package/node_modules/pi-lens/dist/clients/lsp/workspace-diagnostics-cache.js

@@ -8,6 +8,7 @@ import { normalizeMapKey } from "../path-utils.js";
 import { loadReverseDependencyIndexFromSnapshot } from "../reverse-deps.js";
 import { freshnessFromMtime } from "../freshness.js";
 import { logLatency } from "../latency-logger.js";
+import { recordDegradationOnce } from "../degradation-ledger.js";
 import { compareOrdinal } from "../string-utils.js";
 import { workspaceDiagnosticsCacheSessionStart } from "./workspace-diagnostics-session.js";
 import { createDiskBindingCache, } from "./diagnostic-binding.js";
@@ -31,12 +32,17 @@ import { createDiskBindingCache, } from "./diagnostic-binding.js";
  * `LSPWorkspaceDiagnosticResult.timedOut` in `./index.ts`) into
  * `WorkspaceDiagnosticsCacheEntry`.
  */
+// v3 (#2776): cached diagnostics must carry per-diagnostic `serverId`
+// provenance before replay, because primary/auxiliary partitioning is
+// server-owned rather than source-owned. v2 entries predate that contract and
+// are rejected so the owning server can re-collect them instead of silently
+// demoting old primary findings to auxiliary.
 // v2 (#1095): entries may carry an optional `contentHash` fingerprint of the
 // file bytes the cached diagnostics were computed against, so a `lookup` can
 // surface a content `binding` (boundToCurrentDisk) beyond the mtime proxy.
 // Legacy v1 entries are rejected by the version guard and re-scanned — a
 // deliberately clean break so no entry lacking the field is ever served.
-export const WORKSPACE_DIAGNOSTICS_CACHE_VERSION = 2;
+export const WORKSPACE_DIAGNOSTICS_CACHE_VERSION = 3;
 const CACHE_FILE = "lsp-workspace-diagnostics.json";
 function cachePath(cwd) {
     return path.join(getProjectDataDir(cwd), "cache", CACHE_FILE);
@@ -161,11 +167,34 @@ export function loadWorkspaceDiagnosticsCache(cwd) {
         if (!parsed || typeof parsed !== "object")
             return undefined;
         const cache = parsed;
-        if (cache.version !== WORKSPACE_DIAGNOSTICS_CACHE_VERSION)
+        if (cache.version !== WORKSPACE_DIAGNOSTICS_CACHE_VERSION) {
+            if (cache.version === 1 || cache.version === 2) {
+                recordDegradationOnce({
+                    kind: "lsp-workspace-cache-migration",
+                    subject: path.resolve(cwd),
+                    reason: `rejected v${cache.version} cache with ${cache.entries && typeof cache.entries === "object"
+                        ? Object.keys(cache.entries).length
+                        : 0} entries during provenance migration`,
+                });
+            }
             return undefined;
+        }
         if (!cache.entries || typeof cache.entries !== "object")
             return undefined;
-        return cache;
+        const validEntries = {};
+        for (const [key, entry] of Object.entries(cache.entries)) {
+            if (!entry || typeof entry !== "object")
+                continue;
+            if (!Array.isArray(entry.diagnostics) ||
+                entry.diagnostics.some((diagnostic) => !diagnostic ||
+                    typeof diagnostic !== "object" ||
+                    typeof diagnostic.serverId !== "string" ||
+                    diagnostic.serverId.length === 0)) {
+                continue;
+            }
+            validEntries[key] = entry;
+        }
+        return { ...cache, entries: validEntries };
     });
 }
 export function saveWorkspaceDiagnosticsCache(cwd, cache) {
@@ -470,6 +499,9 @@ export function createWorkspaceDiagnosticsCacheContext(cwd) {
         depIndexColdRefusalCount = 0;
     };
     return {
+        importsFor(filePath) {
+            return getImports(filePath);
+        },
         lookup(filePath, scopeKey) {
             // #1669 review N4: the epoch guarded `persist()` but not `lookup()` —
             // an in-flight sweep kept REPLAYING disowned entries into its OWN
@@ -552,11 +584,12 @@ export function createWorkspaceDiagnosticsCacheContext(cwd) {
             };
         },
         record(filePath, scopeKey, diagnostics, mtimeMs, contentHash, sizeBytes) {
+            const scanGeneration = Date.now();
             entries[cacheKeyFor(filePath)] = {
                 diagnostics,
                 count: diagnostics.length,
                 mtimeMs,
-                scannedAt: Date.now(),
+                scannedAt: scanGeneration,
                 scopeKey,
                 // #1793: stamp whether THIS FILE actually had dependency
                 // knowledge this sweep (not just whether SOME index was

package/node_modules/pi-lens/dist/clients/lsp-document-symbols.js

@@ -2,7 +2,7 @@ import { getLSPService } from "./lsp/index.js";
 // Grounded against this repo's workspace-native TypeScript 7.0.2 server
 // (`tsc --lsp --stdio`) on 2026-07-30: 20 already-open documentSymbol calls
 // measured p50 3.70 ms / p95 5.28 ms. Keep generous headroom for slower hosts.
-export const LSP_DOCUMENT_SYMBOL_TIMEOUT_MS = 150;
+const LSP_DOCUMENT_SYMBOL_TIMEOUT_MS = 150;
 export const SYMBOL_KIND_NAMES = {
     1: "file",
     2: "module",

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

@@ -367,6 +367,9 @@ export async function analyzeFile(filePath, cwd, options = {}) {
     const lspRunner = latencyReport?.runners.find((runner) => runner.runnerId === "lsp");
     const lsp = lspRunner
         ? {
+            // `deferred` means the runner entered the LSP path but its auxiliary
+            // coverage is delivered later, so it still counts as ran here. The
+            // status remains available to surfaces that need the coverage detail.
             ran: lspRunner.status !== "skipped" &&
                 lspRunner.status !== "when_skipped" &&
                 lspRunner.status !== "test_file_skipped",

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

@@ -30,6 +30,7 @@ import { RuntimeCoordinator } from "../runtime-coordinator.js";
 import { handleSessionStart } from "../runtime-session.js";
 import { handleTurnEnd } from "../runtime-turn.js";
 import { createMcpHost } from "./host-shim.js";
+import { startSituationalToolTelemetrySession } from "../situational-tool-telemetry.js";
 let contextPromise;
 let resolvedRuntime;
 /**
@@ -79,6 +80,7 @@ function joinMessages(consumed) {
  * `pilens_health` afterwards for the scan results as they land.
  */
 export async function runSessionStart(cwd) {
+    startSituationalToolTelemetrySession("mcp");
     const ctx = await getMcpSessionContext();
     const host = createMcpHost(undefined, cwd);
     await handleSessionStart({

package/node_modules/pi-lens/dist/clients/metrics-history.js

@@ -93,7 +93,7 @@ export function loadHistory() {
 /**
  * Save history to disk
  */
-export function saveHistory(history) {
+function saveHistory(history) {
     const historyDir = getProjectDataDir(process.cwd());
     if (!fs.existsSync(historyDir)) {
         fs.mkdirSync(historyDir, { recursive: true });
@@ -161,10 +161,35 @@ export function captureSnapshot(filePath, metrics) {
     }, SAVE_DEBOUNCE_MS);
     saveTimer.unref?.();
 }
+// --- Trend Analysis ---
 /**
- * Capture snapshots for multiple files (explicit, immediate save)
- * Used by /lens-metrics for batch capture
+ * Compute trend direction from history snapshots
+ * Uses last 3 snapshots for stability (or 2 if only 2 available)
  */
+function computeTrend(history) {
+    if (history.length < 2)
+        return "stable";
+    const recent = history.slice(-3);
+    const first = recent[0];
+    const last = recent[recent.length - 1];
+    // Use MI as primary indicator, cognitive as secondary
+    const miDelta = last.mi - first.mi;
+    const cogDelta = last.cognitive - first.cognitive;
+    // Thresholds (MI changes < 2 are noise)
+    if (miDelta > 2)
+        return "improving";
+    if (miDelta < -2)
+        return "regressing";
+    // If MI is stable, check cognitive
+    if (cogDelta < -10)
+        return "improving";
+    if (cogDelta > 10)
+        return "regressing";
+    return "stable";
+}
+// --- Technical Debt Index (TDI) ---
+// Test-reached through a child-process `require` string
+/** @public — reached through a child-process `require` string in tests/clients/metrics-history-stderr.test.ts; knip cannot see it. */
 export function captureSnapshots(files) {
     const history = loadHistory();
     for (const file of files) {
@@ -200,110 +225,6 @@ export function captureSnapshots(files) {
     saveHistory(history);
     return history;
 }
-// --- Trend Analysis ---
-/**
- * Compute trend direction from history snapshots
- * Uses last 3 snapshots for stability (or 2 if only 2 available)
- */
-export function computeTrend(history) {
-    if (history.length < 2)
-        return "stable";
-    const recent = history.slice(-3);
-    const first = recent[0];
-    const last = recent[recent.length - 1];
-    // Use MI as primary indicator, cognitive as secondary
-    const miDelta = last.mi - first.mi;
-    const cogDelta = last.cognitive - first.cognitive;
-    // Thresholds (MI changes < 2 are noise)
-    if (miDelta > 2)
-        return "improving";
-    if (miDelta < -2)
-        return "regressing";
-    // If MI is stable, check cognitive
-    if (cogDelta < -10)
-        return "improving";
-    if (cogDelta > 10)
-        return "regressing";
-    return "stable";
-}
-/**
- * Get delta between current snapshot and previous
- */
-export function getDelta(history) {
-    if (!history || history.history.length < 2)
-        return null;
-    const current = history.history[history.history.length - 1];
-    const previous = history.history[history.history.length - 2];
-    return {
-        mi: Math.round((current.mi - previous.mi) * 10) / 10,
-        cognitive: current.cognitive - previous.cognitive,
-        trend: history.trend,
-    };
-}
-/**
- * Get trend emoji for display
- */
-export function getTrendEmoji(trend) {
-    switch (trend) {
-        case "improving":
-            return "📈";
-        case "regressing":
-            return "📉";
-        default:
-            return "➡️";
-    }
-}
-/**
- * Get trend summary across all files
- */
-export function getTrendSummary(history) {
-    let improving = 0;
-    let regressing = 0;
-    let stable = 0;
-    const regressions = [];
-    for (const [file, fileHistory] of Object.entries(history.files)) {
-        switch (fileHistory.trend) {
-            case "improving":
-                improving++;
-                break;
-            case "regressing": {
-                regressing++;
-                const delta = getDelta(fileHistory);
-                if (delta) {
-                    regressions.push({ file, miDelta: delta.mi });
-                }
-                break;
-            }
-            default:
-                stable++;
-        }
-    }
-    // Sort regressions by MI delta (worst first)
-    regressions.sort((a, b) => a.miDelta - b.miDelta);
-    return {
-        improving,
-        regressing,
-        stable,
-        worstRegressions: regressions.slice(0, 5),
-    };
-}
-/**
- * Format trend for metrics table
- */
-export function formatTrendCell(filePath, history) {
-    const relativePath = path.relative(process.cwd(), filePath);
-    const fileHistory = history.files[relativePath];
-    if (!fileHistory || fileHistory.history.length < 2) {
-        return "—"; // No history
-    }
-    const delta = getDelta(fileHistory);
-    if (!delta)
-        return "—";
-    const emoji = getTrendEmoji(delta.trend);
-    const miSign = delta.mi > 0 ? "+" : "";
-    const miColor = delta.mi > 0 ? "🟢" : delta.mi < 0 ? "🔴" : "⚪";
-    return `${emoji} ${miColor}${miSign}${delta.mi}`;
-}
 /**
  * Calculate Technical Debt Index for the project.
  * Score: 0 = perfect, 100 = maximum debt.

package/node_modules/pi-lens/dist/clients/middle-man-analysis.js

@@ -159,7 +159,7 @@ function isAccessorLine(rawLine) {
  * extracted data — no re-parsing, no file I/O beyond the lines already read
  * by the caller.
  */
-export function analyzeMiddleMan(classEntry, lines, languageId) {
+function analyzeMiddleMan(classEntry, lines, languageId) {
     if (!languageId)
         return undefined;
     const selfSpec = SELF_TOKEN[languageId];

package/node_modules/pi-lens/dist/clients/module-report.js

@@ -48,7 +48,7 @@ import { symbolExtractionGrammar, TreeSitterSymbolExtractor, } from "./tree-sitt
 // lsp.ts) to be re-homed in #236, where LSP writes provenance-tagged edges INTO
 // the review graph (computed once, persisted) so this path just reads them.
 /** Hard payload bound for the per-symbol who-uses-this section. */
-export const MAX_MODULE_REPORT_REFS = 100;
+const MAX_MODULE_REPORT_REFS = 100;
 function normalizeMaxRefsPerSymbol(value) {
     if (value === undefined || !Number.isFinite(value))
         return 10;

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

@@ -113,7 +113,7 @@ function asRecord(value) {
  * field list the seam classifies with — a second spelling list would arm on
  * inputs the seam cannot resolve, and miss ones it can.
  */
-export function resolveMutationPath(input) {
+function resolveMutationPath(input) {
     for (const key of ["path", "filePath", "file_path"]) {
         const value = input[key];
         if (typeof value === "string" && value.length > 0)
@@ -141,7 +141,7 @@ export function readMutationPathField(event) {
  * base62 anchor — handled by `clients/hashline-anchor.ts`. Do not reach for
  * this function there.
  */
-export function parseHashlineAnchor(anchor) {
+function parseHashlineAnchor(anchor) {
     if (typeof anchor !== "string")
         return undefined;
     const trimmed = anchor.trim();
@@ -153,7 +153,7 @@ export function parseHashlineAnchor(anchor) {
     return Number.isInteger(line) && line > 0 ? line : undefined;
 }
 /** Bounding box plus per-range detail for a multi-range edit. */
-export function combineRanges(ranges) {
+function combineRanges(ranges) {
     const starts = ranges.map(([start]) => start);
     const ends = ranges.map(([, end]) => end);
     return {