@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/scripts/lib/process-scan.mjs

@@ -12,7 +12,7 @@ const FIELD_COLUMNS = Object.freeze({
   rssBytes: { wmi: "WorkingSetSize", ps: null, token: "int" },
   cpuKernel100ns: { wmi: "KernelModeTime", ps: null, token: "int" },
   cpuUser100ns: { wmi: "UserModeTime", ps: null, token: "int" },
-  startedAt: { wmi: "CreationDate", ps: null, token: "text" },
+  startedAt: { wmi: "CreationDate", ps: "lstart", token: "lstart" },
   command: { wmi: "CommandLine", ps: "args", token: "tail" }
 });
 const FIELD_ORDER = Object.freeze(Object.keys(FIELD_COLUMNS));
@@ -74,8 +74,14 @@ export function buildProcessQuery(fields = ALL_PROCESS_FIELDS, options = {}) {
     ];
     const where = filter ? ` WHERE ${wqlFilterExpression(filter)}` : "";
     const excludeSelf = options.excludeSelfPid ? " | Where-Object { $_.ProcessId -ne $PID }" : "";
-    const prelude = layout.includes("ageMs") ? "$age = if ($_.CreationDate -is [datetime]) { [int64]((Get-Date) - $_.CreationDate).TotalMilliseconds } else { '' }; " : "";
-    const row = layout.map((field) => field === "ageMs" ? "$age" : `$($_.${FIELD_COLUMNS[field].wmi})`).join("`t");
+    const prelude = (layout.includes("ageMs") ? "$age = if ($_.CreationDate -is [datetime]) { [int64]((Get-Date) - $_.CreationDate).TotalMilliseconds } else { '' }; " : "") + (layout.includes("startedAt") ? "$st = if ($_.CreationDate -is [datetime]) { $_.CreationDate.ToUniversalTime().ToString('o') } else { '' }; " : "");
+    const row = layout.map((field) => {
+      if (field === "ageMs")
+        return "$age";
+      if (field === "startedAt")
+        return "$st";
+      return `$($_.${FIELD_COLUMNS[field].wmi})`;
+    }).join("`t");
     return {
       command: windowsExe("WindowsPowerShell\\v1.0\\powershell.exe"),
       args: [
@@ -93,6 +99,9 @@ export function buildProcessQuery(fields = ALL_PROCESS_FIELDS, options = {}) {
   if (unsupported.length > 0) {
     throw new Error(`process query: ${unsupported.join(", ")} has no POSIX ps column`);
   }
+  if (layout.includes("startedAt") && process.platform === "linux") {
+    throw new Error("process query: startedAt on Linux is read from /proc, not ps");
+  }
   const columns = layout.map((field) => `${FIELD_COLUMNS[field].ps}=`).join(",");
   const pidFilter = filter && filter.column === "ProcessId" && filter.op === "eq" ? [...filter.values].map((value) => assertPid(value)) : null;
   return {
@@ -100,9 +109,89 @@ export function buildProcessQuery(fields = ALL_PROCESS_FIELDS, options = {}) {
     args: pidFilter ? ["-p", pidFilter.join(","), "-o", columns] : ["-eo", columns],
     tabSeparated: false,
     fields: layout,
-    serverSideFiltered: Boolean(pidFilter)
+    serverSideFiltered: Boolean(pidFilter),
+    ...layout.includes("startedAt") ? { env: posixStartEnv() } : {}
   };
 }
+function posixStartEnv() {
+  return { ...process.env, LC_ALL: "C", TZ: "UTC0" };
+}
+export function readLinuxProcessStart(pid) {
+  try {
+    const ticks = parseLinuxStatStart(fs.readFileSync(`/proc/${assertPid(pid)}/stat`, "utf8"));
+    const boot = fs.readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+    const offset = readBoottimeOffsetTicks();
+    return ticks === undefined || offset === undefined || !/^[0-9a-f-]{36}$/.test(boot) ? undefined : `${Number(ticks) - offset}@${boot}`;
+  } catch {
+    return;
+  }
+}
+const USER_HZ = 100;
+const NSEC_PER_TICK = 1e9 / USER_HZ;
+function readBoottimeOffsetTicks() {
+  let text;
+  try {
+    text = fs.readFileSync("/proc/self/timens_offsets", "utf8");
+  } catch (error) {
+    return error.code === "ENOENT" ? 0 : undefined;
+  }
+  const match = /^boottime\s+(-?\d+)\s+(\d+)\s*$/m.exec(String(text));
+  if (!match)
+    return;
+  const nsec = Number(match[2]);
+  if (nsec % NSEC_PER_TICK !== 0)
+    return;
+  return Number(match[1]) * USER_HZ + nsec / NSEC_PER_TICK;
+}
+export function parseLinuxStatStart(stat) {
+  const fields = String(stat).slice(stat.lastIndexOf(")") + 2).split(" ");
+  const start = fields[19];
+  return /^\d+$/.test(start ?? "") ? start : undefined;
+}
+export function readLinuxPidNamespace(pid) {
+  try {
+    return fs.readlinkSync(`/proc/${assertPid(pid)}/ns/pid`);
+  } catch {
+    return;
+  }
+}
+export function readLinuxProcessEnvironmentVariable(pid, name) {
+  let environ;
+  try {
+    environ = fs.readFileSync(`/proc/${assertPid(pid)}/environ`, "utf8");
+  } catch {
+    return;
+  }
+  const prefix = `${name}=`;
+  const entry = environ.split("\x00").find((item) => item.startsWith(prefix));
+  return entry === undefined ? undefined : entry.slice(prefix.length);
+}
+export function buildEnvironmentQuery(pids) {
+  return {
+    command: posixPsPath(),
+    args: [
+      "-E",
+      "-ww",
+      "-p",
+      pids.map((pid) => assertPid(pid)).join(","),
+      "-o",
+      "pid=,command="
+    ]
+  };
+}
+export function parseEnvironmentVariable(out, name) {
+  const values = new Map;
+  const pattern = new RegExp(`(?:^|\\s)${name}=(\\S+)`);
+  for (const line of String(out ?? "").split(/\r?\n/)) {
+    const row = /^\s*(\d+)\s+(.*)$/.exec(line);
+    if (!row)
+      continue;
+    const value = pattern.exec(row[2]);
+    if (value)
+      values.set(Number(row[1]), value[1]);
+  }
+  return values;
+}
 function parseNonNegativeInt(raw) {
   const token = String(raw ?? "").trim();
   if (!/^\d+$/.test(token))
@@ -128,7 +217,36 @@ export function ageMsFromPosixEtime(raw) {
   return ((days * 24 + hours) * 60 * 60 + minutes * 60 + seconds) * 1000;
 }
 function posixTokenPattern(field) {
-  return FIELD_COLUMNS[field].token === "age" ? "(\\S+)" : "(\\d+)";
+  const token = FIELD_COLUMNS[field].token;
+  if (token === "age")
+    return "(\\S+)";
+  if (token === "lstart")
+    return "(\\S+\\s+\\S+\\s+\\d+\\s+\\d+:\\d+:\\d+\\s+\\d+)";
+  return "(\\d+)";
+}
+const LSTART_MONTHS = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+export function isoFromLstart(raw) {
+  const match = /^\w{3}\s+(\w{3})\s+(\d{1,2})\s+(\d{1,2}):(\d{2}):(\d{2})\s+(\d{4})$/.exec(String(raw ?? "").trim());
+  if (!match)
+    return;
+  const month = LSTART_MONTHS.indexOf(match[1]);
+  if (month === -1)
+    return;
+  const [day, hours, minutes, seconds, year] = [2, 3, 4, 5, 6].map((i) => Number(match[i]));
+  return new Date(Date.UTC(year, month, day, hours, minutes, seconds)).toISOString();
 }
 export function parseProcessTable(out, tabSeparated, fields = ALL_PROCESS_FIELDS) {
   const layout = normalizeProcessFields(fields);
@@ -173,7 +291,7 @@ export function parseProcessTable(out, tabSeparated, fields = ALL_PROCESS_FIELDS
       if (field === "ageMs") {
         row.ageMs = tabSeparated ? parseNonNegativeInt(raw) : ageMsFromPosixEtime(raw ?? "");
       } else if (field === "startedAt") {
-        row.startedAt = String(raw ?? "").trim();
+        row.startedAt = tabSeparated ? String(raw ?? "").trim() : isoFromLstart(raw ?? "");
       } else {
         row[field] = parseNonNegativeInt(raw);
       }
@@ -209,7 +327,8 @@ export function snapshotProcesses(fields = ALL_PROCESS_FIELDS, timeoutMs = DEFAU
       child = spawn(query.command, query.args, {
         shell: false,
         windowsHide: true,
-        stdio: ["ignore", "pipe", "ignore"]
+        stdio: ["ignore", "pipe", "ignore"],
+        env: query.env
       });
     } catch {
       finish([], false);

package/extensions/dm-lens/scripts/lib/web-tree-sitter-dir.mjs

@@ -43,3 +43,9 @@ export function resolveWebTreeSitterPackageDir(deps) {
   }
   return;
 }
+export function findCoreGrammarDir({ packageRoot, webTreeSitterDir }) {
+  return [
+    path.join(packageRoot, "grammars"),
+    webTreeSitterDir && path.join(webTreeSitterDir, "grammars")
+  ].find((dir) => dir && fs.existsSync(path.join(dir, "tree-sitter-typescript.wasm")));
+}

package/extensions/dm-lens/tools/activate-tools.js

@@ -2,15 +2,16 @@ import { Type } from "../clients/deps/typebox.js";
 export function createActivateToolsTool(pi, lazyTools, options = {}) {
   const lazyNames = lazyTools.map((t) => t.name);
   const lazyNameSet = new Set(lazyNames);
+  const exampleName = lazyNames[0];
   return {
     name: "dm_lens_activate_tools",
     label: "Activate dm-lens Tools",
-    description: 'Activate registered situational tools for the next turn. Example: `{tools: ["lsp_navigation"]}`.',
+    description: exampleName ? `Activate registered situational tools for the next turn. Example: \`{tools: ["${exampleName}"]}\`.` : "Activate registered situational tools for the next turn.",
     promptSnippet: "Activate a situational tool",
     parameters: Type.Object({
       tools: Type.Array(Type.String({ enum: lazyNames }), {
         minItems: 1,
-        description: "Names of situational tools to activate, e.g. `lsp_navigation`."
+        description: exampleName ? `Names of situational tools to activate, e.g. \`${exampleName}\`.` : "Names of situational tools to activate."
       })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {

package/extensions/dm-lens/tools/ast-grep-outline.js

@@ -1,7 +1,6 @@
-import * as path from "node:path";
 import { Type } from "../clients/deps/typebox.js";
 import { compactRenderResult } from "./render-compact.js";
-import { LANGUAGES } from "./shared.js";
+import { LANGUAGES, resolveAstGrepPaths } from "./shared.js";
 const MAX_FILES = 50;
 const MAX_ITEMS_PER_FILE = 200;
 function withReadHandles(filePath, item) {
@@ -73,7 +72,7 @@ export function createAstGrepOutlineTool(astGrepClient) {
       const rawPaths = (params.paths ?? []).filter((p) => typeof p === "string" && p.trim().length > 0);
       if (rawPaths.length === 0)
         return errorResult("paths is required");
-      const absPaths = rawPaths.map((p) => path.isAbsolute(p) ? p : path.resolve(cwd, p));
+      const absPaths = resolveAstGrepPaths(rawPaths, cwd);
       if (!await astGrepClient.ensureAvailable()) {
         return errorResult("ast-grep CLI not found. Install: npm i -D @ast-grep/cli");
       }

package/extensions/dm-lens/tools/ast-grep-replace.js

@@ -15,7 +15,7 @@ function errorTextWithHint(raw) {
 
 ${hint}` : `Error: ${raw}`;
 }
-import { LANGUAGES } from "./shared.js";
+import { LANGUAGES, resolveAstGrepPaths } from "./shared.js";
 function lineCount(value) {
   if (!value)
     return 0;
@@ -26,7 +26,7 @@ function lineCount(value) {
   }
   return lines;
 }
-export function createAstGrepReplaceTool(astGrepClient) {
+export function createAstGrepReplaceTool(astGrepClient, captureLineage) {
   return {
     name: "ast_grep_replace",
     label: "AST Replace",
@@ -78,6 +78,7 @@ export function createAstGrepReplaceTool(astGrepClient) {
       }))
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const lineage = captureLineage?.();
       const startedAt = Date.now();
       const {
         pattern,
@@ -128,7 +129,7 @@ export function createAstGrepReplaceTool(astGrepClient) {
           details: {}
         };
       }
-      const searchPaths = paths?.length ? paths : [ctx.cwd || "."];
+      const searchPaths = resolveAstGrepPaths(paths, ctx.cwd);
       if (hasStructuralIntent({
         insideKind,
         hasKind,
@@ -161,7 +162,7 @@ export function createAstGrepReplaceTool(astGrepClient) {
             details: {}
           };
         }
-        const ruleResult = await astGrepClient.replaceWithRule(ruleYaml, searchPaths, applyFlag);
+        const ruleResult = await astGrepClient.replaceWithRule(ruleYaml, searchPaths, applyFlag, { lineage, toolCallId: _toolCallId });
         if (ruleResult.stalePreview) {
           logOutcome("error", { errorRaw: "stale_preview" });
           return {
@@ -200,7 +201,7 @@ export function createAstGrepReplaceTool(astGrepClient) {
           }
         };
       }
-      const result = await astGrepClient.replace(pattern, rewrite, lang, searchPaths, applyFlag, { strictness });
+      const result = await astGrepClient.replace(pattern, rewrite, lang, searchPaths, applyFlag, { strictness, lineage, toolCallId: _toolCallId });
       if (result.stalePreview) {
         logOutcome("error", { errorRaw: "stale_preview" });
         return {

package/extensions/dm-lens/tools/ast-grep-search.js

@@ -11,7 +11,7 @@ import {
 import { isAtOrAboveHomeDir } from "../clients/path-utils.js";
 import { compactRenderResult } from "./render-compact.js";
 import { combineAbortSignals } from "../clients/deadline-utils.js";
-import { LANGUAGES } from "./shared.js";
+import { LANGUAGES, resolveAstGrepPaths } from "./shared.js";
 function errorTextWithHint(raw) {
   const hint = astGrepRemediationHint(classifyAstGrepError(raw));
   return hint ? `Error: ${raw}
@@ -527,7 +527,7 @@ export function createAstGrepSearchTool(astGrepClient) {
             details: {}
           };
         }
-        const searchPaths = paths?.length ? paths : [ctx.cwd || "."];
+        const searchPaths = resolveAstGrepPaths(paths, ctx.cwd);
         const PAGE_SIZE = Math.max(1, Math.min(MAX_PAGE_SIZE, Number.isFinite(maxMatches) ? Math.floor(maxMatches) : DEFAULT_PAGE_SIZE));
         let effectiveRule = hasRawRule ? rawRule : undefined;
         if (!effectiveRule && (hasNodeKind || hasStructuralIntent({

package/extensions/dm-lens/tools/lens-diagnostic-mark.js

@@ -6,6 +6,7 @@ import {
   normalizeMessage
 } from "../clients/diagnostic-dispositions.js";
 import { insertSuppressComment } from "../clients/dispatch/suppress-writer.js";
+import { getMutationBridge } from "../clients/mutation-bridge.js";
 import { normalizeMapKey } from "../clients/path-utils.js";
 import { resolveLensToolName } from "../clients/tool-config.js";
 import {
@@ -88,7 +89,7 @@ function verifyLine(content, absPath, tool, rule, message, callerLine) {
     };
   }
 }
-export function createLensDiagnosticMarkTool(getCwd, getIdentity) {
+export function createLensDiagnosticMarkTool(getCwd, getIdentity, captureLineage) {
   return {
     name: "lens_diagnostic_mark",
     label: "Mark Diagnostic",
@@ -119,6 +120,7 @@ export function createLensDiagnosticMarkTool(getCwd, getIdentity) {
       }))
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const lineage = captureLineage?.();
       const cwd = ctx.cwd ?? getCwd();
       const filePathArg = params.filePath;
       const line = params.line;
@@ -219,6 +221,15 @@ export function createLensDiagnosticMarkTool(getCwd, getIdentity) {
           };
         }
         await fs.writeFile(absPath, updated, "utf-8");
+        getMutationBridge()?.recordMutation({
+          filePath: absPath,
+          kind: "edit",
+          editRanges: [[Math.max(1, verifiedLine - 1), verifiedLine]],
+          consumer: "lens_diagnostic_mark",
+          provenance: "observed",
+          ...lineage && { lineage },
+          toolCallId: _toolCallId
+        });
       }
       const anchor = markDisposition(cwd, {
         cwd,

package/extensions/dm-lens/tools/lens-diagnostics.js

@@ -17,7 +17,10 @@ import {
   applyFindingPolicy,
   loadProjectRulePolicyMap
 } from "../clients/dispatch/finding-policy.js";
-import { gateFindingsByPathFreshness } from "../clients/advisory-provenance.js";
+import {
+  gateFindingsByPathFreshness,
+  parseScannedAtMs
+} from "../clients/advisory-provenance.js";
 import {
   formatCacheAgeLabel,
   markUnreconciledFindings
@@ -36,7 +39,7 @@ import {
   normalizeMapKey,
   realpathOrResolve
 } from "../clients/path-utils.js";
-import { getLSPService } from "../clients/lsp/index.js";
+import { getLSPService } from "../clients/lsp/capabilities.js";
 import { retireInlineBlockerAndResyncGuard } from "../clients/git-guard.js";
 import {
   primaryServerId,
@@ -470,7 +473,10 @@ function filterDeltaReportDispositions(report, cwd, policyMap) {
   if (!report?.diagnostics.length)
     return report;
   const kept = report.diagnostics.filter((d) => applyCachedDispositions([projectDiagnosticToWidget(d, d.filePath)], cwd, d.filePath).length === 1);
-  const policyKept = applyRulePolicy(kept, policyMap);
+  const policyKept = applyRulePolicy(kept, policyMap, {
+    root: cwd,
+    filePath: cwd
+  });
   if (policyKept.length === report.diagnostics.length)
     return report;
   return { ...report, diagnostics: policyKept };
@@ -560,7 +566,7 @@ function formatDeltaMode(cacheManager, cwd, severity, pathsScope) {
   const visibleWarningFiles = (files) => (files ?? []).filter((file) => includeFile(file.filePath)).map((file) => ({
     filePath: file.filePath,
     generatedAt: file.generatedAt,
-    warnings: applyRulePolicy(applyCachedDispositions(file.warnings ?? [], cwd, file.filePath), policyMap)
+    warnings: applyRulePolicy(applyCachedDispositions(file.warnings ?? [], cwd, file.filePath), policyMap, { root: cwd, filePath: file.filePath })
   })).filter((file) => file.warnings.length > 0);
   const actionableFiles = applyDeltaFreshnessGate(visibleWarningFiles(actionable?.files), cwd, actionable?.generatedAt);
   const qualityFiles = applyDeltaFreshnessGate(visibleWarningFiles(quality?.files), cwd, quality?.generatedAt);
@@ -629,7 +635,7 @@ function formatDeltaMode(cacheManager, cwd, severity, pathsScope) {
     let text = `No ${severity === "all" ? "" : severity + " "}issues in the current turn delta.`;
     const carried = getFileDiagnosticSummaries().filter((f) => includeFile(f.filePath)).map((f) => ({
       ...f,
-      diagnostics: applyRulePolicy(applyCachedDispositions(f.diagnostics, cwd, f.filePath), policyMap)
+      diagnostics: applyRulePolicy(applyCachedDispositions(f.diagnostics, cwd, f.filePath), policyMap, { root: cwd, filePath: f.filePath })
     })).filter((f) => f.diagnostics.length > 0);
     const carriedIssues = carried.reduce((n, f) => n + f.diagnostics.length, 0);
     if (carried.length > 0) {
@@ -748,12 +754,15 @@ function filterProjectDiagnosticsDeltaReport(report, includeFile) {
     diagnostics: report.diagnostics.filter((d) => includeFile(d.filePath))
   };
 }
-function applyProjectRulePolicy(value, policyMap) {
+function applyProjectRulePolicy(value, policyMap, root) {
   if (!value)
     return;
   return {
     ...value,
-    diagnostics: applyRulePolicy(value.diagnostics, policyMap)
+    diagnostics: applyRulePolicy(value.diagnostics, policyMap, {
+      root,
+      filePath: value.diagnostics[0]?.filePath ?? root
+    })
   };
 }
 function isErrorLike(d) {
@@ -826,7 +835,10 @@ function projectDiagnosticToWidget(diagnostic, filePath) {
     col: diagnostic.column,
     rule: diagnostic.rule ?? diagnostic.code,
     tool: diagnostic.runner || diagnostic.tool,
-    uri: widgetDiagnosticUri(filePath, diagnostic.line, diagnostic.column)
+    uri: widgetDiagnosticUri(filePath, diagnostic.line, diagnostic.column),
+    ...diagnostic.observedAt !== undefined && {
+      observedAt: diagnostic.observedAt
+    }
   };
 }
 function diagnosticDedupKey(filePath, diagnostic) {
@@ -987,14 +999,33 @@ function mergeDiagnosticsWithWidgetSummaries(widgetSummaries, lspResults, projec
   for (const result of lspResults) {
     const filePath = path.resolve(result.filePath);
     for (const diagnostic of result.diagnostics ?? []) {
-      addDiagnostic(filePath, lspDiagnosticToWidget(diagnostic));
+      addDiagnostic(filePath, {
+        ...lspDiagnosticToWidget(diagnostic),
+        ...result.observedAt !== undefined && {
+          observedAt: result.observedAt
+        }
+      });
     }
   }
+  const deltaDiagnostics = projectDelta?.diagnostics ?? [];
+  const deltaObservedAt = parseScannedAtMs(projectDelta?.generatedAt);
+  if (deltaDiagnostics.length > 0 && deltaObservedAt === undefined) {
+    recordDegradationOnce({
+      kind: "project-delta-generatedat-unparseable",
+      subject: String(projectDelta?.generatedAt),
+      reason: "projectDelta rows fell back to the fold time because generatedAt could not be parsed"
+    });
+  }
   for (const diagnostic of projectSnapshot?.diagnostics ?? []) {
     addDiagnostic(path.resolve(diagnostic.filePath), projectDiagnosticToWidget(diagnostic, diagnostic.filePath));
   }
-  for (const diagnostic of projectDelta?.diagnostics ?? []) {
-    addDiagnostic(path.resolve(diagnostic.filePath), projectDiagnosticToWidget(diagnostic, diagnostic.filePath));
+  for (const diagnostic of deltaDiagnostics) {
+    const widget = projectDiagnosticToWidget(diagnostic, diagnostic.filePath);
+    const observedAt = widget.observedAt ?? deltaObservedAt;
+    addDiagnostic(path.resolve(diagnostic.filePath), {
+      ...widget,
+      ...observedAt !== undefined && { observedAt }
+    });
   }
   return [...byFile.values()];
 }
@@ -1006,7 +1037,10 @@ async function applyInlineSuppressionsToSummaries(summaries, cwd, policyMap) {
     try {
       content = await fs.readFile(summary.filePath, "utf8");
     } catch {
-      const policyKept = applyRulePolicy(summary.diagnostics, policyMap);
+      const policyKept = applyRulePolicy(summary.diagnostics, policyMap, {
+        root: cwd,
+        filePath: summary.filePath
+      });
       return policyKept.length === summary.diagnostics.length ? summary : summarizeDiagnostics(summary.filePath, policyKept, summary.hasFinalSnapshot);
     }
     const { kept: policyKept } = applyFindingPolicy(summary.diagnostics, {
@@ -1057,8 +1091,9 @@ function foldExtraDiagnosticsIntoSnapshot(snapshot, extra, runners, cwd) {
   };
 }
 async function getProjectDiagnosticsSnapshotForFullMode(cwd, options) {
+  let loaded;
   if (shouldRefreshProjectDiagnostics(options.refreshRunners)) {
-    return scanProjectDiagnostics({
+    loaded = await scanProjectDiagnostics({
       cwd,
       tier: "cheap",
       maxFiles: options.maxProjectFiles,
@@ -1066,29 +1101,28 @@ async function getProjectDiagnosticsSnapshotForFullMode(cwd, options) {
       files: options.files,
       includeGenerated: options.includeGenerated
     });
+  } else if (shouldUseCachedProjectDiagnostics(options.refreshRunners)) {
+    loaded = loadProjectDiagnosticsSnapshot(cwd);
   }
-  if (shouldUseCachedProjectDiagnostics(options.refreshRunners)) {
-    const cached = loadProjectDiagnosticsSnapshot(cwd);
-    if (!cached)
-      return;
-    const reconciled = reconcileProjectDiagnosticsSnapshot(cached);
-    if (reconciled.staleDropped > 0) {
-      logLatency({
-        type: "phase",
-        toolName: "lens_diagnostics",
-        filePath: cwd,
-        phase: "project_snapshot_rows_retired",
-        durationMs: 0,
-        metadata: {
-          files: reconciled.staleDropped,
-          rows: cached.diagnostics.length - reconciled.snapshot.diagnostics.length,
-          scannedAt: cached.scannedAt
-        }
-      });
-    }
-    return reconciled.snapshot;
+  if (!loaded)
+    return;
+  const reconciled = reconcileProjectDiagnosticsSnapshot(loaded);
+  if (reconciled.staleDropped > 0) {
+    logLatency({
+      type: "phase",
+      toolName: "lens_diagnostics",
+      filePath: cwd,
+      phase: "project_snapshot_rows_retired",
+      durationMs: 0,
+      metadata: {
+        files: reconciled.staleDropped,
+        rows: loaded.diagnostics.length - reconciled.snapshot.diagnostics.length,
+        scannedAt: loaded.scannedAt,
+        arm: shouldRefreshProjectDiagnostics(options.refreshRunners) ? "fresh" : "cached"
+      }
+    });
   }
-  return;
+  return reconciled.snapshot;
 }
 async function formatFullMode(cwd, severity, lspService, cacheManager, options = {}) {
   const runWorkspaceDiagnostics = lspService.runWorkspaceDiagnostics;
@@ -1185,8 +1219,8 @@ async function formatFullMode(cwd, severity, lspService, cacheManager, options =
   const authoritativeRunnerIds = new Set(extracted.analyzed ?? []);
   const authoritativeRunnerCoverage = extracted.authoritativeCoverage ?? [];
   const foldedProjectSnapshot = foldExtraDiagnosticsIntoSnapshot(scannedSnapshot, extracted.diagnostics.filter((d) => includeFile(d.filePath)), extracted.runners, cwd);
-  const projectSnapshot = applyProjectRulePolicy(foldedProjectSnapshot, policyMap);
-  const projectDelta = applyProjectRulePolicy(filterProjectDiagnosticsDeltaReport(loadProjectDiagnosticsDeltaReport(cwd), includeFile), policyMap);
+  const projectSnapshot = applyProjectRulePolicy(foldedProjectSnapshot, policyMap, cwd);
+  const projectDelta = applyProjectRulePolicy(filterProjectDiagnosticsDeltaReport(loadProjectDiagnosticsDeltaReport(cwd), includeFile), policyMap, cwd);
   const authoritativeRetiredCount = getFileDiagnosticSummaries().filter((summary) => includeFile(summary.filePath) && authoritativeLspFiles.has(path.resolve(summary.filePath)) && (summary.diagnostics?.length ?? 0) > 0).length;
   if (authoritativeRetiredCount > 0) {
     logLatency({
@@ -1437,7 +1471,10 @@ async function formatAllMode(cwd, severity, summaries = getFileDiagnosticSummari
   const dispositioned = isFullMode ? summaries : summaries.map((s) => {
     const diagnostics = s.diagnostics ?? [];
     const kept = applyCachedDispositions(diagnostics, cwd, s.filePath);
-    const policyKept = applyRulePolicy(kept, policyMap);
+    const policyKept = applyRulePolicy(kept, policyMap, {
+      root: cwd,
+      filePath: s.filePath
+    });
     if (policyKept.length === kept.length && kept.length === diagnostics.length)
       return s;
     return summarizeDiagnostics(s.filePath, policyKept, s.hasFinalSnapshot);