@herbertgao/pi-extensions 2026.9.6 → 2026.9.8

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

@@ -0,0 +1,423 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { BoundedFifoMap } from "./bounded-cache.js";
+import { findNearestMarkerRoot } from "./path-utils.js";
+import { getDegradationLedgerGeneration } from "./degradation-ledger.js";
+import { hasBlackConfig, hasClangFormatConfig, hasCljfmtConfig, hasCmakeFormatConfig, hasCsharpierConfig, hasDetektConfig, hasFantomasConfig, hasGoogleJavaFormatConfig, hasGradleKtlintPlugin, hasGolangciConfig, hasKtfmtConfig, hasKtlintConfig, hasMarkdownlintConfig, hasMixFormatConfig, hasOcamlformatConfig, hasOrmoluConfig, hasPhpCsFixerConfig, hasRubocopConfig, hasRuffConfig, hasSqlfluffConfig, hasStandardrbConfig, hasStyluaConfig, hasSwiftformatConfig, hasTaploConfig, hasTerraformConfig, } from "./tool-policy.js";
+const NODE_PACKAGES = {
+    biome: "@biomejs/biome",
+    eslint: "eslint",
+    markdownlint: "markdownlint-cli2",
+    oxfmt: "oxfmt",
+    oxlint: "oxlint",
+    prettier: "prettier",
+    stylelint: "stylelint",
+};
+/**
+ * The complete autonomous writer population. Keep this table declarative: a
+ * caller may ask about an LSP warning tool that is not in the autofix or
+ * formatter tables, and that must take the unknown-tool default below rather
+ * than accidentally becoming established (#3005).
+ *
+ * Config evidence is deliberately presence-based. The existing policy
+ * detectors own each format's syntax and scope; agreement only answers the
+ * narrower question of whether this project elected the tool. Node tools use
+ * the stronger lockfile identity check in `nodeAgreement`.
+ */
+export const TOOL_AGREEMENT_POLICIES = {
+    biome: { bucket: "node-lockfile", withoutEvidence: "decline" },
+    eslint: { bucket: "node-lockfile", withoutEvidence: "decline" },
+    markdownlint: {
+        bucket: "node-lockfile",
+        withoutEvidence: "decline",
+        check: hasMarkdownlintConfig,
+    },
+    oxfmt: { bucket: "node-lockfile", withoutEvidence: "decline" },
+    oxlint: { bucket: "node-lockfile", withoutEvidence: "decline" },
+    prettier: { bucket: "node-lockfile", withoutEvidence: "decline" },
+    stylelint: { bucket: "node-lockfile", withoutEvidence: "decline" },
+    ruff: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasRuffConfig,
+    },
+    black: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasBlackConfig,
+    },
+    sqlfluff: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasSqlfluffConfig,
+    },
+    rubocop: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasRubocopConfig,
+    },
+    standardrb: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasStandardrbConfig,
+    },
+    ktlint: { bucket: "standalone-cli", withoutEvidence: "decline" },
+    // typstyle is a standalone formatter binary. Its smart-default policy is
+    // autonomous, so PATH or managed-install availability is sufficient
+    // agreement; it is not owned by a project manifest (#3037).
+    typstyle: { bucket: "standalone-cli", withoutEvidence: "decline" },
+    ktfmt: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasKtfmtConfig,
+    },
+    "rust-clippy": {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: (cwd) => hasMarker(cwd, ["Cargo.toml"]),
+    },
+    "dart-analyze": {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: (cwd) => hasMarker(cwd, ["pubspec.yaml"]),
+    },
+    "golangci-lint": {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasGolangciConfig,
+    },
+    detekt: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasDetektConfig,
+    },
+    gofmt: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: (cwd) => hasMarker(cwd, ["go.mod"]),
+    },
+    rustfmt: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: (cwd) => hasMarker(cwd, ["Cargo.toml"]),
+    },
+    zig: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: (cwd) => hasMarker(cwd, ["build.zig"]),
+    },
+    dart: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: (cwd) => hasMarker(cwd, ["pubspec.yaml"]),
+    },
+    shfmt: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: (cwd) => hasMarker(cwd, [".editorconfig"]),
+    },
+    // nixfmt has no honest project marker. It remains in the population and is
+    // declined by the conservative absent-evidence path below.
+    nixfmt: { bucket: "project-config", withoutEvidence: "decline" },
+    mix: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasMixFormatConfig,
+    },
+    ocamlformat: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasOcamlformatConfig,
+    },
+    "clang-format": {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasClangFormatConfig,
+    },
+    gleam: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: (cwd) => hasMarker(cwd, ["gleam.toml"]),
+    },
+    terraform: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasTerraformConfig,
+    },
+    "terragrunt-hcl": {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: (cwd) => hasMarker(cwd, ["terragrunt.hcl", "terragrunt.hcl.json"]),
+    },
+    "php-cs-fixer": {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasPhpCsFixerConfig,
+    },
+    csharpier: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasCsharpierConfig,
+    },
+    fantomas: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasFantomasConfig,
+    },
+    swiftformat: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasSwiftformatConfig,
+    },
+    stylua: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasStyluaConfig,
+    },
+    ormolu: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasOrmoluConfig,
+    },
+    taplo: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasTaploConfig,
+    },
+    "google-java-format": {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasGoogleJavaFormatConfig,
+    },
+    cljfmt: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasCljfmtConfig,
+    },
+    "cmake-format": {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: hasCmakeFormatConfig,
+    },
+    "psscriptanalyzer-format": {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: (cwd) => hasMarker(cwd, [
+            "PSScriptAnalyzerSettings.psd1",
+            "ScriptAnalyzerSettings.psd1",
+        ]),
+    },
+    cue: {
+        bucket: "project-config",
+        withoutEvidence: "decline",
+        check: (cwd) => hasMarker(cwd, ["cue.mod"]),
+    },
+};
+function hasMarker(cwd, markers) {
+    return (findNearestMarkerRoot(cwd, markers, {
+        boundaries: [".git", ".hg", ".svn"],
+    }) !== null);
+}
+function readJson(filePath) {
+    if (!fs.existsSync(filePath))
+        return { kind: "missing" };
+    try {
+        const value = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        return value && typeof value === "object"
+            ? { kind: "value", value: value }
+            : { kind: "unparseable" };
+    }
+    catch (error) {
+        return {
+            kind: error instanceof SyntaxError ? "unparseable" : "unreadable",
+        };
+    }
+}
+function declaredRange(pkg, name) {
+    for (const field of [
+        "dependencies",
+        "devDependencies",
+        "optionalDependencies",
+    ]) {
+        const deps = pkg[field];
+        if (deps && typeof deps === "object") {
+            const range = deps[name];
+            if (typeof range === "string")
+                return range;
+        }
+    }
+    return undefined;
+}
+function parseCoreVersion(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
+    if (!match)
+        return undefined;
+    const parts = match.slice(1).map(Number);
+    if (parts.some((part) => !Number.isSafeInteger(part)))
+        return undefined;
+    return parts;
+}
+function exactOrSimpleRangeMatches(range, version) {
+    const clean = range.trim().replace(/^v/, "");
+    const actual = parseCoreVersion(version);
+    if (!actual)
+        return { matches: false, unsupported: version.includes("+") };
+    if (/^\d+\.\d+\.\d+$/.test(clean))
+        return { matches: clean === version, unsupported: false };
+    const caret = clean.match(/^\^(\d+)\.(\d+)\.(\d+)$/);
+    if (caret) {
+        const [major, minor, patch] = caret.slice(1).map(Number);
+        return {
+            matches: actual[0] === major &&
+                (major !== 0 || actual[1] === minor) &&
+                (major !== 0 || minor !== 0 || actual[2] === patch) &&
+                (actual[1] > minor || (actual[1] === minor && actual[2] >= patch)),
+            unsupported: false,
+        };
+    }
+    const tilde = clean.match(/^~(\d+)\.(\d+)\.(\d+)$/);
+    if (tilde) {
+        const [major, minor, patch] = tilde.slice(1).map(Number);
+        return {
+            matches: actual[0] === major && actual[1] === minor && actual[2] >= patch,
+            unsupported: false,
+        };
+    }
+    return { matches: false, unsupported: true };
+}
+function nodeAgreement(tool, root) {
+    const packageName = NODE_PACKAGES[tool];
+    if (!packageName)
+        return undefined;
+    const pkg = readJson(path.join(root, "package.json"));
+    if (pkg.kind === "unreadable" || pkg.kind === "unparseable") {
+        return {
+            decision: "decline",
+            subject: `node:${tool}`,
+            reason: `the project package.json is ${pkg.kind}; tool agreement cannot be established`,
+            reasonCode: `evidence-${pkg.kind}`,
+        };
+    }
+    const range = pkg.kind === "value" ? declaredRange(pkg.value, packageName) : undefined;
+    if (!range)
+        return undefined;
+    const lock = readJson(path.join(root, "package-lock.json"));
+    if (lock.kind === "unreadable" || lock.kind === "unparseable") {
+        return {
+            decision: "decline",
+            subject: `node:${tool}`,
+            reason: `the project package-lock.json is ${lock.kind}; tool agreement cannot be established`,
+            reasonCode: `evidence-${lock.kind}`,
+        };
+    }
+    const packages = lock.kind === "value" ? lock.value.packages : undefined;
+    const entry = packages && typeof packages === "object"
+        ? packages[`node_modules/${packageName}`]
+        : undefined;
+    const version = entry && typeof entry === "object"
+        ? entry.version
+        : undefined;
+    const comparison = typeof version === "string"
+        ? exactOrSimpleRangeMatches(range, version)
+        : { matches: false, unsupported: false };
+    if (typeof version !== "string" || !comparison.matches) {
+        const reasonCode = typeof version === "string" && comparison.unsupported
+            ? "evidence-unsupported"
+            : typeof version === "string" && version.includes("+")
+                ? "evidence-unsupported"
+                : "evidence-unparseable";
+        const reason = typeof version === "string" && comparison.unsupported
+            ? `the project declares ${packageName}@${range}, but the lockfile shape ${packageName}@${version} or its range is unsupported; tool agreement cannot be established`
+            : typeof version === "string" && parseCoreVersion(version)
+                ? `the project declares ${packageName}@${range} in package.json, but the lockfile resolves ${packageName}@${version} in package-lock.json; agreement disagrees`
+                : `the project declares ${packageName}@${range} in package.json, but package-lock.json does not establish its resolved version; tool agreement cannot be established`;
+        return {
+            decision: "decline",
+            subject: `node:${tool}`,
+            reason,
+            reasonCode,
+        };
+    }
+    return { decision: "established" };
+}
+/** Decide whether autofix has project evidence to act on. Never infers a CLI
+ * version from build-plugin metadata (#3000). */
+export function establishToolAgreement(tool, cwd) {
+    const key = `${getDegradationLedgerGeneration()}\0${path.resolve(cwd)}\0${tool}`;
+    const cached = agreementCache.get(key);
+    if (cached)
+        return cached;
+    agreementResolutionCount += 1;
+    const policy = TOOL_AGREEMENT_POLICIES[tool];
+    if (!policy) {
+        const agreement = {
+            decision: "decline",
+            subject: `tool:${tool}`,
+            reason: "the autonomous writer is not registered with a project-evidence policy; tool agreement cannot be established",
+            reasonCode: "evidence-unsupported",
+        };
+        agreementCache.set(key, agreement);
+        return agreement;
+    }
+    let agreement = { decision: "established" };
+    if (tool === "ktlint") {
+        const ownership = hasGradleKtlintPlugin(cwd);
+        if (ownership.kind === "owned" || hasKtlintConfig(cwd)) {
+            agreement = {
+                decision: "decline",
+                subject: "kotlin:gradle-ktlint",
+                reason: "the project resolves ktlint through Gradle, so CLI agreement cannot be established from project data",
+                reasonCode: "evidence-unsupported",
+            };
+        }
+        else if (ownership.kind === "indeterminate") {
+            agreement = {
+                decision: "decline",
+                subject: "kotlin:gradle-ktlint",
+                reason: "Gradle ownership evidence is unreadable or exceeded its scan budget; tool agreement cannot be established",
+                reasonCode: "evidence-unreadable",
+            };
+        }
+    }
+    if (agreement.decision === "established" &&
+        policy.bucket === "node-lockfile") {
+        const root = findNearestMarkerRoot(cwd, ["package.json"], {
+            boundaries: [".git", ".hg", ".svn"],
+        });
+        const node = root ? nodeAgreement(tool, root) : undefined;
+        agreement = node ?? {
+            decision: "decline",
+            subject: `node:${tool}`,
+            reason: "the project has no package declaration and lockfile evidence for this tool",
+            reasonCode: "evidence-absent",
+        };
+    }
+    else if (agreement.decision === "established" &&
+        policy.bucket === "project-config" &&
+        (!policy.check || !policy.check(cwd))) {
+        agreement = {
+            decision: "decline",
+            subject: `project:${tool}`,
+            reason: "the project has no readable configuration or manifest evidence selecting this tool",
+            reasonCode: "evidence-absent",
+        };
+    }
+    /* Keep the branch below as a final assertion that no policy can bypass the
+     * registry. It also makes future bucket additions fail closed at runtime. */
+    if (agreement.decision === "established" && !policy.bucket) {
+        agreement = {
+            decision: "decline",
+            subject: `tool:${tool}`,
+            reason: "the tool evidence bucket is unsupported",
+            reasonCode: "evidence-unsupported",
+        };
+    }
+    agreementCache.set(key, agreement);
+    return agreement;
+}
+const agreementCache = new BoundedFifoMap(512);
+let agreementResolutionCount = 0;
+/** Test-only counter for the bounded hot-path resolution. */
+export function _getAgreementResolutionCountForTests() {
+    return agreementResolutionCount;
+}

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

