pi-lens 4.1.5 → 4.2.0

package/dist/clients/tool-cwd.js

@@ -0,0 +1,270 @@
+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";
+import { rootMarkersForFile } from "./language-profile.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",
+    ],
+    typstyle: [".gitignore"],
+};
+const toolCwdGeneration = createGenerationSource("tool-cwd");
+const logged = createGenerationMap("tool-cwd-resolution-log");
+/** Pure key seam for resolution-log and runner-advisory identity. */
+export function _toolCwdEphemeralKey(parts) {
+    return parts.map(normalizeEphemeralMapKey).join("\0");
+}
+function syncGeneration() {
+    if (toolCwdGeneration.current() === getDegradationLedgerGeneration())
+        return;
+    logged.clear();
+    while (toolCwdGeneration.current() < getDegradationLedgerGeneration()) {
+        toolCwdGeneration.bump();
+    }
+}
+function walkMarkerRoot(startDir, markers, homeDir) {
+    let current = path.resolve(startDir);
+    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)
+                return { root: current, marker };
+        }
+        const parentDir = path.dirname(current);
+        if (parentDir === current)
+            break;
+        current = parentDir;
+    }
+    return { root: null };
+}
+function findMarkerRoot(startDir, markers, homeDir) {
+    syncGeneration();
+    return walkMarkerRoot(startDir, markers, homeDir);
+}
+function markersFor(kind, tool, file, ctx) {
+    if (kind === "lsp")
+        return ctx.rootMarkers ?? [];
+    // #2965: runner fallback uses the language table that also anchors the
+    // dispatch context. A caller-owned table remains an explicit override.
+    if (kind === "runner")
+        return ctx.rootMarkers ?? rootMarkersForFile(file, 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 { cwd: serverRoot };
+    }
+    const markers = markersFor(kind, tool, absoluteFile, 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 {
+            cwd: markerRoot,
+            ...(markerResult.marker !== undefined
+                ? { marker: markerResult.marker }
+                : {}),
+        };
+    }
+    const memo = ctx.toolCwdMemo;
+    if (memo && memo.gitRoot === undefined) {
+        const gitResult = findMarkerRoot(fileDir, [".git"], homeDir);
+        memo.gitRoot =
+            gitResult.root && isRealGitMarker(path.join(gitResult.root, ".git"))
+                ? gitResult.root
+                : null;
+    }
+    const gitRoot = memo && memo.gitRoot !== undefined
+        ? memo.gitRoot
+        : (() => {
+            const gitResult = findMarkerRoot(fileDir, [".git"], homeDir);
+            return 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 { cwd: gitRoot, marker: ".git" };
+    }
+    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 { cwd: fileDir };
+        }
+        if (!ctx.suppressTelemetry)
+            emitResolution(kind, tool, dispatchRoot, "dispatch-root");
+        return { cwd: 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 { cwd: 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).cwd;
+}
+export function resolveRunnerCwdWithReason(ctx, tool) {
+    return resolveToolCwd("runner", tool, ctx.filePath, ctx);
+}

package/dist/clients/tool-policy.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { TERRAGRUNT_FILENAMES } from "./file-kinds.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
 import { logLatency } from "./latency-logger.js";
 import { resolvePackagePath } from "./package-root.js";
 import { findNearestContaining, normalizeMapKey, walkUpDirs, } from "./path-utils.js";
@@ -371,6 +372,24 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
             gate: "smart-default",
         },
     ],
