@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/clients/startup-scan.js

@@ -1,400 +0,0 @@
-/**
- * Startup scan safety — gates eager cache warmups to real project roots.
- *
- * Prevents pi-lens from scanning $HOME or generic directories at session
- * start, which would hang or produce meaningless results.
- *
- * Credit: alexx-ftw (PR #1)
- */
-import * as os from "node:os";
-import * as path from "node:path";
-import { BoundedLruCache } from "./bounded-cache.js";
-import { normalizeMapKey } from "./path-utils.js";
-import { lazyEnvNumber } from "./env-utils.js";
-import { getProjectIgnoreMatcher, } from "./file-utils.js";
-import { isAtOrAboveHomeDir } from "./path-utils.js";
-import { getStartupScanMaxSourceFilesDerived } from "./project-scale.js";
-import { shouldRecurseIntoDir, walkTreeStackAsync, walkTreeStackSync, } from "./source-walker.js";
-import { getDirectoryMarkers, registerWorkspaceTopologyReset, } from "./workspace-topology.js";
-const PROJECT_ROOT_MARKERS = [
-    ".git",
-    "package.json",
-    "pyproject.toml",
-    "Cargo.toml",
-    "go.mod",
-    "composer.json",
-];
-// #758: hard ceiling on the number of directory entries the startup source
-// count walk will visit before it gives up and declares the tree too big to
-// a project has MANY source files — a repo with FEW source files but a huge
-// pile of non-source files (e.g. a game mod: 300 scripts among 84k data files)
-// never trips it, so the pre-#758 walk traversed the entire tree, dominated by
-// one ignoreMatcher.isIgnored() call per entry, blocking session_start for
-// seconds. Capping total entries bounds that worst case deterministically. The
-// same pattern already guards jscpd-client.ts's hasSourceFilesRecursive walk.
-export const MAX_STARTUP_SCAN_ENTRIES = 50_000;
-const SOURCE_FILE_PATTERN = /\.(ts|tsx|js|jsx|py|go|rs|rb)$/;
-// Default TTL for a persisted `too-many-source-files` verdict (#699): 24h.
-const DEFAULT_STARTUP_SCAN_VERDICT_TTL_MS = 24 * 60 * 60 * 1000;
-/**
- * How long a persisted `too-many-source-files` verdict stays reusable before
- * a session re-walks the tree to refresh it (#699).
- *
- * Resolution order: `PI_LENS_STARTUP_SCAN_VERDICT_TTL_MS` env var, else the
- * 24h default. Lazy + memoized (via `lazyEnvNumber`, #763) so importing this
- * module never touches `process.env` at load time (house style — see
- * `runtime-config.ts` / `slow-fs.ts` / `subagent-mode.ts`).
- */
-const _ttl = lazyEnvNumber("PI_LENS_STARTUP_SCAN_VERDICT_TTL_MS", DEFAULT_STARTUP_SCAN_VERDICT_TTL_MS);
-export const getStartupScanVerdictTtlMs = _ttl.get;
-/** Test-only: clears the memoized TTL so a subsequent call re-reads the env
- * var (matching the `_resetForTests` convention). */
-export const _resetStartupScanVerdictTtlForTests = _ttl._resetForTests;
-/**
- * Total directory-entry ceiling for the startup source-count walk (#758).
- *
- * Resolution order: `PI_LENS_STARTUP_SCAN_MAX_ENTRIES` env var, else the
- * `MAX_STARTUP_SCAN_ENTRIES` default. Lazy + memoized (via `lazyEnvNumber`,
- * #763) so importing this module never touches `process.env` at load time
- * (same house style as `getStartupScanVerdictTtlMs`).
- */
-const _maxEntries = lazyEnvNumber("PI_LENS_STARTUP_SCAN_MAX_ENTRIES", MAX_STARTUP_SCAN_ENTRIES);
-export const getStartupScanMaxEntries = _maxEntries.get;
-/** Test-only: clears the memoized entry cap so a subsequent call re-reads the
- * env var (matching the `_resetForTests` convention). */
-export const _resetStartupScanMaxEntriesForTests = _maxEntries._resetForTests;
-/**
- * Whether a persisted startup-scan verdict is still safe to reuse without
- * re-walking the project tree (#699).
- *
- * The content-derived reasons `too-many-source-files` and `too-many-entries`
- * (#758) are the ones that are TTL'd. They can go stale on their own: the repo
- * can shrink below the source-file cap (or below the entry ceiling)
- * between sessions, and nothing else would notice
- * — the seq-based freshness check that guards every other
- * `project-snapshot.json` field never fires for them, because pi-lens never
- * writes anything while `canWarmCaches` is false, so the snapshot's seq
- * never advances on its own. Trade-off, by design: a shrunk repo recovers
- * automatically once the TTL expires and the next session re-walks, in
- * exchange for skipping a walk that (per #699) can cost 17s+ on a large
- * monorepo, on every single process start, for a result nothing could use.
- *
- * `home-dir` / `no-project-root` describe the resolved root's location
- * relative to $HOME, not its contents, so they don't drift the same way —
- * reused indefinitely here (still gated by the snapshot's own seq-freshness
- * check upstream). `canWarmCaches: true` verdicts aren't TTL'd by this
- * function either; a fresh snapshot's `seq` match already implies the
- * project state hasn't moved since it warmed successfully.
- *
- * Fails closed on a verdict with no `computedAt` (e.g. hand-written test
- * fixture, or a pre-#699 snapshot) — treated as stale so it gets refreshed
- * rather than trusted indefinitely.
- */
-export function isStartupScanVerdictFresh(verdict, now = Date.now()) {
-    if (verdict.reason !== "too-many-source-files" &&
-        verdict.reason !== "too-many-entries")
-        return true;
-    if (typeof verdict.computedAt !== "number")
-        return false;
-    return now - verdict.computedAt < getStartupScanVerdictTtlMs();
-}
-/**
- * Nearest ancestor (inclusive) of `startDir` containing any of
- * `PROJECT_ROOT_MARKERS`, or `null` if none found before the filesystem root.
- *
- * #807: the per-directory marker check now reads through
- * `workspace-topology.ts`'s `getDirectoryMarkers` (one cached `readdir` per
- * directory) instead of doing `PROJECT_ROOT_MARKERS.length` separate
- * `existsSync` stats per directory — same dedup win as the rest of the #806
- * migration. Deliberately NOT routed through the topology service's
- * home-guarded `findNearestDirWithMarker`/`findNearestDirWithAnyBasename`
- * walkers, though: this function's callers (`computeStartupScanContext` /
- * `resolveStartupScanContextAsync`, below) need the ACTUAL directory a marker
- * resolved to — including one AT or ABOVE `$HOME` — to tell the
- * `"home-dir"` verdict apart from `"no-project-root"` and to populate
- * `scanRoot`/`projectRoot` for diagnostics (see the `startup-scan-home-ceiling`
- * tests: a marker found in an ancestor of `$HOME` must still be *returned*
- * here, with the home rejection applied by the caller). A guarded walker that
- * stops before ever looking at/above `$HOME` would go blind exactly where
- * this function's contract requires it to keep looking, silently turning a
- * `"home-dir"` verdict into `"no-project-root"`. The walk-UP loop itself
- * therefore stays hand-written, unbounded by `$HOME`/depth, matching its
- * pre-#807 behavior exactly.
- */
-export function findNearestProjectRoot(startDir) {
-    let current = path.resolve(startDir);
-    while (true) {
-        const entryNames = getDirectoryMarkers(current).entryNames;
-        if (PROJECT_ROOT_MARKERS.some((marker) => entryNames.has(marker))) {
-            return current;
-        }
-        const parent = path.dirname(current);
-        if (parent === current)
-            return null;
-        current = parent;
-    }
-}
-/**
- * Per-entry step of the source-count walk (#761), plugged into both the sync
- * and async {@link walkTreeStackSync}/`Async` drivers, which differ only in
- * yield cadence. Applies both bounds in their historical order:
- *   - `limit`: source-file early-exit (existing behavior) — fires as soon as
- *     more than `limit` source files are seen.
- *   - `maxEntries`: total directory-entry ceiling (#758) — fires as soon as
- *     `maxEntries` entries have been visited (`visited >= maxEntries`, checked
- *     AFTER classification), flagging `entryBudgetExceeded` so a mixed
- *     source/non-source tree can't drag the walk across the whole tree.
- * The source-limit check precedes the entry-budget check, so an entry that
- * trips both stops as a source-limit hit (`entryBudgetExceeded` stays false).
- *
- * Directories here never check for generated-artifact names. Symlinked
- * directories are NEVER traversed — not by policy but by classification
- * (#775 audit follow-up): `fs.Dirent` reports a symlink-to-directory as
- * `isSymbolicLink() === true` / `isDirectory() === false` (junctions
- * included), so such entries fall through to the file branch below and are
- * merely counted as entries. The `followSymlinks: true` passed to
- * `shouldRecurseIntoDir` is therefore inert here; a symlink cycle cannot
- * hang this walk. Pinned by tests/clients/startup-scan-symlink-cycle.test.ts.
- */
-function makeSourceCountVisitor(state, ignoreMatcher, limit, maxEntries) {
-    return (entry, fullPath) => {
-        state.visited += 1;
-        if (entry.isDirectory()) {
-            const recurse = shouldRecurseIntoDir(entry, fullPath, {
-                ignoreMatcher,
-                followSymlinks: true,
-            });
-            if (state.visited >= maxEntries) {
-                state.entryBudgetExceeded = true;
-                return "stop";
-            }
-            return recurse ? "recurse" : "skip";
-        }
-        // #1974: extension-pattern gate before isIgnored — isIgnored recompiles
-        // minimatch patterns per ancestor dir per call, so it should only run for
-        // entries the cheap regex already flags as source.
-        if (entry.isFile() &&
-            SOURCE_FILE_PATTERN.test(entry.name) &&
-            !ignoreMatcher.isIgnored(fullPath, false)) {
-            state.count += 1;
-            if (state.count > limit)
-                return "stop";
-        }
-        if (state.visited >= maxEntries) {
-            state.entryBudgetExceeded = true;
-            return "stop";
-        }
-        return "skip";
-    };
-}
-/**
- * Core synchronous source-count walk shared by the public
- * `countSourceFilesWithinLimit` wrapper and `computeStartupScanContext`.
- * Bounds are documented on `makeSourceCountVisitor`.
- */
-function walkSourceCount(dir, limit, maxEntries) {
-    const state = {
-        count: 0,
-        visited: 0,
-        entryBudgetExceeded: false,
-    };
-    const rootDir = path.resolve(dir);
-    const ignoreMatcher = getProjectIgnoreMatcher(rootDir);
-    walkTreeStackSync(rootDir, makeSourceCountVisitor(state, ignoreMatcher, limit, maxEntries));
-    return { count: state.count, entryBudgetExceeded: state.entryBudgetExceeded };
-}
-export function countSourceFilesWithinLimit(dir, limit) {
-    // Public wrapper keeps its pre-#758 contract: only the source-file limit
-    // bounds it (no entry ceiling). The #758 entry budget applies solely to the
-    // startup-scan verdict path via `walkSourceCount`.
-    return walkSourceCount(dir, limit, Number.POSITIVE_INFINITY).count;
-}
-// Session-lifetime memo for the (cwd, homeDir, maxSourceFiles) tuple. The
-// underlying computation walks the entire project root counting source
-// files and is dominated by ignoreMatcher.isIgnored() calls; on a 2k-file
-// project it costs ~2-3s the first time. The topology-reset registry clears
-// this memo at session start, so each session re-derives its answer. The memo
-// remains valid until the next session-start reset.
-const startupScanContextCache = new BoundedLruCache(32);
-registerWorkspaceTopologyReset(() => startupScanContextCache.clear());
-function startupScanCacheKey(cwd, options) {
-    return [
-        normalizeMapKey(path.resolve(cwd)),
-        options.homeDir ? normalizeMapKey(path.resolve(options.homeDir)) : "",
-        options.maxSourceFiles ?? "",
-        options.maxScanEntries ?? "",
-    ].join("|");
-}
-export const __testing = { startupScanCacheKey };
-export function resolveStartupScanContext(cwd, options = {}) {
-    const cacheKey = startupScanCacheKey(cwd, options);
-    const cached = startupScanContextCache.get(cacheKey);
-    if (cached)
-        return cached;
-    const result = {
-        ...computeStartupScanContext(cwd, options),
-        computedAt: Date.now(),
-    };
-    startupScanContextCache.set(cacheKey, result);
-    return result;
-}
-function computeStartupScanContext(cwd, options = {}) {
-    const resolvedCwd = path.resolve(cwd);
-    const homeDir = path.resolve(options.homeDir ?? os.homedir());
-    const maxSourceFiles = options.maxSourceFiles ?? getStartupScanMaxSourceFilesDerived(resolvedCwd);
-    const maxScanEntries = options.maxScanEntries ?? getStartupScanMaxEntries();
-    const projectRoot = findNearestProjectRoot(resolvedCwd);
-    if (!projectRoot) {
-        return {
-            cwd: resolvedCwd,
-            scanRoot: resolvedCwd,
-            projectRoot: null,
-            canWarmCaches: false,
-            reason: isAtOrAboveHomeDir(resolvedCwd, homeDir)
-                ? "home-dir"
-                : "no-project-root",
-        };
-    }
-    // A marker resolved at $HOME — OR at an ancestor of it (e.g. /home,
-    // C:\Users) — means the upward search escaped the workspace; warming caches
-    // would walk an unrelated tree (#250/#253). The old exact `=== homeDir`
-    // check missed the above-home case.
-    if (isAtOrAboveHomeDir(projectRoot, homeDir)) {
-        return {
-            cwd: resolvedCwd,
-            scanRoot: projectRoot,
-            projectRoot,
-            canWarmCaches: false,
-            reason: "home-dir",
-        };
-    }
-    const { count: sourceFileCount, entryBudgetExceeded } = walkSourceCount(projectRoot, maxSourceFiles, maxScanEntries);
-    if (sourceFileCount > maxSourceFiles || entryBudgetExceeded) {
-        return {
-            cwd: resolvedCwd,
-            scanRoot: projectRoot,
-            projectRoot,
-            canWarmCaches: false,
-            reason: entryBudgetExceeded
-                ? "too-many-entries"
-                : "too-many-source-files",
-            sourceFileCount,
-        };
-    }
-    return {
-        cwd: resolvedCwd,
-        scanRoot: projectRoot,
-        projectRoot,
-        canWarmCaches: true,
-        sourceFileCount,
-    };
-}
-// ---------------------------------------------------------------------------
-// Async, chunked-yield counterparts used by the cold-start warmup pipeline
-// (see runtime-session.ts handleSessionStart). The synchronous variants above
-// block the Node event loop for the full duration of the project walk, which
-// is fine when called from a non-interactive code path but freezes the TUI
-// when called during `session_start`. These async variants do the same work
-// but yield control via `await new Promise(setImmediate)` every N directory
-// entries, so stdin handlers (i.e. keystrokes) stay responsive.
-//
-// They share the same memo (`startupScanContextCache`) as their sync siblings,
-// so whichever runs first warms the cache for the other. By design the
-// warmup pipeline runs the async version 2s after a cold-start "quick" return,
-// then the user's first /new sees a sync-path cache hit and skips the work
-// entirely.
-// ---------------------------------------------------------------------------
-/**
- * Async core of the source-count walk (the yield-cadence twin of
- * `walkSourceCount`). Same visitor and two bounds — `limit` (source files) and
- * `maxEntries` (total entries, #758) — driven through the shared
- * {@link walkTreeStackAsync} engine (#761), which yields via `setImmediate`
- * every `yieldEvery` entries to keep `session_start` keystrokes responsive.
- */
-async function walkSourceCountAsync(dir, limit, maxEntries, opts = {}) {
-    const state = {
-        count: 0,
-        visited: 0,
-        entryBudgetExceeded: false,
-    };
-    const rootDir = path.resolve(dir);
-    const ignoreMatcher = getProjectIgnoreMatcher(rootDir);
-    await walkTreeStackAsync(rootDir, makeSourceCountVisitor(state, ignoreMatcher, limit, maxEntries), {
-        // Yield every 100 entries by default. Empirically each yield costs
-        // ~0.1ms of overhead and a 2k-file project produces ~20 yields, so the
-        // total async overhead is well under 5ms while keeping per-burst sync
-        // work under 50ms (the perceptual threshold for "instant" keystrokes).
-        budgetMs: opts.budgetMs ?? 8,
-        // #703: prime the tracked-files set ONCE before the walk (not per file)
-        // so a tracked file matching a `.gitignore`/global pattern isn't dropped
-        // from the startup source-file count. Fail-open: resolves even when git
-        // is absent, and `isIgnored` degrades to pattern-only if this never
-        // resolves before a caller inspects results.
-        beforeWalk: () => ignoreMatcher.ensureTrackedIndex(),
-    });
-    return { count: state.count, entryBudgetExceeded: state.entryBudgetExceeded };
-}
-export async function countSourceFilesWithinLimitAsync(dir, limit, opts = {}) {
-    // Public wrapper keeps its pre-#758 contract: only the source-file limit
-    // bounds it (no entry ceiling).
-    return (await walkSourceCountAsync(dir, limit, Number.POSITIVE_INFINITY, opts)).count;
-}
-export async function resolveStartupScanContextAsync(cwd, options = {}) {
-    const cacheKey = startupScanCacheKey(cwd, options);
-    const cached = startupScanContextCache.get(cacheKey);
-    if (cached)
-        return cached;
-    const resolvedCwd = path.resolve(cwd);
-    const homeDir = path.resolve(options.homeDir ?? os.homedir());
-    const maxSourceFiles = options.maxSourceFiles ?? getStartupScanMaxSourceFilesDerived(resolvedCwd);
-    const maxScanEntries = options.maxScanEntries ?? getStartupScanMaxEntries();
-    const projectRoot = findNearestProjectRoot(resolvedCwd);
-    let result;
-    if (!projectRoot) {
-        result = {
-            cwd: resolvedCwd,
-            scanRoot: resolvedCwd,
-            projectRoot: null,
-            canWarmCaches: false,
-            reason: isAtOrAboveHomeDir(resolvedCwd, homeDir)
-                ? "home-dir"
-                : "no-project-root",
-        };
-    }
-    else if (isAtOrAboveHomeDir(projectRoot, homeDir)) {
-        result = {
-            cwd: resolvedCwd,
-            scanRoot: projectRoot,
-            projectRoot,
-            canWarmCaches: false,
-            reason: "home-dir",
-        };
-    }
-    else {
-        const { count: sourceFileCount, entryBudgetExceeded } = await walkSourceCountAsync(projectRoot, maxSourceFiles, maxScanEntries);
-        if (sourceFileCount > maxSourceFiles || entryBudgetExceeded) {
-            result = {
-                cwd: resolvedCwd,
-                scanRoot: projectRoot,
-                projectRoot,
-                canWarmCaches: false,
-                reason: entryBudgetExceeded
-                    ? "too-many-entries"
-                    : "too-many-source-files",
-                sourceFileCount,
-            };
-        }
-        else {
-            result = {
-                cwd: resolvedCwd,
-                scanRoot: projectRoot,
-                projectRoot,
-                canWarmCaches: true,
-                sourceFileCount,
-            };
-        }
-    }
-    result = { ...result, computedAt: Date.now() };
-    startupScanContextCache.set(cacheKey, result);
-    return result;
-}

