@duckmind/dm-darwin-x64 0.66.5 → 0.66.7

package/extensions/dm-lens/dist/clients/finding-delivery-gate.js

@@ -0,0 +1,132 @@
+const MS_PER_MINUTE = 60000;
+export function markUnreconciledFindings(findings) {
+  return findings.map((finding) => ({ ...finding, stale: true }));
+}
+export function formatCacheAgeLabel(scannedAt, nowMs = Date.now()) {
+  if (scannedAt === undefined || scannedAt === null || scannedAt === "") {
+    return "scan age unknown";
+  }
+  const scannedAtMs = typeof scannedAt === "number" ? scannedAt : Date.parse(scannedAt);
+  if (!Number.isFinite(scannedAtMs))
+    return "scan age unknown";
+  const ageMs = Math.max(0, nowMs - scannedAtMs);
+  const ageMinutes = Math.round(ageMs / MS_PER_MINUTE);
+  if (ageMinutes < 1)
+    return "scanned <1m ago";
+  if (ageMinutes < 60)
+    return `scanned ${ageMinutes}m ago`;
+  const ageHours = Math.floor(ageMinutes / 60);
+  const remMinutes = ageMinutes % 60;
+  return remMinutes === 0 ? `scanned ${ageHours}h ago` : `scanned ${ageHours}h ${remMinutes}m ago`;
+}
+export function admitsProjectWideFindings(sessionRole) {
+  return sessionRole === "primary";
+}
+function gated(file, description, gates, evidence, extra = {}) {
+  return { mode: "gated", file, description, gates, evidence, ...extra };
+}
+function labeled(file, description, reason, ageSource, evidence = [], extra = {}) {
+  return {
+    mode: "labeled",
+    file,
+    description,
+    reason,
+    ageSource,
+    evidence,
+    ...extra
+  };
+}
+const RUNTIME_TURN_FILE = "clients/runtime-turn.ts";
+const LENS_DIAGNOSTICS_FILE = "tools/lens-diagnostics.ts";
+export const DELIVERY_SURFACES = {
+  "runtime-turn:secrets-gitleaks": gated(RUNTIME_TURN_FILE, "Turn-end \uD83D\uDD34 secrets blocker, gitleaks cache.", ["gateFindingsByPathFreshness"], ["gitleaksGate,"]),
+  "runtime-turn:secrets-trivy": gated(RUNTIME_TURN_FILE, "Turn-end \uD83D\uDD34 secrets blocker, trivy secrets cache.", ["gateFindingsByPathFreshness"], ["trivySecretsGate,"]),
+  "runtime-turn:govulncheck-advisory": gated(RUNTIME_TURN_FILE, "Turn-end \uD83D\uDEE1️ Go CVE advisory (call-site line only).", ["gateFindingsByPathFreshness"], ["scannerGates.govulncheck"]),
+  "runtime-turn:unresolved-inline-blocker": gated(RUNTIME_TURN_FILE, "Turn-end re-surfaced unresolved inline blockers.", ["sweepInlineBlockerFreshness"], ["sweepInlineBlockerFreshness(runtime, cwd, {"], { evidenceMin: 2 }),
+  "runtime-turn:stale-secrets-tier": gated(RUNTIME_TURN_FILE, "Turn-end \uD83D\uDD11 demoted-secrets tier (drifted since scan).", ["gateFindingsByPathFreshness"], ["gitleaksGate,", "trivySecretsGate,"]),
+  "runtime-turn:trivy-critical-blocker": labeled(RUNTIME_TURN_FILE, "Turn-end \uD83D\uDD34 CRITICAL dependency CVE blocker (trivy).", "Package-pinned finding with no cited file:line to stat — freshness has " + "nothing to check drift against. The session_start cache can be " + "arbitrarily old, so its age is stated instead. Also routes through " + "`filterFindingsByDisposition` (#1625) first — a suppressed/false-" + "positive finding never reaches this render, so the age label and the " + "disposition filter compose rather than substitute for each other.", "TrivyResult.scannedAt", ["CRITICAL dependency CVEs (trivy, ${trivyAgeLabel}"]),
+  "runtime-turn:trivy-cve-advisory": labeled(RUNTIME_TURN_FILE, "Turn-end \uD83D\uDEE1️ non-critical dependency CVE advisory (trivy).", "Same package-pinned shape and #1625 disposition composition as the " + "CRITICAL blocker above.", "TrivyResult.scannedAt", ["Dependency CVEs (trivy, ${trivyAgeLabel}"]),
+  "runtime-turn:trivy-license-advisory": labeled(RUNTIME_TURN_FILE, "Turn-end \uD83D\uDCDC dependency license-risk advisory (trivy).", "Same package-pinned shape as the CRITICAL blocker above.", "TrivyResult.scannedAt", ["Dependency license risk (trivy, ${trivyAgeLabel}"]),
+  "runtime-turn:dead-code-advisory": labeled(RUNTIME_TURN_FILE, "Turn-end dead-code delta advisory (knip/vulture/etc).", "The delta shown is computed from THIS turn's own analyze() call, " + "diffed against the previous cache — never a replay of a stale cache.", "live"),
+  "runtime-turn:knip-blocker": labeled(RUNTIME_TURN_FILE, "Turn-end \uD83D\uDD34 Knip unresolved-imports/deps blocker.", "Same shape as the dead-code advisory: `await knipClient.analyze(cwd, " + "...)` runs fresh THIS turn, diffed against the previous cache and " + "filtered to files edited this turn — never a replay of a stale cache.", "live"),
+  "runtime-turn:knip-advisory": labeled(RUNTIME_TURN_FILE, "Turn-end ⚠️ Knip newly-unused-exports advisory.", "Same live-this-turn shape as the Knip blocker above.", "live"),
+  "runtime-turn:actionable-warnings-advisory": labeled(RUNTIME_TURN_FILE, "Turn-end actionable-warnings advisory (ast-grep etc).", "`peekActionableWarnings` reads `_actionableWarningsThisTurn` — recorded " + "fresh from this turn's own dispatch, never a cross-turn cache.", "live"),
+  "runtime-turn:code-quality-warnings-advisory": labeled(RUNTIME_TURN_FILE, "Turn-end code-quality-warnings advisory.", "`peekCodeQualityWarnings` reads `_codeQualityWarningsThisTurn` — the " + "same per-turn accumulator shape as actionable-warnings above.", "live"),
+  "runtime-turn:disposition-suppressed-notice": labeled(RUNTIME_TURN_FILE, "Turn-end running disposition-suppressed-count notice (#1616).", "A live running total accumulated from this turn's own gate/disposition " + "calls above (`dispositionSuppressedTotal`) — telemetry ABOUT the other " + "gated surfaces, not a cache of its own.", "live"),
+  "runtime-turn:late-auxiliary-findings": gated(RUNTIME_TURN_FILE, "Turn-end late-auxiliary LSP findings (collect-later probe of aux " + "client caches whose grace window expired).", ["gateFindingsByPathFreshness", "applyPushedFindingPolicy"], ['"late-auxiliary-findings": {', "applyPushedFindingPolicy(gate.live, {"]),
+  "runtime-turn:late-runner-findings": gated(RUNTIME_TURN_FILE, "Turn-end CLI runner findings collected after the post-write path.", ["judgeDeferredRunnerFindings"], ["judgeDeferredRunnerFindings("], { evidenceMin: 2 }),
+  "runtime-turn:cascade-blocker": labeled(RUNTIME_TURN_FILE, "Turn-end \uD83E\uDDEA cascade neighbor blocker.", "Cascade results settle synchronously this turn where possible " + "(`settleCascadeRuns`), but an unsettled compute can carry over to a " + "later turn (bounded by a carry cap) — a carried-over result renders " + "with an explicit `(carried N turns · scanned Xm ago)` label (#3167, " + "#3168 F3), so the agent can tell it from a fresh observation.", "live", ["cascadeCarrySuffix("], { evidenceMin: 1 }),
+  "runtime-turn:cascade-coverage-advisory": labeled(RUNTIME_TURN_FILE, "Turn-end cascade-coverage-gap advisories (graph/binding/budget).", "Explains what the cascade check could NOT confirm this turn — not a " + "finding with a cited path, an absence-of-coverage disclosure computed " + "from this turn's own indeterminate-run list. An advisory computed from " + "a carried indeterminate run is labeled `(carried N turns · <age>)` " + "(#3167, #3168 F4 — dropped on mixed carried/fresh buckets). The age " + "half reads `scan age unknown` on this surface today: no indeterminate-" + "run producer stamps `observedAt` (only the resolved-found plumb does, " + "`clients/cascade-format.ts`), and one unstamped carried run collapses " + "the whole bucket's age rather than claiming the stamped runs' (#3168 " + "F13). The carry COUNT is always real.", "live", ["withCarryLabel("], { evidenceMin: 3 }),
+  "cascade-format:resolved-found-run": gated("clients/cascade-format.ts", "Cold-neighbour ERROR diagnostics formatted into the turn-end cascade " + "run by `buildResolvedFoundCascadeRun` (quiet-window reconcile of a " + "cascade touch that skipped its in-lane wait).", ["applyFindingPolicy"], ["applyFindingPolicy(retained, {"]),
+  "dispatch-integration:in-lane-cascade": gated("clients/dispatch/integration.ts", "In-lane per-edit cascade neighbour ERROR diagnostics, rendered into the " + "turn-end cascade block by `computeCascadeForFile`.", ["applyCascadeDisplayPolicy"], ["cascadeDisplay("], { evidenceMin: 4 }),
+  "runtime-turn:call-graph-advisory": labeled(RUNTIME_TURN_FILE, "Turn-end \uD83D\uDCCA call-graph impact advisory.", "`runtime.callGraph` is a session-lifetime in-memory structure; this " + "round does not verify or gate ITS OWN freshness policy (how/when it " + "incorporates edits made earlier in the session).", "live", [], {
+    status: "partial",
+    partialReason: "call-graph freshness/invalidation policy is out of this PR's scope — " + "tracked as a follow-up, not silently assumed fresh."
+  }),
+  "lens-diagnostics:mode-full": gated(LENS_DIAGNOSTICS_FILE, "`lens_diagnostics mode=full` report.", ["applyFindingPolicy", "reconcileProjectDiagnosticsSnapshot"], [
+    "applyFindingPolicy(summary.diagnostics, {",
+    "reconcileProjectDiagnosticsSnapshot("
+  ]),
+  "lens-diagnostics:mode-all": gated(LENS_DIAGNOSTICS_FILE, "`lens_diagnostics mode=all` report (widget-state read).", ["reconcileStaleWidgetFiles", "reconcileStaleWidgetDependencyBlockers"], ["reconcileStaleWidgetFiles(", "reconcileStaleWidgetDependencyBlockers("]),
+  "lens-diagnostics:mode-delta": gated(LENS_DIAGNOSTICS_FILE, "`lens_diagnostics mode=delta` report (the tool's DEFAULT mode) — " + "re-serves the actionable-warnings/code-quality-warnings caches AND " + "the persisted project-diagnostics delta report.", ["gateFindingsByPathFreshness"], [
+    '"lens-diagnostics-delta": {',
+    "applyDeltaFreshnessGate(",
+    '"lens-diagnostics-delta-project": {'
+  ]),
+  "widget-state:footer": gated("clients/widget-state.ts", "TUI footer blocking/error/warning tally.", ["reconcileStaleWidgetFiles", "isBlocking"], ["isBlocking(diagnostic)", "reconcileStaleWidgetFiles()"]),
+  "agent-nudge:context-message": labeled("clients/agent-nudge.ts", "Post-edit file-touch nudge injected via `context`.", "Not a scanner finding store: no severity, no cited line, no cache — the " + "accumulator is drained and cleared at the moment of injection, so the " + "content IS the current state by construction.", "live"),
+  "test-runner-delivery:custom-entry": labeled("clients/test-runner-delivery.ts", "Post-agent test-runner failures in a non-context custom entry.", "The cache remains authoritative for pull diagnostics and the commit guard; this surface appends only after provenance validation and an idle recheck.", "live"),
+  "project-diagnostics:persisted-snapshot": gated(LENS_DIAGNOSTICS_FILE, "Cross-session persisted project-diagnostics snapshot read.", ["reconcileProjectDiagnosticsSnapshot"], ["reconcileProjectDiagnosticsSnapshot("]),
+  "tool-call:stop-blocker": gated("clients/pipeline.ts", "Per-edit \uD83D\uDD34 STOP blocker output appended to the write/edit tool result.", ["dropFindingsForMissingPaths"], ['store: "stop-blocker"']),
+  "lsp-diagnostics:tool-output": gated("tools/lsp-diagnostics.ts", "`lsp_diagnostics` batch/directory sweep results. Cache hits replay through " + "the shared workspace-diagnostics cache: createWorkspaceDiagnosticsCacheContext " + "is the tool's entry, and its lookup() applies the #671/#672 freshness stack " + "(own-file mtime + reverse-dependency mtimes via isEntryFresh) plus the " + "#1095 content binding. #3088: every route out of this tool — fresh, " + "cache replay, single file, directory — also passes applyProbeFindingPolicy, " + "the stored-disposition / .dm-lens.json rule-policy / inline dm-lens-ignore " + "stack the per-edit dispatch path and mode=full apply.", [
+    "createWorkspaceDiagnosticsCacheContext",
+    "isEntryFresh",
+    "cacheCtx.lookup",
+    "applyProbeFindingPolicy"
+  ], [
+    "createWorkspaceDiagnosticsCacheContext(resolvedCwd)",
+    "cacheCtx.lookup(file, scopeKey)",
+    "applyProbeFindingPolicy("
+  ]),
+  "git-guard:commit-blocked": labeled("clients/git-guard.ts", "Git-guard commit/push \uD83D\uDD34 COMMIT BLOCKED verdict (--lens-guard).", "Synchronous preflight rejection returned inline with the failed git " + "command. The blocker map it reads is refreshed at decision time: the " + "gate first judges settled collect-later runner answers through the " + "freshness gate and the finding policy (#3814), so a stale answer " + "cannot block.", "live"),
+  "shared-checkout-guard:worktree-mutation-blocked": labeled("clients/shared-checkout-guard.ts", "Shared-checkout \uD83D\uDD34 WORKING-TREE CHANGE BLOCKED verdict (--lens-checkout-guard).", "Synchronous preflight rejection returned inline with the failed git " + "command. Both inputs are read at decision time — the instance registry " + "and `git status` — so no stored finding is replayed and nothing can go " + "stale between detection and delivery.", "live"),
+  "read-guard-tool-lines:preflight-errors": labeled("clients/read-guard-tool-lines.ts", "Read-guard hashline BLOCKED / RE-READ REQUIRED / PARTIAL APPLY / " + "ALREADY APPLIED preflight errors (#2402).", "Computed fresh per edit attempt and returned as that attempt's rejection — " + "no cached findings are replayed, so there is no staleness window. The " + "PARTIAL APPLY and ALREADY APPLIED variants describe the same attempt's " + "commit outcome; applied-edit recognition reads RuntimeCoordinator's " + "session-scoped record, which resets with the session.", "live"),
+  "mutating-tool:adapter-preflight-errors": labeled("clients/mutating-tool.ts", "Shape-adapter BLOCKED preflight errors for hashline edit inputs the " + "adapter recognized but could not resolve to a range (#2423).", "Computed fresh from the tool input on each attempt and returned as that " + "attempt's rejection, so there is no staleness window. The adapters " + "read only the call's own arguments; nothing cached is replayed.", "live"),
+  "tool-call:duplicate-export-blocker": labeled("clients/runtime-tool-call.ts", "Duplicate-export STOP rejection returned inline with the failed edit.", "Synchronous preflight rejection computed per edit attempt; no stored state.", "live"),
+  "agent-behavior:thrashing-notice": labeled("clients/agent-behavior-client.ts", "In-result thrashing/blind-write detection notice.", "Ephemeral notice computed at detection time inside the same tool result — " + "no persistence and no cache, so nothing can be stale.", "live")
+};
+function assertPartialStatusHasReason(id, entry) {
+  if (entry.status === "partial" && !entry.partialReason) {
+    throw new Error(`finding-delivery-gate: surface "${id}" is status=partial but names no partialReason`);
+  }
+}
+function assertGatedShapeIsWellFormed(id, entry) {
+  if (!Array.isArray(entry.gates) || entry.gates.length === 0) {
+    throw new Error(`finding-delivery-gate: surface "${id}" is mode=gated but names no gate`);
+  }
+  if (!Array.isArray(entry.evidence) || entry.evidence.length === 0) {
+    throw new Error(`finding-delivery-gate: surface "${id}" is mode=gated but names no evidence`);
+  }
+}
+function assertLabeledShapeIsWellFormed(id, entry) {
+  if (!entry.reason || !entry.ageSource) {
+    throw new Error(`finding-delivery-gate: surface "${id}" is mode=labeled but is missing reason/ageSource`);
+  }
+  if (entry.ageSource !== "live" && entry.evidence.length === 0) {
+    throw new Error(`finding-delivery-gate: surface "${id}" claims ageSource "${entry.ageSource}" but names no evidence`);
+  }
+}
+export function assertNoDeliveryBypass(registry = DELIVERY_SURFACES) {
+  for (const [id, entry] of Object.entries(registry)) {
+    assertPartialStatusHasReason(id, entry);
+    if (entry.mode === "gated") {
+      assertGatedShapeIsWellFormed(id, entry);
+      continue;
+    }
+    if (entry.mode === "labeled") {
+      assertLabeledShapeIsWellFormed(id, entry);
+      continue;
+    }
+    throw new Error(`finding-delivery-gate: surface "${id}" has unrecognized mode ${JSON.stringify(entry.mode)} — must be "gated" or "labeled"`);
+  }
+}

