pi-lens 3.8.71 → 3.8.72

package/dist/clients/dispatch/runners/lsp.js

@@ -18,6 +18,8 @@ import { resolveRunnerPath } from "../runner-context.js";
 import { convertLspDiagnostics } from "../utils/lsp-diagnostics.js";
 import { enabledAuxiliaryLspServerIds, retagAuxiliaryDiagnostics, } from "../auxiliary-lsp.js";
 import { readFileContent } from "./utils.js";
+import { tryWarmAttachedCodeActions, tryWarmAttachedDiagnostics, } from "../../warm-attach.js";
+import { contentHash, WARM_CODE_ACTION_LOOKUP_LIMIT, } from "../../mcp/ipc.js";
 const LSP_MAX_FILE_BYTES = RUNTIME_CONFIG.pipeline.lspMaxFileBytes;
 const LSP_MAX_FILE_LINES = RUNTIME_CONFIG.pipeline.lspMaxFileLines;
 const LSP_SPAWN_BUDGET_MS = RUNTIME_CONFIG.pipeline.lspSpawnBudgetMs;
@@ -27,7 +29,6 @@ const LSP_SPAWN_BUDGET_MS = RUNTIME_CONFIG.pipeline.lspSpawnBudgetMs;
 // after the cap still land in the client's cache and surface on the
 // next edit. Overridable via PI_LENS_LSP_DIAGNOSTICS_MAX_WAIT_MS.
 const LSP_DIAGNOSTICS_WAIT_MS = 2500;