package/node_modules/pi-lens/dist/clients/startup-timing.js

@@ -1,130 +0,0 @@
-import { performance } from "node:perf_hooks";
-// #1434 S3d: import the constant from the side-effect-free module, not from
-// `console-guard-install.ts` — that module installs the console guard as an
-// import side effect, so importing it here (for a single constant, from a
-// module measuring load time) would have silently installed the guard
-// wherever this file is imported, including test-only measurement code that
-// has no business flipping a global switch.
-import { PI_LENS_EVAL_STARTED_MS } from "./eval-timestamp.js";
-import { getProcessSingleton, nextModuleEvaluationOrdinal, } from "./process-singletons.js";
-/**
- * Startup timing for pi-lens.
- *
- * `performance.now()` is measured relative to `performance.timeOrigin`, which
- * is the moment the host pi process started. Capturing it the instant pi-lens
- * has finished loading therefore yields the wall-clock cost of pi loading +
- * (under source mode) jiti-transpiling every pi-lens module before any of our
- * code runs. With the precompiled `dist/` (#182) that transpile cost is gone,
- * so this number is how we verify the startup win instead of guessing at it.
- */
-/** "dist" when pi-lens loaded from compiled JS, "source" when jiti-transpiled. */
-export const PI_LENS_LOADED_FROM = import.meta.url.endsWith(".js")
-    ? "dist"
-    : "source";
-// `loadMs`/`loadedAtMs` deliberately stay at module scope: they measure THIS
-// evaluation's own load cost, so a second evaluation must get its own numbers
-// rather than adopt the first's (#2146 class sweep — per-evaluation by design).
-let loadMs;
-let loadedAtMs;
-/**
- * The host-ready anchor is a once-PER-PROCESS latch, so it lives on the shared
- * process singleton (#2146). Left at module scope it was consumed once per
- * module evaluation, which meant a nine-evaluation process could emit the
- * "first session" host-ready delay nine times.
- */
-const HOST_READY_ANCHOR_FAMILY = "startup-timing.host-ready-anchor";
-const HOST_READY_ANCHOR_VERSION = 1;
-function hostReadyAnchorState() {
-    return getProcessSingleton(HOST_READY_ANCHOR_FAMILY, HOST_READY_ANCHOR_VERSION, () => ({ consumed: false }));
-}
-/**
- * 1-based count of pi-lens module-graph evaluations in this process (#2146).
- *
- * Captured at module scope so it advances exactly once per evaluation, and
- * carried on `host_boot.metadata.evaluationOrdinal` so multi-evaluation hosts
- * are greppable in `latency.log`.
- */
-export const PI_LENS_EVALUATION_ORDINAL = nextModuleEvaluationOrdinal();
-/**
- * Record the load-complete time. Call once, as the first statement in the
- * extension entry's module body — by then every import has been evaluated, so
- * the full transpile/load cost has been paid. Idempotent: later calls return
- * the first captured value.
- */
-export function markPiLensLoaded() {
-    if (loadMs === undefined) {
-        loadedAtMs = performance.now();
-        loadMs = Math.round(loadedAtMs);
-    }
-    return loadMs;
-}
-/** Monotonic instant when pi-lens finished loading, for cross-hook spans. */
-export function getPiLensLoadedAtMs() {
-    return loadedAtMs;
-}
-/** Consume the process-lifetime first-session host-ready anchor exactly once. */
-export function consumeHostReadyDelayAnchor() {
-    const state = hostReadyAnchorState();
-    if (state.consumed)
-        return false;
-    state.consumed = true;
-    return true;
-}
-/** Test seam for the process-lifetime session-state registry probe boundary. */
-export function resetHostReadyDelayAnchorForTests() {
-    hostReadyAnchorState().consumed = false;
-}
-/** ms from pi process start to pi-lens load-complete, or undefined if unmarked. */
-export function getPiLensLoadMs() {
-    return loadMs;
-}
-/** ms from host process start until pi-lens evaluation began. */
-export const PI_LENS_HOST_BOOT_MS = Math.round(PI_LENS_EVAL_STARTED_MS);
-/** pi-lens module-graph evaluation time once markPiLensLoaded() has run. */
-export function getPiLensEvalMs() {
-    return loadMs === undefined
-        ? undefined
-        : Math.max(0, loadMs - PI_LENS_HOST_BOOT_MS);
-}
-/**
- * Build the three startup latency records the extension entry emits at module
- * scope (`extension_loaded`, `host_boot`, `extension_eval`).
- *
- * A builder rather than three inline `logLatency` calls in `index.ts` so the
- * record CONTENT is testable: `logLatency` is a no-op under `PI_LENS_TEST_MODE`,
- * and `index.ts`'s module body cannot be re-run per assertion. `index.ts` maps
- * the returned records straight into `logLatency`, so this is the production
- * shape, not a parallel path.
- *
- * `host_boot` carries `evaluationOrdinal` (#2146): one `host_boot` line is one
- * module-graph evaluation, and the ordinal makes a multi-evaluation host
- * greppable instead of inferable by counting lines per pid.
- */
-export function buildStartupTimingRecords(input) {
-    return [
-        {
-            type: "phase",
-            filePath: "<pi-lens>",
-            phase: "extension_loaded",
-            durationMs: input.loadMs,
-            metadata: { loadedFrom: PI_LENS_LOADED_FROM },
-        },
-        {
-            type: "phase",
-            filePath: "<pi-lens>",
-            phase: "host_boot",
-            durationMs: PI_LENS_HOST_BOOT_MS,
-            metadata: {
-                loadedFrom: PI_LENS_LOADED_FROM,
-                evaluationOrdinal: PI_LENS_EVALUATION_ORDINAL,
-            },
-        },
-        {
-            type: "phase",
-            filePath: "<pi-lens>",
-            phase: "extension_eval",
-            durationMs: input.evalMs,
-            metadata: { loadedFrom: PI_LENS_LOADED_FROM },
-        },
-    ];
-}

