@duckmind/dm-linux-x64 0.65.5 → 0.65.7

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

@@ -1,4 +1,6 @@
+import { createHash } from "node:crypto";
 import * as nodeFs from "node:fs";
+import * as nodeCrypto from "node:crypto";
 import * as path from "node:path";
 import {
   findNearestContaining,
@@ -10,7 +12,10 @@ import {
 import {
   recordFromCodeQualityDiagnostic
 } from "./code-quality-warnings.js";
-import { recordDiagnostics } from "./widget-state.js";
+import {
+  admitWidgetDiagnosticsWrite,
+  recordDiagnostics
+} from "./widget-state.js";
 import { getDiagnosticLogger } from "./diagnostic-logger.js";
 import { getDiagnosticTracker } from "./diagnostic-tracker.js";
 import { loadDispatchIntegration } from "./dispatch/lazy.js";
@@ -28,6 +33,7 @@ import {
   resolveToolCommandWithInstallFallback
 } from "./dispatch/runners/utils/runner-helpers.js";
 import { findDetektConfig } from "./dispatch/runners/detekt.js";
+import { formatDiagnostics } from "./dispatch/utils/format-utils.js";
 import { detectFileKind, getFileKindLabel } from "./file-kinds.js";
 import {
   detectFileChangedAfterCommand,
@@ -46,8 +52,15 @@ import { clearGraphCache } from "./review-graph/builder.js";
 import { BoundedLruCache } from "./bounded-cache.js";
 import { RUNTIME_CONFIG } from "./runtime-config.js";
 import { getAmbientAbortSignal, safeSpawnAsync } from "./safe-spawn.js";
+import { probeToolAsync } from "./tool-probe.js";
 import { bounded } from "./deadline-utils.js";
-import { recordDegradationOnce } from "./degradation-ledger.js";
+import { HOOK_WALL_BUDGET_MS } from "./hook-budgets.js";
+import { enabledAuxiliaryLspServerIds } from "./dispatch/auxiliary-lsp.js";
+import {
+  incrementDegradationCount,
+  recordDegradationOnce
+} from "./degradation-ledger.js";
+import { establishToolAgreement } from "./tool-agreement.js";
 import { dropFindingsForMissingPaths } from "./advisory-provenance.js";
 import {
   getAutofixPolicyForFile,
@@ -65,8 +78,7 @@ import {
   hasStylelintConfig,
   markdownlintConfigArgs
 } from "./tool-policy.js";
-const LSP_MAX_FILE_BYTES = RUNTIME_CONFIG.pipeline.lspMaxFileBytes;
-const LSP_MAX_FILE_LINES = RUNTIME_CONFIG.pipeline.lspMaxFileLines;
+import { exceedsLspSyncLimits } from "./lsp/content-limits.js";
 const LSP_SPAWN_BUDGET_MS = RUNTIME_CONFIG.pipeline.lspSpawnBudgetMs;
 const AUTOFIX_CHANGED_FILE_SCAN_LIMIT = 5000;
 function lspSyncBudgetMs() {
@@ -132,24 +144,6 @@ async function diffProjectSnapshot(root, before) {
   }
   return [...changed].sort((a, b) => a.localeCompare(b));
 }
-function exceedsLspSyncLimits(_filePath, content) {
-  const sizeBytes = Buffer.byteLength(content, "utf-8");
-  if (sizeBytes > LSP_MAX_FILE_BYTES) {
-    return {
-      tooLarge: true,
-      reason: `${Math.round(sizeBytes / 1024)}KB exceeds ${Math.round(LSP_MAX_FILE_BYTES / 1024)}KB`
-    };
-  }
-  const lineCount = content.split(`
-`).length;
-  if (lineCount > LSP_MAX_FILE_LINES) {
-    return {
-      tooLarge: true,
-      reason: `${lineCount} lines exceeds ${LSP_MAX_FILE_LINES}`
-    };
-  }
-  return { tooLarge: false, reason: "" };
-}
 function createPhaseTracker(toolName, filePath) {
   const phases = [];
   return {
@@ -173,12 +167,7 @@ function createPhaseTracker(toolName, filePath) {
   };
 }
 
-export {
-  hasEslintConfig,
-  hasRubocopConfig,
-  hasSqlfluffConfig,
-  hasStylelintConfig
-};
+export { hasEslintConfig, hasSqlfluffConfig, hasStylelintConfig };
 const ESLINT_FIX_PROBE_BUDGET_MS = 5000;
 const _eslintCache = new BoundedLruCache(32);
 async function tryEslintFix(filePath, cwd) {
@@ -305,7 +294,7 @@ async function tryDetektFix(filePath, cwd) {
   const absPath = path.resolve(cwd, filePath);
   return detectFileChangedAfterCommand(filePath, cmd, ["--auto-correct", "--input", absPath, "--config", configPath], cwd, [1, 2]);
 }
-export async function tryMarkdownlintFix(filePath, cwd) {
+async function tryMarkdownlintFix(filePath, cwd) {
   const cmd = await resolveToolCommandWithInstallFallback(cwd, "markdownlint");
   if (!cmd)
     return 0;
@@ -318,7 +307,7 @@ async function tryOxlintFix(filePath, cwd) {
   return detectFileChangedAfterCommand(filePath, cmd, ["--fix", filePath], cwd, [1]);
 }
 async function tryRustClippyFix(filePath) {
-  const check = await safeSpawnAsync("cargo", ["--version"], { timeout: 5000 });
+  const check = await probeToolAsync("cargo", ["--version"], { timeout: 5000 });
   if (check.error || check.status !== 0)
     return [];
   const cargoDir = findNearestContaining(path.dirname(path.resolve(filePath)), [
@@ -333,7 +322,7 @@ async function tryRustClippyFix(filePath) {
   return diffProjectSnapshot(cargoDir, before);
 }
 async function tryDartFix(filePath) {
-  const check = await safeSpawnAsync("dart", ["--version"], { timeout: 5000 });
+  const check = await probeToolAsync("dart", ["--version"], { timeout: 5000 });
   if (check.error || check.status !== 0)
     return [];
   const pubspecDir = findNearestContaining(path.dirname(path.resolve(filePath)), ["pubspec.yaml"]);
@@ -419,6 +408,17 @@ export async function runAutofix(filePath, cwd, getFlag, dbg, deps, getFlagSourc
   }
   for (const toolName of preferredAutofixTools) {
     attemptedTools.push(toolName);
+    const agreement = establishToolAgreement(toolName, cwd);
+    if (agreement.decision === "decline") {
+      const reason = agreement.reason;
+      dbg(`autofix: ${toolName} declined (${reason})`);
+      recordDegradationOnce({
+        kind: "autofix-agreement-unavailable",
+        subject: agreement.subject,
+        reason
+      });
+      continue;
+    }
     if (toolName === "ruff") {
       const ruffReady = ruffClient.isPythonFile(filePath) ? await ruffClient.ensureAvailable() : false;
       if (!ruffReady) {
@@ -615,7 +615,7 @@ export async function resyncLspFile(filePath, fileContent, needsContentRefresh,
     return;
   if (!needsContentRefresh && lspSyncCompleted)
     return;
-  const limitCheck = exceedsLspSyncLimits(filePath, fileContent);
+  const limitCheck = exceedsLspSyncLimits(fileContent);
   if (limitCheck.tooLarge)
     return;
   try {
@@ -630,11 +630,16 @@ export async function resyncLspFile(filePath, fileContent, needsContentRefresh,
         diagnostics: "none",
         source: "lsp_sync",
         clientScope: "primary",
-        maxClientWaitMs: LSP_SPAWN_BUDGET_MS
+        maxClientWaitMs: LSP_SPAWN_BUDGET_MS,
+        saved: true
       }).then(() => "done").catch((err) => {
         dbg(`LSP resync after autofix error: ${err}`);
         return "done";
       });
+      const auxServerIds = enabledAuxiliaryLspServerIds(getFlag);
+      if (auxServerIds.length > 0) {
+        (async () => lspService.getAuxiliaryClientsForFile(filePath, new Set(auxServerIds), undefined, LSP_SPAWN_BUDGET_MS, abort, "tool_result_edit"))().catch(() => {});
+      }
       const outcome = await bounded(touch, {
         ms: budgetMs,
         signal: abort,
@@ -642,7 +647,7 @@ export async function resyncLspFile(filePath, fileContent, needsContentRefresh,
         label: "resyncLspFile"
       });
       if (outcome === undefined) {
-        const spawnInFlight = !abort?.aborted && typeof lspService.isSpawnInFlight === "function" && lspService.isSpawnInFlight(filePath);
+        const spawnInFlight = !abort?.aborted && lspService.isSpawnInFlight(filePath);
         const reason = abort?.aborted ? "aborted" : spawnInFlight ? "spawn-in-flight" : "timeout";
         logLatency({
           type: "phase",
@@ -689,7 +694,7 @@ function buildAllClearOutput(_dispatchResult, elapsed, filePath) {
   parts.push(`${elapsed}ms`);
   return `checkmark ${parts.join(" · ")}`.replace("checkmark", "✓");
 }
-export async function runFormatPhase(filePath, getFormatService, dbg) {
+export async function runFormatPhase(filePath, getFormatService, dbg, signal, budgetMs = HOOK_WALL_BUDGET_MS.tool_result_edit, hook = "tool_result_edit") {
   let formatChanged = false;
   let formattersUsed = [];
   const formatFailures = [];
@@ -698,10 +703,16 @@ export async function runFormatPhase(filePath, getFormatService, dbg) {
   const formatService = getFormatService();
   try {
     formatService.recordRead(filePath);
-    const result = await formatService.formatFile(filePath);
+    const result = await formatService.formatFile(filePath, {
+      signal,
+      budgetMs,
+      hook
+    });
     for (const f of result.formatters) {
       if (f.outcome !== "unavailable")
         continue;
+      if (f.error?.includes("project tool agreement could not be established"))
+        continue;
       const reason = f.error ?? "formatter executable not found";
       formatUnavailable.push({ formatter: f.name, reason });
       recordDegradationOnce({
@@ -751,6 +762,8 @@ export async function runFormatPhase(filePath, getFormatService, dbg) {
   };
 }
 function buildEnrichedBlockerOutput(blockers, fileContent = "") {
+  if (blockers.length === 0)
+    return "";
   const fileLines = fileContent ? fileContent.split(`
 `) : [];
   const MAX_SNIPPET = 120;
@@ -782,6 +795,15 @@ function buildEnrichedBlockerOutput(blockers, fileContent = "") {
 export async function runPipeline(ctx, deps) {
   const { filePath, cwd, toolName, getFlag, getFlagSource, dbg } = ctx;
   const { getFormatService } = deps;
+  const allowAutonomousWriters = ctx.allowAutonomousWriters !== false;
+  if (!allowAutonomousWriters) {
+    incrementDegradationCount({
+      kind: "opaque-mutation-ownership-boundary",
+      subject: "pipeline",
+      reason: `observed mutation is not evidence of agent authorship (${filePath})`
+    });
+  }
+  admitWidgetDiagnosticsWrite(filePath, ctx.telemetry?.writeIndex);
   const phase = createPhaseTracker(toolName, filePath);
   const pipelineStart = Date.now();
   clearGraphCache();
@@ -799,9 +821,9 @@ export async function runPipeline(ctx, deps) {
   const piChangedFiles = new Set;
   const autoformatDisabled = !!getFlag("no-autoformat", filePath);
   const immediateFormat = !!getFlag("immediate-format");
-  const formatDeferred = !autoformatDisabled && !immediateFormat && !!fileContent;
-  if (!autoformatDisabled && immediateFormat && fileContent) {
-    const formatResult = await runFormatPhase(filePath, getFormatService, dbg);
+  const formatDeferred = allowAutonomousWriters && !autoformatDisabled && !immediateFormat && !!fileContent;
+  if (allowAutonomousWriters && !autoformatDisabled && immediateFormat && fileContent) {
+    const formatResult = await runFormatPhase(filePath, getFormatService, dbg, ctx.signal);
     formatChanged = formatResult.formatChanged;
     formattersUsed = formatResult.formattersUsed;
     formatFailures = formatResult.formatFailures;
@@ -823,6 +845,8 @@ export async function runPipeline(ctx, deps) {
     }
   } else if (formatDeferred) {
     dbg(`autoformat: deferred until agent_end for ${filePath}`);
+  } else if (!allowAutonomousWriters) {
+    dbg(`autoformat: skipped for ${filePath} (mutation ownership is unproven)`);
   } else if (autoformatDisabled) {
     const source = getFlagSource?.("no-autoformat", filePath);
     dbg(`autoformat: skipped for ${filePath} (--no-autoformat${source ? `, source=${source}` : ""})`);
@@ -839,7 +863,10 @@ export async function runPipeline(ctx, deps) {
   let autofixChangedFiles = [];
   let fixRefresh = false;
   let autofixSkipReason;
-  if (ctx.autofixMode === "deferred") {
+  if (!allowAutonomousWriters) {
+    autofixSkipReason = "mutation_ownership_unproven";
+    dbg(`autofix: skipped for ${filePath} (mutation ownership is unproven)`);
+  } else if (ctx.autofixMode === "deferred") {
     autofixSkipReason = "deferred_to_agent_end";
     dbg(`autofix: deferred until agent_end for ${filePath}`);
   } else
@@ -878,6 +905,20 @@ export async function runPipeline(ctx, deps) {
     attemptedTools,
     skipReason: autofixSkipReason
   });
+  const fileModified = formatChanged || fixedCount > 0;
+  const targetFileModified = piChangedFiles.has(path.resolve(filePath));
+  const postWriteStateHash = fileModified && targetFileModified ? (() => {
+    try {
+      return nodeCrypto.createHash("sha256").update(nodeFs.readFileSync(filePath)).digest("hex");
+    } catch (error) {
+      recordDegradationOnce({
+        kind: "pipeline-post-write-hash-unavailable",
+        subject: filePath,
+        reason: error instanceof Error ? error.message : String(error)
+      });
+      return;
+    }
+  })() : undefined;
   phase.start("lsp_sync");
   let lspSyncCompleted = false;
   if (fileContent) {
@@ -891,6 +932,13 @@ export async function runPipeline(ctx, deps) {
     getFlag
   };
   const { dispatchLintWithResult, computeCascadeForFile } = await loadDispatchIntegration();
+  const inlineBlockerFileContent = fileContent ? (() => {
+    const content = Buffer.from(fileContent, "utf8");
+    return content.byteLength <= 2 * 1024 * 1024 ? {
+      size: content.byteLength,
+      sha256: createHash("sha256").update(content).digest("hex")
+    } : undefined;
+  })() : undefined;
   const dispatchResult = await dispatchLintWithResult(filePath, cwd, piApi, ctx.modifiedRanges, {
     model: ctx.telemetry?.model ?? "unknown",
     sessionId: ctx.telemetry?.sessionId ?? "unknown",
@@ -919,13 +967,27 @@ export async function runPipeline(ctx, deps) {
       });
     }
   }
-  const hasBlockers = dispatchResult.hasBlockers;
-  const actionableWarnings = dispatchResult.warnings.map((diagnostic) => recordFromDispatchDiagnostic(diagnostic, cwd)).filter((warning) => Boolean(warning));
+  const hasBlockers = allowAutonomousWriters && dispatchResult.hasBlockers;
+  const actionableWarnings = allowAutonomousWriters ? dispatchResult.warnings.map((diagnostic) => recordFromDispatchDiagnostic(diagnostic, cwd)).filter((warning) => Boolean(warning)) : [];
   const codeQualityWarnings = dispatchResult.warnings.map((diagnostic) => recordFromCodeQualityDiagnostic(diagnostic, cwd)).filter((warning) => Boolean(warning));
   if (dispatchResult.diagnostics.length > 0) {
-    const logger = getDiagnosticLogger();
     const tracker = getDiagnosticTracker();
     tracker.trackShown(dispatchResult.diagnostics);
+  }
+  if (fixedCount > 0)
+    getDiagnosticTracker().trackAutoFixed(fixedCount);
+  if (dispatchResult.resolvedCount > 0)
+    getDiagnosticTracker().trackAgentFixed(dispatchResult.resolvedCount);
+  let output = "";
+  const deliverableBlockers = hasBlockers ? dropFindingsForMissingPaths({
+    store: "stop-blocker",
+    findings: dispatchResult.blockers,
+    cwd,
+    citedPath: (b) => b.filePath || undefined
+  }) : [];
+  const hasDeliverableBlockers = deliverableBlockers.length > 0;
+  if (dispatchResult.diagnostics.length > 0) {
+    const logger = getDiagnosticLogger();
     const toKey = (d) => [
       d.tool || "",
       d.id || "",
@@ -934,7 +996,7 @@ export async function runPipeline(ctx, deps) {
       d.line || 0,
       d.column || 0
     ].join("|");
-    const inlineKeys = new Set([...dispatchResult.blockers, ...dispatchResult.fixed].map(toKey));
+    const inlineKeys = new Set([...deliverableBlockers, ...dispatchResult.fixed].map(toKey));
     for (const d of dispatchResult.diagnostics) {
       logger.logCaught(d, {
         model: ctx.telemetry?.model ?? "unknown",
@@ -944,37 +1006,28 @@ export async function runPipeline(ctx, deps) {
       }, inlineKeys.has(toKey(d)));
     }
   }
-  if (fixedCount > 0)
-    getDiagnosticTracker().trackAutoFixed(fixedCount);
-  if (dispatchResult.resolvedCount > 0)
-    getDiagnosticTracker().trackAgentFixed(dispatchResult.resolvedCount);
-  let output = "";
-  const deliverableBlockers = dispatchResult.hasBlockers ? dropFindingsForMissingPaths({
-    store: "stop-blocker",
-    findings: dispatchResult.blockers,
-    cwd,
-    citedPath: (b) => b.filePath || undefined
-  }) : dispatchResult.blockers;
-  if (dispatchResult.hasBlockers && fileContent) {
+  const deliveredOutput = !allowAutonomousWriters && dispatchResult.hasBlockers ? dispatchResult.output.slice(dispatchResult.blockerOutput.length) : dispatchResult.output;
+  if (hasBlockers && fileContent) {
     if (deliverableBlockers.length > 0) {
       output += buildEnrichedBlockerOutput(deliverableBlockers, fileContent);
     }
     const rest = dispatchResult.output.slice(dispatchResult.blockerOutput.length);
     if (rest)
       output += rest;
-  } else if (dispatchResult.output) {
-    if (dispatchResult.hasBlockers && deliverableBlockers.length !== dispatchResult.blockers.length) {
+  } else if (deliveredOutput) {
+    if (hasBlockers && deliverableBlockers.length !== dispatchResult.blockers.length) {
       let gatedOut = buildEnrichedBlockerOutput(deliverableBlockers);
       const rest = dispatchResult.output.slice(dispatchResult.blockerOutput.length);
       if (rest)
         gatedOut += rest;
-      output += `
+      if (gatedOut)
+        output += `
 
 ${gatedOut}`;
     } else {
       output += `
 
-${dispatchResult.output}`;
+${deliveredOutput}`;
     }
   }
   if (fixedCount > 0) {
@@ -1008,6 +1061,7 @@ ${dispatchResult.output}`;
     dbg,
     turnSeq: ctx.telemetry?.turnIndex,
     writeSeq: ctx.telemetry?.writeIndex,
+    projectRoot: ctx.projectRoot,
     seqState: ctx.seqState,
     turnEndCascadeSettleStart: ctx.turnEndCascadeSettleStart,
     fileContent,
@@ -1033,7 +1087,6 @@ ${dispatchResult.output}`;
     output = buildAllClearOutput(dispatchResult, elapsed, filePath);
   }
   phase.end("total", { hasOutput: !!output });
-  const fileModified = formatChanged || fixedCount > 0;
   const changedFiles = [...piChangedFiles];
   emitLensAnalysisComplete({
     cwd,
@@ -1044,7 +1097,7 @@ ${dispatchResult.output}`;
     turnIndex: ctx.telemetry?.turnIndex ?? 0,
     writeIndex: ctx.telemetry?.writeIndex ?? 0,
     diagnostics: dispatchResult.diagnostics,
-    blockers: dispatchResult.blockers,
+    blockers: hasBlockers ? dispatchResult.blockers : [],
     warnings: dispatchResult.warnings,
     fixed: dispatchResult.fixed,
     resolvedCount: dispatchResult.resolvedCount,
@@ -1055,16 +1108,17 @@ ${dispatchResult.output}`;
   });
   return {
     output,
-    hasBlockers,
+    hasBlockers: hasDeliverableBlockers,
     cascadePromise,
     isError: false,
     fileModified,
+    postWriteStateHash,
     changedFiles,
-    inlineBlockerSummary: dispatchResult.hasBlockers ? dispatchResult.blockerOutput.trim() || undefined : undefined,
-    inlineBlockerSources: dispatchResult.hasBlockers ? [
-      ...new Set(dispatchResult.blockers.map((d) => d.tool?.trim() || "unknown"))
+    inlineBlockerSummary: hasDeliverableBlockers ? formatDiagnostics(deliverableBlockers, "blocking").trim() || undefined : undefined,
+    inlineBlockerSources: hasDeliverableBlockers ? [
+      ...new Set(deliverableBlockers.map((d) => d.tool?.trim() || "unknown"))
     ] : undefined,
-    inlineBlockerLines: dispatchResult.hasBlockers ? dispatchResult.blockers.filter((d) => normalizeEphemeralMapKey(d.filePath) === normalizeEphemeralMapKey(filePath)).map((d) => d.line).filter((line) => typeof line === "number") : undefined,
+    inlineBlockerLines: hasDeliverableBlockers ? deliverableBlockers.filter((d) => normalizeEphemeralMapKey(d.filePath) === normalizeEphemeralMapKey(filePath)).map((d) => d.line).filter((line) => typeof line === "number") : undefined,
     actionableWarnings,
     codeQualityWarnings,
     diagnostics: dispatchResult.diagnostics,
@@ -1076,6 +1130,8 @@ ${dispatchResult.output}`;
       filePath: path.resolve(filePath),
       content: fileContent,
       source: "autofix"
-    } : undefined
+    } : undefined,
+    inlineBlockerFileContent: hasBlockers ? inlineBlockerFileContent : undefined,
+    inlineBlockerDiagnostics: hasDeliverableBlockers ? deliverableBlockers : undefined
   };
 }

package/extensions/dm-lens/clients/project-changes.js

@@ -34,7 +34,7 @@ export function readProjectChanges(cwd) {
     return [];
   }
 }
-export async function readProjectChangesAsync(cwd) {
+async function readProjectChangesAsync(cwd) {
   const logPath = getProjectChangeLogPath(cwd);
   try {
     const content = await fs.promises.readFile(logPath, "utf-8");

package/extensions/dm-lens/clients/project-diagnostics/cache.js

@@ -4,7 +4,8 @@ import { getProjectDataDir } from "../file-utils.js";
 import { writeFileAtomic } from "../atomic-write.js";
 import { readJsonCache } from "../json-cache-read.js";
 import { freshnessFromMtime } from "../freshness.js";
-export const PROJECT_DIAGNOSTICS_CACHE_VERSION = 2;
+import { hashDiagnosticContent } from "../lsp/diagnostic-binding.js";
+export const PROJECT_DIAGNOSTICS_CACHE_VERSION = 3;
 const SNAPSHOT_CACHE_FILE = "project-diagnostics.json";
 const DELTA_CACHE_FILE = "project-diagnostics-delta.json";
 function cachePath(cwd, fileName) {
@@ -54,14 +55,27 @@ export function reconcileProjectDiagnosticsSnapshot(snapshot) {
     if (cached !== undefined)
       return cached;
     let stale;
-    let mtimeMs;
+    let stat;
     try {
-      mtimeMs = fs.statSync(filePath).mtimeMs;
+      stat = fs.statSync(filePath);
     } catch {
-      mtimeMs = undefined;
+      stat = undefined;
+    }
+    const fingerprint = snapshot.fileFingerprints?.[filePath];
+    if (fingerprint && stat) {
+      stale = true;
+      if (stat.size === fingerprint.sizeBytes) {
+        try {
+          stale = hashDiagnosticContent(fs.readFileSync(filePath, "utf-8")) !== fingerprint.contentHash;
+        } catch {
+          stale = true;
+        }
+      }
+      staleByFile.set(filePath, stale);
+      return stale;
     }
     const verdict = freshnessFromMtime({
-      mtimeMs,
+      mtimeMs: stat?.mtimeMs,
       referenceMs: scannedAtMs
     });
     stale = verdict.verdict !== "fresh";

package/extensions/dm-lens/clients/project-diagnostics/extractors.js

@@ -9,7 +9,7 @@ const WARM_TRIGGER = {
   "dead-code": "runs at session-start (Python projects only)",
   "test-runner": "fires per-edit at turn_end (only after a source file with a discoverable test companion is edited)"
 };
-export function warmTriggerFor(analyzerId) {
+function warmTriggerFor(analyzerId) {
   return WARM_TRIGGER[analyzerId] ?? "runs at session-start";
 }
 export function formatNotRunEntry(analyzerId, coldReasons) {