-const MAX_CODE_ACTION_LOOKUPS = 6;
 const MAX_CODE_ACTION_TITLES = 3;
 function normalizeActionTitle(title) {
     return title.replace(/\s+/g, " ").trim();
@@ -109,6 +110,7 @@ const lspRunner = {
         // one spawned server) — an empty `lspDiags` in that case is NOT a
         // confirmed clean result and must not be reported as one (#570).
         let diagnosticsInconclusive = false;
+        let usedWarmAttach = false;
         let failureReason = "";
         const content = readFileContent(ctx.filePath);
         if (!content) {
@@ -124,21 +126,27 @@ const lspRunner = {
         // path so their warm diagnostics merge into this same result.
         const auxiliaryServerIds = enabledAuxiliaryLspServerIds((f) => ctx.pi.getFlag(f));
         try {
-            const touched = await lspService.touchFile(ctx.filePath, content, {
-                diagnostics: "document",
-                collectDiagnostics: true,
-                clientScope: auxiliaryServerIds.length > 0 ? "with-auxiliary" : "primary",
-                auxiliaryServerIds,
-                maxClientWaitMs: LSP_SPAWN_BUDGET_MS,
-                maxDiagnosticsWaitMs: LSP_DIAGNOSTICS_WAIT_MS,
-                source: "dispatch-lsp-runner",
-            });
+            const attached = await tryWarmAttachedDiagnostics(ctx.filePath, content, Math.max(LSP_SPAWN_BUDGET_MS, LSP_DIAGNOSTICS_WAIT_MS));
+            usedWarmAttach = attached?.available === true;
+            const touched = attached?.available
+                ? attached.response.diagnostics
+                : await lspService.touchFile(ctx.filePath, content, {
+                    diagnostics: "document",
+                    collectDiagnostics: true,
+                    clientScope: auxiliaryServerIds.length > 0 ? "with-auxiliary" : "primary",
+                    auxiliaryServerIds,
+                    maxClientWaitMs: LSP_SPAWN_BUDGET_MS,
+                    maxDiagnosticsWaitMs: LSP_DIAGNOSTICS_WAIT_MS,
+                    source: "dispatch-lsp-runner",
+                });
             if (touched === undefined) {
                 lspClientReady = false;
             }
             else {
                 lspDiags = touched;
-                diagnosticsInconclusive = touched.inconclusive === true;
+                diagnosticsInconclusive =
+                    touched
+                        .inconclusive === true;
             }
         }
         catch (err) {
@@ -206,21 +214,42 @@ const lspRunner = {
         const blockingDiagIndexes = validLspDiags
             .map((d, idx) => ({ d, idx }))
             .filter(({ d }) => d.severity === 1)
-            .slice(0, MAX_CODE_ACTION_LOOKUPS);
-        await Promise.all(blockingDiagIndexes.map(async ({ d, idx }) => {
-            try {
-                const start = d.range.start;
-                const end = d.range.end ?? d.range.start;
-                const actions = await lspService.codeAction(ctx.filePath, start.line, start.character, end.line, end.character);
-                const suggestion = buildCodeActionSuggestion(actions);
-                if (suggestion) {
-                    fixSuggestionByIndex.set(idx, suggestion);
-                }
-            }
-            catch {
-                // Best-effort enrichment only; base diagnostics remain authoritative.
+            .slice(0, WARM_CODE_ACTION_LOOKUP_LIMIT);
+        if (usedWarmAttach) {
+            // Diagnostics have already succeeded. Code actions are optional
+            // enrichment, so ANY IPC failure degrades to today's skip without
+            // promoting the attached session to a local LSP fleet.
+            const ranges = blockingDiagIndexes.map(({ d }) => ({
+                start: d.range.start,
+                end: d.range.end ?? d.range.start,
+            }));
+            const result = await tryWarmAttachedCodeActions(ctx.filePath, contentHash(content), ranges, LSP_DIAGNOSTICS_WAIT_MS);
+            if (result?.available) {
+                result.response.actions.forEach((actions, responseIndex) => {
+                    const diagnosticIndex = blockingDiagIndexes[responseIndex]?.idx;
+                    const suggestion = buildCodeActionSuggestion(actions);
+                    if (diagnosticIndex !== undefined && suggestion) {
+                        fixSuggestionByIndex.set(diagnosticIndex, suggestion);
+                    }
+                });
             }
-        }));
+        }
+        else {
+            await Promise.all(blockingDiagIndexes.map(async ({ d, idx }) => {
+                try {
+                    const start = d.range.start;
+                    const end = d.range.end ?? d.range.start;
+                    const actions = await lspService.codeAction(ctx.filePath, start.line, start.character, end.line, end.character);
+                    const suggestion = buildCodeActionSuggestion(actions);
+                    if (suggestion) {
+                        fixSuggestionByIndex.set(idx, suggestion);
+                    }
+                }
+                catch {
+                    // Best-effort enrichment only; base diagnostics remain authoritative.
+                }
+            }));
+        }
         const diagnostics = convertLspDiagnostics(validLspDiags, diagnosticPath, { fixSuggestionByIndex });
         // convertLspDiagnostics maps validLspDiags 1:1, so re-tag any
         // auxiliary-sourced diagnostics (opengrep emits source "Semgrep", …) with

package/dist/clients/dispatch/runners/markdownlint.js

@@ -1,3 +1,4 @@
+import { resolvePackagePath } from "../../package-root.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd, hasMarkdownlintConfig, } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
@@ -93,9 +94,6 @@ const markdownlintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const hasConfig = hasMarkdownlintConfig(cwd);
-        if (!hasConfig) {
-            // Run with sensible defaults even without explicit config
-        }
         let cmd = null;
         if (await (markdownlint.isAvailableAsync(cwd))) {
             cmd = markdownlint.getCommand(cwd);
@@ -105,7 +103,12 @@ const markdownlintRunner = {
         }
         if (!cmd)
             return { status: "skipped", diagnostics: [], semantic: "none" };
-        const configArgs = hasConfig ? [] : ["--disable", "MD013"];
+        const configArgs = hasConfig
+            ? []
+            : [
+                "--config",
+                resolvePackagePath(import.meta.url, "config/markdownlint/core.json"),
+            ];
         const result = await safeSpawnAsync(cmd, [...configArgs, ctx.filePath], {
             timeout: 15000,
             cwd,

package/dist/clients/dispatch/runners/pyright.js

@@ -82,6 +82,7 @@ const pyrightRunner = {
                         ? "warning"
                         : "none",
             };
+            // pi-lens-ignore: missing-error-propagation
         }
         catch {
             console.error(`[runner:pyright] JSON parse failed for ${ctx.filePath} — raw output: ${output.slice(0, 200)}`);

package/dist/clients/dispatch/runners/tree-sitter.js

@@ -23,7 +23,7 @@ function runBlastRadiusInBackground(cwd, filePath, languageId, facts) {
     void (async () => {
         try {
             const graph = await buildOrUpdateGraph(cwd, [filePath], facts);
-            const impact = computeImpactCascade(graph, filePath);
+            const impact = computeImpactCascade(graph, filePath, cwd);
             logTreeSitter({
                 phase: "blast_radius",
                 filePath,

package/dist/clients/env-utils.js

@@ -43,3 +43,41 @@ export function toPositiveFinite(value) {
     const num = typeof value === "number" ? value : Number(value);
     return Number.isFinite(num) && num > 0 ? num : 0;
 }
+/**
+ * Factory for the lazy-memoized "positive-finite-number env override, else a
+ * default" getter pattern repeated across `startup-scan.ts` (#699, #758) and
+ * originally documented as house style in `runtime-config.ts` / `slow-fs.ts` /
+ * `subagent-mode.ts` (#763).
+ *
+ * `get()` reads `process.env[envName]` through {@link toPositiveFinite} the
+ * first time it's called, memoizes the result (or `fallback` when the env var
+ * is unset/non-finite/non-positive), and returns the memo on every subsequent
+ * call. `_resetForTests()` clears the memo so a test can flip the env var and
+ * observe a fresh read (matching the existing `_resetForTests` convention).
+ *
+ * Deliberately does NOT touch `process.env` until `get()` is first called —
+ * that's the entire point of the lazy pattern: importing a module must never
+ * have a side effect on process env at load time.
+ *
+ * @example
+ * ```ts
+ * const _ttl = lazyEnvNumber("PI_LENS_STARTUP_SCAN_VERDICT_TTL_MS", DEFAULT_TTL_MS);
+ * export const getStartupScanVerdictTtlMs = _ttl.get;
+ * export const _resetStartupScanVerdictTtlForTests = _ttl._resetForTests;
+ * ```
+ */
+export function lazyEnvNumber(envName, fallback) {
+    let memo;
+    return {
+        get() {
+            if (memo !== undefined)
+                return memo;
+            const envValue = toPositiveFinite(process.env[envName]);
+            memo = envValue > 0 ? envValue : fallback;
+            return memo;
+        },
+        _resetForTests() {
+            memo = undefined;
+        },
+    };
+}

package/dist/clients/file-utils.js

@@ -8,7 +8,7 @@ import { minimatch } from "./deps/minimatch.js";
 import { collectTrackedFiles, getTrackedFilesSnapshot } from "./git-tracked-ignore.js";
 import { getGlobalIgnorePatterns, getPiLensGlobalConfigPath, } from "./lens-config.js";
 import { normalizeEphemeralMapKey, normalizeFilePath } from "./path-utils.js";
-import { findPiLensProjectConfig, loadPiLensProjectConfig, } from "./project-lens-config.js";
+import { findPiLensConfigInDir, findPiLensProjectConfig, loadPiLensConfigInDir, loadPiLensProjectConfig, } from "./project-lens-config.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 /**
  * Return the directory where pi-lens stores project-specific data
@@ -252,16 +252,34 @@ function ancestorDirsBetween(rootDir, targetDir) {
 }
 function buildProjectIgnoreMatcher(resolvedRoot, patterns) {
     const nestedCache = new Map();
+    // #783: layer a NESTED `.pi-lens.json`'s `ignore` field the same way a
+    // nested `.gitignore` is already layered — each ancestor directory between
+    // `resolvedRoot` and the target is checked for its OWN config file (no
+    // upward walk; `findPiLensConfigInDir`/`loadPiLensConfigInDir` look only
+    // directly in `dir`), and its `ignore` patterns are anchored to `dir` (same
+    // anchoring semantics as a `.gitignore` living in that directory) and
+    // tagged `"pilens"` so #703's tracked-file-rescue rule still skips them.
+    // `loadPiLensConfigInDir` reuses `project-lens-config.ts`'s own
+    // path+mtime cache, so this never re-reads/re-parses JSON that some other
+    // caller (or the root-config lookup above) already loaded.
     const patternsForDir = (dir) => {
         if (dir === resolvedRoot)
             return patterns;
         const gitignoreMtime = gitignoreMtimeMs(dir);
+        const pilensMtime = findPiLensConfigInDir(dir)?.mtimeMs ?? -1;
         const cached = nestedCache.get(dir);
-        if (cached?.gitignoreMtimeMs === gitignoreMtime)
+        if (cached?.gitignoreMtimeMs === gitignoreMtime &&
+            cached?.pilensMtimeMs === pilensMtime) {
             return cached.patterns;
-        const nextPatterns = readGitignorePatterns(dir);
+        }
+        const nestedConfig = loadPiLensConfigInDir(dir);
+        const nextPatterns = [
+            ...readGitignorePatterns(dir),
+            ...parseGitignoreContent(nestedConfig.ignore.join("\n"), "pilens"),
+        ];
         nestedCache.set(dir, {
             gitignoreMtimeMs: gitignoreMtime,
+            pilensMtimeMs: pilensMtime,
             patterns: nextPatterns,
         });
         return nextPatterns;

package/dist/clients/instance-registry.js

@@ -22,6 +22,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { writeFileAtomic, writeFileAtomicAsync } from "./atomic-write.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
 // #735: reuse the #449/#525 reaper's exact conservative liveness check
 // (`process.kill(pid, 0)`, ESRCH-only-means-dead) rather than inventing a
@@ -34,6 +35,7 @@ import { getGlobalPiLensDir } from "./file-utils.js";
 // import is actually invoked.
 import { realIsPidAlive } from "./instance-reaper.js";
 import { normalizeFilePath } from "./path-utils.js";
+import { getSubagentIdentity, isSubagentSession, } from "./subagent-mode.js";
 function registryPath() {
     return path.join(getGlobalPiLensDir(), "instances.json");
 }
@@ -87,44 +89,32 @@ export async function readInstanceRegistry() {
     const file = await readRegistryAsync();
     return file.instances;
 }
-// --- Write (atomic tmp + rename, same pattern as review-graph/builder.ts) ---
+// --- Write (atomic tmp + rename via clients/atomic-write.ts, #762) ---
 async function writeRegistryAsync(file) {
     const dir = getGlobalPiLensDir();
     const target = registryPath();
-    const tmpPath = `${target}.tmp-${process.pid}`;
     try {
         await fs.promises.mkdir(dir, { recursive: true });
-        await fs.promises.writeFile(tmpPath, JSON.stringify(file), "utf-8");
-        await fs.promises.rename(tmpPath, target);
     }
     catch {
-        // Best-effort observability substrate — a failed write just means this
+        // Best-effort observability substrate — a failed mkdir just means this
         // update is lost, never a thrown error for the caller.
-        try {
-            await fs.promises.rm(tmpPath, { force: true });
-        }
-        catch {
-            // ignore
-        }
+        return;
     }
+    // bestEffort (default): a failed write just means this update is lost,
+    // never a thrown error for the caller.
+    await writeFileAtomicAsync(target, JSON.stringify(file));
 }
 function writeRegistrySync(file) {
     const dir = getGlobalPiLensDir();
     const target = registryPath();
-    const tmpPath = `${target}.tmp-${process.pid}`;
     try {
         fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(tmpPath, JSON.stringify(file), "utf-8");
-        fs.renameSync(tmpPath, target);
     }
     catch {
-        try {
-            fs.rmSync(tmpPath, { force: true });
-        }
-        catch {
-            // ignore
-        }
+        return;
     }
+    writeFileAtomic(target, JSON.stringify(file));
 }
 // --- Mutations (all read-modify-write whole file) ---
 /** Create/overwrite this process's entry. */
@@ -137,6 +127,15 @@ export async function registerInstance(projectRoot) {
     const now = new Date().toISOString();
     const others = file.instances.filter((entry) => entry.pid !== pid);
     const existing = file.instances.find((entry) => entry.pid === pid);
+    const identity = isSubagentSession() ? getSubagentIdentity() : undefined;
+    const subagent = identity
+        ? {
+            marker: identity.marker,
+            agentType: identity.agentName,
+            parentPid: identity.parentPid,
+            runId: identity.runId,
+        }
+        : undefined;
     others.push({
         pid,
         startedAt: existing?.startedAt ?? now,
@@ -145,6 +144,7 @@ export async function registerInstance(projectRoot) {
         lspChildCount: existing?.lspChildren?.length ?? 0,
         rssBytes: process.memoryUsage().rss,
         heartbeatAt: now,
+        ...(subagent ? { subagent } : {}),
     });
     await writeRegistryAsync({ instances: others });
 }

package/dist/clients/jscpd-client.js

@@ -11,9 +11,12 @@ import * as fs from "node:fs";
 import { mkdtempSync } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { getExcludedDirGlobs, getGlobalPiLensDir, getProjectIgnoreGlobs, getProjectIgnoreMatcher, isExcludedDirName, } from "./file-utils.js";
+import { getExcludedDirGlobs, getGlobalPiLensDir, getProjectIgnoreGlobs, getProjectIgnoreMatcher, } from "./file-utils.js";
 import { findNodeToolBinary } from "./package-manager.js";
+import { isAtOrAboveHomeDir } from "./path-utils.js";
+import { getJscpdMaxEntriesDerived } from "./project-scale.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
+import { shouldRecurseIntoDir, walkTreeStackSync } from "./source-walker.js";
 const EMPTY_RESULT = {
     success: false,
     clones: [],
@@ -45,46 +48,42 @@ export class JscpdClient {
      * them.
      */
     hasSourceFilesRecursive(rootDir) {
-        const stack = [rootDir];
         const ignoreMatcher = getProjectIgnoreMatcher(rootDir);
-        let visited = 0;
-        const MAX_ENTRIES = 6000;
-        while (stack.length > 0 && visited < MAX_ENTRIES) {
-            const dir = stack.pop();
-            if (!dir)
-                continue;
-            let entries;
-            try {
-                entries = fs.readdirSync(dir, { withFileTypes: true });
-            }
-            catch {
-                continue;
+        const state = { visited: 0 };
+        // #776: derived from the `maxProjectFiles` scale knob (project-scale.ts),
+        // reproducing this same 6,000 default at the default base.
+        const MAX_ENTRIES = getJscpdMaxEntriesDerived(rootDir);
+        // #761: the traversal loop, readdir-safety, and directory-recursion
+        // decision are the shared `walkTreeStackSync` engine; this client keeps
+        // its own per-entry policy (skip ALL symlinks — files too — before the
+        // dir/file branch, its own multi-language source regex, and a
+        // per-directory entry budget via `shouldStop`, matching the pre-#761
+        // `while (stack.length > 0 && visited < MAX_ENTRIES)` condition: the
+        // current directory's entry loop always finishes, but no further
+        // directory is popped once the budget is spent).
+        return walkTreeStackSync(rootDir, (entry, fullPath) => {
+            state.visited += 1;
+            if (entry.isSymbolicLink())
+                return "skip";
+            if (entry.isDirectory()) {
+                return shouldRecurseIntoDir(entry, fullPath, {
+                    ignoreMatcher,
+                    followSymlinks: true,
+                })
+                    ? "recurse"
+                    : "skip";
             }
-            for (const entry of entries) {
-                visited += 1;
-                if (entry.isSymbolicLink())
-                    continue;
-                if (entry.isDirectory()) {
-                    const fullPath = path.join(dir, entry.name);
-                    if (isExcludedDirName(entry.name))
-                        continue;
-                    if (ignoreMatcher.isIgnored(fullPath, true))
-                        continue;
-                    stack.push(fullPath);
-                    continue;
-                }
-                if (!entry.isFile())
-                    continue;
-                if (ignoreMatcher.isIgnored(path.join(dir, entry.name), false))
-                    continue;
-                if (/\.(ts|tsx|js|jsx|mjs|cjs|py|pyi|java|go|rs|rb|php|swift|kt|kts|dart|lua|scala|c|h|cpp|cc|cxx|hpp|hxx|cs|m|mm)$/.test(entry.name)) {
-                    if (entry.name.endsWith(".d.ts"))
-                        continue;
-                    return true;
-                }
+            if (!entry.isFile())
+                return "skip";
+            if (ignoreMatcher.isIgnored(fullPath, false))
+                return "skip";
+            if (/\.(ts|tsx|js|jsx|mjs|cjs|py|pyi|java|go|rs|rb|php|swift|kt|kts|dart|lua|scala|c|h|cpp|cc|cxx|hpp|hxx|cs|m|mm)$/.test(entry.name)) {
+                if (entry.name.endsWith(".d.ts"))
+                    return "skip";
+                return "stop";
             }
-        }
-        return false;
+            return "skip";
+        }, { shouldStop: () => state.visited >= MAX_ENTRIES });
     }
     /**
      * Check if jscpd is available, auto-install if not
@@ -144,9 +143,23 @@ export class JscpdClient {
      * Scan a directory for duplicate code blocks.
      * Uses a temp output dir to capture JSON report.
      * @param isTsProject - If true, excludes .js files (they're compiled artifacts in TS projects)
+     *
+     * Root contract (#747/#250): unlike `KnipClient`/`DeadCodeClient`, this
+     * client does NOT resolve a project root via `findNearestMarkerRoot`, so it
+     * has historically relied on every caller to guard the scan root itself. The
+     * `isAtOrAboveHomeDir` refusal below is belt-and-braces internal protection
+     * so a FUTURE caller that forgets that contract can't spawn a whole-$HOME
+     * jscpd walk (the observed OOM: a jscpd run from a WSL home reached 44 GB
+     * RSS). `options.homeDir` overrides `os.homedir()` for tests.
      */
-    async scan(cwd, minLines = 5, minTokens = 50, isTsProject = false) {
+    async scan(cwd, minLines = 5, minTokens = 50, isTsProject = false, options = {}) {
         const targetDir = path.resolve(cwd);
+        // #747/#250: never walk from a cwd at/above $HOME — from there jscpd's
+        // tokenizer would run across every unrelated repo under home.
+        if (isAtOrAboveHomeDir(targetDir, options.homeDir)) {
+            this.log(`Refusing scan of unsafe root at/above home: ${targetDir}`);
+            return { ...EMPTY_RESULT };
+        }
         // Return early for non-existent or empty directories before probing/installing.
         if (!fs.existsSync(targetDir)) {
             return { ...EMPTY_RESULT };

package/dist/clients/language-profile.js

@@ -5,6 +5,7 @@ import { getProjectIgnoreMatcher } from "./file-utils.js";
 import { LANGUAGE_POLICY, } from "./language-policy.js";
 import { getSourceFiles } from "./scan-utils.js";
 import { readDirEntriesSafe, shouldRecurseIntoDir } from "./source-walker.js";
+import { findNearestDirWithAnyBasename } from "./workspace-topology.js";
 export const SUPPORTED_FILE_KINDS = [
     "jsts",
     "python",
@@ -114,24 +115,6 @@ const ROOT_MARKERS_BY_KIND = {
     nix: ["flake.nix"],
     toml: ["pyproject.toml", "Cargo.toml", "taplo.toml"],
 };
-function nearestRoot(start, markers) {
-    let dir = path.resolve(start);
-    const { root } = path.parse(dir);
-    while (true) {
-        for (const marker of markers) {
-            if (fs.existsSync(path.join(dir, marker))) {
-                return dir;
-            }
-        }
-        if (dir === root)
-            break;
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return undefined;
-}
 // Process-lifetime memo keyed on projectRoot. Only populated when the
 // caller did not pass an explicit `sourceFiles` array — the explicit-array
 // case is used by the warmup pipeline to inject pre-collected files and
@@ -225,7 +208,17 @@ export function resolveLanguageRootForFile(filePath, workspaceRoot) {
     if (!markers || markers.length === 0) {
         return path.resolve(workspaceRoot);
     }
-    const found = nearestRoot(startDir, markers);
+    // #807: nearest-marker discovery now shares workspace-topology.ts's single
+    // walk/cache/invalidation seam instead of this file's own per-kind
+    // `existsSync` climb loop. `findNearestDirWithAnyBasename` additionally
+    // rejects a marker at/above `$HOME` (the pre-#807 loop didn't), matching
+    // the AGENTS.md walker invariant — harmless here because the
+    // workspace-relative check right below already discards any candidate
+    // outside `workspaceRoot`, and `workspaceRoot` is never at/above `$HOME`
+    // in practice. This keeps resolveLanguageRootForFile's OWN stricter
+    // workspace-relative policy check unchanged: the topology service only
+    // supplies discovery, not this function's policy.
+    const found = findNearestDirWithAnyBasename(startDir, markers);
     if (!found)
         return path.resolve(workspaceRoot);
     const workspace = path.resolve(workspaceRoot);