package/node_modules/pi-lens/dist/clients/string-utils.js

@@ -1,33 +0,0 @@
-/**
- * Ordinal (code-unit) string comparator for identity-feeding sorts — cache
- * keys, dedupe keys, hashes, and signatures. Refs #2155, #2165.
- *
- * `localeCompare` orders strings by locale-dependent collation (the DEFAULT
- * `Array.prototype.sort`, with no comparator, does not — it compares UTF-16
- * code units, which is already ordinal). Locale-dependent order is fine for
- * a list a human reads. It is a bug (SonarCloud S2871) when the sorted
- * result feeds an identity: two processes — or one process whose locale
- * changes — can order the same input differently under `localeCompare` and
- * mint different keys for equivalent state, producing a silent cache or
- * dedupe miss.
- *
- * Use this comparator whenever a sort's output becomes a key, a hash input,
- * or a signature compared for equality later. Keep `localeCompare` for
- * sorting that only affects what a person reads.
- */
-export function compareOrdinal(a, b) {
-    return a < b ? -1 : a > b ? 1 : 0;
-}
-/**
- * Escape a string for safe interpolation into a `RegExp` source, so every
- * regex metacharacter it contains is matched literally instead of taking on
- * its regex meaning. This is the ONE runtime copy (#2558) — string-utils.ts
- * is a leaf (no imports of its own), so importing it never creates a cycle.
- * Before #2558 this same body was hand-copied under this name (and as
- * `escapeRegExpChar`/`escapeRegExpLiteral`) into ~8 production modules and 3
- * test helpers; fold new call sites onto this export instead of re-copying
- * it.
- */
-export function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}

