@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/clients/bounded-pid-file-lock.js

@@ -2,7 +2,30 @@ import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import fsp from "node:fs/promises";
 import path from "node:path";
+import { BoundedFifoMap } from "./bounded-cache.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import {
+  heartbeatIntervalMs,
+  isLockContention,
+  recordGenerationTakeover,
+  recordLegacyLockHeld,
+  releaseGeneration,
+  startGenerationHeartbeat,
+  topGenerationHolder,
+  tryAcquireGeneration
+} from "./generation-lock.js";
 const waitArray = new Int32Array(new SharedArrayBuffer(4));
+const UNREADABLE_LOCK_STALE_MS = 5000;
+function generationDir(lockPath) {
+  return `${lockPath}s`;
+}
+function boundedLockIsStale(lockPath) {
+  const [pidText] = fs.readFileSync(lockPath, "utf8").split(":", 1);
+  const pid = Number.parseInt(pidText ?? "", 10);
+  if (Number.isSafeInteger(pid) && pid > 0)
+    return !ownerPidIsLive(pid);
+  return Date.now() - fs.statSync(lockPath).mtimeMs > UNREADABLE_LOCK_STALE_MS;
+}
 function ownerPidIsLive(pid) {
   if (!Number.isSafeInteger(pid) || pid <= 0)
     return false;
@@ -115,12 +138,41 @@ async function tryAcquireQuarantineLock(lockPath, staleMs) {
   }
   return null;
 }
