@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-lens/clients/lsp/inferred-project.js

@@ -19,7 +19,7 @@ const TYPESCRIPT_DIAGNOSTIC_SOURCES = new Set(["typescript", "ts", "tsserver"]);
 export function isTsProjectFile(filePath) {
   return TS_PROJECT_EXTENSIONS.has(path.extname(filePath).toLowerCase());
 }
-export function isTypeScriptSourcedDiagnostic(d) {
+function isTypeScriptSourcedDiagnostic(d) {
   return TYPESCRIPT_DIAGNOSTIC_SOURCES.has((d.source ?? "").toLowerCase());
 }
 export function suggestTsconfigInclude(filePath, cwd) {

package/extensions/dm-lens/clients/lsp/language.js

@@ -24,6 +24,3 @@ export function getLanguageId(filePath) {
   const base = path.basename(filePath);
   return LANGUAGE_EXTENSIONS[base] ?? LANGUAGE_EXTENSIONS[base.toLowerCase()] ?? getBasenameLanguageId(base);
 }
-export function getExtensionsForLanguage(languageId) {
-  return Object.entries(LANGUAGE_EXTENSIONS).filter(([, id]) => id === languageId).map(([ext]) => ext);
-}

package/extensions/dm-lens/clients/lsp/launch.js

@@ -11,7 +11,12 @@ import { getGlobalDmLensLogDir } from "../probe-home-state.js";
 import { isFullyQualified } from "../path-utils.js";
 import { findGlobalBinary } from "../package-manager.js";
 import { redactSecrets } from "../redact/secrets.js";
-import { classifySpawnFailure, SpawnFailureError } from "../safe-spawn.js";
+import {
+  classifySpawnFailure,
+  holdOwnChildPid,
+  isOwnLiveChild,
+  SpawnFailureError
+} from "../safe-spawn.js";
 import { getRubyVersionDirNamesAsync } from "./ruby-drive-dirs.js";
 const isWindows = process.platform === "win32";
 function computeNeedsShell(resolvedCommand) {
@@ -49,8 +54,9 @@ function splitPathEntries(value, delimiter) {
   return value.split(delimiter).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
 }
 function normalizePathEntry(entry, platform) {
-  const normalized = path.normalize(entry);
-  return platform === "win32" ? normalized.toLowerCase() : normalized;
+  if (platform !== "win32")
+    return path.posix.normalize(entry);
+  return path.win32.normalize(entry).toLowerCase();
 }
 export function combinePathValuesForPlatform(values, platform = process.platform) {
   const unique = [];
@@ -223,6 +229,7 @@ function trySpawn(command, args, cwd, env, needsShell) {
   if (proc.exitCode !== null || proc.killed) {
     throw new Error(`LSP server ${command} exited immediately (code: ${proc.exitCode}). ` + `The binary may be missing or corrupted.`);
   }
+  holdOwnChildPid(proc.pid, "lsp-spawn");
   return proc;
 }
 function unrefLspProcessHandles(proc) {
@@ -428,9 +435,9 @@ export async function stopLSP(handle) {
     handle.process.once("exit", done);
     handle.process.once("error", done);
     const killWindowsTree = () => {
-      if (!isWindows || handle.pid <= 0)
+      if (!isWindows)
         return false;
-      if (handle.process.exitCode !== null || handle.process.signalCode !== null)
+      if (!isOwnLiveChild(handle.pid, "lsp-stop-windows-tree", handle.process))
         return false;
       try {
         const taskkill = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\taskkill.exe`;

package/extensions/dm-lens/clients/lsp/path-utils.js

@@ -1,10 +1,8 @@
 export {
   isUnderDir,
-  normalizeFilePath,
   normalizeEphemeralMapKey,
   normalizeMapKey,
   pathsEqual,
-  pathToUri,
   uriToDiskPath,
   uriToPath
 } from "../path-utils.js";

package/extensions/dm-lens/clients/lsp/pending-aux-coverage.js

@@ -64,7 +64,6 @@ export function drainPendingAuxiliaryCoverage() {
 export function pendingAuxiliaryCoverageSize() {
   return pending.size;
 }
-export const pendingAuxiliaryCoverageSizeForTests = pendingAuxiliaryCoverageSize;
 export function drainPendingAuxCapEvictedCount() {
   const count = capEvictedCount;
   capEvictedCount = 0;

package/extensions/dm-lens/clients/lsp/server.js

@@ -21,12 +21,17 @@ import {
   DOTNET_FSHARP_ROOT_MARKERS,
   KIND_EXTENSIONS
 } from "../file-kinds.js";
+import { extensionsForLanguage } from "../language-registry.js";
 import {
+  CARGO_WORKSPACE_MEMBER_DIALECT,
   direntsHaveMarkerGlobMatch,
   isAtOrAboveHomeDir,
   isFullyQualified,
   isWindowsPath,
-  pathsEqual
+  matchesWorkspaceMemberPattern,
+  normalizeEphemeralMapKey,
+  pathsEqual,
+  toPosix
 } from "../path-utils.js";
 import {
   ensureTool,
@@ -50,6 +55,16 @@ import { logSessionStart } from "../sessionstart-logger.js";
 import { findLocalSgconfig, resolveBaselineSgconfig } from "../sgconfig.js";
 import { findLocalTyposConfig } from "../typos-config.js";
 import { resolvePackagePath } from "../package-root.js";
+import { resolveToolCwd } from "../tool-cwd.js";
+import {
+  dirMtimeRecordsAsync,
+  dirMtimesStillFreshAsync,
+  unknownDirMtimeRecords
+} from "../workspace-topology.js";
+import { bounded } from "../deadline-utils.js";
+import { FRESHNESS_CADENCE_MS } from "../freshness-cadence.js";
+import { HOOK_WALL_BUDGET_MS } from "../hook-budgets.js";
+import { recordDegradationOnce } from "../degradation-ledger.js";
 import {
   hasCargoWorkspaceTable,
   readCargoWorkspaceExclude,
@@ -71,6 +86,44 @@ import { getProcessSingleton } from "../process-singletons.js";
 import {
   createGenerationSource
 } from "../generation-guard.js";
+function withRootMarkers(root, markers) {
+  root.rootMarkers = markers;
+  return root;
+}
+export async function resolveLspServerCwd(server, filePath, sessionCwd, onRootFailure) {
+  const rootMarkers = server.rootMarkers ?? server.root.rootMarkers;
+  let serverRoot;
+  let rootFailed = false;
+  try {
+    serverRoot = await server.root(filePath);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    rootFailed = true;
+    onRootFailure?.(reason);
+  }
+  const isFileDirFallback = serverRoot !== undefined && rootMarkers?.length && path.resolve(serverRoot) === path.resolve(path.dirname(filePath));
+  if (!serverRoot || isFileDirFallback) {
+    if (!serverRoot) {
+      recordDegradationOnce({
+        kind: "tool-cwd-resolution",
+        subject: server.id,
+        reason: `lsp:server-root-${rootFailed ? "failed" : "fallback"}:${filePath}`
+      });
+    }
+    if (!rootMarkers?.length)
+      return;
+    return resolveToolCwd("lsp", server.id, filePath, {
+      cwd: path.dirname(path.resolve(filePath)),
+      rootMarkers
+    }).cwd;
+  }
+  const boundedServerRoot = enforceLspRootCeiling(serverRoot, sessionCwd, filePath);
+  return resolveToolCwd("lsp", server.id, filePath, {
+    cwd: sessionCwd,
+    rootMarkers,
+    serverRoot: boundedServerRoot
+  }).cwd;
+}
 const FIXTURE_ROOT_SEGMENTS = new Set(["__fixtures__", "testdata"]);
 const FALLBACK_PROJECT_MARKERS = [
   ".git",
@@ -709,29 +762,22 @@ function nodeBinLocalCandidates(root, baseName) {
 function nodeBinCandidates(root, baseName) {
   return [...nodeBinLocalCandidates(root, baseName), baseName];
 }
-function normalizeSlashKey(value) {
-  const normalized = path.resolve(value).replace(/\\/g, "/");
-  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
-}
 function piAgentExtensionsRootKey(file) {
-  const dirKey = normalizeSlashKey(path.dirname(path.resolve(file)));
+  const dirKey = normalizeEphemeralMapKey(path.dirname(path.resolve(file)));
   const marker = "/.pi/agent/extensions";
   const index = dirKey.indexOf(marker);
   if (index === -1)
     return;
   return dirKey.slice(0, index + marker.length);
 }
-function normalizeRootKey(root) {
-  return process.platform === "win32" ? path.resolve(root).toLowerCase() : path.resolve(root);
-}
 function IgnoreHomeRoot(primary) {
-  const homeKey = normalizeRootKey(os.homedir());
-  return async (file) => {
+  const homeKey = normalizeEphemeralMapKey(path.resolve(os.homedir()));
+  return withRootMarkers(async (file) => {
     const root = await primary(file);
     if (!root)
       return;
-    return normalizeRootKey(root) === homeKey ? undefined : root;
-  };
+    return normalizeEphemeralMapKey(path.resolve(root)) === homeKey ? undefined : root;
+  }, primary.rootMarkers ?? []);
 }
 function rubyBinCandidates(baseName) {
   const candidates = [];
@@ -755,6 +801,7 @@ function createInteractiveServer(spec) {
     name: spec.name,
     extensions: spec.extensions,
     root: spec.root,
+    rootMarkers: spec.root.rootMarkers,
     fallbackFor: spec.fallbackFor,
     availabilityKey: typeof spec.command === "string" && isSimpleCommand(spec.command) ? spec.command : undefined,
     async spawn(root) {
@@ -782,34 +829,40 @@ function createInteractiveServer(spec) {
 }
 export function PriorityRoot(markerGroups, excludePatterns, stopDir) {
   const resolvers = markerGroups.map((markers) => NearestRoot(markers, excludePatterns, stopDir));
-  return async (file) => {
+  return withRootMarkers(async (file) => {
     for (const resolve of resolvers) {
       const root = await resolve(file);
       if (root)
         return root;
     }
     return;
-  };
+  }, markerGroups.flat());
 }
 export const FileDirRoot = async (file) => {
   const candidate = path.resolve(path.dirname(file));
   return nearestNonExcludedFallbackRoot(candidate);
 };
 export function RootWithFallback(primary, fallback = FileDirRoot) {
-  return async (file) => {
+  return withRootMarkers(async (file) => {
     const primaryRoot = await primary(file);
     if (primaryRoot)
       return primaryRoot;
     return fallback(file);
-  };
+  }, primary.rootMarkers ?? []);
 }
 export function WorkspacePriorityRoot(markerGroups, excludePatterns) {
-  return async (file) => PriorityRoot(markerGroups, excludePatterns, process.cwd())(file);
+  return withRootMarkers(async (file) => PriorityRoot(markerGroups, excludePatterns, process.cwd())(file), markerGroups.flat());
 }
 function isPermissionFsError(err) {
   const code = err?.code;
   return code === "EACCES" || code === "EPERM";
 }
+function markerProbeDir(dir, pattern) {
+  const normalized = toPosix(pattern);
+  const slash = normalized.lastIndexOf("/");
+  const parentPattern = slash >= 0 ? normalized.slice(0, slash) : "";
+  return parentPattern ? path.join(dir, ...parentPattern.split("/").filter(Boolean)) : dir;
+}
 async function markerExists(dir, pattern) {
   if (!pattern.includes("*")) {
     try {
@@ -824,11 +877,10 @@ async function markerExists(dir, pattern) {
   }
   const normalized = pattern.replace(/\\/g, "/");
   const slash = normalized.lastIndexOf("/");
-  const parentPattern = slash >= 0 ? normalized.slice(0, slash) : "";
   const basenamePattern = slash >= 0 ? normalized.slice(slash + 1) : normalized;
   if (!basenamePattern)
     return false;
-  const targetDir = parentPattern ? path.join(dir, ...parentPattern.split("/").filter(Boolean)) : dir;
+  const targetDir = markerProbeDir(dir, normalized);
   try {
     const entries = await readdir(targetDir, { withFileTypes: true });
     return direntsHaveMarkerGlobMatch(entries, basenamePattern);
@@ -839,18 +891,31 @@ async function markerExists(dir, pattern) {
     return false;
   }
 }
+const rootMtimeBound = (label) => ({
+  ms: HOOK_WALL_BUDGET_MS.tool_result_edit,
+  signal: undefined,
+  hook: "tool_result_edit",
+  label
+});
 export function NearestRoot(includePatterns, excludePatterns, stopDir) {
   const cache = new Map;
   const inFlight = new Map;
-  return async (file) => {
+  const subdirPatterns = [];
+  for (const pattern of [...includePatterns, ...excludePatterns ?? []]) {
+    if (markerProbeDir("", pattern))
+      subdirPatterns.push(pattern);
+  }
+  return withRootMarkers(async (file) => {
     const startDir = path.resolve(path.dirname(file));
     const dirKey = normalizeMapKey(startDir);
     const cached = cache.get(dirKey);
-    if (cached !== undefined)
-      return cached;
+    if (cached !== undefined && Date.now() - cached.walkedAt < FRESHNESS_CADENCE_MS && await bounded(dirMtimesStillFreshAsync(cached.probedDirs), rootMtimeBound("lsp-root-memo-freshness")) === true)
+      return cached.root;
     const flying = inFlight.get(dirKey);
     if (flying)
       return flying;
+    const probedDirs = [];
+    const walkedAt = Date.now();
     const promise = (async () => {
       let currentDir = startDir;
       const fsRoot = path.parse(currentDir).root;
@@ -859,6 +924,12 @@ export function NearestRoot(includePatterns, excludePatterns, stopDir) {
         if (stop !== fsRoot && currentDir.startsWith(stop + path.sep) === false && currentDir !== stop) {
           break;
         }
+        const stepDirs = [
+          currentDir,
+          ...subdirPatterns.map((pattern) => markerProbeDir(currentDir, pattern))
+        ];
+        const stepRecords = await bounded(dirMtimeRecordsAsync(stepDirs), rootMtimeBound("lsp-root-walk-dir-mtimes"));
+        probedDirs.push(...stepRecords ?? unknownDirMtimeRecords(stepDirs));
         if (excludePatterns) {
           let excluded = false;
           for (const pattern of excludePatterns) {
@@ -873,7 +944,7 @@ export function NearestRoot(includePatterns, excludePatterns, stopDir) {
           }
         }
         for (const pattern of includePatterns) {
-          if (await markerExists(currentDir, pattern) && !await isExcludedLspRoot(currentDir)) {
+          if (await markerExists(currentDir, pattern) && (pattern !== ".git" || currentDir !== os.tmpdir()) && !await isExcludedLspRoot(currentDir)) {
             return enforceLspRootCeiling(currentDir, process.cwd(), file);
           }
         }
@@ -888,12 +959,12 @@ export function NearestRoot(includePatterns, excludePatterns, stopDir) {
     try {
       const result = await promise;
       if (result !== undefined)
-        cache.set(dirKey, result);
+        cache.set(dirKey, { root: result, probedDirs, walkedAt });
       return result;
     } finally {
       inFlight.delete(dirKey);
     }
-  };
+  }, includePatterns);
 }
 export const createRootDetector = NearestRoot;
 function isOnPath(command) {
@@ -1168,7 +1239,7 @@ async function findExtensionBoundedRoot(file, extensionRootKey) {
         return currentDir;
       } catch {}
     }
-    const currentKey = normalizeSlashKey(currentDir);
+    const currentKey = normalizeEphemeralMapKey(path.resolve(currentDir));
     if (currentKey === extensionRootKey)
       return;
     const parent = path.dirname(currentDir);
@@ -1189,7 +1260,7 @@ async function hasAgentLevelProjectMarker(extensionRootKey) {
   }
   return false;
 }
-const TypeScriptRoot = DenoExcludeRoot(async (file) => {
+const TypeScriptRoot = withRootMarkers(DenoExcludeRoot(async (file) => {
   const extensionRootKey = piAgentExtensionsRootKey(file);
   if (extensionRootKey) {
     const bounded = await findExtensionBoundedRoot(file, extensionRootKey);
@@ -1204,13 +1275,14 @@ const TypeScriptRoot = DenoExcludeRoot(async (file) => {
   if (projectRoot)
     return projectRoot;
   return FileDirRoot(file);
-});
+}), [...TS_CONFIG_MARKERS, ...TS_TOOLING_MARKERS]);
 export const TypeScriptServer = {
   id: "typescript",
   name: "TypeScript Language Server",
   extensions: JS_TS_LSP_EXTENSIONS,
   autoPropagateDiagnostics: true,
   root: TypeScriptRoot,
+  rootMarkers: TypeScriptRoot.rootMarkers,
   async spawn(root, options) {
     const fs = await import("node:fs/promises");
     const nativeLsp = await findNativeTypeScriptLsp(root);
@@ -1423,45 +1495,22 @@ export const GoServer = {
     return { ...result, initialization: { ui: { semanticTokens: true } } };
   }
 };
-function segmentGlobToRegExpSource(segment) {
-  let out = "";
-  for (const ch of segment) {
-    if (ch === "*")
-      out += "[^/]*";
-    else if (ch === "?")
-      out += "[^/]";
-    else
-      out += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-  }
-  return out;
-}
-function matchesCargoWorkspacePattern(pattern, relativePath) {
-  const normalized = pattern.replace(/\/+$/, "");
-  if (normalized.includes("**"))
-    return false;
-  const patternSegments = normalized.split("/");
-  const pathSegments = relativePath.split("/");
-  if (patternSegments.length !== pathSegments.length)
-    return false;
-  return patternSegments.every((segment, i) => new RegExp(`^${segmentGlobToRegExpSource(segment)}$`).test(pathSegments[i]));
-}
 function cargoWorkspaceDeclaresMember(workspaceContent, parentDir, childDir) {
   const relativePath = path.relative(parentDir, childDir).split(path.sep).join("/");
   if (relativePath === "" || relativePath.startsWith(".."))
     return false;
+  const matches = (pattern) => matchesWorkspaceMemberPattern(pattern, relativePath, CARGO_WORKSPACE_MEMBER_DIALECT);
   const excluded = readCargoWorkspaceExclude(workspaceContent);
-  if (excluded.some((pattern) => matchesCargoWorkspacePattern(pattern, relativePath))) {
+  if (excluded.some(matches))
     return false;
-  }
-  const members = readCargoWorkspaceMembers(workspaceContent);
-  return members.some((pattern) => matchesCargoWorkspacePattern(pattern, relativePath));
+  return readCargoWorkspaceMembers(workspaceContent).some(matches);
 }
 function sessionHoistCeiling(sessionCwd, file) {
   return isSameOrWithin(path.resolve(sessionCwd), path.resolve(file)) ? path.resolve(sessionCwd) : undefined;
 }
 function RustWorkspaceRoot() {
   const crateRoot = createRootDetector(["Cargo.toml", "Cargo.lock"]);
-  return async (file) => {
+  return withRootMarkers(async (file) => {
     const root = await crateRoot(file);
     if (!root)
       return;
@@ -1486,7 +1535,7 @@ function RustWorkspaceRoot() {
       current = parent;
     }
     return root;
-  };
+  }, crateRoot.rootMarkers ?? []);
 }
 function stripXmlComments(content) {
   let result = content;
@@ -1519,7 +1568,7 @@ function JavaWorkspaceRoot() {
     "build.gradle",
     ".classpath"
   ]);
-  return async (file) => {
+  return withRootMarkers(async (file) => {
     const root = await moduleRoot(file);
     if (!root)
       return;
@@ -1547,7 +1596,7 @@ function JavaWorkspaceRoot() {
       current = parent;
     }
     return enforceLspRootCeiling(lastHop, sessionCwd, file);
-  };
+  }, moduleRoot.rootMarkers ?? []);
 }
 export const RustServer = {
   id: "rust",
@@ -1864,6 +1913,21 @@ export const GleamServer = {
     }, options?.allowInstall);
   }
 };
+export const TinymistServer = {
+  id: "tinymist",
+  name: "Tinymist",
+  extensions: extensionsForLanguage("typst"),
+  root: RootWithFallback(createRootDetector(["typst.toml", ".git"])),
+  availabilityKey: "tinymist",
+  async spawn(root, options) {
+    return resolveAndLaunch({
+      candidates: ["tinymist"],
+      args: ["lsp"],
+      cwd: root,
+      managedToolId: "tinymist"
+    }, options?.allowInstall);
+  }
+};
 export const MarksmanServer = {
   id: "marksman",
   name: "Marksman",
@@ -1960,7 +2024,7 @@ export const FishServer = {
   spawn(root, options) {
     return resolveAndLaunch({
       candidates: nodeBinCandidates(root, "fish-lsp"),
-      args: ["start"],
+      args: ["start", "--stdio"],
       cwd: root,
       managedToolId: "fish-lsp"
     }, options?.allowInstall);
@@ -2372,6 +2436,7 @@ export const LSP_SERVERS = [
   ElixirServer,
   ElixirExpertServer,
   GleamServer,
+  TinymistServer,
   MarksmanServer,
   OCamlServer,
   ClojureServer,

package/extensions/dm-lens/clients/lsp/session-roots.js

@@ -1,10 +1,31 @@
-import { BoundedSet } from "../bounded-cache.js";
+import { BoundedFifoMap } from "../bounded-cache.js";
+import { incrementDegradationCount } from "../degradation-ledger.js";
 import { isSameOrWithin } from "./server.js";
 import path from "node:path";
 const SESSION_ROOT_CAP = 128;
-const sessionRoots = new BoundedSet(SESSION_ROOT_CAP);
+const sessionRoots = new BoundedFifoMap(SESSION_ROOT_CAP);
+function noteEvictedRoots(evicted) {
+  const roots = evicted.map(([root]) => root);
+  if (roots.length > 0) {
+    incrementDegradationCount({
+      kind: "lsp-session-root-evicted",
+      subject: `cap=${SESSION_ROOT_CAP}`,
+      reason: `session root registry at capacity; dropped ${roots[0]} and will load it again on the next session start or tool call naming that root`
+    });
+  }
+  return roots;
+}
 export function registerSessionRoot(cwd) {
-  sessionRoots.add(path.resolve(cwd));
+  const root = path.resolve(cwd);
+  if (sessionRoots.has(root))
+    return [];
+  return noteEvictedRoots(sessionRoots.set(root, undefined));
+}
+export function setSessionRootConfig(cwd, config) {
+  return noteEvictedRoots(sessionRoots.set(path.resolve(cwd), config));
+}
+export function sessionRootConfigEntries() {
+  return sessionRoots;
 }
 export function isSessionRootRegistered(cwd) {
   return sessionRoots.has(path.resolve(cwd));
@@ -17,14 +38,14 @@ export function isOutsideAllSessionRoots(filePath) {
   if (sessionRoots.size === 0)
     return false;
   const resolved = path.resolve(filePath);
-  for (const root of sessionRoots) {
+  for (const root of sessionRoots.keys()) {
     if (isSameOrWithin(root, resolved))
       return false;
   }
   return true;
 }
 export function getSessionRootsForTelemetry(limit = 4) {
-  return [...sessionRoots].sort((a, b) => Number(a > b) - Number(a < b)).slice(0, limit);
+  return [...sessionRoots.keys()].sort((a, b) => Number(a > b) - Number(a < b)).slice(0, limit);
 }
 export function resetSessionRootsForTests() {
   sessionRoots.clear();

package/extensions/dm-lens/clients/lsp/sync-kind.js

@@ -1,4 +1,3 @@
-export const TEXT_DOCUMENT_SYNC_KIND_NONE = 0;
 export const TEXT_DOCUMENT_SYNC_KIND_FULL = 1;
 export const TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL = 2;
 function isSyncKind(value) {
@@ -15,3 +14,17 @@ export function negotiateSyncKind(serverCapabilities) {
   }
   return TEXT_DOCUMENT_SYNC_KIND_FULL;
 }
+export function negotiateSaveOptions(serverCapabilities) {
+  const sync = serverCapabilities?.textDocumentSync;
+  if (!sync || typeof sync !== "object")
+    return;
+  const save = sync.save;
+  if (save === true)
+    return { includeText: false };
+  if (save && typeof save === "object") {
+    return {
+      includeText: save.includeText === true
+    };
+  }
+  return;
+}

package/extensions/dm-lens/clients/lsp/tsserver-sync.js

@@ -1,6 +1,6 @@
 import { logLatency } from "../latency-logger.js";
 import { normalizeMapKey } from "../path-utils.js";
-export const TSSERVER_REQUEST_COMMAND = "typescript.tsserverRequest";
+const TSSERVER_REQUEST_COMMAND = "typescript.tsserverRequest";
 const INFERRED_PROJECT_SENTINEL = /^(?:[A-Za-z]:)?[/\\]dev[/\\]null[/\\]inferredProject\d*\*?$/i;
 export function classifyProjectInfo(body) {
   if (!body || typeof body !== "object") {
@@ -89,13 +89,13 @@ export async function fetchTsserverProjectIdentity(svc, file) {
     return;
   }
 }
-export function isTsserverSyncRawDiagnostic(value) {
+function isTsserverSyncRawDiagnostic(value) {
   if (!value || typeof value !== "object")
     return false;
   const v = value;
   return typeof v.message === "string" && typeof v.category === "string";
 }
-export function tsserverSeverityFromCategory(category) {
+function tsserverSeverityFromCategory(category) {
   switch (category) {
     case "error":
       return 1;
@@ -107,7 +107,7 @@ export function tsserverSeverityFromCategory(category) {
       return 3;
   }
 }
-export function tsserverSyncDiagnosticToLsp(d) {
+function tsserverSyncDiagnosticToLsp(d) {
   const startLine = Math.max(0, (d.startLocation?.line ?? 1) - 1);
   const startChar = Math.max(0, (d.startLocation?.offset ?? 1) - 1);
   const endLine = Math.max(0, (d.endLocation?.line ?? d.startLocation?.line ?? 1) - 1);
@@ -123,7 +123,7 @@ export function tsserverSyncDiagnosticToLsp(d) {
     source: "typescript"
   };
 }
-export async function runTsserverSyncCommand(svc, file, command) {
+async function runTsserverSyncCommand(svc, file, command) {
   if (typeof svc.executeCommand !== "function")
     return;
   const outcome = await svc.executeCommand(file, TSSERVER_REQUEST_COMMAND, [
@@ -140,8 +140,6 @@ export async function runTsserverSyncCommand(svc, file, command) {
 }
 export async function attemptTsserverSyncDiagnostics(file, svc) {
   try {
-    if (typeof svc.getAdvertisedCommands !== "function")
-      return;
     const advertised = await svc.getAdvertisedCommands(file);
     if (!advertised.includes(TSSERVER_REQUEST_COMMAND))
       return;

package/extensions/dm-lens/clients/lsp/wait-policy/classification.js

@@ -6,6 +6,9 @@ export function classifyServerWaitTier(serverId, snapshot) {
   const mode = snapshot.workspaceDiagnosticsSupport?.mode;
   if (mode === "pull")
     return "pull-capable";
+  if (snapshot.customServer === true && mode === "push-only" && snapshot.diagnosticsUnsupported === true && snapshot.diagnosticsPublished !== true) {
+    return "diagnostics-unsupported";
+  }
   if (mode !== "push-only")
     return "waits";
   const strategy = getStrategy(serverId, snapshot.launchVariant);

package/extensions/dm-lens/clients/lsp/wait-policy/strategies.js

@@ -116,13 +116,42 @@ export const SERVER_DIAGNOSTIC_STRATEGIES = {
     workspaceIndexingWarmWaitMs: 250,
     silentOnClean: true
   },
+  php: {
+    seedFirstPush: false,
+    pullRetryBudgetMs: 0,
+    debounceMs: 150,
+    aggregateWaitMs: 8000,
+    expectSemanticSecondPush: false,
+    emptyFirstPublish: "indexing"
+  },
+  svelte: {
+    seedFirstPush: false,
+    pullRetryBudgetMs: 0,
+    debounceMs: 150,
+    aggregateWaitMs: 4000,
+    expectSemanticSecondPush: false
+  },
+  csharp: {
+    seedFirstPush: false,
+    pullRetryBudgetMs: 250,
+    debounceMs: 150,
+    aggregateWaitMs: 6000,
+    expectSemanticSecondPush: false
+  },
   cue: {
     seedFirstPush: true,
     pullRetryBudgetMs: 0,
     debounceMs: 150,
     aggregateWaitMs: 2000,
     expectSemanticSecondPush: false,
-    reopenOnResync: false,
+    reopenOnResync: false
+  },
+  lua: {
+    seedFirstPush: true,
+    pullRetryBudgetMs: 0,
+    debounceMs: 150,
+    aggregateWaitMs: 2000,
+    expectSemanticSecondPush: false,
     silentOnClean: true
   }
 };
@@ -131,7 +160,7 @@ const NATIVE_TS7_DIAGNOSTIC_STRATEGY = {
   seedFirstPush: false,
   silentOnClean: false
 };
-export const DEFAULT_STRATEGY = {
+const DEFAULT_STRATEGY = {
   seedFirstPush: false,
   pullRetryBudgetMs: 250,
   debounceMs: 150,