@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/clients/actionable-warnings-logger.js

@@ -22,9 +22,3 @@ export function logActionableWarningsEvent(entry) {
     ...entry.filePath !== undefined ? { filePath: normalizeFilePath(entry.filePath) } : {}
   });
 }
-export function getActionableWarningsLogPath() {
-  return AW_LOG_FILE;
-}
-export function flushActionableWarningsLog() {
-  return writer.flush();
-}

package/extensions/dm-lens/clients/actionable-warnings.js

@@ -30,6 +30,8 @@ import { toRunnerDisplayPath } from "./dispatch/runner-context.js";
 import { logActionableWarningsEvent } from "./actionable-warnings-logger.js";
 import { displayProjectDataPath, getProjectDataDir } from "./file-utils.js";
 import { commitDurableStore } from "./durable-store.js";
+import { establishToolAgreement } from "./tool-agreement.js";
+import { resolveLensToolName } from "./tool-config.js";
 let beforeWarningStateLockForTests = null;
 export function _setBeforeWarningStateLockForTests(hook) {
   beforeWarningStateLockForTests = hook;
@@ -197,14 +199,15 @@ function lineInModifiedRanges(line, ranges) {
     return true;
   return ranges.some((range) => line >= range.start - 2 && line <= range.end + 2);
 }
-function recordFromLspDiagnostic(diag, filePath, cwd) {
+export function recordFromLspDiagnostic(diag, filePath, cwd) {
   const line = diag.range.start.line + 1;
   const column = diag.range.start.character + 1;
+  const producer = diag.source && diag.source !== "lsp" ? diag.source : diag.serverId;
   const source = diag.source ?? "lsp";
   const code = diag.code === undefined ? undefined : String(diag.code);
   const identityArgs = {
     filePath,
-    tool: "lsp",
+    tool: producer ?? "lsp",
     source,
     code,
     message: diag.message,
@@ -219,7 +222,7 @@ function recordFromLspDiagnostic(diag, filePath, cwd) {
     line,
     column,
     severity: "warning",
-    tool: "lsp",
+    tool: producer ?? "lsp",
     source,
     code,
     rule: code ? `${source}:${code}` : source,
@@ -465,7 +468,7 @@ export async function buildActionableWarningsReport(args) {
     fallbackObservedAt: buildStartedAt
   });
 }
-async function enrichFileFromLsp(cwd, args, target, deps) {
+export async function enrichFileFromLsp(cwd, args, target, deps) {
   const { lspService } = deps;
   const { filePath } = target;
   const out = [];
@@ -681,7 +684,12 @@ export function mergeActionableWarningsReports(args) {
       continue;
     }
     mergedFiles++;
-    const merged = incumbent ? {
+    const merged = incumbent ? incumbent.reVerified || incumbent.reVerifyIncomplete ? {
+      ...incumbent,
+      fileSeq: incumbent.fileSeq ?? entry.fileSeq,
+      generatedAt: olderStamp(incumbent.generatedAt ?? newerReport?.generatedAt, entry.generatedAt ?? olderReport?.generatedAt),
+      warnings: incumbent.warnings
+    } : {
       ...incumbent,
       fileSeq: incumbent.fileSeq ?? entry.fileSeq,
       generatedAt: olderStamp(incumbent.generatedAt ?? newerReport?.generatedAt, entry.generatedAt ?? olderReport?.generatedAt),
@@ -909,6 +917,19 @@ export async function applyConservativeActionableWarningFixes(args) {
         continue;
       }
       summary.considered++;
+      const agreement = establishToolAgreement(warning.tool, args.cwd);
+      if (agreement.decision === "decline") {
+        recordDegradationOnce({
+          kind: "autofix-agreement-unavailable",
+          subject: agreement.subject,
+          reason: agreement.reason
+        });
+        summary.skipped.push({
+          id: warning.id,
+          reason: "tool_agreement_unavailable"
+        });
+        continue;
+      }
       if (!warning.line || !warning.column) {
         summary.skipped.push({ id: warning.id, reason: "missing_position" });
         continue;
@@ -976,23 +997,31 @@ export async function applyConservativeActionableWarningFixes(args) {
   }
   return summary;
 }
-export function formatActionableWarningsAdvisory(report, cwd) {
-  if (report.summary.unsuppressed === 0)
+export function formatActionableWarningsAdvisory(report, cwd, host = "pi", filterBuiltReport) {
+  const filtered = filterBuiltReport?.(report);
+  const advisoryReport = filtered ? {
+    ...report,
+    files: filtered.files,
+    summary: summarizeReportFiles(filtered.files)
+  } : report;
+  if (advisoryReport.summary.unsuppressed === 0)
     return;
-  const files = report.files.filter((file) => file.warnings.some((warning) => !warning.suppressed));
-  const fileList = files.slice(0, 5).map((file) => `  ${file.displayPath}: ${file.warnings.filter((warning) => !warning.suppressed).length}`).join(`
+  const files = advisoryReport.files.filter((file) => file.warnings.some((warning) => !warning.suppressed));
+  const fileList = files.slice(0, 5).map((file) => `  ${file.displayPath}: ${file.warnings.filter((warning) => !warning.suppressed).length}${file.reVerifyIncomplete ? " (re-verify incomplete)" : ""}`).join(`
 `);
   const more = files.length > 5 ? `
   ... and ${files.length - 5} more file(s)` : "";
-  const safe = report.summary.autoFixEligible > 0 ? ` ${report.summary.autoFixEligible} appear to have conservative preferred quickfixes.` : "";
-  const byTier = report.summary.byTier;
+  const safe = advisoryReport.summary.autoFixEligible > 0 ? ` ${advisoryReport.summary.autoFixEligible} appear to have conservative preferred quickfixes.` : "";
+  const byTier = advisoryReport.summary.byTier;
   const quiet = byTier ? byTier.hint + byTier.info : 0;
   const tierLine = quiet > 0 ? `${quiet} of those are hint/info tier — style opinions, worth fixing only while you are already in that code.` : undefined;
   const reportPath = displayProjectDataPath(cwd, "cache", "actionable-warnings.json");
+  const diagnosticsTool = resolveLensToolName("lens_diagnostics", host);
   return [
-    `\uD83D\uDFE1 Fixable warnings introduced this turn: ${report.summary.unsuppressed}.${safe}`,
+    `\uD83D\uDFE1 Fixable warnings introduced this turn: ${advisoryReport.summary.unsuppressed}.${safe}`,
+    filtered && filtered.suppressed > 0 ? `suppressed by disposition: ${filtered.suppressed} finding(s).` : undefined,
     tierLine,
-    "Use lens_diagnostics with mode=delta to inspect these warnings.",
+    diagnosticsTool ? `Use ${diagnosticsTool} with mode=delta to inspect these warnings.` : undefined,
     fileList ? `Files:
 ${fileList}${more}` : undefined,
     "If continuing in these files, resolve warnings that are safe and relevant. Do not apply broad refactors unless requested.",

package/extensions/dm-lens/clients/advisory-provenance.js

@@ -154,23 +154,31 @@ export function validateAdvisoryProvenance(record, cwd, runtime) {
     changedPathCount: changedPaths.size
   } : { status: "current", reasons: [], allFilesDeleted, changedPathCount: 0 };
 }
-export const MAX_FINDING_PATH_STATS = MAX_ADVISORY_AFFECTED_FILES;
+const MAX_FINDING_PATH_STATS = MAX_ADVISORY_AFFECTED_FILES;
 const MAX_LOGGED_DEAD_PATHS = 3;
 export function findingPathFreshness(resolvedPath, scannedAtMs) {
+  return freshnessFromFacts(statFindingPath(resolvedPath), scannedAtMs);
+}
+function statFindingPath(resolvedPath) {
   try {
-    const stat = fs.statSync(resolvedPath);
-    if (scannedAtMs === undefined)
-      return "live";
-    const verdict = freshnessFromMtime({
-      mtimeMs: stat.mtimeMs,
-      referenceMs: scannedAtMs
-    });
-    return verdict.verdict === "stale" ? "stale" : "live";
+    return { state: "present", mtimeMs: fs.statSync(resolvedPath).mtimeMs };
   } catch (error) {
     const code = error.code ?? "unknown";
-    return code === "ENOENT" || code === "ENOTDIR" ? "missing" : "unknown";
+    return code === "ENOENT" || code === "ENOTDIR" ? { state: "missing" } : { state: "unknown" };
   }
 }
+function freshnessFromFacts(facts, scannedAtMs) {
+  if (facts.state === "missing")
+    return "missing";
+  if (facts.state === "unknown")
+    return "unknown";
+  if (scannedAtMs === undefined)
+    return "live";
+  return freshnessFromMtime({
+    mtimeMs: facts.mtimeMs,
+    referenceMs: scannedAtMs
+  }).verdict === "stale" ? "stale" : "live";
+}
 export function findingPathExistence(resolvedPath) {
   return findingPathFreshness(resolvedPath);
 }
@@ -182,18 +190,27 @@ export function parseScannedAtMs(scannedAt) {
   return Number.isFinite(ms) ? ms : undefined;
 }
 export function partitionFindingsByCitedPath(args) {
-  const limit = args.maxUniquePaths ?? MAX_FINDING_PATH_STATS;
-  const probe = args.existence ?? findingPathFreshness;
+  return partitionOneSource({ ...args, store: args.store ?? "" }, createPathFactsMemo(args));
+}
+function createPathFactsMemo(args) {
+  return {
+    facts: new Map,
+    probe: args.probePath ?? statFindingPath,
+    limit: args.maxUniquePaths ?? MAX_FINDING_PATH_STATS,
+    starved: new Map
+  };
+}
+function partitionOneSource(args, memo) {
   const scannedAtMs = parseScannedAtMs(args.scannedAt);
   const onMissing = args.onMissing ?? "drop";
   const rawVerdicts = new Map;
-  const verdicts = new Map;
   const live = [];
   const stale = [];
   const dropped = [];
   const deadPaths = [];
   const stalePaths = [];
-  let truncated = false;
+  const seenPaths = new Set;
+  let probed = 0;
   for (const finding of args.findings) {
     const cited = args.citedPath(finding);
     if (!cited) {
@@ -203,24 +220,27 @@ export function partitionFindingsByCitedPath(args) {
     let verdict = rawVerdicts.get(cited);
     if (verdict === undefined) {
       const resolved = resolveRunnerPath(args.cwd, cited);
-      const key = resolved;
-      verdict = verdicts.get(key);
-      if (verdict === undefined) {
-        if (verdicts.size >= limit) {
-          truncated = true;
-          verdict = "live";
+      let facts = memo.facts.get(resolved);
+      if (facts === undefined) {
+        if (probed >= memo.limit) {
+          memo.starved.set(args.store, (memo.starved.get(args.store) ?? 0) + 1);
+          facts = { state: "unknown" };
         } else {
-          verdict = probe(resolved, scannedAtMs);
-          if (verdict === "missing" && onMissing === "demote") {
-            verdict = "stale";
-          }
-          verdicts.set(key, verdict);
-          if (verdict === "missing")
-            deadPaths.push(resolved);
-          else if (verdict === "stale")
-            stalePaths.push(resolved);
+          probed += 1;
+          facts = memo.probe(resolved);
+          memo.facts.set(resolved, facts);
         }
       }
+      verdict = freshnessFromFacts(facts, scannedAtMs);
+      if (verdict === "missing" && onMissing === "demote")
+        verdict = "stale";
+      if (!seenPaths.has(resolved)) {
+        seenPaths.add(resolved);
+        if (verdict === "missing")
+          deadPaths.push(resolved);
+        else if (verdict === "stale")
+          stalePaths.push(resolved);
+      }
       rawVerdicts.set(cited, verdict);
     }
     if (verdict === "missing")
@@ -236,31 +256,76 @@ export function partitionFindingsByCitedPath(args) {
     dropped,
     deadPaths,
     stalePaths,
-    statCount: verdicts.size,
-    truncated
+    statCount: memo.facts.size,
+    truncated: (memo.starved.get(args.store) ?? 0) > 0
   };
 }
 export function dropFindingsForMissingPaths(args) {
   const partition = partitionFindingsByCitedPath(args);
-  emitDeadPathDropRecord(args.store, args.cwd, partition);
+  emitDeadPathDropRecord(args.cwd, partition, {
+    [args.store]: partition.dropped.length
+  });
   return partition.live;
 }
 export function gateFindingsByPathFreshness(args) {
-  const partition = partitionFindingsByCitedPath(args);
-  emitDeadPathDropRecord(args.store, args.cwd, partition);
-  emitStaleLineDemoteRecord(args.store, args.cwd, args.scannedAt, partition);
-  return { live: partition.live, stale: partition.stale };
+  const memo = createPathFactsMemo(args);
+  const names = Object.keys(args.sources).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  const gates = {};
+  const dropped = {};
+  const demoted = {};
+  const merged = {
+    live: [],
+    stale: [],
+    dropped: [],
+    deadPaths: [],
+    stalePaths: [],
+    statCount: 0,
+    truncated: false
+  };
+  const scannedAtByStore = {};
+  for (const name of names) {
+    const source = args.sources[name];
+    const partition = partitionOneSource({ ...source, store: name, cwd: args.cwd }, memo);
+    gates[name] = { live: partition.live, stale: partition.stale };
+    if (partition.dropped.length > 0)
+      dropped[name] = partition.dropped.length;
+    if (partition.stale.length > 0)
+      demoted[name] = partition.stale.length;
+    if (source.scannedAt !== undefined) {
+      scannedAtByStore[name] = String(source.scannedAt);
+    }
+    merged.live.push(...partition.live);
+    merged.stale.push(...partition.stale);
+    merged.dropped.push(...partition.dropped);
+    for (const deadPath of partition.deadPaths) {
+      if (!merged.deadPaths.includes(deadPath))
+        merged.deadPaths.push(deadPath);
+    }
+    for (const stalePath of partition.stalePaths) {
+      if (!merged.stalePaths.includes(stalePath)) {
+        merged.stalePaths.push(stalePath);
+      }
+    }
+  }
+  merged.statCount = memo.facts.size;
+  merged.truncated = memo.starved.size > 0;
+  emitDeadPathDropRecord(args.cwd, merged, dropped);
+  emitStaleLineDemoteRecord(args.cwd, scannedAtByStore, merged, demoted);
+  emitStatBudgetRecord(args.cwd, memo);
+  return gates;
 }
-function emitDeadPathDropRecord(store, cwd, partition) {
+function emitDeadPathDropRecord(cwd, partition, byStore) {
   if (partition.dropped.length === 0)
     return;
+  const stores = Object.keys(byStore);
   logLatency({
     type: "phase",
     phase: "finding_dead_path_drop",
     filePath: cwd,
     durationMs: 0,
     metadata: {
-      store,
+      store: stores.join("+"),
+      byStore,
       droppedDeadPaths: partition.dropped.length,
       deadPathCount: partition.deadPaths.length,
       deliveredCount: partition.live.length,
@@ -270,26 +335,49 @@ function emitDeadPathDropRecord(store, cwd, partition) {
     }
   });
 }
-function emitStaleLineDemoteRecord(store, cwd, scannedAt, partition) {
+function emitStaleLineDemoteRecord(cwd, scannedAtByStore, partition, byStore) {
   if (partition.stale.length === 0)
     return;
+  const stores = Object.keys(byStore);
+  const single = stores.length === 1 ? scannedAtByStore[stores[0]] : undefined;
   logLatency({
     type: "phase",
     phase: "finding_stale_line_demote",
     filePath: cwd,
     durationMs: 0,
     metadata: {
-      store,
+      store: stores.join("+"),
+      byStore,
       demotedStalePaths: partition.stale.length,
       stalePathCount: partition.stalePaths.length,
       deliveredCount: partition.live.length,
       statCount: partition.statCount,
       samplePaths: partition.stalePaths.slice(0, MAX_LOGGED_DEAD_PATHS).map((stalePath) => toProjectRelativePath(stalePath, cwd)),
-      ...scannedAt === undefined ? {} : { scannedAt: String(scannedAt) },
+      ...single === undefined ? {} : { scannedAt: single },
+      ...stores.length > 1 ? {
+        scannedAtByStore: Object.fromEntries(stores.map((name) => [name, scannedAtByStore[name] ?? ""]))
+      } : {},
       ...partition.truncated ? { truncated: true } : {}
     }
   });
 }
+function emitStatBudgetRecord(cwd, memo) {
+  if (memo.starved.size === 0)
+    return;
+  const stores = [...memo.starved.keys()].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  logLatency({
+    type: "phase",
+    phase: "finding_path_stat_budget_exhausted",
+    filePath: cwd,
+    durationMs: 0,
+    metadata: {
+      store: stores.join("+"),
+      byStore: Object.fromEntries(stores.map((name) => [name, memo.starved.get(name) ?? 0])),
+      maxUniquePaths: memo.limit,
+      statCount: memo.facts.size
+    }
+  });
+}
 export function provenanceStamp(provenance) {
   if (!isWellFormed(provenance))
     return "session unknown / turn unknown / generation unknown";

package/extensions/dm-lens/clients/agent-behavior-client.js

@@ -91,3 +91,4 @@ export class AgentBehaviorClient {
     this.fileEditCount.clear();
   }
 }
+export const agentBehaviorClient = new AgentBehaviorClient;

package/extensions/dm-lens/clients/ast-grep-client.js

@@ -2,14 +2,34 @@ import { createSubsystemLogger } from "./extension-log.js";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { AstGrepRuleManager } from "./ast-grep-rule-manager.js";
+import {
+  AstGrepRuleManager,
+  checkAstGrepRulesHealth
+} from "./ast-grep-rule-manager.js";
+import { reportBundledResourceDirHealth } from "./bundled-resource-health.js";
+import { getDegradationLedgerGeneration } from "./degradation-ledger.js";
+import { logLatency } from "./latency-logger.js";
 import { getMutationBridge } from "./mutation-bridge.js";
 import { resolvePackagePath } from "./package-root.js";
 import { truncatedByOutputCap } from "./spawn-output-cap.js";
 import {
   SgRunner
 } from "./sg-runner.js";
-export function recordAstGrepApply(matches) {
+function reportAstGrepRulesHealth(bundledRuleDir) {
+  const health = checkAstGrepRulesHealth(bundledRuleDir);
+  logLatency({
+    type: "phase",
+    phase: "ast_grep_rules_resolved",
+    filePath: bundledRuleDir,
+    durationMs: 0,
+    metadata: {
+      status: health.status,
+      entryCount: health.status === "healthy" ? health.entryCount : 0
+    }
+  });
+  reportBundledResourceDirHealth("ast-grep-rules-dir-missing", bundledRuleDir, health, "ast-grep rule descriptions");
+}
+function recordAstGrepApply(matches) {
   const bridge = getMutationBridge();
   if (!bridge || matches.length === 0)
     return;
@@ -144,14 +164,29 @@ export class AstGrepClient {
   log;
   ruleManager;
   runner;
+  usingBundledRuleDirFallback;
+  rulesHealthReportedGeneration;
   constructor(ruleDir, verbose = false) {
     const projectRuleDir = path.join(process.cwd(), "rules");
-    this.ruleDir = ruleDir || (fs.existsSync(projectRuleDir) ? projectRuleDir : resolvePackagePath(import.meta.url, "rules"));
+    const hasProjectRuleDir = fs.existsSync(projectRuleDir);
+    this.usingBundledRuleDirFallback = !ruleDir && !hasProjectRuleDir;
+    this.ruleDir = ruleDir || (hasProjectRuleDir ? projectRuleDir : resolvePackagePath(import.meta.url, "rules"));
     this.log = verbose ? createSubsystemLogger("ast-grep") : () => {};
+    this.ensureRulesHealthReported();
     this.ruleManager = new AstGrepRuleManager(this.ruleDir, this.log);
     this.runner = new SgRunner(verbose);
   }
+  ensureRulesHealthReported() {
+    const generation = getDegradationLedgerGeneration();
+    if (this.rulesHealthReportedGeneration === generation)
+      return;
+    this.rulesHealthReportedGeneration = generation;
+    if (this.usingBundledRuleDirFallback) {
+      reportAstGrepRulesHealth(this.ruleDir);
+    }
+  }
   ensureAvailable() {
+    this.ensureRulesHealthReported();
     return this.runner.ensureAvailable();
   }
   async replaceWithRule(ruleYaml, paths, apply) {

package/extensions/dm-lens/clients/ast-grep-rule-manager.js

@@ -1,5 +1,41 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+export function candidateAstGrepRulesPaths(ruleDir) {
+  return [
+    path.join(ruleDir, "ast-grep-rules", "rules"),
+    path.join(ruleDir, "rules"),
+    ruleDir
+  ];
+}
+export function checkAstGrepRulesHealth(ruleDir) {
+  const possiblePaths = candidateAstGrepRulesPaths(ruleDir);
+  let rulesPath;
+  for (const candidate of possiblePaths) {
+    if (fs.existsSync(candidate)) {
+      rulesPath = candidate;
+      break;
+    }
+  }
+  if (!rulesPath) {
+    try {
+      fs.readdirSync(ruleDir);
+    } catch (error) {
+      const fsErrorCode = error?.code;
+      if (fsErrorCode && fsErrorCode !== "ENOENT") {
+        return { status: "unreadable", fsErrorCode };
+      }
+    }
+    return { status: "absent" };
+  }
+  let entries;
+  try {
+    entries = fs.readdirSync(rulesPath).filter((f) => f.endsWith(".yml"));
+  } catch (error) {
+    const fsErrorCode = error?.code ?? "UNKNOWN";
+    return { status: "unreadable", fsErrorCode };
+  }
+  return entries.length > 0 ? { status: "healthy", entryCount: entries.length } : { status: "empty" };
+}
 
 export class AstGrepRuleManager {
   ruleDir;
@@ -13,11 +49,7 @@ export class AstGrepRuleManager {
     if (this.ruleDescriptions !== null)
       return this.ruleDescriptions;
     const descriptions = new Map;
-    const possiblePaths = [
-      path.join(this.ruleDir, "ast-grep-rules", "rules"),
-      path.join(this.ruleDir, "rules"),
-      this.ruleDir
-    ];
+    const possiblePaths = candidateAstGrepRulesPaths(this.ruleDir);
     const rulesPath = possiblePaths.find((p) => fs.existsSync(p));
     if (!rulesPath) {
       this.log(`Rule descriptions: no rules directory found in ${possiblePaths.join(", ")}`);

package/extensions/dm-lens/clients/ast-grep-tool-logger.js

@@ -65,7 +65,7 @@ export function astGrepRemediationHint(kind) {
     case "json_parse_failed":
       return "Hint: ast-grep produced output that could not be parsed — retry with a simpler pattern; the installed CLI version may be incompatible.";
     default:
-      return "Hint: verify the pattern is a single valid AST node for this `lang` (use ast_grep_dump to discover node kinds), or fall back to grep for plain-text search.";
+      return "Hint: verify the pattern is a single valid AST node for this `lang` (use ast_grep_search with dump=true to discover node kinds), or fall back to grep for plain-text search.";
   }
 }
 export function logAstGrepToolEvent(event) {
@@ -81,11 +81,5 @@ export function logAstGrepToolEvent(event) {
   };
   writer.log({ ts: new Date().toISOString(), ...payload });
 }
-export function getAstGrepToolLogPath() {
-  return AG_LOG_FILE;
-}
-export function flushAstGrepToolLog() {
-  return writer.flush();
-}
 
 export { countLines as _countLinesForTest };