+async function tryAcquireQuarantineGeneration(lockPath, staleMs) {
+  const hold = tryAcquireGeneration(generationDir(lockPath), staleMs);
+  if (!hold)
+    return "busy";
+  if (hold.tookOverStale)
+    recordGenerationTakeover(hold);
+  let releaseLegacy;
+  try {
+    releaseLegacy = await tryAcquireQuarantineLock(lockPath, staleMs);
+  } catch (cause) {
+    releaseGeneration(hold);
+    throw cause;
+  }
+  if (releaseLegacy) {
+    const heartbeat = startGenerationHeartbeat(hold, heartbeatIntervalMs(staleMs));
+    return async () => {
+      heartbeat.stop();
+      await releaseLegacy();
+      releaseGeneration(hold);
+    };
+  }
+  releaseGeneration(hold);
+  return "legacy-held";
+}
 export async function acquireQuarantinePidFileLock(lockPath, options) {
   const deadline = Date.now() + options.waitMs;
+  let legacyHeldRecorded = false;
   for (;; ) {
-    const release = await tryAcquireQuarantineLock(lockPath, options.staleMs);
-    if (release)
+    const release = await tryAcquireQuarantineGeneration(lockPath, options.staleMs);
+    if (typeof release === "function")
       return release;
+    if (release === "legacy-held" && !legacyHeldRecorded) {
+      legacyHeldRecorded = true;
+      recordLegacyLockHeld(lockPath);
+    }
     const remaining = deadline - Date.now();
     if (remaining <= 0) {
       if (options.onContention === "skip-log") {
@@ -132,42 +184,101 @@ export async function acquireQuarantinePidFileLock(lockPath, options) {
     await new Promise((resolve) => setTimeout(resolve, Math.min(options.retryMs, remaining)));
   }
 }
+function createLegacyBoundedLock(lockPath, token) {
+  try {
+    fs.writeFileSync(lockPath, token, { encoding: "utf8", flag: "wx" });
+    return true;
+  } catch (cause) {
+    if (isLockContention(cause))
+      return false;
+    throw cause;
+  }
+}
+function takeLegacyBoundedLock(lockPath, token) {
+  if (createLegacyBoundedLock(lockPath, token))
+    return true;
+  try {
+    if (!boundedLockIsStale(lockPath))
+      return false;
+    fs.unlinkSync(lockPath);
+  } catch {
+    return false;
+  }
+  return createLegacyBoundedLock(lockPath, token);
+}
+function releaseLegacyBoundedLock(lockPath, token) {
+  try {
+    if (fs.readFileSync(lockPath, "utf8") === token)
+      fs.unlinkSync(lockPath);
+  } catch {}
+}
+function tryAcquireBoundedLock(lockPath, token) {
+  const hold = tryAcquireGeneration(generationDir(lockPath), UNREADABLE_LOCK_STALE_MS);
+  if (!hold)
+    return "busy";
+  if (hold.tookOverStale)
+    recordGenerationTakeover(hold);
+  let took;
+  try {
+    took = takeLegacyBoundedLock(lockPath, token);
+  } catch (cause) {
+    releaseGeneration(hold);
+    throw cause;
+  }
+  if (took)
+    return hold;
+  releaseGeneration(hold);
+  return "legacy-held";
+}
+const timedOutHolders = new BoundedFifoMap(16);
+function currentHolderIdentity(dir, lockPath, hold) {
+  if (hold === "busy")
+    return topGenerationHolder(dir);
+  try {
+    const content = fs.readFileSync(lockPath, "utf8");
+    return content ? `legacy ${content}` : undefined;
+  } catch {
+    return;
+  }
+}
 export function acquireBoundedPidFileLock(lockPath, options) {
   const token = `${process.pid}:${Date.now()}:${randomUUID()}`;
   const deadline = Date.now() + options.waitMs;
+  const dir = generationDir(lockPath);
+  const timedOutHolder = timedOutHolders.get(dir);
+  let legacyHeldRecorded = false;
   for (;; ) {
-    try {
-      const fd = fs.openSync(lockPath, "wx");
-      fs.writeFileSync(fd, token, "utf8");
-      fs.closeSync(fd);
+    const hold = tryAcquireBoundedLock(lockPath, token);
+    if (typeof hold === "object") {
       return () => {
-        try {
-          if (fs.readFileSync(lockPath, "utf8") === token) {
-            fs.unlinkSync(lockPath);
-          }
-        } catch {}
+        releaseLegacyBoundedLock(lockPath, token);
+        releaseGeneration(hold);
       };
-    } catch (error) {
-      if (error.code !== "EEXIST")
-        throw error;
-      try {
-        const [pidText] = fs.readFileSync(lockPath, "utf8").split(":", 1);
-        if (!ownerPidIsLive(Number.parseInt(pidText ?? "", 10))) {
-          fs.unlinkSync(lockPath);
-          continue;
-        }
-      } catch (lockError) {
-        if (lockError.code === "ENOENT")
-          continue;
+    }
+    if (hold === "legacy-held" && !legacyHeldRecorded) {
+      legacyHeldRecorded = true;
+      recordLegacyLockHeld(lockPath);
+    }
+    if (timedOutHolder !== undefined && currentHolderIdentity(dir, lockPath, hold) === timedOutHolder) {
+      recordDegradationOnce({
+        kind: "bounded-pid-lock-wait-skipped",
+        subject: path.resolve(dir),
+        reason: `did not wait: ${timedOutHolder} still holds the lock after an earlier wait ran out`
+      });
+      if (options.onContention === "skip-log") {
+        options.logContention();
+        return null;
       }
-      if (Date.now() >= deadline) {
-        if (options.onContention === "skip-log") {
-          options.logContention();
-          return null;
-        }
-        throw new Error(options.timeoutMessage, { cause: error });
+      throw new Error(options.timeoutMessage);
+    }
+    if (Date.now() >= deadline) {
+      timedOutHolders.set(dir, currentHolderIdentity(dir, lockPath, hold));
+      if (options.onContention === "skip-log") {
+        options.logContention();
+        return null;
       }
-      Atomics.wait(waitArray, 0, 0, options.retryMs);
+      throw new Error(options.timeoutMessage);
     }
+    Atomics.wait(waitArray, 0, 0, options.retryMs);
   }
 }

package/extensions/dm-lens/clients/bounded-telemetry.js

@@ -1,6 +1,8 @@
 import { incrementDegradationCount } from "./degradation-ledger.js";
 import { logLatency } from "./latency-logger.js";
 export const BOUNDED_TELEMETRY_PHASES = [
+  "adopted_root_binary_refused",
+  "adopted_root_writer_skipped",
   "session_start_duplicate_suppressed",
   "bootstrap_clients_unavailable",
   "agent_end_deferred_format_orphan_origin_mismatch",
@@ -16,6 +18,7 @@ export const BOUNDED_TELEMETRY_PHASES = [
   "lsp_capability_skip",
   "test_runner_failed_target_state",
   "test_runner_delivery",
+  "turn_end_test_selection",
   "loop_block",
   "session_event_stale_ctx_skip",
   "shared_checkout_switch_blocked",

package/extensions/dm-lens/clients/cache/rule-cache.js

@@ -1,4 +1,3 @@
-import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { reportBundledResourceDirHealth } from "../bundled-resource-health.js";
@@ -6,15 +5,12 @@ import { getProjectDataDir } from "../file-utils.js";
 import { readJsonCache } from "../json-cache-read.js";
 import {
   BUNDLED_QUERIES_ROOT,
+  computeRuleFilesFingerprint,
   getBundledQueriesRootHealth
 } from "../tree-sitter-query-loader.js";
 import { writeFileAtomic } from "../atomic-write.js";
-import { compareOrdinal } from "../string-utils.js";
 export const CACHE_VERSION = "v7";
 export { BUNDLED_QUERIES_ROOT as BUNDLED_RULES_ROOT } from "../tree-sitter-query-loader.js";
-function isBundledRuleFile(resolvedFile) {
-  return resolvedFile === BUNDLED_QUERIES_ROOT || resolvedFile.startsWith(BUNDLED_QUERIES_ROOT + path.sep);
-}
 function reportBundledRulesRootHealth() {
   reportBundledResourceDirHealth("tree-sitter-queries-dir-missing", BUNDLED_QUERIES_ROOT, getBundledQueriesRootHealth(), "bundled tree-sitter query rules");
 }
@@ -35,18 +31,7 @@ export class RuleCache {
     }
   }
   computeRuleHash(ruleFiles) {
-    const hash = crypto.createHash("sha256");
-    for (const file of ruleFiles.sort(compareOrdinal)) {
-      const resolved = path.resolve(file);
-      if (!fs.existsSync(resolved))
-        continue;
-      const stat = fs.statSync(resolved);
-      hash.update(`${file}:${stat.mtimeMs}:${stat.size}`);
-      if (!isBundledRuleFile(resolved)) {
-        hash.update(fs.readFileSync(resolved));
-      }
-    }
-    return hash.digest("hex").slice(0, 16);
+    return computeRuleFilesFingerprint(ruleFiles);
   }
   get(ruleFiles) {
     try {

package/extensions/dm-lens/clients/cache-manager.js

@@ -14,6 +14,8 @@ const DEFAULT_TURN_STATE = {
 };
 export const MCP_TURN_STATE_OWNER_ID = `mcp-${process.pid}`;
 const TURN_OWNER_STALE_MS = 30 * 60 * 1000;
+const TURN_SESSION_PARTITION_TTL_MS = 30 * 60 * 1000;
+const MAX_TURN_SESSION_PARTITIONS = 16;
 function getLensDir(cwd) {
   return getProjectDataDir(cwd);
 }
@@ -176,7 +178,62 @@ export class CacheManager {
       }
     }
   }
-  readTurnState(cwd) {
+  readTurnState(cwd, sessionId) {
+    return this.resolveTurnStatePartition(cwd, sessionId).state;
+  }
+  ensureSecondaryTurnStatePartition(cwd, sessionId) {
+    const envelope = this.readTurnStateEnvelope(cwd);
+    if (envelope.sessions?.[sessionId])
+      return;
+    const secondary = {
+      ...DEFAULT_TURN_STATE,
+      files: {},
+      lastUpdated: new Date().toISOString(),
+      sessionId,
+      owner: {
+        kind: "pi",
+        id: sessionId,
+        pid: process.pid,
+        lastSeen: new Date().toISOString()
+      }
+    };
+    this.writeTurnState({
+      ...envelope,
+      sessions: { ...envelope.sessions, [sessionId]: secondary }
+    }, cwd);
+  }
+  resolveTurnStatePartition(cwd, sessionId) {
+    const envelope = this.readTurnStateEnvelope(cwd);
+    const persistedSecondary = sessionId === undefined ? undefined : envelope.sessions?.[sessionId];
+    const primary = sessionId === undefined || envelope.owner === undefined && persistedSecondary === undefined || envelope.owner?.kind === "pi" && envelope.owner.id === sessionId;
+    const isSecondary = !primary && (persistedSecondary !== undefined || envelope.owner?.kind === "pi" && envelope.owner.pid === process.pid);
+    const state = primary ? envelope : persistedSecondary ?? {
+      ...DEFAULT_TURN_STATE,
+      files: {},
+      lastUpdated: new Date().toISOString()
+    };
+    return {
+      envelope,
+      state,
+      isSecondary,
+      persist: (next) => {
+        if (isSecondary && sessionId !== undefined) {
+          this.writeTurnState({
+            ...envelope,
+            sessions: { ...envelope.sessions, [sessionId]: next }
+          }, cwd);
+        } else
+          this.writeTurnState(next, cwd);
+      },
+      remove: () => {
+        if (!isSecondary || sessionId === undefined)
+          return;
+        const { [sessionId]: _retired, ...remaining } = envelope.sessions ?? {};
+        this.writeTurnState({ ...envelope, sessions: remaining }, cwd);
+      }
+    };
+  }
+  readTurnStateEnvelope(cwd) {
     const statePath = getTurnStatePath(cwd);
     if (!fs.existsSync(statePath)) {
       return {
@@ -186,11 +243,26 @@ export class CacheManager {
       };
     }
     const state = readJsonCache(statePath, (parsed) => parsed);
-    return state ?? {
+    const envelope = state ?? {
       ...DEFAULT_TURN_STATE,
       files: {},
       lastUpdated: new Date().toISOString()
     };
+    if (!envelope.sessions)
+      return envelope;
+    const now = Date.now();
+    const liveEntries = Object.entries(envelope.sessions).filter(([, partition]) => {
+      const updated = Date.parse(partition.lastUpdated ?? "");
+      return Number.isFinite(updated) && now - updated <= TURN_SESSION_PARTITION_TTL_MS;
+    });
+    liveEntries.sort(([, left], [, right]) => Date.parse(right.lastUpdated) - Date.parse(left.lastUpdated));
+    const sessions = Object.fromEntries(liveEntries.slice(0, MAX_TURN_SESSION_PARTITIONS));
+    if (Object.keys(sessions).length !== Object.keys(envelope.sessions).length) {
+      const pruned = { ...envelope, sessions };
+      writeFileAtomic(statePath, JSON.stringify(pruned, null, 2));
+      return pruned;
+    }
+    return envelope;
   }
   writeTurnState(state, cwd) {
     const lensDir = getLensDir(cwd);
@@ -239,13 +311,17 @@ export class CacheManager {
     const lastSeen = Date.parse(owner.lastSeen);
     return !Number.isFinite(lastSeen) || Date.now() - lastSeen > TURN_OWNER_STALE_MS;
   }
-  addModifiedRange(filePath, range, importsChanged, cwd, sessionId, ownerKind = "pi", projectRoot) {
+  addModifiedRange(filePath, range, importsChanged, cwd, sessionId, ownerKind = "pi", projectRoot, analysisRootMode) {
+    if (analysisRootMode !== undefined && analysisRootMode !== "session" && analysisRootMode !== "linked-worktree")
+      return this.readTurnState(cwd);
     const containmentRoot = projectRoot ?? cwd;
     if (!this.isTurnStatePathWithinRoot(filePath, containmentRoot)) {
       this.log(`turn-state: rejected out-of-project path ${filePath} (project root ${containmentRoot})`);
       return this.readTurnState(cwd);
     }
-    const state = this.readTurnState(cwd);
+    const partition = this.resolveTurnStatePartition(cwd, sessionId !== null ? sessionId : undefined);
+    const useSessionPartition = partition.isSecondary && ownerKind === "pi" && sessionId != null;
+    const state = useSessionPartition ? partition.state : partition.envelope;
     if (sessionId) {
       const owner = {
         kind: ownerKind,
@@ -253,7 +329,7 @@ export class CacheManager {
         pid: process.pid,
         lastSeen: new Date().toISOString()
       };
-      if (this.getTurnStateAccess(cwd, owner) === "foreign-live")
+      if (!useSessionPartition && this.getTurnStateAccess(cwd, owner) === "foreign-live")
         return state;
       state.sessionId = sessionId;
       state.owner = owner;
@@ -274,11 +350,20 @@ export class CacheManager {
         lastEdit: new Date().toISOString()
       };
     }
-    this.writeTurnState(state, cwd);
+    if (useSessionPartition)
+      partition.persist(state);
+    else
+      this.writeTurnState(state, cwd);
     return state;
   }
-  clearTurnState(cwd, owner) {
-    const currentState = this.readTurnState(cwd);
+  clearTurnState(cwd, owner, sessionId) {
+    const partition = this.resolveTurnStatePartition(cwd, sessionId);
+    if (sessionId !== undefined && partition.isSecondary) {
+      if (partition.envelope.sessions?.[sessionId])
+        partition.remove();
+      return true;
+    }
+    const currentState = partition.envelope;
     const isCurrentOwner = this.getTurnStateAccess(cwd, owner) !== "foreign-live";
     if (!isCurrentOwner && process.pid !== currentState.owner?.pid)
       return false;
@@ -298,25 +383,28 @@ export class CacheManager {
     this.writeTurnState(state, cwd);
     return true;
   }
-  incrementTurnCycle(cwd, owner) {
-    const state = this.readTurnState(cwd);
+  incrementTurnCycle(cwd, owner, sessionId) {
+    const partition = this.resolveTurnStatePartition(cwd, sessionId);
+    const state = partition.state;
+    if (sessionId !== undefined && state.owner?.id !== sessionId)
+      return state;
     const isCurrentOwner = this.getTurnStateAccess(cwd, owner) !== "foreign-live";
     if (!isCurrentOwner && process.pid !== state.owner?.pid)
       return state;
     state.turnCycles++;
-    this.writeTurnState(state, cwd);
+    partition.persist(state);
     return state;
   }
-  isMaxCyclesExceeded(cwd) {
-    const state = this.readTurnState(cwd);
+  isMaxCyclesExceeded(cwd, sessionId) {
+    const state = this.readTurnState(cwd, sessionId);
     return state.turnCycles >= state.maxCycles;
   }
-  getFilesForJscpd(cwd) {
-    const state = this.readTurnState(cwd);
+  getFilesForJscpd(cwd, sessionId) {
+    const state = this.readTurnState(cwd, sessionId);
     return Object.keys(state.files).filter((f) => /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|rb|java|cs|php|cpp|c|h|hpp|swift|kt)$/.test(f));
   }
-  getFilesForMadge(cwd) {
-    const state = this.readTurnState(cwd);
+  getFilesForMadge(cwd, sessionId) {
+    const state = this.readTurnState(cwd, sessionId);
     return Object.entries(state.files).filter(([, f]) => f.importsChanged).map(([p]) => p);
   }
   mergeRanges(ranges) {

package/extensions/dm-lens/clients/cargo-manifest.js

@@ -48,10 +48,30 @@ export function parseTomlStringArray(content, key) {
   if (content === undefined)
     return [];
   const normalized = normalizeToml(content);
-  const match = normalized.match(new RegExp(`^[ \\t]*${key}[ \\t]*=[ \\t]*\\[([\\s\\S]*?)\\]`, "m"));
-  if (!match)
+  const open = normalized.match(new RegExp(`^[ \\t]*${key}[ \\t]*=[ \\t]*\\[`, "m"));
+  if (open?.index === undefined)
+    return [];
+  const from = open.index + open[0].length;
+  const to = indexOfArrayEnd(normalized, from);
+  if (to < 0)
     return [];
-  return [...match[1].matchAll(/"([^"]*)"|'([^']*)'/g)].map((m) => (m[1] ?? m[2] ?? "").trim());
+  return [...normalized.slice(from, to).matchAll(/"([^"]*)"|'([^']*)'/g)].map((m) => (m[1] ?? m[2] ?? "").trim());
+}
+function indexOfArrayEnd(text, from) {
+  let quote = null;
+  for (let i = from;i < text.length; i++) {
+    const ch = text[i];
+    if (quote) {
+      if (ch === "\\" && quote === '"')
+        i++;
+      else if (ch === quote)
+        quote = null;
+    } else if (ch === '"' || ch === "'")
+      quote = ch;
+    else if (ch === "]")
+      return i;
+  }
+  return -1;
 }
 function parseTomlScalarString(content, key) {
   if (content === undefined)

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

@@ -355,7 +355,7 @@ export class ComplexityClient {
       return null;
     }
     try {
-      const parsed = await withTreeSitterRoot(absolutePath, content, (root) => this.computeMetrics(absolutePath, content, root, nodes));
+      const parsed = await withTreeSitterRoot(absolutePath, content, (root) => this.computeMetrics(absolutePath, content, root, nodes), "complexity");
       return parsed.parsed ? parsed.value : null;
     } catch (err) {
       this.log(`Analysis error for ${filePath}: ${err.message}`);

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

@@ -218,6 +218,15 @@ function walkScalar(value, schema, context, declared) {
     });
     return DROPPED;
   }
+  const minLength = schema?.minLength;
+  if (declared === "string" && typeof minLength === "number" && typeof value === "string" && value.length < minLength) {
+    record(context, {
+      code: "PILENS_CFG_0005",
+      key: pointerOf(context.path),
+      reason: `string must contain at least ${minLength} character${minLength === 1 ? "" : "s"}; ignored`
+    });
+    return DROPPED;
+  }
   return checkEnum(value, schema, context) ? value : DROPPED;
 }
 function checkEnum(value, schema, context) {

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

@@ -74,6 +74,9 @@ export function propertySchema(node, name) {
         return child;
     }
   }
+  const additional = node.additionalProperties;
+  if (isSchemaNode(additional))
+    return additional;
   return;
 }
 export function additionalPropertyPolicy(node) {

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

@@ -5,7 +5,8 @@ import {
 } from "./config-diagnostic-codes.js";
 import { LEGACY_ROOT_LSP_KEYS, LSP_NAMESPACE_KEY } from "./config-locations.js";
 import {
-  DENY_KEY
+  DENY_KEY,
+  MERGE_STRATEGY_KEY
 } from "./config-core/schema.js";
 import {
   flagConfigSectionKeys,
@@ -34,6 +35,80 @@ function denyAnnotation(key) {
   const policy = LSP_KEY_DENY[key];
   return policy === undefined ? {} : { [DENY_KEY]: policy };
 }
+function lspServerEntryNode() {
+  return {
+    type: "object",
+    additionalProperties: true,
+    [STABILITY_TIER_KEY]: "experimental",
+    properties: {
+      covers: {
+        type: "array",
+        items: { type: "string", [STABILITY_TIER_KEY]: "experimental" },
+        [MERGE_STRATEGY_KEY]: "replace",
+        [STABILITY_TIER_KEY]: "experimental"
+      },
+      name: { type: "string", [STABILITY_TIER_KEY]: "experimental" },
+      enabled: { type: "boolean", [STABILITY_TIER_KEY]: "experimental" },
+      role: {
+        type: "string",
+        enum: ["language", "auxiliary"],
+        [STABILITY_TIER_KEY]: "experimental"
+      },
+      command: { [STABILITY_TIER_KEY]: "experimental" },
+      args: {
+        type: "array",
+        items: { type: "string", [STABILITY_TIER_KEY]: "experimental" },
+        [STABILITY_TIER_KEY]: "experimental"
+      },
+      extensions: {
+        type: "array",
+        items: { type: "string", [STABILITY_TIER_KEY]: "experimental" },
+        [STABILITY_TIER_KEY]: "experimental"
+      },
+      rootMarkers: {
+        type: "array",
+        items: { type: "string", [STABILITY_TIER_KEY]: "experimental" },
+        [STABILITY_TIER_KEY]: "experimental"
+      },
+      env: {
+        type: "object",
+        additionalProperties: {
+          type: "string",
+          [STABILITY_TIER_KEY]: "experimental"
+        },
+        [STABILITY_TIER_KEY]: "experimental"
+      },
+      initializationOptions: {
+        type: "object",
+        additionalProperties: true,
+        [STABILITY_TIER_KEY]: "experimental"
+      }
+    }
+  };
+}
+function lspServerOverrideNode() {
+  return {
+    type: "object",
+    additionalProperties: true,
+    [STABILITY_TIER_KEY]: "experimental",
+    properties: {
+      command: { [STABILITY_TIER_KEY]: "experimental" },
+      env: {
+        type: "object",
+        additionalProperties: {
+          type: "string",
+          [STABILITY_TIER_KEY]: "experimental"
+        },
+        [STABILITY_TIER_KEY]: "experimental"
+      },
+      initializationOptions: {
+        type: "object",
+        additionalProperties: true,
+        [STABILITY_TIER_KEY]: "experimental"
+      }
+    }
+  };
+}
 function lspNamespace() {
   const properties = {
     enabled: { [STABILITY_TIER_KEY]: "stable" }
@@ -43,7 +118,7 @@ function lspNamespace() {
     properties[key] = {
       ...declared ? { type: declared } : {},
       [STABILITY_TIER_KEY]: "experimental",
-      ...declared === "object" ? { additionalProperties: true } : {},
+      ...declared === "object" ? key === "servers" ? { additionalProperties: lspServerEntryNode() } : key === "serverOverrides" ? { additionalProperties: lspServerOverrideNode() } : { additionalProperties: true } : {},
       ...denyAnnotation(key)
     };
   }
@@ -54,6 +129,29 @@ function lspNamespace() {
     properties
   };
 }
+function rulePolicyEntryNode() {
+  return {
+    type: "object",
+    additionalProperties: true,
+    properties: {
+      threshold: { type: "number", [STABILITY_TIER_KEY]: "experimental" },
+      disable: opaque("experimental"),
+      select: opaque("experimental"),
+      ignorePaths: {
+        type: "array",
+        items: {
+          type: "string",
+          minLength: 1,
+          [STABILITY_TIER_KEY]: "experimental"
+        },
+        [MERGE_STRATEGY_KEY]: "append",
+        [DENY_KEY]: "array-union",
+        [STABILITY_TIER_KEY]: "experimental"
+      }
+    },
+    [STABILITY_TIER_KEY]: "experimental"
+  };
+}
 function buildConfigSchema() {
   const properties = {};
   for (const key of [
@@ -79,6 +177,11 @@ function buildConfigSchema() {
     ])),
     [STABILITY_TIER_KEY]: "stable"
   };
+  properties.rules = {
+    type: "object",
+    additionalProperties: rulePolicyEntryNode(),
+    [STABILITY_TIER_KEY]: "experimental"
+  };
   for (const key of PROJECT_FOREIGN_CONFIG_NAMESPACES) {
     properties[key] ??= opaque("experimental");
   }

package/extensions/dm-lens/clients/confirmed-delete.js

@@ -0,0 +1,11 @@
+export function judgeConfirmedDelete(filePath, gates) {
+  if (gates.isExternalOrVendorFile(filePath))
+    return "out-of-scope";
+  if (gates.isPathIgnoredByProject(filePath))
+    return "ignored";
+  if (!gates.hasKnownPath(filePath))
+    return "untracked";
+  if (gates.existsSync(filePath))
+    return "on-disk";
+  return "confirmed";
+}