package/node_modules/pi-lens/dist/clients/subagent-mode.js

@@ -1,111 +0,0 @@
-/**
- * Subagent light mode (#449 slice 0; broadened #507).
- *
- * Two known subagent-spawning ecosystems set different env vocabularies in
- * every spawned child's environment:
- *
- * - nicobailon/pi-subagents sets `PI_SUBAGENT_CHILD=1` unconditionally on
- *   every process that hosts a child session — the only var light mode keys
- *   on for this vocabulary. It ALSO used to set `PI_SUBAGENT_RUN_ID` /
- *   `PI_SUBAGENT_CHILD_AGENT` alongside it for best-effort identity, but
- *   removed both entirely in `pi-subagents@0.65.0`'s native-AgentSession
- *   rewrite (grep-verified absent from the whole 0.66.0 source tree, #2581/
- *   #2680) — child identity now travels through an in-process object, not
- *   env vars. `getSubagentIdentity()` below already treats identity as
- *   optional best-effort metadata, so this permanent absence for the
- *   nicobailon vocabulary needed no behavior change, only the doc update.
- * - avtc-pi-subagent (the spawn engine under avtc-pi-feature-flow) is the same
- *   execution model — real child-process `pi --mode rpc` / `--mode json -p`
- *   spawns, full env inheritance — but never sets `PI_SUBAGENT_CHILD`. It sets
- *   `PI_SUBAGENT_CHILD_AGENT` + `PI_SUBAGENT_PARENT_PID` instead (#507,
- *   grep-verified against avtc-pi-subagent@1.0.3).
- *
- * Every child currently loads pi-lens fully by default, so a fan-out of N
- * subagents pays N full LSP pre-warms + N sets of heavyweight startup scans
- * in the same cwd — mostly wasted on short-lived task agents.
- *
- * Detection requires the avtc PAIR (`PI_SUBAGENT_CHILD_AGENT` AND
- * `PI_SUBAGENT_PARENT_PID`, both non-empty) rather than either var alone —
- * deliberate false-positive protection, since a lone var set by some
- * unrelated tool must not trigger light mode.
- *
- * This module only classifies the session; it does not change any behavior
- * itself. Callers (`runtime-session.ts`) gate the LSP pre-warm and the seven
- * heavyweight external-CLI startup scans on `isSubagentSession()`. Per-edit
- * LSP dispatch is untouched — light mode must not disable diagnostics.
- *
- * Escape hatch: `PI_LENS_SUBAGENT_FULL=1` forces full (non-light) behavior
- * even inside a detected subagent session, for either vocabulary.
- *
- * Follows the lazy-memoized-config house style (see `runtime-config.ts` /
- * `slow-fs.ts`): env values are read lazily at call time, not module load.
- */
-/** Lazily computed once per process (until `_resetSubagentModeForTests`),
- * matching the memoized-getter house style. */
-let cachedClassification;
-function classifySubagentSession() {
-    if (cachedClassification !== undefined)
-        return cachedClassification;
-    if (process.env.PI_SUBAGENT_CHILD === "1") {
-        cachedClassification = { isSubagent: true, marker: "pi-subagents" };
-        return cachedClassification;
-    }
-    const childAgent = process.env.PI_SUBAGENT_CHILD_AGENT || undefined;
-    const parentPid = process.env.PI_SUBAGENT_PARENT_PID || undefined;
-    if (childAgent !== undefined && parentPid !== undefined) {
-        cachedClassification = { isSubagent: true, marker: "avtc-pi-subagent" };
-        return cachedClassification;
-    }
-    cachedClassification = { isSubagent: false };
-    return cachedClassification;
-}
-/** True iff pi-lens is running inside a detected subagent child `pi` process
- * (nicobailon/pi-subagents' `PI_SUBAGENT_CHILD=1`, or avtc-pi-subagent's
- * `PI_SUBAGENT_CHILD_AGENT` + `PI_SUBAGENT_PARENT_PID` pair), and the caller
- * has not forced full behavior via the escape hatch. */
-export function isSubagentSession() {
-    if (process.env.PI_LENS_SUBAGENT_FULL === "1")
-        return false;
-    return classifySubagentSession().isSubagent;
-}
-/**
- * Best-effort identity of the current subagent, read from the env vars the
- * detected extension sets alongside its subagent marker. Returns `undefined`
- * when neither identity var is present — not a subagent session, an
- * extension that never set them, OR nicobailon/pi-subagents@0.65.0+, which
- * removed both identity vars upstream while still setting `PI_SUBAGENT_CHILD`
- * (#2581/#2680): light mode still engages via `isSubagentSession()` alone,
- * `marker` is still populated, only `runId`/`agentName` degrade to
- * `undefined`. Identity is metadata for observability, never a light-mode
- * gate — callers must not treat its absence as "not a subagent".
- */
-export function getSubagentIdentity() {
-    const runId = process.env.PI_SUBAGENT_RUN_ID || undefined;
-    const agentName = process.env.PI_SUBAGENT_CHILD_AGENT || undefined;
-    const parentPidRaw = process.env.PI_SUBAGENT_PARENT_PID || undefined;
-    const parsedParentPid = parentPidRaw === undefined ? undefined : Number(parentPidRaw);
-    const parentPid = parsedParentPid !== undefined &&
-        Number.isSafeInteger(parsedParentPid) &&
-        parsedParentPid > 0
-        ? parsedParentPid
-        : undefined;
-    const classification = classifySubagentSession();
-    if (runId === undefined &&
-        agentName === undefined &&
-        parentPid === undefined &&
-        !classification.isSubagent) {
-        return undefined;
-    }
-    return { runId, agentName, marker: classification.marker, parentPid };
-}
-/** Human-readable degradation notice surfaced once per session when subagent
- * light mode engages, so a subagent never sees a silently-empty scan result. */
-export function subagentLightModeNotice() {
-    return "subagent session — skipped background code-quality scans (set PI_LENS_SUBAGENT_FULL=1 to override)";
-}
-/** Test-only: clears the memoized classification so tests can flip env vars
- * between cases (matching the `_resetForTests` convention used by
- * `runtime-config.ts` / `slow-fs.ts`). */
-export function _resetSubagentModeForTests() {
-    cachedClassification = undefined;
-}