@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

package/extensions/dm-lens/clients/custom-rule-locations.js

@@ -0,0 +1,28 @@
+import * as path from "node:path";
+import { BoundedFifoMap } from "./bounded-cache.js";
+import { getGlobalDmLensDir } from "./file-utils.js";
+import { getTurnId } from "./turn-context.js";
+export function getUserRuleRoot() {
+  return path.join(getGlobalDmLensDir(), "rules");
+}
+const RULE_CORPUS_CYCLE_ENTRIES = 16;
+const ruleCorpusCycleFingerprints = new BoundedFifoMap(RULE_CORPUS_CYCLE_ENTRIES);
+let cycleSlot;
+export function ruleCorpusFingerprintForCycle(family, root, compute, force = false) {
+  const cycle = getTurnId();
+  if (!force && cycleSlot !== undefined && cycleSlot.cycle === cycle && cycleSlot.family === family && cycleSlot.root === root) {
+    return cycleSlot.fingerprint;
+  }
+  const key = `${cycle}\x00${family}\x00${root}`;
+  let fingerprint = force ? undefined : ruleCorpusCycleFingerprints.get(key);
+  if (fingerprint === undefined) {
+    fingerprint = compute(root);
+    ruleCorpusCycleFingerprints.set(key, fingerprint);
+  }
+  cycleSlot = { cycle, family, root, fingerprint };
+  return fingerprint;
+}
+export function _resetRuleCorpusCycleFingerprintsForTests() {
+  ruleCorpusCycleFingerprints.clear();
+  cycleSlot = undefined;
+}

package/extensions/dm-lens/clients/dead-code-client.js

@@ -2,8 +2,15 @@ import { createSubsystemLogger } from "./extension-log.js";
 import { incrementDegradationCount } from "./degradation-ledger.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { resolve } from "node:path";
+import {
+  extractTomlTableSection,
+  parseTomlStringArray
+} from "./cargo-manifest.js";
+import { HardFailureStamps } from "./hard-failure-summary.js";
 import { findLocalBinsAt, VENV_BIN_DIRS } from "./package-manager.js";
 import { findNearestMarkerRoot } from "./path-utils.js";
+import { listNestedLinkedWorktreeRoots } from "./review-graph/git-identity.js";
 import { getScratchTreeFnmatchPatterns } from "./scratch-tree-policy.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 import { probeToolAsync } from "./tool-probe.js";
@@ -70,6 +77,9 @@ export function parseVultureOutput(output, root) {
   }
   return issues;
 }
