@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/clients/dispatch/runners/utils/runner-helpers.js

@@ -1,15 +1,20 @@
-var __dirname = "/Users/que/Projects/dm-release-495/source/dm-mono/packages/coding-agent/dist/extensions/dm-lens/clients/dispatch/runners/utils";
+var __dirname = "/Users/que/Projects/dm/dm-mono/packages/coding-agent/dist/extensions/dm-lens/clients/dispatch/runners/utils";
+import { emitBounded } from "../../../bounded-telemetry.js";
+import { resolveAnalysisRootPath } from "../../../analysis-root.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { delimiter, resolve as resolveCommandPath } from "node:path";
 import { fileURLToPath } from "node:url";
 import { logSessionStart } from "../../../sessionstart-logger.js";
 import { incrementDegradationCount } from "../../../degradation-ledger.js";
 import { getGlobalDmLensDir } from "../../../file-utils.js";
+import { getProjectTrustState } from "../../../project-trust.js";
 import {
   createGenerationSource
 } from "../../../generation-guard.js";
 import { PathKeyedMap } from "../../../path-keyed-map.js";
 import {
+  isUnderDir,
   normalizeEphemeralMapKey,
   normalizeMapKey
 } from "../../../path-utils.js";
@@ -22,21 +27,27 @@ import {
   isSpawnableCommand,
   resetPathWalkMemo
 } from "../../../installer/index.js";
-import {
-  getServersForFileWithConfig,
-  isServerDisabled
-} from "../../../lsp/config.js";
+import { getServersForFileWithConfig } from "../../../lsp/config.js";
+import { BUILTIN_SERVER_RUNNER_COVERS } from "../../../lsp/server-covers.js";
+import { isAuxiliary } from "../../../lsp/server-traits.js";
 import {
   findGlobalBinary,
   findLocalBinAt,
   findLocalBinsUpwards,
   findLocalBinUpwards,
+  localBinPath,
   VENDOR_BIN_DIRS,
   VENV_BIN_DIRS
 } from "../../../package-manager.js";
 import { logLatency } from "../../../latency-logger.js";
