@duckmind/dm-linux-x64 0.65.5 → 0.65.7

package/extensions/dm-lens/clients/ledger-bounds.js

@@ -1,7 +1,19 @@
 export const LEDGER_FIELD_MAX = 200;
 export const DEGRADATION_ENTRIES_PER_KIND = 20;
 export function normalizeForLedger(value) {
-  return String(value ?? "unknown");
+  if (value === null || value === undefined)
+    return "unknown";
+  if (typeof value === "object" && !Object.hasOwn(value, "toString")) {
+    const proto = Object.getPrototypeOf(value);
+    if (proto === Object.prototype || proto === null || Array.isArray(value)) {
+      try {
+        return JSON.stringify(value) ?? "unknown";
+      } catch {
+        return "[unserializable object]";
+      }
+    }
+  }
+  return String(value);
 }
 export function truncateForLedger(value) {
   const text = normalizeForLedger(value);

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

@@ -2,6 +2,7 @@ import {
   resetIgnoredConfigWarnCache,
   warnIgnoredConfigOnce
 } from "./config-warn.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
 import { errorClassName } from "./error-class.js";
 import * as path from "node:path";
 import {
@@ -15,11 +16,19 @@ import {
 } from "./lens-flag-registry.js";
 import {
   CANONICAL_GLOBAL_CONFIG_FILE,
+  canonicalPathIdentity,
   getDmLensGlobalConfigPath,
+  getProductionGlobalConfigResolution,
   GLOBAL_CONFIG_LOCATIONS,
   LEGACY_ROOT_LSP_KEYS
 } from "./config-locations.js";
-export { getDmLensGlobalConfigPath } from "./config-locations.js";
+export {
+  getDmLensGlobalConfigPath,
+  getProductionGlobalConfigResolution,
+  isResolvedGlobalConfigPath,
+  resolveGlobalConfigLocation,
+  resetGlobalConfigLocationCache
+} from "./config-locations.js";
 import {
   ignoredRecordCollector,
   readConfigDocument,
@@ -30,6 +39,7 @@ import {
 import {
   findNestedProjectMutationValue
 } from "./project-lens-config.js";
+import { readToolConfig } from "./tool-config.js";
 function globalCanonicalLocation() {
   const location = GLOBAL_CONFIG_LOCATIONS.find((candidate) => candidate.relativePath === CANONICAL_GLOBAL_CONFIG_FILE);
   if (!location) {
@@ -51,14 +61,50 @@ export function resetGlobalConfigWarnCache() {
 function asConfigObject(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
-export function loadDmLensGlobalConfig(configPath = getDmLensGlobalConfigPath()) {
+function reportGlobalConfigProbeRetention() {
+  const resolution = getProductionGlobalConfigResolution();
+  if (resolution.source !== "legacy-default-unprobed" && resolution.source !== "pi-coding-agent-dir-unprobed") {
+    return;
+  }
+  recordDegradationOnce({
+    kind: "config-location-probe-failed",
+    subject: resolution.path,
+    reason: `existence probe for ${resolution.existsProbeFailed?.path} failed (${resolution.existsProbeFailed?.errorClassName}); the location is retained as the config source and its read failures report through PILENS_CFG_0001`,
+    metadata: { subsystem: "lens-config", configPath: resolution.path }
+  });
+}
+function reportGlobalConfigShadowing() {
+  const resolution = getProductionGlobalConfigResolution();
+  if (resolution.shadowedPath === undefined)
+    return;
+  const winningPath = canonicalPathIdentity(resolution.path);
+  const shadowedPath = canonicalPathIdentity(resolution.shadowedPath);
+  recordDegradationOnce({
+    kind: "config-location-shadowed",
+    subject: winningPath,
+    reason: `shadowed global config ${shadowedPath}; winning path is the record subject`,
+    metadata: {
+      subsystem: "lens-config",
+      configPath: winningPath,
+      shadowedPath
+    },
+    code: "PILENS_CFG_0010"
+  });
+}
+export function loadDmLensGlobalConfig(configPath) {
+  const derivedPath = configPath === undefined;
+  if (derivedPath) {
+    reportGlobalConfigProbeRetention();
+    reportGlobalConfigShadowing();
+  }
+  const resolvedPath = configPath ?? getDmLensGlobalConfigPath();
   const location = globalCanonicalLocation();
-  const outcome = readConfigDocument(configPath);
+  const outcome = readConfigDocument(resolvedPath);
   if (outcome.status === "missing")
     return;
   if (outcome.status === "error") {
     reportConfigReadFailure({
-      file: configPath,
+      file: resolvedPath,
       location,
       tier: "global",
       error: outcome.error,
@@ -66,7 +112,7 @@ export function loadDmLensGlobalConfig(configPath = getDmLensGlobalConfigPath())
     });
     return;
   }
-  const { note, records: notedRecords } = ignoredRecordCollector(configPath, "global");
+  const { note, records: notedRecords } = ignoredRecordCollector(resolvedPath, "global");
   try {
     const parsed = outcome.value;
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -75,7 +121,7 @@ export function loadDmLensGlobalConfig(configPath = getDmLensGlobalConfigPath())
     }
     const document = {
       tier: "global",
-      file: configPath,
+      file: resolvedPath,
       location,
       value: parsed
     };
@@ -84,6 +130,9 @@ export function loadDmLensGlobalConfig(configPath = getDmLensGlobalConfigPath())
     const raw = resolved.value;
     const warnInvalid = note;
     const config = {};
+    const toolConfig = readToolConfig(raw, warnInvalid);
+    if (toolConfig)
+      config.tools = toolConfig;
     for (const spec of LENS_FLAGS) {
       if (spec.readGlobal)
         continue;
@@ -92,6 +141,24 @@ export function loadDmLensGlobalConfig(configPath = getDmLensGlobalConfigPath())
     const ignore = Array.isArray(raw.ignore) ? raw.ignore.filter((p) => typeof p === "string") : undefined;
     if (ignore && ignore.length > 0)
       config.ignore = ignore;
+    const startup = asConfigObject(raw.startup);
+    if (startup) {
+      const startupConfig = {};
+      const mode = startup.mode;
+      const scans = asConfigObject(startup.scans);
+      if (mode === "quick" || mode === "full" || mode === "minimal")
+        startupConfig.mode = mode;
+      else if ("mode" in startup)
+        warnInvalid('startup.mode must be "quick", "full", or "minimal"');
+      if (scans) {
+        if (typeof scans.enabled === "boolean") {
+          startupConfig.scans = { enabled: scans.enabled };
+        } else if ("enabled" in scans)
+          warnInvalid("startup.scans.enabled must be a boolean");
+      }
+      if (startupConfig.mode !== undefined || startupConfig.scans !== undefined)
+        config.startup = startupConfig;
+    }
     const dispatch = asConfigObject(raw.dispatch);
     if (dispatch) {
       const floor = dispatch.runnerTimeoutFloorMs;
@@ -151,7 +218,7 @@ export function loadDmLensGlobalConfig(configPath = getDmLensGlobalConfigPath())
     }
     return config;
   } catch (error) {
-    warnInvalidGlobalConfigOnce(configPath, `global config could not be interpreted (${errorClassName(error)}); configuration ignored`, "PILENS_CFG_0008");
+    warnInvalidGlobalConfigOnce(resolvedPath, `global config could not be interpreted (${errorClassName(error)}); configuration ignored`, "PILENS_CFG_0008");
     return;
   } finally {
     reportDmLensConfigRecords(notedRecords());

package/extensions/dm-lens/clients/lens-engine.js

@@ -14,6 +14,7 @@ import { acquireWarmWordIndex } from "./mcp/analyze.js";
 import { normalizeMapKey } from "./path-utils.js";
 import { scanProjectDiagnostics } from "./project-diagnostics/scanner.js";
 import { loadProjectSnapshotWithoutWordIndex } from "./project-snapshot.js";
+import { resolveLensToolName } from "./tool-config.js";
 import {
   getTreeSitterRuntimeStatus
 } from "./tree-sitter-shared.js";
@@ -23,22 +24,18 @@ import {
   searchWordIndex,
   triggerBackgroundWordIndexBuild
 } from "./word-index.js";
-export {
-  analyzeFile
-} from "./mcp/analyze.js";
+export { analyzeFile } from "./mcp/analyze.js";
 export { createMcpHost } from "./mcp/host-shim.js";
 export {
   createWarmIpcLineReader,
   createWarmIpcRequestQueue,
   ipcPathForCwd,
   readTurnEndStatus,
-  requestWarmAnalyze,
   WARM_TURN_END_SCHEMA_VERSION
 } from "./mcp/ipc.js";
 export {
   analyzeFileFresh,
   canRebuildDmLens,
-  REBUILD_UNAVAILABLE_MESSAGE,
   resolveRebuildScript,
   runRebuild,
   summarizeScan
@@ -59,9 +56,6 @@ export {
   projectReport,
   renderCompactProjectReport
 } from "./project-report.js";
-export {
-  createDefaultHostPorts
-} from "./host-ports.js";
 export {
   effectiveConfig,
   isEffectiveFileViewError
@@ -90,7 +84,7 @@ export function scanTruncationNotice(snapshot) {
   }
   return `⚠ Scan truncated at ${snapshot.filesScanned} file(s) — results are partial; ` + "raise maxProjectFiles in .dm-lens.json to scan fully.";
 }
-export function generatedSkipNotice(snapshot) {
+export function generatedSkipNotice(snapshot, host = "pi") {
   const files = snapshot.generatedNameOnlySkips ?? 0;
   const dirs = snapshot.generatedDirSkips ?? 0;
   if (files === 0 && dirs === 0)
@@ -100,7 +94,12 @@ export function generatedSkipNotice(snapshot) {
     parts.push(`${files} file(s)`);
   if (dirs > 0)
     parts.push(`${dirs} director${dirs === 1 ? "y" : "ies"}`);
-  return `ℹ ${parts.join(" and ")} excluded by generated-name heuristics with no ` + "confirming evidence — a real hand-written file/directory whose name " + "looks generated (e.g. `gen.ts`, `generated/`) can be excluded too; " + "pass includeGenerated: true to dmlens_project_scan / lens_diagnostics " + "to scan without this filter if you suspect a false skip.";
+  const targets = [
+    resolveLensToolName("project_scan", host),
+    resolveLensToolName("lens_diagnostics", host)
+  ].filter((tool) => tool !== undefined);
+  const scanRef = targets.length > 0 ? ` to ${targets.join(" / ")}` : "";
+  return `ℹ ${parts.join(" and ")} excluded by generated-name heuristics with no ` + "confirming evidence — a real hand-written file/directory whose name " + "looks generated (e.g. `gen.ts`, `generated/`) can be excluded too; " + `pass includeGenerated: true${scanRef} to scan without this filter if you suspect a false skip.`;
 }
 export function treeSitterRuntimeStatus() {
   return getTreeSitterRuntimeStatus();

package/extensions/dm-lens/clients/lens-events.js

@@ -6,7 +6,7 @@ import {
   recordStaleBusFailure,
   resolveLiveBusEmitter
 } from "./live-bus-emitter.js";
-export const LENS_EVENT_VERSION = 1;
+const LENS_EVENT_VERSION = 1;
 export const LENS_EVENT_NAMES = {
   analysisComplete: "dm-lens/analysis-complete",
   findings: "dm-lens/findings",

package/extensions/dm-lens/clients/lens-flag-registry.js

@@ -154,6 +154,22 @@ export const LENS_FLAGS = [
     default: false,
     scope: "global"
   },
+  {
+    name: "lens-compact-lsp-status",
+    description: "Opt-in (#3099): collapse the footer LSP status to one state glyph per group (LSP ✓ green, LSP ✗ red, dim LSP ✗ when nothing is warm) instead of listing the active server names. Default off. Also via ui.compactLspStatus=true in ~/.dm-lens/config.json.",
+    configKey: "ui.compactLspStatus",
+    negated: false,
+    default: false,
+    scope: "global"
+  },
+  {
+    name: "lens-hide-lsp-status",
+    description: "Opt-in (#3099): publish no dm-lens-lsp footer status at all, so a host that renders extension statuses stops showing the key. Outranks lens-compact-lsp-status when both are set. Default off. Also via ui.hideLspStatus=true in ~/.dm-lens/config.json.",
+    configKey: "ui.hideLspStatus",
+    negated: false,
+    default: false,
+    scope: "global"
+  },
   {
     name: "no-lazy-tools",
     description: "Keep all dm-lens tools active to avoid tool-list cache changes. Also via tools.lazy=false in ~/.dm-lens/config.json.",
@@ -169,7 +185,23 @@ export const LENS_FLAGS = [
     negated: false,
     default: false,
     scope: "global"
-  }
+  },
+  ...[
+    "knip",
+    "jscpd",
+    "madge",
+    "gitleaks",
+    "govulncheck",
+    "deadCode",
+    "complexity"
+  ].map((analyzer) => ({
+    name: `no-${analyzer.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}`,
+    description: `Disable the ${analyzer} session-start analyzer. Also via ${analyzer}.enabled=false in config.`,
+    configKey: `${analyzer}.enabled`,
+    negated: true,
+    default: false,
+    scope: "project"
+  }))
 ];
 const byName = new Map(LENS_FLAGS.map((spec) => [spec.name, spec]));
 export function getLensFlagSpec(name) {
@@ -180,15 +212,21 @@ export const GLOBAL_NON_FLAG_CONFIG_SECTIONS = [
   "ignore",
   "dispatch",
   "widget",
+  "startup",
   "$schema"
 ];
+export const GLOBAL_ONLY_NON_FLAG_KEYS = [
+  "actionableWarnings.autoFix.maxFixes"
+];
 export const PROJECT_NON_FLAG_CONFIG_SECTIONS = [
   "ignore",
   "rules",
   "maxProjectFiles",
   "reviewGraph",
   "trivy",
-  "helm"
+  "helm",
+  "startup",
+  "tools"
 ];
 const LSP_PROJECT_HONORED_KEYS = DEPRECATED_CONFIG_SURFACES.filter((row) => row.kind === "key").map((row) => row.surface);
 export const PROJECT_FOREIGN_CONFIG_NAMESPACES = [
@@ -227,6 +265,13 @@ function resolveFlagConfigPath(raw, configKey, warnInvalid) {
     return;
   return { source: finalSource, segments };
 }
+export function hasFlagConfigPath(raw, configKey) {
+  const resolved = resolveFlagConfigPath(raw, configKey);
+  if (!resolved)
+    return false;
+  const leaf = resolved.segments.at(-1);
+  return leaf !== undefined && leaf in resolved.source;
+}
 export function readFlagConfigValue(config, configKey) {
   const path = resolveFlagConfigPath(config, configKey);
   if (!path)

package/extensions/dm-lens/clients/lens-map.js

@@ -7,7 +7,7 @@ import { normalizeMapKey, toProjectRelativePath } from "./path-utils.js";
 import { canonicalSourceTwin } from "./source-filter.js";
 import { buildOrUpdateGraph } from "./review-graph/service.js";
 import { detectFileRole } from "./file-role.js";
-export const DEFAULT_MAX_MAP_NODES = 500;
+const DEFAULT_MAX_MAP_NODES = 500;
 export function aggregateGraphToFiles(graph, options) {
   const maxNodes = Math.max(1, options?.maxNodes ?? DEFAULT_MAX_MAP_NODES);
   const files = new Map;

package/extensions/dm-lens/clients/log-cleanup.js

@@ -136,31 +136,3 @@ export function runLogCleanup(dbg) {
   }
   return results;
 }
-export function getLogStorageSummary() {
-  const files = [];
-  let totalMB = 0;
-  for (const name of getManagedLogFiles()) {
-    const filePath = path.join(LOG_DIR, name);
-    if (fs.existsSync(filePath)) {
-      const sizeMB = getFileSizeMB(filePath);
-      const ageDays = getFileAgeDays(filePath);
-      files.push({ name, sizeMB, ageDays });
-      totalMB += sizeMB;
-    }
-  }
-  try {
-    if (fs.existsSync(LOGS_SUBDIR)) {
-      const dailyFiles = fs.readdirSync(LOGS_SUBDIR);
-      for (const name of dailyFiles) {
-        if (!name.endsWith(".jsonl"))
-          continue;
-        const filePath = path.join(LOGS_SUBDIR, name);
-        const sizeMB = getFileSizeMB(filePath);
-        const ageDays = getFileAgeDays(filePath);
-        files.push({ name: `logs/${name}`, sizeMB, ageDays });
-        totalMB += sizeMB;
-      }
-    }
-  } catch {}
-  return { totalMB, files };
-}

package/extensions/dm-lens/clients/lsp/cascade-tier.js

@@ -151,7 +151,8 @@ export function registerCascadeTierReconcileTask(getLspService, options = {}) {
           options.onResolvedFound?.({
             filePath: o.filePath,
             serverId: o.serverId,
-            diagnostics: o.diagnostics
+            diagnostics: o.diagnostics,
+            ...o.publishedAt !== undefined ? { publishedAt: o.publishedAt } : {}
           });
         } else if (o.outcome === "resolved-clean" && o.publishedAt != null) {
           options.onResolvedClean?.({

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

@@ -6,6 +6,7 @@ import { pathToFileURL } from "node:url";
 import { emitBounded } from "../bounded-telemetry.js";
 import { withTimeout } from "../deadline-utils.js";
 import { minimatch } from "../deps/minimatch.js";
+import { mapWithConcurrency } from "../map-with-concurrency.js";
 import {
   incrementDegradationCount,
   recordDegradationOnce
@@ -24,7 +25,11 @@ import {
   newLspMutationCorrelationId
 } from "../lsp-mutation.js";
 import { getProcessSingleton } from "../process-singletons.js";
-import { getAmbientAbortSignal } from "../safe-spawn.js";
+import {
+  getAmbientAbortSignal,
+  isOwnLiveChild,
+  releaseOwnChildPid
+} from "../safe-spawn.js";
 import { raceToCompletion } from "./aggregation.js";
 import {
   hashDiagnosticContent
@@ -38,10 +43,12 @@ import {
   negotiatePositionEncoding
 } from "./position-encoding.js";
 import {
+  negotiateSaveOptions,
   negotiateSyncKind,
   TEXT_DOCUMENT_SYNC_KIND_FULL,
   TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL
 } from "./sync-kind.js";
+import { exceedsLspSyncLimits } from "./content-limits.js";
 import { probeTsserverProjectIdentity } from "./tsserver-sync.js";
 import { getStrategy } from "./wait-policy/index.js";
 import { WatchedFilesQueue } from "./watch-queue.js";
@@ -133,21 +140,6 @@ const LIVENESS_PING_QUERY = "__dm_lens_liveness_ping__";
 const WORKSPACE_PULL_RESULT_CACHE_MAX = 4096;
 const WORKSPACE_PULL_SCOPE = "*workspace*";
 const REFRESH_REPULL_CONCURRENCY = 4;
-async function mapWithConcurrency(items, concurrency, mapper) {
-  if (items.length === 0)
-    return;
-  let nextIndex = 0;
-  const workerCount = Math.max(1, Math.min(concurrency, items.length));
-  const worker = async () => {
-    while (true) {
-      const index = nextIndex++;
-      if (index >= items.length)
-        return;
-      await mapper(items[index]);
-    }
-  };
-  await Promise.all(Array.from({ length: workerCount }, () => worker()));
-}
 const EXECUTE_COMMAND_TIMEOUT_MS = positiveIntFromEnv("DM_LENS_LSP_EXECUTE_COMMAND_TIMEOUT_MS", 30000);
 const PROBE_COMMAND_TIMEOUT_MS = positiveIntFromEnv("DM_LENS_LSP_PROJECT_IDENTITY_PROBE_TIMEOUT_MS", 2500);
 const LSP_CRASH_CODES = new Set([
@@ -219,6 +211,7 @@ function disposeClientConnection(state) {
 }
 export async function killProcessTree(proc, pid, options = {}) {
   if ((proc.exitCode != null || proc.signalCode != null) && !options.processExiting) {
+    releaseOwnChildPid(pid);
     proc.unref?.();
     return;
   }
@@ -268,7 +261,7 @@ export async function killProcessTree(proc, pid, options = {}) {
     return;
   }
   const killPosixProcessGroup = (signal) => {
-    if (pid <= 0)
+    if (!isOwnLiveChild(pid, "lsp-stop-posix-group"))
       return false;
     try {
       process.kill(-pid, signal);
@@ -304,6 +297,7 @@ export async function killProcessTree(proc, pid, options = {}) {
             killDirectChild("SIGKILL");
           }
         }
+        releaseOwnChildPid(pid);
       }, 1500);
       timer.unref?.();
       proc.unref?.();
@@ -336,6 +330,7 @@ export async function killProcessTree(proc, pid, options = {}) {
         killDirectChild("SIGKILL");
       }
     }
+    releaseOwnChildPid(pid);
   } catch {}
 }
 export function stripDiagnosticNoiseLines(message) {
@@ -667,25 +662,26 @@ export function applyDynamicCapabilities(state) {
 }
 export function resolveConfigurationSection(initialization, section) {
   if (!initialization)
-    return section ? null : {};
+    return {};
   if (!section)
     return initialization;
   let cur = initialization;
   for (const part of section.split(".")) {
     if (typeof cur !== "object" || cur === null || !Object.hasOwn(cur, part)) {
-      return null;
+      return {};
     }
     cur = cur[part];
   }
   return cur;
 }
-export function setupIncomingHandlers(state, initialization) {
+export function setupIncomingHandlers(state, initialization, onDiagnosticsPublished) {
   state.connection.onNotification("textDocument/publishDiagnostics", (params) => {
     const publishReceivedAt = Date.now();
     const filePath = uriToPath(params.uri);
     const normalizedPath = normalizeMapKey(filePath);
     if (state.closedDocuments?.has(normalizedPath))
       return;
+    onDiagnosticsPublished?.(state.serverId);
     const newDiags = normalizeLspDiagnostics(params.diagnostics || []);
     const docVersion = params.version;
     if (PUB_DEBUG) {
@@ -750,6 +746,21 @@ export function setupIncomingHandlers(state, initialization) {
       const currentVersion = state.documentVersions.get(normalizedPath);
       return currentVersion !== undefined && docVersion < currentVersion;
     };
+    if (strategy.emptyFirstPublish === "indexing" && !state.emptyFirstPublishHoldSpent && newDiags.length === 0 && !state.pushDiagnostics.has(normalizedPath) && !state.pendingDiagnostics.has(normalizedPath)) {
+      state.emptyFirstPublishHoldSpent = true;
+      logLatency({
+        type: "phase",
+        phase: "lsp_empty_first_publish_held",
+        filePath: normalizedPath,
+        durationMs: Math.max(0, publishReceivedAt - (state.documentOpenedAt.get(normalizedPath) ?? publishReceivedAt)),
+        metadata: {
+          serverId: state.serverId,
+          emptyFirstPublish: strategy.emptyFirstPublish,
+          pubVersion: docVersion ?? "push-unversioned"
+        }
+      });
+      return;
+    }
     if (strategy.seedFirstPush && !state.pushDiagnostics.has(normalizedPath)) {
       if (isSupersededPush())
         return;
@@ -1383,7 +1394,26 @@ export function handleNotifyExternalChange(state, filePath, type) {
   const uri = state.openDocumentUris?.get(normalizedPath) ?? pathToFileURL(filePath).href;
   state.watchQueue.enqueue(uri, type);
 }
-async function handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics = false, silent = false, coalescedCount = 0) {
+async function sendDidSave(state, uri, content) {
+  const save = state.saveOptions;
+  if (!save)
+    return;
+  if (!isClientAlive(state))
+    return;
+  const limit = save.includeText ? exceedsLspSyncLimits(content) : { tooLarge: false, reason: "" };
+  if (limit.tooLarge) {
+    recordDegradationOnce({
+      kind: "lsp-did-save-text-omitted",
+      subject: state.serverId,
+      reason: limit.reason
+    });
+  }
+  await safeSendNotification(state.connection, "textDocument/didSave", {
+    textDocument: { uri },
+    ...save.includeText && !limit.tooLarge ? { text: content } : {}
+  });
+}
+async function handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics = false, silent = false, coalescedCount = 0, saved = false) {
   if (!isClientAlive(state))
     return;
   const normalizedPath = normalizeMapKey(filePath);
@@ -1410,6 +1440,8 @@ async function handleNotifyOpenOnce(state, filePath, content, languageId, preser
         recordSentContent(state, normalizedPath, version, content, coalescedCount);
       state.openDocuments.add(normalizedPath);
       state.openDocumentUris?.set(normalizedPath, uri);
+      if (saved && reopenSent)
+        await sendDidSave(state, uri, content);
       return;
     }
     const changeSent = await safeSendNotification(state.connection, "textDocument/didChange", {
@@ -1418,6 +1450,8 @@ async function handleNotifyOpenOnce(state, filePath, content, languageId, preser
     });
     if (changeSent)
       recordSentContent(state, normalizedPath, version, content, coalescedCount);
+    if (saved && changeSent)
+      await sendDidSave(state, uri, content);
     return;
   }
   state.pendingOpens.add(normalizedPath);
@@ -1443,6 +1477,8 @@ async function handleNotifyOpenOnce(state, filePath, content, languageId, preser
   state.openDocuments.add(normalizedPath);
   state.closedDocuments?.delete(normalizedPath);
   state.openDocumentUris?.set(normalizedPath, uri);
+  if (saved && openSent)
+    await sendDidSave(state, uri, content);
   probeTsserverProjectIdentity({
     serverId: state.serverId,
     launchVariant: state.launchVariant,
@@ -1455,7 +1491,7 @@ async function handleNotifyOpenOnce(state, filePath, content, languageId, preser
     }
   });
 }
-function enqueueDocumentNotify(state, normalizedPath, run) {
+function enqueueDocumentNotify(state, normalizedPath, run, saved = false) {
   let queue = state.notifyChangeQueues.get(normalizedPath);
   if (!queue) {
     queue = { running: false };
@@ -1468,7 +1504,8 @@ function enqueueDocumentNotify(state, normalizedPath, run) {
     queue.pending = {
       run,
       waiters,
-      coalescedCount: (previous?.coalescedCount ?? 0) + (previous ? 1 : 0)
+      coalescedCount: (previous?.coalescedCount ?? 0) + (previous ? 1 : 0),
+      saved: saved || previous?.saved === true
     };
     if (queue.running)
       return;
@@ -1481,7 +1518,7 @@ function enqueueDocumentNotify(state, normalizedPath, run) {
             break;
           queue.pending = undefined;
           try {
-            await next.run(next.coalescedCount);
+            await next.run(next.coalescedCount, next.saved);
             for (const waiter of next.waiters)
               waiter.resolve();
           } catch (error) {
@@ -1506,11 +1543,11 @@ function cancelDocumentNotifyQueues(state) {
   }
   state.notifyChangeQueues.clear();
 }
-export function handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics = false, silent = false) {
+export function handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics = false, silent = false, saved = false) {
   if (!isClientAlive(state))
     return Promise.resolve();
   const normalizedPath = normalizeMapKey(filePath);
-  return enqueueDocumentNotify(state, normalizedPath, (coalescedCount) => handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics, silent, coalescedCount));
+  return enqueueDocumentNotify(state, normalizedPath, (coalescedCount, queuedSaved) => handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics, silent, coalescedCount, queuedSaved), saved);
 }
 async function handleNotifyChangeOnce(state, filePath, content, normalizedPath, coalescedCount = 0) {
   if (!isClientAlive(state))
@@ -1965,7 +2002,8 @@ export async function createLSPClient(options) {
     sessionCwd,
     initialization,
     initializeTimeoutMs = INITIALIZE_TIMEOUT_MS,
-    launchVariant
+    launchVariant,
+    onDiagnosticsPublished
   } = options;
   recordLspChild({
     pid: lspProcess.pid,
@@ -2071,6 +2109,7 @@ export async function createLSPClient(options) {
     pullRequestSequences: new Map,
     workspacePullResultCache: new Map,
     openDocuments: new Set,
+    emptyFirstPublishHoldSpent: false,
     closedDocuments: new Set,
     openDocumentUris: new Map,
     pendingOpens: new Set,
@@ -2096,7 +2135,7 @@ export async function createLSPClient(options) {
       return;
     safeSendNotification(state.connection, "workspace/didChangeWatchedFiles", { changes });
   });
-  setupIncomingHandlers(state, initialization);
+  setupIncomingHandlers(state, initialization, onDiagnosticsPublished);
   connection.listen();
   setupConnectionLifecycle(state, recentStderr);
   let initResult;
@@ -2168,6 +2207,7 @@ export async function createLSPClient(options) {
   }
   state.positionEncoding = negotiatePositionEncoding(initResult?.capabilities);
   state.syncKind = negotiateSyncKind(initResult?.capabilities);
+  state.saveOptions = negotiateSaveOptions(initResult?.capabilities);
   state.rawCapabilityKeys = Object.keys(initResult?.capabilities ?? {}).sort((a, b) => a.localeCompare(b));
   for (const cmd of detectExecuteCommands(initResult)) {
     state.advertisedCommands.add(cmd);
@@ -2196,8 +2236,8 @@ export async function createLSPClient(options) {
     pingLiveness: (timeoutMs) => clientPingLiveness(state, timeoutMs),
     getProcessPid: () => lspProcess.pid,
     notify: {
-      async open(filePath, content, languageId, preserveDiagnostics, silent) {
-        return handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics, silent);
+      async open(filePath, content, languageId, preserveDiagnostics, silent, saved) {
+        return handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics, silent, saved);
       },
       async change(filePath, content) {
         return handleNotifyChange(state, filePath, content);