+function escapeFnmatchLiteral(text) {
+  return text.replace(/[*?[]/g, (ch) => `[${ch}]`);
+}
 
 export class PythonDeadCodeClient {
   id = "python";
@@ -78,10 +88,17 @@ export class PythonDeadCodeClient {
   resolved = null;
   ensureInFlight = null;
   inFlight = new Map;
+  hardFailures = new HardFailureStamps;
   log;
   constructor(verbose = false) {
     this.log = verbose ? createSubsystemLogger("dead-code:python") : () => {};
   }
+  recentHardFailure(cwd) {
+    const root = this.resolveProjectRoot(cwd || process.cwd());
+    if (!root)
+      return null;
+    return this.hardFailures.recent(resolve(root));
+  }
   get minConfidence() {
     const raw = Number.parseInt(process.env.DM_LENS_VULTURE_MIN_CONFIDENCE ?? "60", 10);
     return Number.isFinite(raw) ? Math.min(100, Math.max(0, raw)) : 60;
@@ -120,7 +137,7 @@ export class PythonDeadCodeClient {
     return findLocalBinsAt(["vulture"], root, {
       windowsExt: ".exe",
       binDirs: VENV_BIN_DIRS
-    }).map((full) => ({ cmd: full, prefix: [] }));
+    }).flatMap((full) => typeof full === "string" ? [{ cmd: full, prefix: [] }] : []);
   }
   async doEnsureAvailable(root) {
     const candidates = [
@@ -228,7 +245,10 @@ export class PythonDeadCodeClient {
     const existing = this.inFlight.get(key);
     if (existing)
       return existing;
-    const promise = this.runAnalyze(key);
+    const promise = this.runAnalyze(key).then((result) => {
+      this.hardFailures.settle(key, result);
+      return result;
+    });
     const wrapped = promise.finally(() => {
       if (this.inFlight.get(key) === wrapped)
         this.inFlight.delete(key);
@@ -236,23 +256,64 @@ export class PythonDeadCodeClient {
     this.inFlight.set(key, wrapped);
     return wrapped;
   }
-  hasProjectVultureConfig(root) {
+  readProjectVultureConfig(root) {
+    let content;
     try {
-      const content = fs.readFileSync(path.join(root, "pyproject.toml"), "utf-8");
-      return content.includes("[tool.vulture]");
+      content = fs.readFileSync(path.join(root, "pyproject.toml"), "utf-8");
     } catch {
-      return false;
+      return null;
+    }
+    if (!content.includes("[tool.vulture]"))
+      return null;
+    const table = extractTomlTableSection(content, "tool.vulture") ?? "";
+    const exclude = parseTomlStringArray(table, "exclude");
+    const keyed = /^[ \t]*exclude[ \t]*=/m.test(table);
+    const emptyList = /^[ \t]*exclude[ \t]*=[ \t]*\[\s*\]/m.test(table);
+    const unreadable = keyed && exclude.length === 0 && !emptyList || exclude.some((entry) => entry.includes(","));
+    return { exclude: unreadable ? null : exclude };
+  }
+  worktreeExcludes(root) {
+    const nested = listNestedLinkedWorktreeRoots(root);
+    const patterns = [];
+    for (const worktree of nested) {
+      if (worktree.includes(",")) {
+        incrementDegradationCount({
+          kind: "scan-worktree-exclusion-skipped",
+          subject: "vulture",
+          reason: `comma-in-path: ${worktree} not excluded under ${root}`
+        });
+        continue;
+      }
+      patterns.push(`${escapeFnmatchLiteral(worktree)}/*`);
     }
+    return { patterns };
   }
   async runAnalyze(root) {
+    const scannedAt = new Date().toISOString();
     const startMs = Date.now();
     const invocation = this.resolved ?? { cmd: "vulture", prefix: [] };
-    const hasConfig = this.hasProjectVultureConfig(root);
+    const config = this.readProjectVultureConfig(root);
+    const worktrees = this.worktreeExcludes(root);
+    let exclude;
+    if (config === null) {
+      exclude = [...VULTURE_EXCLUDES, ...worktrees.patterns];
+    } else if (worktrees.patterns.length > 0) {
+      if (config.exclude === null) {
+        incrementDegradationCount({
+          kind: "scan-worktree-exclusion-skipped",
+          subject: "vulture",
+          reason: `config-exclude-unreadable: ${worktrees.patterns.length} linked worktree(s) under ${root} not excluded`
+        });
+      } else {
+        exclude = [...config.exclude, ...worktrees.patterns];
+      }
+    }
+    const excludedWorktrees = exclude === undefined ? 0 : worktrees.patterns.length;
     const args = [
       ...invocation.prefix,
       ".",
-      ...hasConfig ? [] : [`--min-confidence=${this.minConfidence}`],
-      ...hasConfig ? [] : [`--exclude=${VULTURE_EXCLUDES.join(",")}`],
+      ...config === null ? [`--min-confidence=${this.minConfidence}`] : [],
+      ...exclude === undefined ? [] : [`--exclude=${exclude.join(",")}`],
       `--ignore-decorators=${VULTURE_IGNORE_DECORATORS.join(",")}`
     ];
     const result = await safeSpawnAsync(invocation.cmd, args, {
@@ -295,10 +356,17 @@ export class PythonDeadCodeClient {
         success: true,
         analyzed: true,
         summary: "No dead code found",
-        durationMs
+        durationMs,
+        scannedAt,
+        excludedWorktrees
       };
     }
-    return { ...this.parseOutput(output, root), durationMs };
+    return {
+      ...this.parseOutput(output, root),
+      durationMs,
+      scannedAt,
+      excludedWorktrees
+    };
   }
   parseOutput(output, root) {
     const unusedExports = parseVultureOutput(output, root);
@@ -332,7 +400,8 @@ export function stableFindingKey(...parts) {
 export function deadCodeIssueKey(issue) {
   return stableFindingKey(issue.category, issue.file, issue.name);
 }
-export function formatDeadCodeDelta(issues, language, max = 5) {
+export const DEAD_CODE_DELTA_MAX_SHOWN = 5;
+export function formatDeadCodeDelta(issues, language, max = DEAD_CODE_DELTA_MAX_SHOWN) {
   if (issues.length === 0)
     return "";
   let report = `\uD83D\uDC80 Newly unused ${language} symbols in files you edited — check if callers need updating (dead-code):

package/extensions/dm-lens/clients/deferred-runner-blockers.js

@@ -0,0 +1,108 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import { gateFindingsByPathFreshness } from "./advisory-provenance.js";
+import {
+  peekSettledRunnerFindings
+} from "./dispatch/pending-runner-findings.js";
+import { applyPushedFindingPolicy } from "./dispatch/finding-policy.js";
+import { logLatency } from "./latency-logger.js";
+const MAX_LOGGED_RUNNER_IDS = 5;
+export function judgeDeferredRunnerFindings(pending, cwd, options = {}) {
+  const findings = pending.result?.diagnostics ?? [];
+  if (findings.length === 0) {
+    return { stale: 0, live: 0, kept: [], suppressed: 0, bytes: undefined };
+  }
+  const { "late-runner-findings": gate } = gateFindingsByPathFreshness({
+    cwd,
+    sources: {
+      "late-runner-findings": {
+        findings,
+        scannedAt: pending.markedAtMs,
+        citedPath: (finding) => finding.filePath
+      }
+    },
+    ...options.quiet === true ? { quiet: true } : {}
+  });
+  if (gate.live.length === 0) {
+    return {
+      stale: gate.stale.length,
+      live: 0,
+      kept: [],
+      suppressed: 0,
+      bytes: undefined
+    };
+  }
+  const bytes = readBytes(pending.filePath);
+  const { kept, suppressed } = applyPushedFindingPolicy(gate.live, {
+    cwd,
+    filePath: pending.filePath,
+    content: bytes?.toString("utf-8")
+  });
+  return {
+    stale: gate.stale.length,
+    live: gate.live.length,
+    kept,
+    suppressed,
+    bytes
+  };
+}
+export function recordDeferredRunnerBlockers(runtime, pending, survivors, bytes) {
+  const blocking = survivors.flatMap((d) => d.semantic === "blocking" ? [d] : []);
+  if (blocking.length === 0)
+    return 0;
+  const recorded = runtime.recordDeferredInlineBlockers(pending.filePath, blocking, {
+    recordedAtMs: pending.markedAtMs,
+    ...bytes ? {
+      contentBaseline: {
+        size: bytes.byteLength,
+        sha256: createHash("sha256").update(bytes).digest("hex")
+      }
+    } : {}
+  });
+  if (recorded > 0)
+    runtime.updateGitGuardStatus(false, "");
+  return recorded;
+}
+function readBytes(filePath) {
+  try {
+    return fs.readFileSync(filePath);
+  } catch {
+    return;
+  }
+}
+export function absorbSettledRunnerBlockers(runtime, cwd) {
+  const total = {
+    recorded: 0,
+    runnerIds: [],
+    fileCount: 0
+  };
+  const files = new Set;
+  for (const pending of peekSettledRunnerFindings()) {
+    const verdict = judgeDeferredRunnerFindings(pending, cwd, { quiet: true });
+    const recorded = recordDeferredRunnerBlockers(runtime, pending, verdict.kept, verdict.bytes);
+    if (recorded === 0)
+      continue;
+    total.recorded += recorded;
+    files.add(pending.filePath);
+    if (!total.runnerIds.includes(pending.runnerId) && total.runnerIds.length < MAX_LOGGED_RUNNER_IDS) {
+      total.runnerIds.push(pending.runnerId);
+    }
+  }
+  total.fileCount = files.size;
+  if (total.recorded > 0) {
+    logLatency({
+      type: "phase",
+      toolName: "git-guard",
+      filePath: cwd,
+      phase: "deferred_runner_blockers",
+      durationMs: 0,
+      metadata: {
+        site: "commit_gate",
+        recorded: total.recorded,
+        runnerIds: total.runnerIds,
+        fileCount: total.fileCount
+      }
+    });
+  }
+  return total;
+}

package/extensions/dm-lens/clients/deferred-test-targets.js

@@ -0,0 +1,31 @@
+import * as path from "node:path";
+import { normalizeMapKey } from "./path-utils.js";
+export const TEST_RUNNER_MAX_PERSISTED_TARGETS = 64;
+function deferralEntryKey(entry) {
+  return `${entry.sessionId ?? ""}\x00${normalizeMapKey(path.resolve(entry.testFile))}`;
+}
+export function mergeDeferredTargets(existing, incoming) {
+  const byKey = new Map;
+  for (const entry of [...existing, ...incoming]) {
+    const key = deferralEntryKey(entry);
+    const prior = byKey.get(key);
+    if (prior && (prior.attempts ?? 0) >= (entry.attempts ?? 0))
+      continue;
+    byKey.set(key, entry);
+  }
+  return [...byKey.values()];
+}
+export function boundDeferredTargets(entries, max, isOwn) {
+  const foreign = [];
+  const own = [];
+  for (const entry of entries) {
+    if (isOwn(entry))
+      own.push(entry);
+    else
+      foreign.push(entry);
+  }
+  const ordered = [...foreign, ...own];
+  if (ordered.length <= max)
+    return ordered;
+  return ordered.slice(-max);
+}

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

@@ -8,6 +8,7 @@ import { logLatency } from "./latency-logger.js";
 import {
   getSinkRotations,
   getSinkOptionConflicts,
+  getSinkTruncateRefusals,
   getSinkWriteFailures,
   resetSinkRotations,
   resetSinkWriteFailures
@@ -63,13 +64,15 @@ export function recordDegradationOnce(record) {
     const subject = subjectForLedger(record.subject);
     const key = `${kind}\x00${subject}`;
     if (onceKeys.has(key))
-      return;
+      return false;
     onceKeys.add(key);
     if (recordDegradation({ kind, subject, reason: record.reason })) {
       logDurableDegradation(kind, subject, 1, record.metadata, record.code);
     }
+    return true;
   } catch (error) {
     debugLedgerFailure("record-once", error);
+    return false;
   }
 }
 export function incrementDegradationCount(record) {
@@ -201,6 +204,18 @@ export function getDegradationSummary() {
       }))
     });
   }
+  const truncateRefusals = getSinkTruncateRefusals();
+  if (truncateRefusals.length > 0) {
+    summary.push({
+      kind: "log-sink-truncate-refused",
+      count: truncateRefusals.reduce((total, sink) => total + sink.refusedCount, 0),
+      droppedCount: 0,
+      latestReasons: truncateRefusals.map((sink) => ({
+        subject: truncateForLedger(sink.file),
+        reason: truncateForLedger(`${sink.refusedCount} truncate call(s) refused: a test process aimed them at the real ~/.dm-lens`)
+      }))
+    });
+  }
   const singletonResets = getProcessSingletonResets();
   if (singletonResets.length > 0) {
     summary.push({
@@ -222,7 +237,7 @@ export function getDegradationSummary() {
       latestReasons: [
         {
           subject: truncateForLedger(probeHomeRedirect.probeHome),
-          reason: truncateForLedger(`DM_LENS_HOME unset with cwd in an agent worktree/tmp probe context (${probeHomeRedirect.cwd}), or PILENS_PROBE=1 forced it; LOGS redirected away from the real home directory (tools, bin and instances.json are unaffected)`)
+          reason: truncateForLedger("DM_LENS_HOME unset with cwd in an agent worktree/tmp probe context, or PILENS_PROBE=1 forced it; LOGS redirected away from the real home directory (tools, bin and instances.json are unaffected)")
         }
       ]
     });
@@ -245,7 +260,10 @@ const INFORMATIONAL_DEGRADATION_KINDS = new Set([
   "actionable-warnings-deferred-superseded",
   "hook-await-abandoned",
   "resource-sampler-scanner-escalated",
-  "data_dir_migrated"
+  "data-dir-ephemeral",
+  "data_dir_migrated",
+  "instance-registry-deregister-landed",
+  "turn-end-sections-held"
 ]);
 export function renderDegradationLines(summary = getDegradationSummary()) {
   if (!isRenderableSummary(summary))

package/extensions/dm-lens/clients/demoted-finding-render.js

@@ -1,3 +1,4 @@
+import { DELTA_UNUSED_PROMOTION_NOTE } from "./dispatch/utils/format-utils.js";
 export const DEAD_LINE_ANNOTATION = "(line no longer exists)";
 const AUTHORITY_REWRITES = [
   [
@@ -9,6 +10,7 @@ const AUTHORITY_REWRITES = [
   [/\bmust be fixed\b/g, "were flagged"]
 ];
 const CITED_LINE_RE = /^([^\S\n]*)L(\d+)\b/;
+const PROMOTION_NOTE_ROW = `  ℹ️ ${DELTA_UNUSED_PROMOTION_NOTE}`;
 function splitBannerRegion(lines) {
   const firstCitedRow = lines.findIndex((line) => CITED_LINE_RE.test(line));
   if (firstCitedRow !== -1)
@@ -34,11 +36,12 @@ export function degradeDemotedFindingBody(summary, options = {}) {
     }
     return rewritten;
   });
-  let body = degradedLines.join(`
+  const keptLines = degradedLines.filter((line) => line !== PROMOTION_NOTE_ROW);
+  let body = keptLines.join(`
 `);
   const deadLinesAnnotated = [];
   if (deadLines.size > 0) {
-    body = degradedLines.map((line) => {
+    body = keptLines.map((line) => {
       const hit = CITED_LINE_RE.exec(line);
       if (!hit)
         return line;

package/extensions/dm-lens/clients/dependency-checker.js

@@ -7,6 +7,7 @@ import { findNodeToolBinary } from "./package-manager.js";
 import { isFullyQualified } from "./path-utils.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 import { compareOrdinal } from "./string-utils.js";
+import { getIsolatedNpxSpawnOptions } from "./tool-probe.js";
 import {
   createAvailabilityChecker,
   discoverManagedTool,
@@ -26,7 +27,12 @@ export function buildMadgeArgs(target, projectRoot) {
   return args;
 }
 function parseMadgeCycles(stdout, baseDir, projectRoot) {
-  const parsed = JSON.parse(stdout || "[]");
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout || "[]");
+  } catch (err) {
+    throw new Error(`madge report is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+  }
   const cycles = Array.isArray(parsed) ? parsed : [];
   const circular = [];
   const circularFiles = new Set;
@@ -325,7 +331,8 @@ export class DependencyChecker {
     try {
       const result = await safeSpawnAsync(cmd, [...prefix, ...buildMadgeArgs(normalized, projectRoot)], {
         timeout: 15000,
-        cwd: projectRoot
+        cwd: projectRoot,
+        ...cmd === "npx" ? getIsolatedNpxSpawnOptions() : {}
       });
       if (result.error) {
         this.log(`Check error: ${result.error.message}`);
@@ -488,11 +495,13 @@ export class DependencyChecker {
     return promise;
   }
   async runScanProject(projectRoot, gen) {
+    const scannedAt = new Date().toISOString();
     try {
       const { cmd, prefix } = await this.resolveMadge(projectRoot);
       const result = await safeSpawnAsync(cmd, [...prefix, ...buildMadgeArgs(projectRoot, projectRoot)], {
         timeout: 30000,
-        cwd: projectRoot
+        cwd: projectRoot,
+        ...cmd === "npx" ? getIsolatedNpxSpawnOptions() : {}
       });
       if (result.error) {
         this.log(`Scan error: ${result.error.message}`);
@@ -500,7 +509,7 @@ export class DependencyChecker {
       }
       const { circular, circularFiles } = parseMadgeCycles(result.stdout || "", projectRoot, projectRoot);
       this.publishState(gen, circular, circularFiles);
-      return { circular, count: circular.length, analyzed: true };
+      return { circular, count: circular.length, analyzed: true, scannedAt };
     } catch (err) {
       this.log(`Scan error: ${err.message}`);
       return { circular: [], count: 0 };

package/extensions/dm-lens/clients/diagnostic-line-freshness.js

@@ -132,13 +132,11 @@ export function demotePastEofDiagnostics(args) {
 export function resyncDocumentOnPastEof(filePath) {
   (async () => {
     try {
-      const [{ getLSPService }, content] = await Promise.all([
-        import("./lsp/index.js"),
+      const [{ getOwnedLspService }, content] = await Promise.all([
+        import("./lsp/service-singleton.js"),
         fs.promises.readFile(filePath, "utf-8")
       ]);
-      await getLSPService().openFile(filePath, content, {
-        preserveDiagnostics: false
-      });
+      await getOwnedLspService().openFile(filePath, content, { preserveDiagnostics: false });
     } catch {}
   })();
 }

package/extensions/dm-lens/clients/dispatch/adopted-root-runners.js

@@ -0,0 +1,22 @@
+export const ADOPTED_ROOT_RUNNER_ALLOWLIST = [
+  "fish-indent",
+  "php-lint"
+];
+const ADMITTED = new Set(ADOPTED_ROOT_RUNNER_ALLOWLIST);
+export function isAdoptedRootRunnerAdmitted(runnerId) {
+  return ADMITTED.has(runnerId);
+}
+export function filterGroupsForAdoptedRoot(groups) {
+  const filtered = [];
+  for (const group of groups) {
+    const runnerIds = [];
+    for (const runnerId of group.runnerIds) {
+      if (isAdoptedRootRunnerAdmitted(runnerId))
+        runnerIds.push(runnerId);
+    }
+    if (runnerIds.length === 0)
+      continue;
+    filtered.push(runnerIds.length === group.runnerIds.length ? group : { ...group, runnerIds });
+  }
+  return filtered;
+}