package/extensions/dm-lens/dist/clients/finding-identity.js

@@ -0,0 +1,23 @@
+import { createHash } from "node:crypto";
+import * as path from "node:path";
+import { normalizeMapKey } from "./path-utils.js";
+export const FINDING_ID_HASH_LENGTH = 12;
+export function normalizeMessage(message) {
+  return message.replace(/\s+/g, " ").trim().toLowerCase();
+}
+export function hashText(value, length = FINDING_ID_HASH_LENGTH) {
+  return createHash("sha256").update(value).digest("hex").slice(0, length);
+}
+export function relativeFile(filePath, cwd) {
+  const canonicalCwd = normalizeMapKey(cwd);
+  const canonicalFile = normalizeMapKey(filePath);
+  const rel = path.relative(canonicalCwd, canonicalFile).replace(/\\/g, "/");
+  return rel && !rel.startsWith("..") ? rel : canonicalFile;
+}
+export function stableFindingId(prefix, args) {
+  const joined = [
+    relativeFile(args.filePath, args.cwd),
+    ...args.parts.map((part) => part === undefined || part === null ? "" : String(part))
+  ].join("|");
+  return `${prefix}${hashText(joined)}`;
+}

package/extensions/dm-lens/dist/clients/fix-run-restore.js

@@ -0,0 +1,413 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import { writeFileAtomicAsync } from "./atomic-write.js";
+import { incrementDegradationCount, recordDegradationOnce } from "./degradation-ledger.js";
+import { withHostFileMutationQueue } from "./file-mutation-queue.js";
+import { logLatency } from "./latency-logger.js";
+import { normalizeMapKey } from "./path-utils.js";
+import { getProcessSingleton } from "./process-singletons.js";
+import { compareOrdinal } from "./string-utils.js";
+export const FIX_RUN_MAX_FILE_BYTES = 1024 * 1024;
+export const FIX_RUN_HASH_BYTE_BUDGET = 64 * 1024 * 1024;
+const HASH_CONCURRENCY = 32;
+export async function runWithFixRestore(args, run, afterRun) {
+  const fixRun = await beginFixRun(args);
+  let finished;
+  let outcome;
+  try {
+    const value = await run();
+    finished = fixRun.finish();
+    outcome = { result: await afterRun(value, finished.agentEdited) };
+  } catch (failure) {
+    outcome = { failure };
+  }
+  const restoring = (finished ?? fixRun.finish()).restore();
+  if ("failure" in outcome) {
+    throw outcome.failure;
+  }
+  return { result: outcome.result, restoring };
+}
+const REGISTRY_FAMILY = "fix-run-restore";
+const REGISTRY_VERSION = 2;
+function registry() {
+  return getProcessSingleton(REGISTRY_FAMILY, REGISTRY_VERSION, () => ({
+    active: new Set,
+    pendingCalls: new Map
+  }));
+}
+function sha256(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+export async function beginFixRun(args) {
+  const startedAt = Date.now();
+  const files = new Map;
+  const run = { files, calls: new Map };
+  const wanted = [];
+  for (const candidate of args.candidates)
+    if (candidate.endsWith(args.extension))
+      wanted.push(candidate);
+  wanted.sort(compareOrdinal);
+  const budget = args.byteBudget ?? FIX_RUN_HASH_BYTE_BUDGET;
+  let remaining = budget;
+  let hashedBytes = 0;
+  let cut = 0;
+  for (let i = 0;i < wanted.length; i += HASH_CONCURRENCY) {
+    const batch = wanted.slice(i, i + HASH_CONCURRENCY);
+    const read = await Promise.all(batch.map(async (candidate) => {
+      try {
+        const stat = await fs.promises.stat(candidate);
+        if (stat.size > FIX_RUN_MAX_FILE_BYTES || stat.size > remaining)
+          return;
+        remaining -= stat.size;
+        return { candidate, bytes: await fs.promises.readFile(candidate) };
+      } catch {
+        return;
+      }
+    }));
+    for (const entry of read) {
+      if (!entry) {
+        cut += 1;
+        continue;
+      }
+      hashedBytes += entry.bytes.length;
+      files.set(normalizeMapKey(entry.candidate), {
+        filePath: entry.candidate,
+        hash: sha256(entry.bytes)
+      });
+    }
+  }
+  logLatency({
+    type: "phase",
+    filePath: "<dm-lens>",
+    phase: "fix_run_hash",
+    durationMs: Date.now() - startedAt,
+    metadata: {
+      tool: args.tool,
+      files: files.size,
+      bytes: hashedBytes,
+      cut,
+      byteBudget: budget
+    }
+  });
+  if (cut > 0) {
+    recordDegradationOnce({
+      kind: "fix-run-scope-truncated",
+      subject: args.tool,
+      reason: `${cut} of ${wanted.length} ${args.extension} file(s) were not hashed (unreadable, over ${FIX_RUN_MAX_FILE_BYTES} bytes, or past the ${budget}-byte budget); an agent edit to one of them during the run is not protected`
+    });
+  }
+  const { active } = registry();
+  active.add(run);
+  for (const [toolCallId, call] of registry().pendingCalls) {
+    if (run.files.has(call.key))
+      run.calls.set(toolCallId, call);
+  }
+  return {
+    finish() {
+      return {
+        agentEdited: [...files.values()].flatMap((file) => file.capture ? [file.filePath] : []),
+        restore: () => restoreRun(args.tool, run, active)
+      };
+    }
+  };
+}
+function callsOn(run, key, exceptId) {
+  const calls = [];
+  for (const [id, call] of run.calls)
+    if (id !== exceptId && call.key === key)
+      calls.push(call);
+  return calls;
+}
+function unverifiedInFlight(run, key, current) {
+  return callsOn(run, key).some((call) => verdictFor(current, call.expected) !== "verified");
+}
+function coversContradiction(captured, own, text) {
+  for (const edit of captured) {
+    const added = normalized(edit.newText);
+    const removed = normalized(edit.oldText ?? "");
+    if (added.length > 0 && !text.includes(added) && !own.some((stated) => normalized(stated.oldText ?? "").includes(added)))
+      return false;
+    if (removed.length > 0 && !added.includes(removed) && text.includes(removed) && !own.some((stated) => normalized(stated.newText).includes(removed)))
+      return false;
+  }
+  return true;
+}
+function covers(stated, own, disk, text) {
+  if (!own || verdictFor(disk, own) !== "verified")
+    return false;
+  if (own.content !== undefined)
+    return true;
+  if (stated.content !== undefined)
+    return false;
+  return coversContradiction(stated.edits ?? [], own.edits ?? [], text);
+}
+function accountedByOwnCall(run, key, stated, disk, exceptId) {
+  if (!stated)
+    return false;
+  const text = normalized(disk.toString("utf8"));
+  for (const call of callsOn(run, key, exceptId))
+    if (covers(stated, call.expected, disk, text))
+      return true;
+  return false;
+}
+function captureVerdict(run, key, bytes, expected) {
+  const verdict = verdictFor(bytes, expected);
+  return verdict === "overwritten" && accountedByOwnCall(run, key, expected, bytes) ? "accounted" : verdict;
+}
+function keepsNewerCapture(stated, verdict, bytes, old) {
+  if (verdict !== "overwritten")
+    return false;
+  if (old?.verdict !== "verified" || !old.bytes.equals(bytes))
+    return false;
+  const own = old.expected;
+  if (!stated || !own || own.content !== undefined || stated.content !== undefined)
+    return false;
+  return coversContradiction(stated.edits ?? [], own.edits ?? [], normalized(bytes.toString("utf8")));
+}
+function name(list, filePath) {
+  if (!list.includes(filePath))
+    list.push(filePath);
+}
+async function restoreRun(tool, run, active) {
+  const report = {
+    restored: [],
+    lost: [],
+    possiblyLost: [],
+    agentEdited: []
+  };
+  const skipped = [];
+  const startedAt = Date.now();
+  let queueWaitMs = 0;
+  try {
+    for (const [key, file] of run.files) {
+      if (!file.capture) {
+        if (callsOn(run, key).length > 0) {
+          report.agentEdited.push(file.filePath);
+          const current = await fs.promises.readFile(file.filePath).catch(() => {
+            return;
+          });
+          if (!current || unverifiedInFlight(run, key, current))
+            name(report.possiblyLost, file.filePath);
+        }
+        continue;
+      }
+      report.agentEdited.push(file.filePath);
+      const requestedAt = Date.now();
+      try {
+        await withHostFileMutationQueue(file.filePath, () => {
+          queueWaitMs += Date.now() - requestedAt;
+          return restoreFile(run, key, file, report, skipped);
+        });
+      } catch {
+        name(report.lost, file.filePath);
+      }
+    }
+  } finally {
+    active.delete(run);
+  }
+  if (report.agentEdited.length > 0) {
+    logLatency({
+      type: "phase",
+      filePath: "<dm-lens>",
+      phase: "fix_run_restore",
+      durationMs: Date.now() - startedAt,
+      metadata: {
+        tool,
+        files: report.agentEdited.length,
+        restored: report.restored.length,
+        lost: report.lost.length,
+        possiblyLost: report.possiblyLost.length,
+        queueWaitMs
+      }
+    });
+  }
+  if (skipped.length > 0) {
+    incrementDegradationCount({
+      kind: "fix-run-restore-skipped-newer-edit",
+      subject: tool,
+      reason: `${tool}'s restore left ${skipped.length} file(s) alone because a newer agent edit may have won, and named them as possibly lost (${skipped.slice(0, 5).join(", ")})`
+    });
+  }
+  if (report.restored.length > 0 || report.lost.length > 0 || report.possiblyLost.length > 0) {
+    const named = [...report.restored, ...report.lost, ...report.possiblyLost];
+    incrementDegradationCount({
+      kind: "fix-run-agent-edit-overwritten",
+      subject: tool,
+      reason: `${tool} rewrote files an agent edited during the run: ${report.restored.length} restored, ${report.lost.length} lost, ${report.possiblyLost.length} possibly lost (${named.slice(0, 5).join(", ")})`
+    });
+  }
+  return report;
+}
+async function restoreFile(run, key, file, report, skipped) {
+  const capture = file.capture;
+  if (!capture)
+    return;
+  if (file.superseded === "overwritten")
+    name(report.lost, file.filePath);
+  else if (file.superseded === "unverifiable")
+    name(report.possiblyLost, file.filePath);
+  let current;
+  try {
+    current = await fs.promises.readFile(file.filePath);
+  } catch {
+    return;
+  }
+  if (capture.verdict === "overwritten") {
+    name(report.lost, file.filePath);
+    return;
+  }
+  const unchanged = current.equals(capture.bytes);
+  if (callsOn(run, key).length > 0) {
+    if (!unchanged || capture.verdict === "unverifiable" || unverifiedInFlight(run, key, current))
+      name(report.possiblyLost, file.filePath);
+    if (!unchanged)
+      skipped.push(file.filePath);
+    return;
+  }
+  if (capture.verdict === "unverifiable")
+    name(report.possiblyLost, file.filePath);
+  if (unchanged)
+    return;
+  let again;
+  try {
+    again = await fs.promises.readFile(file.filePath);
+  } catch {
+    return;
+  }
+  if (!again.equals(current)) {
+    name(report.possiblyLost, file.filePath);
+    skipped.push(file.filePath);
+    return;
+  }
+  await writeFileAtomicAsync(file.filePath, capture.bytes, {
+    bestEffort: false
+  });
+  report.restored.push(file.filePath);
+}
+export function noteAgentMutation(filePath, expected) {
+  const { active } = registry();
+  if (active.size === 0)
+    return;
+  let key;
+  for (const run of active) {
+    key ??= normalizeMapKey(filePath);
+    const file = run.files.get(key);
+    if (!file)
+      continue;
+    try {
+      const bytes = fs.readFileSync(file.filePath);
+      if (sha256(bytes) === file.hash) {
+        delete file.capture;
+        continue;
+      }
+      const old = file.capture;
+      const verdict = captureVerdict(run, key, bytes, expected);
+      if (old && (old.verdict === "overwritten" || !old.bytes.equals(bytes) && (old.verdict === "unverifiable" || old.displaced)))
+        file.superseded = file.superseded === "overwritten" || old.verdict === "overwritten" ? "overwritten" : "unverifiable";
+      if (!keepsNewerCapture(expected, verdict, bytes, old))
+        file.capture = { bytes, verdict, expected };
+    } catch {
+      delete file.capture;
+    }
+  }
+}
+export function noteAgentCallStart(toolCallId, filePath, expected) {
+  if (toolCallId === undefined)
+    return;
+  const { active } = registry();
+  const key = normalizeMapKey(filePath);
+  if (registry().pendingCalls.size < 256)
+    registry().pendingCalls.set(toolCallId, { key, expected });
+  else
+    recordDegradationOnce({
+      kind: "fix-run-pending-call-cap",
+      subject: "fix-run-restore",
+      reason: "more than 256 agent mutation calls were in flight before a fixer run; later calls were not carried into the run"
+    });
+  for (const run of active) {
+    const file = run.files.get(key);
+    if (!file)
+      continue;
+    run.calls.set(toolCallId, { key, expected });
+    const capture = file.capture;
+    if (!capture)
+      continue;
+    try {
+      const disk = fs.readFileSync(file.filePath);
+      if (verdictFor(disk, capture.expected) !== "verified" && !accountedByOwnCall(run, key, capture.expected, disk, toolCallId))
+        capture.displaced = true;
+    } catch {}
+  }
+}
+export function noteAgentCallEnd(toolCallId) {
+  if (toolCallId === undefined)
+    return;
+  const { active } = registry();
+  registry().pendingCalls.delete(toolCallId);
+  for (const run of active)
+    run.calls.delete(toolCallId);
+}
+function normalized(text) {
+  return text.replace(/\r\n/g, `
+`);
+}
+function verdictFor(bytes, expected) {
+  if (!expected)
+    return "unverifiable";
+  const text = normalized(bytes.toString("utf8"));
+  if (expected.content !== undefined)
+    return text === normalized(expected.content) ? "verified" : "overwritten";
+  const edits = expected.edits ?? [];
+  let checkable = 0;
+  for (const edit of edits) {
+    const added = normalized(edit.newText);
+    const removed = normalized(edit.oldText ?? "");
+    let checked = false;
+    if (added.length > 0) {
+      checked = true;
+      if (!text.includes(added))
+        return "overwritten";
+    }
+    if (removed.length > 0 && !added.includes(removed)) {
+      checked = true;
+      if (text.includes(removed))
+        return "overwritten";
+    }
+    if (checked)
+      checkable += 1;
+  }
+  return edits.length > 0 && checkable === edits.length ? "verified" : "unverifiable";
+}
+export function expectationFromToolInput(input, kind) {
+  const args = input;
+  if (kind === "write")
+    return typeof args?.content === "string" ? { content: args.content } : undefined;
+  const raw = Array.isArray(args?.edits) ? args.edits : [args];
+  const edits = raw.flatMap((edit) => {
+    const pair = edit;
+    if (typeof pair?.newText !== "string")
+      return [];
+    return [
+      {
+        newText: pair.newText,
+        ...typeof pair.oldText === "string" && { oldText: pair.oldText }
+      }
+    ];
+  });
+  return edits.length > 0 ? { edits } : undefined;
+}
+export function renderFixRunLoss(loss) {
+  const list = (files) => files.slice(0, 8).map((file) => `  - ${file}`).join(`
+`) + (files.length > 8 ? `
+  - ... and ${files.length - 8} more` : "");
+  const parts = [];
+  if (loss.lost.length > 0)
+    parts.push(`⚠️ **An auto-fix run overwrote your edit to ${loss.lost.length === 1 ? "this file" : "these files"} while it ran, and dm-lens could not restore it. Re-read ${loss.lost.length === 1 ? "it" : "each"} and re-apply your change:**
+${list(loss.lost)}`);
+  if (loss.possiblyLost.length > 0)
+    parts.push(`⚠️ **An auto-fix run rewrote ${loss.possiblyLost.length === 1 ? "this file" : "these files"} while you were editing, and dm-lens cannot confirm your edit survived. Re-read ${loss.possiblyLost.length === 1 ? "it" : "each"} and re-apply your change if it is missing:**
+${list(loss.possiblyLost)}`);
+  return parts.join(`
+
+`);
+}

package/extensions/dm-lens/dist/clients/fix-worklog.js

@@ -0,0 +1,75 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { getProjectDataDir } from "./file-utils.js";
+import { redactSecrets } from "./redact/secrets.js";
+export function getWorklogPath(cwd) {
+  return path.join(getProjectDataDir(cwd), "worklog.jsonl");
+}
+export function appendToWorklog(cwd, diagnostics, autoFixed, identity) {
+  if (diagnostics.length === 0)
+    return;
+  const worklogPath = getWorklogPath(cwd);
+  try {
+    fs.mkdirSync(path.dirname(worklogPath), { recursive: true });
+    const timestamp = new Date().toISOString();
+    const model = identity?.model?.trim() || undefined;
+    const provider = identity?.provider?.trim() || undefined;
+    const lines = diagnostics.map((d) => {
+      const entry = {
+        timestamp,
+        filePath: d.filePath,
+        rule: d.rule ?? d.id ?? "unknown",
+        tool: d.tool,
+        message: d.message,
+        line: d.line ?? 1,
+        column: d.column,
+        fixable: d.fixable ?? false,
+        fixSuggestion: d.fixSuggestion,
+        autoFixed,
+        model,
+        provider
+      };
+      return JSON.stringify(entry);
+    }).join(`
+`) + `
+`;
+    fs.appendFileSync(worklogPath, redactSecrets(lines), "utf8");
+  } catch {}
+}
+export function readWorklog(cwd) {
+  const worklogPath = getWorklogPath(cwd);
+  try {
+    const raw = fs.readFileSync(worklogPath, "utf8");
+    return raw.split(/\r?\n/).filter(Boolean).flatMap((line) => {
+      try {
+        return [JSON.parse(line)];
+      } catch {
+        return [];
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+export function summarizeWorklog(cwd) {
+  const entries = readWorklog(cwd);
+  const byRule = new Map;
+  let totalAutoFixed = 0;
+  let totalFixable = 0;
+  for (const e of entries) {
+    const r = byRule.get(e.rule) ?? { count: 0, autoFixed: 0 };
+    r.count++;
+    if (e.autoFixed) {
+      r.autoFixed++;
+      totalAutoFixed++;
+    }
+    if (e.fixable)
+      totalFixable++;
+    byRule.set(e.rule, r);
+  }
+  return {
+    totalAutoFixed,
+    totalFixable,
+    byRule: [...byRule.entries()].map(([rule, v]) => ({ rule, ...v })).sort((a, b) => b.count - a.count)
+  };
+}