@@ -1,5 +1,6 @@
 /** Shared resolver for model-facing tool availability (#2800). */
 import { readFlagConfigValue } from "./lens-flag-registry.js";
+import { escapeRegExp } from "./string-utils.js";
 /** The complete model-facing tool population on pi and MCP. */
 export const TOOL_REGISTRY = [
     {
@@ -140,6 +141,55 @@ export const TOOL_REGISTRY = [
     },
 ];
 export const LENS_TOOL_NAMES = TOOL_REGISTRY.map((tool) => tool.name);
+/**
+ * Registry tools with a pi name but no MCP name are pi-only BY DECLARATION
+ * here, never by omission (#2535 F3). A missing entry used to degrade
+ * silently into the pi name on MCP, sending the agent to a dead call — the
+ * guard in tests/clients/adapter-aware-tool-names.test.ts fails on any
+ * pi-only row absent from this map, and `resolveLensToolName` resolves a
+ * known-but-unmapped host to `undefined` so callers omit instead of naming.
+ */
+export const PI_ONLY_TOOL_REASONS = {
+    ast_grep_outline: "pi situational tool with no MCP mirror; MCP parity deferred like read_enclosing was.",
+    lens_diagnostic_mark: "pi-lens-internal disposition tool; MCP has no equivalent surface (needs its own engine seam and tool route).",
+    pi_lens_activate_tools: "pi dynamic-tooling loader; MCP lists every tool statically, so there is nothing to activate.",
+};
+/**
+ * Resolve the name an agent can call on the delivery host. Unknown names
+ * pass through unchanged (no registry identity). A known tool WITHOUT a
+ * mapping on the requested host resolves to `undefined` — the caller must
+ * omit or rephrase, never print a name the host cannot resolve.
+ */
+export function resolveLensToolName(name, host = "pi") {
+    const entry = TOOL_REGISTRY.find((tool) => tool.name === name || tool.piName === name || tool.mcpName === name);
+    if (!entry)
+        return name;
+    if (host === "mcp")
+        return entry.mcpName;
+    return entry.piName;
+}
+/**
+ * Render already-written advisory text for the delivery host (#2535). The pi
+ * host reads it back unchanged. For MCP, every whole-word pi tool name with
+ * an MCP mapping becomes its callable MCP name (driven by TOOL_REGISTRY,
+ * longest first — never a hand-maintained second map), and the pi-only
+ * activation clause is rephrased since MCP lists every tool statically.
+ * A pi-only name with no MCP surface never survives translation: it is
+ * either rephrased here or caught by the adapter-aware guard.
+ */
+export function translateGuidanceToolNames(content, host) {
+    if (host === "pi")
+        return content;
+    let text = content;
+    const byLength = [...TOOL_REGISTRY].sort((a, b) => (b.piName?.length ?? 0) - (a.piName?.length ?? 0));
+    for (const entry of byLength) {
+        if (typeof entry.piName !== "string" || typeof entry.mcpName !== "string") {
+            continue;
+        }
+        text = text.replace(new RegExp(`\\b${escapeRegExp(entry.piName)}\\b`, "g"), entry.mcpName);
+    }
+    return text.replace("activate via pi_lens_activate_tools", "call directly");
+}
 export function toolRegistryEntryForPi(name) {
     return TOOL_REGISTRY.find((tool) => tool.piName === name);
 }

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

@@ -5,6 +5,7 @@ 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: [
@@ -82,70 +83,24 @@ export const FORMATTER_MARKERS = {
         "settings.gradle.kts",
         ".gitignore",
     ],
-};
-const RUNNER_MARKERS = {
-    yamllint: [".yamllint", "yamllint.yaml", "yamllint.yml", "pyproject.toml"],
-    ruff: ["pyproject.toml", "ruff.toml", ".ruff.toml"],
-    "spellcheck/typos": ["_typos.toml", "typos.toml"],
-    biome: ["biome.json", "biome.jsonc", "package.json"],
-    oxlint: [".oxlintrc.json", "oxlint.config.js", "package.json"],
-    sqlfluff: [".sqlfluff", "pyproject.toml", "setup.cfg"],
-    prettier: [".prettierignore", "package.json"],
-    // #2894: cargo must run at the package root. This is the marker walk
-    // `rust-clippy.ts` used to do for itself with `findNearestContaining`.
-    "rust-clippy": ["Cargo.toml"],
+    typstyle: [".gitignore"],
 };
 const toolCwdGeneration = createGenerationSource("tool-cwd");
 const logged = createGenerationMap("tool-cwd-resolution-log");
-const markerWalks = new Map();
-const markerWalkGenerations = createGenerationMap("tool-cwd-marker-walks");
-let markerWalkCount = 0;
-/** Pure key seam for ephemeral tool-cwd memo and log identity. */
+/** Pure key seam for resolution-log and runner-advisory identity. */
 export function _toolCwdEphemeralKey(parts) {
     return parts.map(normalizeEphemeralMapKey).join("\0");
 }
-/** Test probe for the per-generation walk memo; not part of runtime behavior. */
-export function _getToolCwdMarkerWalkCount() {
-    return markerWalkCount;
-}
 function syncGeneration() {
     if (toolCwdGeneration.current() === getDegradationLedgerGeneration())
         return;
-    markerWalks.clear();
-    markerWalkGenerations.clear();
     logged.clear();
     while (toolCwdGeneration.current() < getDegradationLedgerGeneration()) {
         toolCwdGeneration.bump();
     }
 }
-function findMarkerRoot(startDir, markers, homeDir) {
-    syncGeneration();
-    const key = _toolCwdEphemeralKey([
-        path.resolve(startDir),
-        ...markers,
-        path.resolve(homeDir),
-    ]);
-    const cached = markerWalks.get(key);
-    if (cached && markerWalkGenerations.current(key) !== 0) {
-        // A negative walk is not stable: a project marker can be created after
-        // the first resolution, so do not cache absence across calls. Positive
-        // results remain memoized and are still revalidated when their marker is
-        // deleted (#2894).
-        if (!cached.marker || !cached.root) {
-            markerWalks.delete(key);
-            markerWalkGenerations.forget(key);
-        }
-        else {
-            // #2777: a marker can disappear during a session; do not reuse a stale root.
-            if (existsSync(path.join(cached.root, cached.marker)))
-                return cached;
-            markerWalks.delete(key);
-            markerWalkGenerations.forget(key);
-        }
-    }
-    markerWalkCount++;
+function walkMarkerRoot(startDir, markers, homeDir) {
     let current = path.resolve(startDir);
-    let result = { root: null };
     for (let depth = 0; depth < 64; depth++) {
         if (isAtOrAboveHomeDir(current, homeDir))
             break;
@@ -169,32 +124,27 @@ function findMarkerRoot(startDir, markers, homeDir) {
             else {
                 found = existsSync(path.join(target, basename));
             }
-            if (found) {
-                result = { root: current, marker };
-                markerWalks.set(key, result);
-                markerWalkGenerations.bump(key);
-                return result;
-            }
+            if (found)
+                return { root: current, marker };
         }
         const parentDir = path.dirname(current);
         if (parentDir === current)
             break;
         current = parentDir;
     }
-    markerWalks.set(key, result);
-    markerWalkGenerations.bump(key);
-    return result;
+    return { root: null };
+}
+function findMarkerRoot(startDir, markers, homeDir) {
+    syncGeneration();
+    return walkMarkerRoot(startDir, markers, homeDir);
 }
-function markersFor(kind, tool, ctx) {
+function markersFor(kind, tool, file, ctx) {
     if (kind === "lsp")
         return ctx.rootMarkers ?? [];
-    // #2871: caller-supplied markers count for runners too. `RUNNER_MARKERS`
-    // covers the linter/formatter-shaped runners this module has always known;
-    // a caller that owns its own marker table — the test runner, whose
-    // `RUNNERS[x].configFiles` IS that table — passes it here rather than
-    // registering a second copy of the same data in this file.
+    // #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 ?? RUNNER_MARKERS[tool] ?? [];
+        return ctx.rootMarkers ?? rootMarkersForFile(file, tool);
     return FORMATTER_MARKERS[tool] ?? [".gitignore"];
 }
 function emitResolution(kind, tool, cwd, reason) {
@@ -239,9 +189,9 @@ export function resolveToolCwd(kind, tool, file, ctx) {
         const serverRoot = rootPath.resolve(ctx.serverRoot);
         if (!ctx.suppressTelemetry)
             emitResolution(kind, tool, serverRoot, "server-root");
-        return serverRoot;
+        return { cwd: serverRoot };
     }
-    const markers = markersFor(kind, tool, ctx);
+    const markers = markersFor(kind, tool, absoluteFile, ctx);
     const markerResult = markers.length
         ? findMarkerRoot(fileDir, markers, ctx.allowHomeMarker ? path.parse(homeDir).root : homeDir)
         : { root: null };
@@ -251,16 +201,34 @@ export function resolveToolCwd(kind, tool, file, ctx) {
         const finalReason = `marker:${markerResult.marker ?? markers[0]}`;
         if (!ctx.suppressTelemetry)
             emitResolution(kind, tool, markerRoot, finalReason);
-        return markerRoot;
+        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 gitResult = findMarkerRoot(fileDir, [".git"], homeDir);
-    const 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 gitRoot;
+        return { cwd: gitRoot, marker: ".git" };
     }
     if (insideDispatch) {
         if (kind === "formatter") {
@@ -273,11 +241,11 @@ export function resolveToolCwd(kind, tool, file, ctx) {
                     reason: `${kind}:home-cap:${absoluteFile}`,
                 });
             }
-            return fileDir;
+            return { cwd: fileDir };
         }
         if (!ctx.suppressTelemetry)
             emitResolution(kind, tool, dispatchRoot, "dispatch-root");
-        return dispatchRoot;
+        return { cwd: dispatchRoot };
     }
     const reason = isUnderDir(fileDir, homeDir)
         ? "file-dir-fallback"
@@ -291,9 +259,12 @@ export function resolveToolCwd(kind, tool, file, ctx) {
         });
     if (!ctx.suppressTelemetry)
         emitResolution(kind, tool, fallback, reason);
-    return fallback;
+    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);
 }