+    [
+        ".typ",
+        {
+            formatterNames: ["typstyle"],
+            defaultFormatter: "typstyle",
+            defaultWhenUnconfigured: true,
+            gate: "smart-default",
+        },
+    ],
+    [
+        ".typc",
+        {
+            formatterNames: ["typstyle"],
+            defaultFormatter: "typstyle",
+            defaultWhenUnconfigured: true,
+            gate: "smart-default",
+        },
+    ],
     [
         ".c",
         {
@@ -738,6 +757,7 @@ const AUTO_INSTALLABLE_DEFAULT_FORMATTERS = new Map([
     ["shfmt", "shfmt"],
     ["taplo", "taplo"],
     ["ktlint", "ktlint"],
+    ["typstyle", "typstyle"],
 ]);
 // `gate: "smart-default"` so a matched file is formatted only when nothing else
 // claims it. Misdetection edge: `root.hcl` is filename-detected as terragrunt, so
@@ -1633,17 +1653,25 @@ export function getAutofixPolicyForFile(filePath, context = {}) {
 export function getPreferredAutofixTools(filePath, context) {
     return getAutofixPolicyForFile(filePath, context)?.preferredTools ?? [];
 }
-const ESLINT_CONFIGS = [
+// Flat-config filenames resolve like ESLint itself: upward from cwd without
+// stopping at an intermediate package.json (#3017, shape 39). Legacy
+// `.eslintrc.*` names and the `package.json#eslintConfig` field keep the
+// historic per-package boundary below.
+const ESLINT_FLAT_CONFIGS = [
+    "eslint.config.js",
+    "eslint.config.mjs",
+    "eslint.config.cjs",
+    "eslint.config.ts",
+    "eslint.config.mts",
+    "eslint.config.cts",
+];
+const ESLINT_LEGACY_CONFIGS = [
     ".eslintrc",
     ".eslintrc.js",
     ".eslintrc.cjs",
     ".eslintrc.json",
     ".eslintrc.yaml",
     ".eslintrc.yml",
-    "eslint.config.js",
-    "eslint.config.mjs",
-    "eslint.config.cjs",
-    "eslint.config.ts",
 ];
 function* walkUpDirsUntilPackageJson(cwd) {
     for (const dir of walkUpDirs(cwd)) {
@@ -1692,8 +1720,19 @@ export function hasNearestPackageJsonField(cwd, fieldName) {
     return false;
 }
 export function hasEslintConfig(cwd) {
+    // Flat configs mirror ESLint's own discovery: every ancestor dir up to
+    // the filesystem root, ignoring intermediate package.json boundaries, so
+    // a monorepo root config stays visible from inside a nested package.
+    for (const dir of walkUpDirs(cwd)) {
+        for (const cfg of ESLINT_FLAT_CONFIGS) {
+            if (fs.existsSync(path.join(dir, cfg)))
+                return true;
+        }
+    }
+    // Legacy `.eslintrc.*` and `package.json#eslintConfig` keep per-package
+    // semantics: the walk stops at the nearest package.json.
     for (const dir of walkUpDirsUntilPackageJson(cwd)) {
-        for (const cfg of ESLINT_CONFIGS) {
+        for (const cfg of ESLINT_LEGACY_CONFIGS) {
             if (fs.existsSync(path.join(dir, cfg)))
                 return true;
         }
@@ -2231,6 +2270,16 @@ const KOTLIN_GRADLE_FILES = [
     "settings.gradle.kts",
     "settings.gradle",
 ];
+const GRADLE_KTLINT_PLUGIN_PATTERN = /(?:id\s*\(\s*|id\s+|apply\s+plugin\s*:\s*)["']org\.jlleitschuh\.gradle\.ktlint["']/g;
+const GRADLE_BUILD_LOGIC_DIRS = ["buildSrc", "build-logic"];
+const GRADLE_BUILD_LOGIC_EXTENSIONS = [".gradle", ".gradle.kts", ".kt"];
+const GRADLE_INCLUDE_BUILD_PATTERN = /\bincludeBuild\s*\(\s*["']([^"']+)["']/g;
+/**
+ * Bound the synchronous ownership probe so a large convention tree cannot
+ * stall every autofix. Exceeding it is an unknown ownership result, not proof
+ * of no owner, and callers must decline the write (#3004).
+ */
+export const GRADLE_BUILD_LOGIC_SCAN_MAX_ENTRIES = 10_000;
 const spotlessKotlinConfigCache = new Map();
 let spotlessGradleReadCount = 0;
 /** Test-only observability for asserting the hot-path I/O bound. */
@@ -2429,6 +2478,110 @@ export function getSpotlessKotlinFormatter(cwd) {
 export function hasKtlintConfig(cwd) {
     return getSpotlessKotlinFormatter(cwd) === "ktlint";
 }
+/**
+ * Whether Gradle build logic applies the ktlint Gradle plugin. The plugin
+ * establishes project ownership of ktlint, but its plugin version is not a
+ * ktlint CLI version and must never be used as one (#3000).
+ */
+export function hasGradleKtlintPlugin(cwd) {
+    const files = new Set();
+    const scan = { entries: 0, exceeded: false, indeterminate: false };
+    for (const dir of walkUpDirs(cwd)) {
+        for (const gradle of KOTLIN_GRADLE_FILES) {
+            const filePath = path.join(dir, gradle);
+            if (fs.existsSync(filePath))
+                files.add(filePath);
+        }
+        for (const buildLogicDir of GRADLE_BUILD_LOGIC_DIRS) {
+            if (!addGradleBuildLogicFiles(path.join(dir, buildLogicDir), files, scan)) {
+                scan.exceeded = true;
+            }
+        }
+        for (const settings of ["settings.gradle.kts", "settings.gradle"]) {
+            const settingsPath = path.join(dir, settings);
+            if (!fs.existsSync(settingsPath))
+                continue;
+            try {
+                const raw = fs.readFileSync(settingsPath, "utf-8");
+                const stripped = stripGradleCommentsAndStrings(raw);
+                GRADLE_INCLUDE_BUILD_PATTERN.lastIndex = 0;
+                let match;
+                while ((match = GRADLE_INCLUDE_BUILD_PATTERN.exec(raw)) !== null) {
+                    const code = stripped.slice(match.index, match.index + match[0].length);
+                    const includedBuild = match[1];
+                    if (includedBuild && /^\s*includeBuild\s*\(\s*/.test(code)) {
+                        if (!addGradleBuildLogicFiles(path.resolve(dir, includedBuild), files, scan)) {
+                            scan.exceeded = true;
+                        }
+                    }
+                }
+            }
+            catch {
+                scan.indeterminate = true;
+            }
+        }
+    }
+    if (scan.exceeded) {
+        recordDegradationOnce({
+            kind: "gradle-ktlint-scan-budget-exceeded",
+            subject: "ktlint:gradle-build-logic",
+            reason: `Gradle build-logic ownership scan exceeded its ${GRADLE_BUILD_LOGIC_SCAN_MAX_ENTRIES}-entry budget; ` +
+                "ownership cannot be established, so ktlint autofix is declined",
+        });
+        return { kind: "indeterminate" };
+    }
+    if (scan.indeterminate)
+        return { kind: "indeterminate" };
+    for (const filePath of files) {
+        try {
+            const raw = fs.readFileSync(filePath, "utf-8");
+            const stripped = stripGradleCommentsAndStrings(raw);
+            GRADLE_KTLINT_PLUGIN_PATTERN.lastIndex = 0;
+            let match;
+            while ((match = GRADLE_KTLINT_PLUGIN_PATTERN.exec(raw)) !== null) {
+                const code = stripped.slice(match.index, match.index + match[0].length);
+                if (!/^\s*$/.test(code))
+                    return { kind: "owned" };
+            }
+        }
+        catch {
+            return { kind: "indeterminate" };
+        }
+    }
+    return { kind: "not-owned" };
+}
+function addGradleBuildLogicFiles(root, files, scan) {
+    if (!fs.existsSync(root))
+        return true;
+    const pending = [root];
+    while (pending.length > 0) {
+        const dir = pending.pop();
+        if (!dir)
+            continue;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            scan.indeterminate = true;
+            continue;
+        }
+        for (const entry of entries) {
+            scan.entries += 1;
+            if (scan.entries > GRADLE_BUILD_LOGIC_SCAN_MAX_ENTRIES)
+                return false;
+            const entryPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                pending.push(entryPath);
+            }
+            else if (entry.isFile() &&
+                GRADLE_BUILD_LOGIC_EXTENSIONS.some((extension) => entry.name.endsWith(extension))) {
+                files.add(entryPath);
+            }
+        }
+    }
+    return true;
+}
 export function hasKtfmtConfig(cwd) {
     const spotlessFormatter = getSpotlessKotlinFormatter(cwd);
     if (spotlessFormatter)
@@ -2557,7 +2710,10 @@ const OXLINT_CONFIGS = [
     "oxlint.config.mts",
 ];
 export function hasOxlintConfig(cwd) {
-    for (const dir of walkUpDirsUntilPackageJson(cwd)) {
+    // Oxlint auto-discovers the nearest config by file location, so the walk
+    // ignores intermediate package.json boundaries just like the flat
+    // ESLint branch above (#3017).
+    for (const dir of walkUpDirs(cwd)) {
         for (const cfg of OXLINT_CONFIGS) {
             if (fs.existsSync(path.join(dir, cfg)))
                 return true;

package/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/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.