-import { safeSpawnAsync } from "../../../safe-spawn.js";
-import { probeToolAsync } from "../../../tool-probe.js";
+import {
+  safeSpawnAsync,
+  resolveWindowsCommandForEnvironment
+} from "../../../safe-spawn.js";
+import {
+  getIsolatedNpxSpawnOptions,
+  probeToolAsync
+} from "../../../tool-probe.js";
 import { compareOrdinal } from "../../../string-utils.js";
 import {
   getToolCommandSpec,
@@ -64,13 +75,31 @@ export {
   logAvailabilityDecision,
   startHostStallSampler
 } from "./availability-policy.js";
-export function lspPrimaryCoversFile(ctx, serverId) {
+export function lspPrimaryCoversFile(ctx, runnerId) {
   if (ctx.pi?.getFlag?.("no-lsp"))
-    return false;
-  if (isServerDisabled(serverId, ctx.filePath))
-    return false;
-  const primary = getServersForFileWithConfig(ctx.filePath).find((s) => s.role !== "auxiliary");
-  return primary?.id === serverId;
+    return;
+  const primary = getServersForFileWithConfig(ctx.filePath).find((s) => !isAuxiliary(s));
+  if (!primary)
+    return;
+  const fact = primary.custom ? undefined : BUILTIN_SERVER_RUNNER_COVERS.get(primary.id);
+  const covers = primary.covers ?? fact?.runnerIds;
+  if (!covers?.includes(runnerId))
+    return;
+  const gateCommands = fact ? fact.gateCommands : primary.custom ? primary.command ? [primary.command] : undefined : [];
+  if (gateCommands === undefined)
+    return;
+  return {
+    serverId: primary.id,
+    gateCommands,
+    claimSource: fact ? "builtin-fact" : "declared"
+  };
+}
+export async function coveringLaneAvailable(ctx, cover) {
+  for (const gate of cover.gateCommands) {
+    if (!await ctx.hasTool(gate))
+      return false;
+  }
+  return true;
 }
 const _realThisDir = (() => {
   if (typeof __dirname !== "undefined")
@@ -171,21 +200,65 @@ async function findManagedReleaseBinary(tool, verificationArgs = ["--version"])
   const verdict = await verifyManagedCandidate(candidate, verificationArgs);
   return verdict === "ok" || verdict === "unverified" ? candidate : null;
 }
-export function createVenvFinder(command, windowsExt = "", verificationArgs = ["--version"]) {
+export function resolveAdoptedRootCommand(command, ctx, cwd) {
+  const candidates = managedNodeToolCandidates(command);
+  let selected = candidates.find((candidate) => candidate && fs.existsSync(candidate));
+  if (!selected) {
+    if (process.platform === "win32") {
+      selected = resolveWindowsCommandForEnvironment(command, cwd, process.env)?.resolvedPath;
+    } else {
+      selected = (process.env.PATH ?? "").split(delimiter).map((dir) => resolveCommandPath(cwd, dir, command)).find((candidate) => {
+        try {
+          fs.accessSync(candidate, fs.constants.X_OK);
+          return fs.statSync(candidate).isFile();
+        } catch {
+          return false;
+        }
+      });
+    }
+  }
+  if (!selected)
+    return null;
+  try {
+    const binary = fs.realpathSync.native(selected);
+    const session = ctx.projectRoot ?? ctx.cwd;
+    const adopted = resolveAnalysisRootPath(ctx.filePath, session);
+    if (!adopted)
+      return null;
+    const roots = [adopted, session].map((root) => fs.realpathSync.native(root));
+    if (roots.some((root) => binary === root || isUnderDir(binary, root) || isUnderDir(selected, root))) {
+      emitBounded("adopted_root_binary_refused", `${ctx.filePath}:${command}:${binary}`, {
+        filePath: ctx.filePath,
+        durationMs: 0,
+        metadata: { command, binary }
+      }, {
+        ledgerKind: "adopted-root-binary-refused",
+        risingEdgePer: "identity"
+      });
+      return null;
+    }
+    return binary;
+  } catch {
+    return null;
+  }
+}
+export function createVenvFinder(command, windowsExt = "", verificationArgs = ["--version"], allowProjectLocal = true) {
   return async (cwd) => {
-    const venvBin = findLocalBinAt(command, cwd, {
-      windowsExt,
-      binDirs: VENV_BIN_DIRS
-    });
-    if (venvBin)
-      return venvBin;
+    if (allowProjectLocal) {
+      const venvBin = localBinPath(findLocalBinAt(command, cwd, {
+        windowsExt,
+        binDirs: VENV_BIN_DIRS
+      }));
+      if (venvBin)
+        return { path: venvBin, rung: "venv" };
+    }
     const managed = await findManagedNodeToolBinary(command, verificationArgs);
     if (managed)
-      return managed;
+      return { path: managed, rung: "managed-dir" };
     const release = await findManagedReleaseBinary(command, verificationArgs);
     if (release)
-      return release;
-    return command;
+      return { path: release, rung: "managed-release" };
+    return { path: command, rung: "path" };
   };
 }
 export async function resolveManagedToolClient(options) {
@@ -220,6 +293,8 @@ export async function getManagedToolEnvironment(_toolId, cwd) {
   }
   if (!cwd)
     return env;
+  if (getProjectTrustState() !== "trusted")
+    return env;
   const separator = process.platform === "win32" ? ";" : ":";
   const currentPath = env.PATH || env.Path || process.env.PATH || "";
   const localBin = path.join(cwd, "node_modules", ".bin");
@@ -334,13 +409,13 @@ function sourceTagForToolId(toolId) {
       return;
   }
 }
-async function describeManagedResolution(tool, resolved) {
-  const managed = managedNodeToolCandidates(tool).includes(resolved) || await findManagedToolBinary(tool) === resolved;
-  if (!managed)
+function describeManagedResolution(tool, resolution) {
+  if (resolution.rung !== "managed-dir" && resolution.rung !== "managed-release") {
     return {};
+  }
   const source = sourceTagForToolId(tool);
   return {
-    binary: path.basename(resolved),
+    binary: path.basename(resolution.path),
     ...source !== undefined && { source }
   };
 }
@@ -402,7 +477,7 @@ export function createAvailabilityChecker(command, windowsExt = "", versionArgs
   const inFlightByCwd = new PathKeyedMap(normalizeEphemeralMapKey);
   let checkerGeneration = availabilityGeneration.current();
   let checkerFlightGeneration = 0;
-  const findCommand = createVenvFinder(command, windowsExt, versionArgs);
+  const findCommand = createVenvFinder(command, windowsExt, versionArgs, options.allowProjectLocal !== false);
   function ensureCurrentGeneration() {
     if (checkerGeneration === availabilityGeneration.current())
       return;
@@ -535,7 +610,8 @@ export function createAvailabilityChecker(command, windowsExt = "", versionArgs
         return false;
       }
       const resolveStartedAt = Date.now();
-      const cmd = await findCommand(resolvedCwd);
+      const resolution = await findCommand(resolvedCwd);
+      const cmd = resolution.path;
       const resolveMs = Date.now() - resolveStartedAt;
       if (isInSpawnTimeoutCooldown(cmd)) {
         noteDecision(cache, resolvedCwd, {
@@ -582,7 +658,7 @@ export function createAvailabilityChecker(command, windowsExt = "", versionArgs
           classifiedBy: probeJoined ? "joined" : "probe",
           evidence: {
             ...describeProbeEvidence(result),
-            ...await describeManagedResolution(command, cmd),
+            ...describeManagedResolution(command, resolution),
             resolveMs
           }
         });
@@ -774,10 +850,8 @@ export function createCwdCachedProbe(probe, options) {
   return cached;
 }
 export function resolveNodeToolCommand(cwd, toolName, windowsExt = ".cmd") {
-  const isWin = process.platform === "win32";
-  const binName = isWin ? `${toolName}${windowsExt}` : toolName;
-  const local = path.join(cwd, "node_modules", ".bin", binName);
-  if (fs.existsSync(local))
+  const local = localBinPath(findLocalBinAt(toolName, cwd, { windowsExt }));
+  if (local)
     return local;
   return toolName;
 }
@@ -788,10 +862,10 @@ export function resolveToolCommand(cwd, toolId) {
   return resolveNodeToolCommand(cwd, spec.command, spec.windowsExt ?? ".cmd");
 }
 export function resolveVendorToolCommand(cwd, toolName, windowsExt = ".bat") {
-  return findLocalBinUpwards(toolName, cwd, {
+  return localBinPath(findLocalBinUpwards(toolName, cwd, {
     windowsExt,
     binDirs: VENDOR_BIN_DIRS
-  }) ?? null;
+  })) ?? null;
 }
 export async function resolveToolCommandWithInstallFallback(cwd, toolId, timeout = 5000) {
   const spec = getToolCommandSpec(toolId);
@@ -909,7 +983,10 @@ async function probeAstGrepCommandAsync(cmd, argsPrefix = []) {
   let check;
   let hostStallMs;
   try {
-    check = await probeToolAsync(cmd, [...argsPrefix, "--version"], {
+    check = cmd === "npx" ? await safeSpawnAsync(cmd, [...argsPrefix, "--version"], {
+      ...getIsolatedNpxSpawnOptions(),
+      timeout: 5000
+    }) : await probeToolAsync(cmd, [...argsPrefix, "--version"], {
       timeout: 5000
     });
   } finally {
@@ -940,8 +1017,8 @@ function buildSgLocalBins() {
   const projectWalkOptions = { windowsExt: "" };
   const ownInstallWalkOptions = { windowsExt: "", ceiling: false };
   const bins = [
-    ...findLocalBinsUpwards(binaryCandidates, _thisDir, ownInstallWalkOptions).map((binPath) => ({ path: binPath, source: "own-install" })),
-    ...findLocalBinsUpwards(binaryCandidates, process.cwd(), projectWalkOptions).map((binPath) => ({ path: binPath, source: "project" }))
+    ...findLocalBinsUpwards(binaryCandidates, _thisDir, ownInstallWalkOptions).flatMap((binPath) => typeof binPath === "string" ? [{ path: binPath, source: "own-install" }] : []),
+    ...findLocalBinsUpwards(binaryCandidates, process.cwd(), projectWalkOptions).flatMap((binPath) => typeof binPath === "string" ? [{ path: binPath, source: "project" }] : [])
   ];
   for (const candidate of binaryCandidates) {
     const managedBin = path.join(_managedToolsDir, "node_modules", ".bin", candidate);
@@ -1001,9 +1078,15 @@ export async function isSgAvailableAsync() {
         return true;
       }
     }
-    if (await probeAstGrepCommandAsync("npx", ["--no", "--", "ast-grep"])) {
+    if (await probeAstGrepCommandAsync("npx", [
+      "--no",
+      "--package",
+      "@ast-grep/cli",
+      "--",
+      "ast-grep"
+    ])) {
       sgCmd = "npx";
-      sgCmdArgs = ["--no", "--", "ast-grep"];
+      sgCmdArgs = ["--no", "--package", "@ast-grep/cli", "--", "ast-grep"];
       noteSgAvailable(startedAt, { source: "npx" });
       return true;
     }
@@ -1078,14 +1161,12 @@ export function getSgCommand() {
   ensureCurrentSgGeneration();
   return {
     cmd: sgCmd ?? "npx",
-    args: sgCmdArgs.length ? sgCmdArgs : ["--no", "--", "ast-grep"]
+    args: sgCmdArgs.length ? sgCmdArgs : ["--no", "--package", "@ast-grep/cli", "--", "ast-grep"]
   };
 }
 export async function resolveLocalFirstAsync(toolName, cwd, windowsExt = ".cmd") {
-  const isWin = process.platform === "win32";
-  const binName = isWin ? `${toolName}${windowsExt}` : toolName;
-  const local = path.join(cwd, "node_modules", ".bin", binName);
-  if (fs.existsSync(local))
+  const local = localBinPath(findLocalBinAt(toolName, cwd, { windowsExt }));
+  if (local)
     return { cmd: local, args: [] };
   const globalBin = await findGlobalBinary(toolName, windowsExt);
   if (globalBin)

package/extensions/dm-lens/clients/dispatch/runners/utils/tool-failure.js

@@ -1,5 +1,8 @@
 import { incrementDegradationCount } from "../../../degradation-ledger.js";
 import { truncateForLedger } from "../../../ledger-bounds.js";
+import {
+  findingsResult
+} from "../../types.js";
 import {
   classifyRunOutcome,
   firstOutputLine
@@ -88,12 +91,13 @@ export function finishParsedRun(input) {
   const status = input.result.status ?? null;
   if (input.diagnostics.length === 0) {
     if (status !== 0 && raw.trim().length > 0) {
+      const message = `${input.tool} exited ${status} but its output could not be parsed`;
       return {
         status: "failed",
         diagnostics: [
           {
             id: `${input.tool}:parse-error:1`,
-            message: `${input.tool} exited ${status} but its output could not be parsed`,
+            message,
             filePath: input.ctx.filePath,
             line: 1,
             column: 1,
@@ -102,19 +106,20 @@ export function finishParsedRun(input) {
             tool: input.tool
           }
         ],
-        semantic: "warning"
+        semantic: "warning",
+        failureKind: "parser_error",
+        failureMessage: message
       };
     }
     return { status: "succeeded", diagnostics: [], semantic: "none" };
   }
   const mapped = input.classify?.(input.diagnostics);
   if (mapped) {
-    return { ...mapped, diagnostics: input.diagnostics };
+    return findingsResult(input.diagnostics, mapped);
   }
   const hasBlocking = input.diagnostics.some((d) => d.semantic === "blocking");
-  return {
+  return findingsResult(input.diagnostics, {
     status: hasBlocking ? "failed" : "succeeded",
-    diagnostics: input.diagnostics,
     semantic: hasBlocking ? "blocking" : "warning"
-  };
+  });
 }

package/extensions/dm-lens/clients/dispatch/runners/vale.js

@@ -4,6 +4,7 @@ import { pathsEqual } from "../../path-utils.js";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { resolveRunnerCwd } from "../../tool-cwd.js";
 import { PRIORITY } from "../priorities.js";
+import { findingsResult } from "../types.js";
 import {
   createAvailabilityChecker,
   resolveToolCommandWithInstallFallback
@@ -99,11 +100,10 @@ const valeRunner = {
       return { status: "succeeded", diagnostics: [], semantic: "none" };
     }
     const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
-    return {
+    return findingsResult(diagnostics, {
       status: hasBlocking ? "failed" : "succeeded",
-      diagnostics,
       semantic: hasBlocking ? "blocking" : "warning"
-    };
+    });
   }
 };
 export default valeRunner;

package/extensions/dm-lens/clients/dispatch/runners/yaml-rule-parser.js

@@ -4,6 +4,7 @@ import * as path from "node:path";
 import yaml from "../../deps/js-yaml.js";
 import { BoundedLruCache } from "../../bounded-cache.js";
 import { compareOrdinal } from "../../string-utils.js";
+import { recordDegradationOnce } from "../../degradation-ledger.js";
 const OVERLY_BROAD_PATTERNS = ["$NAME", "$FIELD", "$_", "$X", "$VAR", "$EXPR"];
 export const MAX_BLOCKING_RULE_COMPLEXITY = 8;
 export const RULES_CACHE_FRESHNESS_CADENCE_MS = 2000;
@@ -44,8 +45,14 @@ function loadYamlRuleFiles(files, severityFilter) {
     const documents = content.split(/^---\s*$/m).filter((doc) => doc.trim());
     for (const document of documents) {
       const rule = parseSimpleYaml(document.trim());
-      if (!rule?.id)
+      if (!rule?.id) {
+        recordDegradationOnce({
+          kind: "ast-grep-rule-invalid",
+          subject: file,
+          reason: "ast-grep rule could not be parsed"
+        });
         continue;
+      }
       if (severityFilter && rule.severity !== severityFilter)
         continue;
       rules.push(rule);

package/extensions/dm-lens/clients/dispatch/types.js

@@ -1,7 +1,27 @@
 export const RUNNER_SKIP_REASONS = [
   "no-files-matched",
-  "configured-non-biome-linter"
+  "configured-non-biome-linter",
+  "dialect-unsupported",
+  "covered-by-primary"
 ];
 export function isRunnerSkipReason(value) {
   return RUNNER_SKIP_REASONS.some((reason) => reason === value);
 }
+export const RUNNER_CLAIM_SOURCES = ["declared", "builtin-fact"];
+export function isRunnerClaimSource(value) {
+  return RUNNER_CLAIM_SOURCES.some((source) => source === value);
+}
+export const BLOCKING_DIAGNOSTICS_FAILURE_KIND = "blocking_diagnostics";
+export function findingsResult(diagnostics, verdict) {
+  if (verdict.status === "failed") {
+    return {
+      ...verdict,
+      diagnostics,
+      failureKind: BLOCKING_DIAGNOSTICS_FAILURE_KIND
+    };
+  }
+  return { ...verdict, diagnostics };
+}
+export function hasUsableResult(result) {
+  return result.status === "succeeded" || result.status === "failed" && result.failureKind === BLOCKING_DIAGNOSTICS_FAILURE_KIND;
+}

package/extensions/dm-lens/clients/dispatch/utils/format-utils.js

@@ -15,6 +15,18 @@ function formatDiagnostic(d) {
     \uD83D\uDCA1 Fix: ${d.fixSuggestion}` : "";
   return `  ${line}${indented}${fix}`;
 }
+export const DELTA_UNUSED_PROMOTION_NOTE = "new in this edit → blocks in delta mode; pre-existing unused declarations only advise.";
+export function formatPromotionNotes(diagnostics) {
+  const notes = new Set;
+  for (const d of diagnostics) {
+    if (d.promotionNote)
+      notes.add(d.promotionNote);
+  }
+  if (notes.size === 0)
+    return "";
+  return [...notes].map((note) => `  ℹ️ ${note}
+`).join("");
+}
 export function formatDiagnostics(diagnostics, semantic, maxDisplay = 10) {
   if (diagnostics.length === 0)
     return "";
@@ -41,5 +53,6 @@ ${emoji} Auto-fixed ${diagnostics.length} issue(s):
     output += `  ... and ${diagnostics.length - maxDisplay} more
 `;
   }
+  output += formatPromotionNotes(diagnostics);
   return output;
 }

package/extensions/dm-lens/clients/effective-config.js

@@ -18,6 +18,7 @@ import { getGlobalDmLensDir } from "./file-utils.js";
 import { resolveLanguage } from "./language-registry.js";
 import { getDmLensGlobalConfigPath } from "./lens-config.js";
 import {
+  customServerSpecsOf,
   explainServersForFile,
   lspConfigOf,
   registerLSPConfig
@@ -46,10 +47,20 @@ function redactServerSpec(entry) {
   const command = typeof record.command === "string" ? record.command : undefined;
   const args = Array.isArray(record.args) ? record.args : [];
   const env = typeof record.env === "object" && record.env !== null ? Object.keys(record.env).sort(compareOrdinal) : [];
+  const rawCovers = record.covers;
+  let covers;
+  if (Array.isArray(rawCovers)) {
+    covers = [];
+    for (const member of rawCovers) {
+      if (typeof member === "string")
+        covers.push(member);
+    }
+  }
   return {
     ...command === undefined ? {} : { command },
     argvCount: (command === undefined ? 0 : 1) + args.length,
-    envNames: env
+    envNames: env,
+    ...covers === undefined || covers.length === 0 ? {} : { covers }
   };
 }
 function provenanceOfSubtree(resolved, pointer) {
@@ -113,7 +124,7 @@ export async function effectiveConfig(options = {}) {
         error: `file is outside cwd (${homeRelativeCwd}); query with cwd set ` + "to the file's own workspace instead"
       }
     } : absolute === undefined ? {} : {
-      file: await fileView(absolute, resolved, homeDir, cwd, registerLSPConfig(lspConfigOf(resolution.value)))
+      file: await fileView(absolute, resolved, homeDir, cwd, registerLSPConfig(lspConfigOf(resolution.value, undefined, resolution.provenance)))
     }
   };
   return view;
@@ -127,7 +138,7 @@ async function fileView(absolute, resolved, homeDir, workspaceCwd, lspConfig) {
   const language = resolveLanguage(absolute);
   const kind = detectFileKind(absolute);
   const section = lspSectionOf(resolved.value);
-  const customServers = typeof section.servers === "object" && section.servers !== null && !Array.isArray(section.servers) ? section.servers : {};
+  const customServers = customServerSpecsOf(resolved.value);
   const denied = Array.isArray(section.disabledServers) ? section.disabledServers : [];
   const denyPointer = `/${LSP_NAMESPACE_KEY}/disabledServers`;
   const decidedByDeny = (id) => {

package/extensions/dm-lens/clients/ephemeral-root.js

@@ -0,0 +1,71 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { BoundedFifoMap } from "./bounded-cache.js";
+import {
+  isRealGitMarker,
+  isUnderDir,
+  normalizeEphemeralMapKey
+} from "./path-utils.js";
+const NOT_EPHEMERAL = { checkout: false };
+const classified = new BoundedFifoMap(1024);
+function realPathOfNearestExisting(target) {
+  const resolved = path.resolve(target);
+  const tail = [];
+  for (let current = resolved;; current = path.dirname(current)) {
+    try {
+      return path.join(fs.realpathSync.native(current), ...tail.reverse());
+    } catch {
+      if (path.dirname(current) === current)
+        return resolved;
+      tail.push(path.basename(current));
+    }
+  }
+}
+function classifyTmpDir(dir) {
+  const tmpSpelling = os.tmpdir();
+  const key = `${normalizeEphemeralMapKey(tmpSpelling)}\x00${normalizeEphemeralMapKey(path.resolve(dir))}`;
+  const memo = classified.get(key);
+  if (memo)
+    return memo;
+  const tmpRoot = realPathOfNearestExisting(tmpSpelling);
+  const real = realPathOfNearestExisting(dir);
+  let result = NOT_EPHEMERAL;
+  if (isUnderDir(real, tmpRoot)) {
+    for (let current = real;current !== tmpRoot && path.dirname(current) !== current; current = path.dirname(current)) {
+      if (isRealGitMarker(path.join(current, ".git"))) {
+        result = { checkout: true };
+        break;
+      }
+    }
+    if (!result.checkout) {
+      const segments = path.relative(tmpRoot, real).split(path.sep);
+      const index = segments.findIndex((segment) => /^pi-agent(?:-|$)/i.test(segment));
+      if (index >= 0) {
+        result = {
+          checkout: false,
+          stagingRoot: path.join(tmpRoot, ...segments.slice(0, index + 1))
+        };
+      }
+    }
+  }
+  classified.set(key, result);
+  return result;
+}
+export function ephemeralStagingRoot(filePath) {
+  return classifyTmpDir(path.dirname(path.resolve(filePath))).stagingRoot;
+}
+export function isPiOwnedTempPath(filePath) {
+  const tmpRoot = realPathOfNearestExisting(os.tmpdir());
+  const real = realPathOfNearestExisting(filePath);
+  if (!isUnderDir(real, tmpRoot))
+    return false;
+  const relative = path.relative(tmpRoot, real);
+  if (relative.length === 0 || path.isAbsolute(relative))
+    return false;
+  const segments = relative.split(path.sep);
+  return segments.length === 1 || /^pi-/i.test(segments[0] ?? "");
+}
+export function isEphemeralCheckoutRoot(dir) {
+  return classifyTmpDir(dir).checkout;
+}

package/extensions/dm-lens/clients/file-kinds.js

@@ -60,6 +60,7 @@ export const KIND_EXTENSIONS = {
     ".vue"
   ],
   kotlin: [".kt", ".kts"],
+  lean: [".lean"],
   lua: [".lua"],
   markdown: [".md", ".mdx"],
   nix: [".nix"],
@@ -99,6 +100,11 @@ export function isReadableSourceFile(filePath) {
   const extension = extname(filePath).toLowerCase();
   return Object.keys(KIND_EXTENSIONS).some((kind) => hasKindExtension(filePath, kind)) || NON_KIND_READABLE_EXTENSIONS.has(extension);
 }
+export const LEAN_ROOT_MARKERS = [
+  "lakefile.lean",
+  "lakefile.toml",
+  "lean-toolchain"
+];
 export const DOTNET_CSHARP_ROOT_MARKERS = [
   "*.csproj",
   "*.sln",
@@ -188,6 +194,7 @@ export const CODE_KINDS = new Set([
   "java",
   "jsts",
   "kotlin",
+  "lean",
   "lua",
   "nix",
   "ocaml",
@@ -241,6 +248,7 @@ export function getFileKindLabel(kind) {
     fsharp: "F#",
     java: "Java",
     kotlin: "Kotlin",
+    lean: "Lean 4",
     swift: "Swift",
     dart: "Dart",
     lua: "Lua",
@@ -284,6 +292,7 @@ export function getLanguageId(kind) {
     fsharp: "fsharp",
     java: "java",
     kotlin: "kotlin",
+    lean: "lean",
     swift: "swift",
     dart: "dart",
     lua: "lua",