@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/clients/quiet-window.js

@@ -1,236 +0,0 @@
-/**
- * Quiet-window scheduler for pi 0.80.6's `agent_settled` extension event (#483).
- *
- * `agent_settled` fires after the SDK's `_runAgentPrompt` finally-block sets
- * `_isAgentRunActive = false` — i.e. once the whole agent run (including any
- * auto-retry/continue loop) is fully done, on BOTH normal completion and
- * aborts/errors (it lives in a `finally`, not a success-only branch). It
- * fires strictly after `agent_end`/`turn_end` for that run. Unlike
- * `turn_end` — which fires while the next turn may already be looming and
- * therefore bounds its cascade-settle wait tightly — `agent_settled` is a
- * genuine idle window: nothing else is queued behind it until the user
- * types again. That makes it the right home for expensive, deferrable work
- * that would otherwise contend with live per-edit traffic.
- *
- * Feature detection: the SDK's extension registration (`pi.on(event, fn)`)
- * pushes onto a plain `Map<string, handler[]>` keyed by the literal event
- * string, with no allowlist or validation — registering an unknown event
- * name is a silent no-op on older hosts (the emit side only look up
- * handlers for events it actually emits). Registration therefore can't
- * throw; we still wrap it in try/catch defensively, and every task run
- * through this scheduler is independently isolated so a host that never
- * fires the event simply never executes them.
- *
- * The SDK awaits each registered handler in sequence
- * (`core/extensions/runner.js` `emit()`), and that `emit()` call is itself
- * awaited inside `_emitAgentSettled()`, which is awaited inside
- * `_runAgentPrompt`'s `finally`. A slow handler would therefore delay
- * `_runAgentPrompt` returning — so the handler registered here must not
- * await the task chain; it kicks the chain off unawaited (fire-and-forget)
- * and returns immediately.
- */
-import { readInstanceRegistry, updateHeartbeat, } from "./instance-registry.js";
-import { logLatency } from "./latency-logger.js";
-import { sampleProcesses } from "./resource-sampler.js";
-import { _resetQuietWindowEnabledForTests, isQuietWindowEnabled, quietWindowWaitMs, } from "./quiet-window-config.js";
-// Module-level registry so future work (#458 Tier-3 reconcile, #236
-// enrichment) can plug into the same scheduler without touching it.
-const _tasks = [];
-/**
- * Register a task to run sequentially during the quiet window. Each task is
- * isolated in its own try/catch — one throwing never prevents the rest from
- * running, and no failure propagates out of `runQuietWindow`.
- */
-export function registerQuietWindowTask(name, fn) {
-    _tasks.push({ name, fn });
-}
-/** Test-only: clear the task registry between test files/cases. */
-export function _resetQuietWindowTasksForTests() {
-    _tasks.length = 0;
-}
-// --- Kill switch and wait budget ---
-//
-// #1462 review (N4): both live in `quiet-window-config.ts` now, so a caller
-// that needs only the numbers (`cascade-budget.ts`, on the dispatch load path)
-// does not drag this module's `resource-sampler` → `pidusage` import in with
-// them. Re-exported here so every existing importer is unaffected and there is
-// still one memo behind `isQuietWindowEnabled`.
-export { isQuietWindowEnabled, quietWindowWaitMs, _resetQuietWindowEnabledForTests, };
-// Re-entrancy guard: agent_settled can fire multiple times per session
-// (once per completed/aborted run). If a previous quiet-window run is still
-// in flight when the next fires, skip rather than queue/overlap.
-let _inProgress = false;
-/**
- * Run every registered quiet-window task sequentially, logging a
- * `quiet_window` phase to the latency log. Never throws — every task
- * failure is swallowed and logged; callers should invoke this
- * fire-and-forget (do not await inside an SDK-awaited event handler).
- */
-export async function runQuietWindow(deps) {
-    // `runtime` is accepted for API symmetry with turn_end's deps shape and
-    // for future built-in tasks that may need it directly; today's built-ins
-    // close over `getRuntime` via registerBuiltinQuietWindowTasks instead.
-    const { dbg, cwd } = deps;
-    if (!isQuietWindowEnabled()) {
-        logLatency({
-            type: "phase",
-            filePath: cwd ?? "<pi-lens>",
-            phase: "quiet_window",
-            durationMs: 0,
-            metadata: { skipped: "disabled" },
-        });
-        return;
-    }
-    if (_inProgress) {
-        dbg("quiet_window: skipping — a previous run is still in progress");
-        logLatency({
-            type: "phase",
-            filePath: cwd ?? "<pi-lens>",
-            phase: "quiet_window",
-            durationMs: 0,
-            metadata: { skipped: "in-progress" },
-        });
-        return;
-    }
-    _inProgress = true;
-    const totalStart = Date.now();
-    const results = [];
-    try {
-        for (const task of _tasks) {
-            const taskStart = Date.now();
-            let ok = true;
-            try {
-                await task.fn({
-                    runtime: deps.runtime,
-                    cwd: deps.cwd,
-                    sessionId: deps.sessionId,
-                    ownerId: deps.ownerId,
-                });
-            }
-            catch (err) {
-                ok = false;
-                // Surface the stack (not just the message) so the next failure is
-                // diagnosable from the log alone — a task can fail dozens of times
-                // and `${err}` (message only) may not pin the throw site. Still
-                // non-fatal: the loop continues and runQuietWindow never rethrows
-                // (see the finally below), so one bad task can't break the turn.
-                const detail = err instanceof Error
-                    ? (err.stack ?? `${err.name}: ${err.message}`)
-                    : String(err);
-                dbg(`quiet_window: task "${task.name}" failed: ${detail}`);
-            }
-            results.push({
-                name: task.name,
-                durationMs: Date.now() - taskStart,
-                ok,
-            });
-        }
-    }
-    finally {
-        _inProgress = false;
-        logLatency({
-            type: "phase",
-            filePath: cwd ?? "<pi-lens>",
-            phase: "quiet_window",
-            durationMs: Date.now() - totalStart,
-            metadata: { tasks: results },
-        });
-    }
-}
-/**
- * Register the two built-in quiet-window tasks (#483):
- *   1. carried-over cascade settle — a second, more generous attempt at
- *      draining cascade computes still pending after the turn_end cap
- *      (the #450 carry-over set in RuntimeCoordinator).
- *   2. instance-registry heartbeat refresh (#449) — off the turn hot path.
- *
- * Idempotent guard via a module flag so repeated calls (e.g. multiple
- * extension activations in tests) don't double-register.
- */
-let _builtinsRegistered = false;
-export function registerBuiltinQuietWindowTasks(getRuntime) {
-    if (_builtinsRegistered)
-        return;
-    _builtinsRegistered = true;
-    registerQuietWindowTask("cascade_carry_over_settle", async () => {
-        const runtime = getRuntime();
-        await runtime.settleCascadeRuns(quietWindowWaitMs());
-    });
-    registerQuietWindowTask("instance_registry_heartbeat", async () => {
-        await updateHeartbeat(await buildHeartbeatResourcePatchBounded());
-    });
-}
-/**
- * #620 sampling can never take longer than this to answer — on Windows it
- * shells out to PowerShell/CIM (via `pidusage`), which is normally fast but
- * has no hard upper bound the way an in-process computation would. Per this
- * repo's "async work needs both bounds" convention (a bulk/background step
- * needs a timeout, not just a happy-path await), a slow/hung sample must
- * still let the quiet-window task — and, transitively, the caller awaiting
- * `runQuietWindow` — return promptly rather than block on it indefinitely.
- */
-const HEARTBEAT_SAMPLE_TIMEOUT_MS = 2000;
-/** Race `buildHeartbeatResourcePatch` against `HEARTBEAT_SAMPLE_TIMEOUT_MS`;
- *  a timeout resolves to `{}` (same "leave everything untouched" semantics as
- *  any other sampling failure — see the module docstring below). */
-async function buildHeartbeatResourcePatchBounded() {
-    // #1097: clear the timeout once the race settles. An uncleared, REF'D
-    // setTimeout would keep the event loop alive for the full
-    // HEARTBEAT_SAMPLE_TIMEOUT_MS after `agent_settled` fires the quiet window —
-    // a same-class sibling of the LSP client-wait leak: harmless in a long-lived
-    // session, but a keep-alive tail in a one-shot `pi --print` process.
-    let timer;
-    try {
-        return await Promise.race([
-            buildHeartbeatResourcePatch(),
-            new Promise((resolve) => {
-                timer = setTimeout(() => resolve({}), HEARTBEAT_SAMPLE_TIMEOUT_MS);
-            }),
-        ]);
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
-}
-/**
- * #620: sample this process's host CPU% plus every currently-recorded LSP
- * child's CPU%/RSS, once per heartbeat tick, and shape it into the patch
- * `updateHeartbeat` expects. Lives here (not clients/instance-registry.ts)
- * to keep that module a pure data store with no `pidusage` dependency of its
- * own — this is the one call site that knows both "what's the heartbeat
- * cadence" (quiet-window, off the turn hot path) and "what pids to sample"
- * (this process's own registry entry).
- *
- * Best-effort end to end: any failure (registry read, sampling) resolves to
- * `{}` — an empty patch leaves `updateHeartbeat` free to fall back to its own
- * `process.memoryUsage().rss` default and leaves cpu/child values untouched,
- * never zeroed.
- */
-async function buildHeartbeatResourcePatch() {
-    try {
-        const instances = await readInstanceRegistry();
-        const self = instances.find((instance) => instance.pid === process.pid);
-        const childPids = self?.lspChildren.map((child) => child.pid) ?? [];
-        const usage = await sampleProcesses([process.pid, ...childPids]);
-        if (usage === null)
-            return {};
-        const childUsage = {};
-        for (const pid of childPids) {
-            const sample = usage.get(pid);
-            if (sample)
-                childUsage[pid] = sample;
-        }
-        return {
-            cpuPercent: usage.get(process.pid)?.cpuPercent,
-            childUsage,
-        };
-    }
-    catch {
-        return {};
-    }
-}
-/** Test-only: undo registerBuiltinQuietWindowTasks' idempotency guard. */
-export function _resetBuiltinQuietWindowRegistrationForTests() {
-    _builtinsRegistered = false;
-}

package/node_modules/pi-lens/dist/clients/read-bridge.js

@@ -1,139 +0,0 @@
-/**
- * Generic read-recording bridge for pi-lens.
- *
- * ## Trust model — explicitly advisory
- *
- * This bridge is an **advisory, trust-based protocol** for same-process Pi
- * extensions. Any code sharing the same Node.js process already has full
- * access to pi-lens's internal state, so the bridge cannot and does not
- * provide a meaningful security boundary. What it *does* provide is:
- *
- * - A stable API surface so extensions do not need to import pi-lens
- *   internals directly.
- * - A single place for flag/scope checks (no-read-guard, ignored paths).
- * - Basic defensive validation to catch integration bugs early (malformed
- *   payloads).
- *
- * Mounts a `ReadBridge` object at `globalThis[READ_BRIDGE_KEY]` that any
- * co-process extension can call to register a file read against pi-lens's
- * read-guard — without either party needing to know about the other.
- *
- * Protocol (producer side)
- * ────────────────────────
- * A co-process Pi extension that performs file reads outside pi-lens's
- * awareness (e.g. via a custom registered tool) can forward those reads so
- * that a subsequent `edit` call on the same file is not blocked by the
- * read-before-edit guard:
- *
- *   const bridge = (globalThis as any)[Symbol.for("pi-lens:read-bridge")];
- *   bridge?.recordRead({
- *     filePath,          // absolute path
- *     requestedOffset,   // 1-indexed first line (default 1)
- *     requestedLimit,    // line count, or undefined for the whole file
- *     consumer,          // optional identifier, e.g. "my-extension" (appears in read-guard.log)
- *   });
- *
- * Check `bridge.version` before calling to guard against future incompatible
- * changes — a bridge whose version you don't recognise should be treated as
- * unsupported.
- *
- * The timestamp is stamped by the bridge itself (Date.now()) to match
- * exactly how the internal read path works.
- *
- * Calling before pi-lens is loaded, or when the guard is disabled via
- * `PI_LENS_NO_READ_GUARD`, is safe — the bridge is absent or the call is
- * silently dropped.
- *
- * Protocol (registration side, internal to pi-lens)
- * ──────────────────────────────────────────────────
- * `registerReadBridge` is called once from inside the extension factory
- * (after `getLensFlag` is available) via the `_readBridgeRegistered`
- * singleton guard so that factory re-activations in the same process do not
- * mount a second bridge.
- *
- * The `isRecordable` predicate is re-evaluated on every `recordRead` call
- * using the *current* activation's flag getter (stored in a module-level
- * holder refreshed on every factory activation — same pattern as
- * `_turnSummaryEmitCtx`), so flag changes take effect immediately.
- */
-/** Stable Symbol key — identical across module reloads in the same process. */
-import { registerProcessBridge } from "./process-bridge.js";
-import { captureReadContentBinding, } from "./read-guard.js";
-export const READ_BRIDGE_KEY = Symbol.for("pi-lens:read-bridge");
-/**
- * Validate a raw entry from an untrusted caller.
- * Returns `true` when the entry is structurally sound and safe to forward.
- *
- * Validation is deliberately lightweight — this is an advisory protocol
- * between same-process extensions (see the module-level trust-model note).
- * The goal is to catch integration bugs (typo'd fields, bad numbers) early
- * rather than to enforce a security boundary.
- */
-function isValidEntry(entry) {
-    if (typeof entry !== "object" || entry === null)
-        return false;
-    const e = entry;
-    // filePath must be a non-empty string (absolute paths are expected but
-    // we don't re-resolve here — `isRecordable` handles scope checks).
-    if (typeof e["filePath"] !== "string" || e["filePath"] === "")
-        return false;
-    // requestedOffset must be a finite integer ≥ 1.
-    const offset = e["requestedOffset"];
-    if (typeof offset !== "number" ||
-        !Number.isFinite(offset) ||
-        offset < 1 ||
-        !Number.isInteger(offset))
-        return false;
-    // requestedLimit must be undefined or a finite positive integer.
-    const limit = e["requestedLimit"];
-    if (limit !== undefined) {
-        if (typeof limit !== "number" ||
-            !Number.isFinite(limit) ||
-            limit < 1 ||
-            !Number.isInteger(limit))
-            return false;
-    }
-    return true;
-}
-/**
- * Mount the bridge singleton. Call once from inside the extension factory
- * (protected by the `_readBridgeRegistered` module-level flag). Subsequent
- * calls are no-ops (first-wins, `clients/process-bridge.ts` owns the mount
- * body — see that module's header, #2437).
- */
-export function registerReadBridge(deps) {
-    registerProcessBridge(READ_BRIDGE_KEY, () => ({
-        version: 1,
-        recordRead(entry) {
-            // Validate the payload before doing anything else — this catches
-            // integration bugs in callers (malformed fields, bad numbers).
-            if (!isValidEntry(entry))
-                return;
-            if (!deps.isRecordable(entry.filePath))
-                return;
-            const offset = entry.requestedOffset;
-            // When no limit is given treat the whole file as covered — the
-            // guard clips to the actual line count via its own file-length
-            // probe.
-            const limit = entry.requestedLimit ?? Number.MAX_SAFE_INTEGER;
-            const contentBinding = captureReadContentBinding(entry.filePath, offset, limit);
-            deps.getReadGuard().recordRead({
-                filePath: entry.filePath,
-                requestedOffset: offset,
-                requestedLimit: limit,
-                effectiveOffset: offset,
-                effectiveLimit: limit,
-                expandedByLsp: false,
-                turnIndex: deps.getTurnIndex(),
-                writeIndex: deps.peekWriteIndex(),
-                // Stamp the timestamp here, matching exactly how the internal
-                // read path works (runtime-tool-call.ts always uses Date.now()).
-                timestamp: Date.now(),
-                // Provenance: identifies this record as bridge-sourced in
-                // read-guard.log.
-                source: `bridge:${entry.consumer ?? "unknown"}`,
-                ...(contentBinding !== undefined && { contentBinding }),
-            });
-        },
-    }));
-}

package/node_modules/pi-lens/dist/clients/read-expansion.js

@@ -1,266 +0,0 @@
-/**
- * Tree-sitter–based read expansion for the read-before-edit guard.
- *
- * When an agent reads a small slice of a file, this module uses the tree-sitter
- * AST to expand the read to cover the entire enclosing symbol (function, method,
- * class). This gives the read guard accurate symbol-level coverage so edits
- * within the symbol pass without requiring the agent to have read every line.
- */
-import * as fs from "node:fs";
-import { extname } from "node:path";
-import { withBudget } from "./deadline-utils.js";
-import { EXTENSION_TO_GRAMMAR } from "./language-registry.js";
-/** Only expand reads smaller than this (lines). Larger reads don't benefit. */
-export const EXPANSION_LIMIT_LINES = 100;
-/** Don't expand to a symbol larger than this. */
-const EXPANDED_SIZE_CAP_LINES = 300;
-/** Async budget for tree-sitter parse + walk. */
-export const EXPANSION_BUDGET_MS = 200;
-/**
- * The grammar this module would parse `filePath` with, or undefined when read
- * expansion does not understand the extension. Exported so the
- * language-identity golden snapshot can record this consumer's answer.
- */
-export function readExpansionLanguage(filePath) {
-    return EXTENSION_TO_GRAMMAR[extname(filePath).toLowerCase()];
-}
-/** AST node types considered "enclosing symbols" for coverage purposes. */
-const ENCLOSING_TYPES = {
-    typescript: [
-        "function_declaration",
-        "function_expression",
-        "arrow_function",
-        "method_definition",
-        "class_declaration",
-    ],
-    tsx: [
-        "function_declaration",
-        "function_expression",
-        "arrow_function",
-        "method_definition",
-        "class_declaration",
-    ],
-    javascript: [
-        "function_declaration",
-        "function_expression",
-        "arrow_function",
-        "method_definition",
-        "class_declaration",
-    ],
-    python: ["function_definition", "class_definition", "decorated_definition"],
-    go: ["function_declaration", "method_declaration"],
-    rust: ["function_item", "impl_item"],
-    ruby: ["method", "class", "module"],
-    java: [
-        "method_declaration",
-        "constructor_declaration",
-        "class_declaration",
-        "interface_declaration",
-        "enum_declaration",
-    ],
-    kotlin: ["function_declaration", "class_declaration", "object_declaration"],
-    dart: [
-        "function_declaration",
-        "method_declaration",
-        "class_definition",
-        "mixin_declaration",
-    ],
-    elixir: ["call"],
-    c: ["function_definition"],
-    cpp: ["function_definition", "class_specifier", "struct_specifier"],
-    csharp: [
-        "method_declaration",
-        "constructor_declaration",
-        "class_declaration",
-        "interface_declaration",
-        "struct_declaration",
-    ],
-    php: ["function_definition", "method_declaration", "class_declaration"],
-    swift: [
-        "function_declaration",
-        "class_declaration",
-        "protocol_declaration",
-        "init_declaration",
-    ],
-    lua: ["function_declaration", "function_definition"],
-    ocaml: ["value_definition", "module_definition"],
-    zig: ["function_declaration"],
-    bash: ["function_definition"],
-};
-// biome-ignore lint/suspicious/noExplicitAny: tree-sitter AST node
-function findEnclosingNodeForRange(node, startRow, endRow, types) {
-    const nodeStartRow = node.startPosition?.row ?? 0;
-    // biome-ignore lint/suspicious/noExplicitAny: endPosition not declared in local interface
-    const nodeEndRow = node.endPosition?.row ?? nodeStartRow;
-    if (endRow < nodeStartRow || startRow > nodeEndRow)
-        return undefined;
-    // Prefer deepest overlapping match — check children first.
-    for (const child of node.children ?? []) {
-        const match = findEnclosingNodeForRange(child, startRow, endRow, types);
-        if (match)
-            return match;
-    }
-    return types.includes(node.type) ? node : undefined;
-}
-// biome-ignore lint/suspicious/noExplicitAny: tree-sitter AST node
-function getSymbolName(node) {
-    for (const child of node.children ?? []) {
-        if (child.type === "identifier" ||
-            child.type === "property_identifier" ||
-            child.type === "name") {
-            return child.text;
-        }
-    }
-    return node.type;
-}
-/**
- * Walk parent nodes from `node` upward, collecting every ancestor that is
- * one of the enclosing symbol types. Returns them outermost-first.
- */
-// biome-ignore lint/suspicious/noExplicitAny: tree-sitter AST node
-function buildAncestryChain(node, types) {
-    const chain = [];
-    // biome-ignore lint/suspicious/noExplicitAny: tree-sitter parent node
-    let current = node.parent;
-    while (current) {
-        if (types.includes(current.type)) {
-            chain.push({
-                name: getSymbolName(current),
-                kind: current.type,
-                startLine: (current.startPosition?.row ?? 0) + 1,
-            });
-        }
-        current = current.parent;
-    }
-    return chain.reverse(); // outermost first
-}
-function tryExpandMarkdownSection(content, requestedStartRow, requestedLimit, totalLines) {
-    const lines = content.split(/\r?\n/);
-    const lastRow = totalLines - 1;
-    // Find heading at or before the requested start row
-    let headingLevel = 7;
-    let sectionStartRow = 0;
-    let headingText = "";
-    for (let i = requestedStartRow; i >= 0; i--) {
-        const match = lines[i]?.match(/^(#{1,6})\s+(.*)/);
-        if (match) {
-            headingLevel = match[1].length;
-            sectionStartRow = i;
-            headingText = match[2].trim();
-            break;
-        }
-    }
-    // Find end: next heading of same or higher level (smaller or equal number)
-    let sectionEndRow = lastRow;
-    for (let i = sectionStartRow + 1; i <= lastRow; i++) {
-        const match = lines[i]?.match(/^(#{1,6})\s+/);
-        if (match && match[1].length <= headingLevel) {
-            sectionEndRow = i - 1;
-            break;
-        }
-    }
-    const expandedStart = sectionStartRow + 1;
-    const expandedEnd = sectionEndRow + 1;
-    const expandedSize = expandedEnd - expandedStart + 1;
-    if (expandedSize > EXPANDED_SIZE_CAP_LINES)
-        return undefined;
-    if (expandedSize <= requestedLimit)
-        return undefined;
-    return {
-        newOffset: expandedStart,
-        newLimit: expandedSize,
-        enclosingSymbol: {
-            name: headingText || "(untitled section)",
-            kind: "markdown_section",
-            startLine: expandedStart,
-            endLine: expandedEnd,
-        },
-    };
-}
-/**
- * Attempt to expand a partial read to its enclosing symbol using tree-sitter.
- *
- * Returns undefined when:
- * - The file extension has no grammar
- * - The read is large (> EXPANSION_LIMIT_LINES) — already covers enough
- * - No enclosing symbol overlaps the requested read span
- * - The enclosing symbol is larger than EXPANDED_SIZE_CAP_LINES
- * - Tree-sitter init/parse exceeds EXPANSION_BUDGET_MS
- */
-export async function tryExpandRead(filePath, requestedOffset, requestedLimit, totalLines, tsClient) {
-    if (requestedLimit > EXPANSION_LIMIT_LINES)
-        return undefined;
-    if (requestedLimit >= totalLines)
-        return undefined;
-    const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
-    const startedAt = Date.now();
-    try {
-        const content = fs.readFileSync(filePath, "utf8");
-        // Fast path: Markdown section expansion (no tree-sitter needed)
-        if (ext === ".md" || ext === ".mdx") {
-            const requestedStartRow = requestedOffset - 1;
-            const result = tryExpandMarkdownSection(content, requestedStartRow, requestedLimit, totalLines);
-            if (!result)
-                return undefined;
-            return { ...result, durationMs: Date.now() - startedAt };
-        }
-        const languageId = readExpansionLanguage(filePath);
-        if (!languageId)
-            return undefined;
-        const enclosingTypes = ENCLOSING_TYPES[languageId];
-        if (!enclosingTypes)
-            return undefined;
-        const initOk = await withBudget(tsClient.init(), EXPANSION_BUDGET_MS);
-        if (!initOk)
-            return undefined;
-        const remaining = Math.max(0, EXPANSION_BUDGET_MS - (Date.now() - startedAt));
-        // tree-sitter rows are 0-indexed; offsets are 1-indexed
-        const requestedStartRow = requestedOffset - 1;
-        const requestedEndRow = Math.min(totalLines - 1, requestedOffset + requestedLimit - 2);
-        // Resolve the enclosing node INSIDE the cache-safe callback: a tree handed
-        // back across an await can be retired by another consumer's eviction (#417).
-        const parsed = await withBudget(tsClient.withParsedTree(filePath, languageId, content, (tree) => {
-            // biome-ignore lint/suspicious/noExplicitAny: tree-sitter root node
-            const node = findEnclosingNodeForRange(tree.rootNode, requestedStartRow, requestedEndRow, enclosingTypes);
-            if (!node)
-                return undefined;
-            return {
-                name: getSymbolName(node),
-                kind: node.type,
-                startRow: node.startPosition.row,
-                // biome-ignore lint/suspicious/noExplicitAny: endPosition not in local interface
-                endRow: node.endPosition?.row ?? node.startPosition.row,
-                ancestry: buildAncestryChain(node, enclosingTypes),
-            };
-        }), remaining);
-        const enclosing = parsed?.parsed ? parsed.value : undefined;
-        if (!enclosing)
-            return undefined;
-        const symbolStart = enclosing.startRow + 1;
-        const symbolEnd = enclosing.endRow + 1;
-        const requestedStartLine = requestedOffset;
-        const requestedEndLine = requestedEndRow + 1;
-        const expandedStart = Math.min(requestedStartLine, symbolStart);
-        const expandedEnd = Math.max(requestedEndLine, symbolEnd);
-        const expandedSize = expandedEnd - expandedStart + 1;
-        if (expandedSize > EXPANDED_SIZE_CAP_LINES)
-            return undefined;
-        if (expandedSize <= requestedLimit)
-            return undefined;
-        return {
-            newOffset: expandedStart,
-            newLimit: expandedSize,
-            enclosingSymbol: {
-                name: enclosing.name,
-                kind: enclosing.kind,
-                startLine: symbolStart,
-                endLine: symbolEnd,
-            },
-            ancestry: enclosing.ancestry.length > 0 ? enclosing.ancestry : undefined,
-            durationMs: Date.now() - startedAt,
-        };
-    }
-    catch {
-        return undefined;
-    }
-}