@duckmind/dm-linux-x64 0.65.5 → 0.65.6

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

@@ -0,0 +1,129 @@
+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`;
+}
+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.", ["gateFindingsByPathFreshness", "applyPushedFindingPolicy"], ['"late-runner-findings"'], { 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 — no stored state is delivered, so nothing can go stale between " + "detection and delivery.", "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-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)
+  };
+}

package/extensions/dm-lens/dist/clients/format-events-publish.js

@@ -0,0 +1,230 @@
+import { logBusEvent } from "./bus-events-logger.js";
+import { isBusPublishEnabled } from "./bus-publish.js";
+import { normalizeFilePath } from "./path-utils.js";
+import { createLiveBusEmitter, recordStaleBusFailure, resolveLiveBusEmitter } from "./live-bus-emitter.js";
+export const BUS_FORMAT_QUEUED_EVENT = "dmlens:format:queued";
+export const BUS_FORMAT_QUEUED_VERSION = 1;
+export const BUS_FORMAT_START_EVENT = "dmlens:format:start";
+export const BUS_FORMAT_START_VERSION = 1;
+export const BUS_AUTOFIX_START_EVENT = "dmlens:autofix:start";
+export const BUS_AUTOFIX_START_VERSION = 1;
+const liveEmitter = createLiveBusEmitter();
+let hasLoggedQueuedFailure = false;
+let hasLoggedQueuedUnwired = false;
+let hasLoggedQueuedDisabled = false;
+let hasLoggedStartFailure = false;
+let hasLoggedStartUnwired = false;
+let hasLoggedStartDisabled = false;
+let hasLoggedAutofixStartFailure = false;
+let hasLoggedAutofixStartUnwired = false;
+let hasLoggedAutofixStartDisabled = false;
+export function wireFormatEventsBusEmitter(emitFn) {
+  liveEmitter.wire(emitFn);
+}
+export function wireFormatEventsBusEmitterGetter(getter) {
+  liveEmitter.wireGetter(getter);
+}
+export function _resetFormatEventsPublishForTests() {
+  liveEmitter.reset();
+  hasLoggedQueuedFailure = false;
+  hasLoggedQueuedUnwired = false;
+  hasLoggedQueuedDisabled = false;
+  hasLoggedStartFailure = false;
+  hasLoggedStartUnwired = false;
+  hasLoggedStartDisabled = false;
+  hasLoggedAutofixStartFailure = false;
+  hasLoggedAutofixStartUnwired = false;
+  hasLoggedAutofixStartDisabled = false;
+}
+export function publishFormatQueued(args) {
+  if (!isBusPublishEnabled()) {
+    if (!hasLoggedQueuedDisabled) {
+      hasLoggedQueuedDisabled = true;
+      logBusEvent({
+        event: BUS_FORMAT_QUEUED_EVENT,
+        outcome: "skipped_disabled",
+        cwd: normalizeFilePath(args.cwd)
+      });
+    }
+    return;
+  }
+  const resolution = resolveLiveBusEmitter(liveEmitter, () => ({
+    event: BUS_FORMAT_QUEUED_EVENT,
+    cwd: normalizeFilePath(args.cwd)
+  }));
+  if (resolution.outcome === "stale-session")
+    return;
+  if (resolution.outcome === "unwired") {
+    if (!hasLoggedQueuedUnwired) {
+      hasLoggedQueuedUnwired = true;
+      logBusEvent({
+        event: BUS_FORMAT_QUEUED_EVENT,
+        outcome: "skipped_unwired",
+        cwd: normalizeFilePath(args.cwd)
+      });
+    }
+    return;
+  }
+  const busEmit = resolution.emit;
+  try {
+    const payload = {
+      v: BUS_FORMAT_QUEUED_VERSION,
+      source: "dm-lens",
+      filePath: normalizeFilePath(args.filePath),
+      cwd: normalizeFilePath(args.cwd),
+      tool: args.tool,
+      kinds: args.kinds
+    };
+    busEmit(BUS_FORMAT_QUEUED_EVENT, payload);
+    hasLoggedQueuedFailure = false;
+    logBusEvent({
+      event: BUS_FORMAT_QUEUED_EVENT,
+      outcome: "emitted",
+      cwd: payload.cwd,
+      fileCount: 1
+    });
+  } catch (err) {
+    logBusEvent({
+      event: BUS_FORMAT_QUEUED_EVENT,
+      outcome: "emit_failed",
+      cwd: normalizeFilePath(args.cwd),
+      error: String(err),
+      ctxSource: resolution.ctxSource
+    });
+    if (!hasLoggedQueuedFailure) {
+      hasLoggedQueuedFailure = true;
+      recordStaleBusFailure(BUS_FORMAT_QUEUED_EVENT, err);
+      args.dbg?.(`format-events-publish: dmlens:format:queued emit failed (further failures suppressed): ${err}`);
+    }
+  }
+}
+export function publishFormatStart(args) {
+  if (args.paths.length === 0)
+    return;
+  if (!isBusPublishEnabled()) {
+    if (!hasLoggedStartDisabled) {
+      hasLoggedStartDisabled = true;
+      logBusEvent({
+        event: BUS_FORMAT_START_EVENT,
+        outcome: "skipped_disabled",
+        cwd: normalizeFilePath(args.cwd)
+      });
+    }
+    return;
+  }
+  const resolution = resolveLiveBusEmitter(liveEmitter, () => ({
+    event: BUS_FORMAT_START_EVENT,
+    cwd: normalizeFilePath(args.cwd)
+  }));
+  if (resolution.outcome === "stale-session")
+    return;
+  if (resolution.outcome === "unwired") {
+    if (!hasLoggedStartUnwired) {
+      hasLoggedStartUnwired = true;
+      logBusEvent({
+        event: BUS_FORMAT_START_EVENT,
+        outcome: "skipped_unwired",
+        cwd: normalizeFilePath(args.cwd)
+      });
+    }
+    return;
+  }
+  const busEmit = resolution.emit;
+  try {
+    const paths = args.paths.map((p) => normalizeFilePath(p));
+    const payload = {
+      v: BUS_FORMAT_START_VERSION,
+      source: "dm-lens",
+      cwd: normalizeFilePath(args.cwd),
+      paths,
+      fileCount: paths.length,
+      kinds: args.kinds ?? ["format"]
+    };
+    busEmit(BUS_FORMAT_START_EVENT, payload);
+    hasLoggedStartFailure = false;
+    logBusEvent({
+      event: BUS_FORMAT_START_EVENT,
+      outcome: "emitted",
+      cwd: payload.cwd,
+      fileCount: payload.fileCount
+    });
+  } catch (err) {
+    logBusEvent({
+      event: BUS_FORMAT_START_EVENT,
+      outcome: "emit_failed",
+      cwd: normalizeFilePath(args.cwd),
+      error: String(err),
+      ctxSource: resolution.ctxSource
+    });
+    if (!hasLoggedStartFailure) {
+      hasLoggedStartFailure = true;
+      recordStaleBusFailure(BUS_FORMAT_START_EVENT, err);
+      args.dbg?.(`format-events-publish: dmlens:format:start emit failed (further failures suppressed): ${err}`);
+    }
+  }
+}
+export function publishAutofixStart(args) {
+  if (args.paths.length === 0)
+    return;
+  if (!isBusPublishEnabled()) {
+    if (!hasLoggedAutofixStartDisabled) {
+      hasLoggedAutofixStartDisabled = true;
+      logBusEvent({
+        event: BUS_AUTOFIX_START_EVENT,
+        outcome: "skipped_disabled",
+        cwd: normalizeFilePath(args.cwd)
+      });
+    }
+    return;
+  }
+  const resolution = resolveLiveBusEmitter(liveEmitter, () => ({
+    event: BUS_AUTOFIX_START_EVENT,
+    cwd: normalizeFilePath(args.cwd)
+  }));
+  if (resolution.outcome === "stale-session")
+    return;
+  if (resolution.outcome === "unwired") {
+    if (!hasLoggedAutofixStartUnwired) {
+      hasLoggedAutofixStartUnwired = true;
+      logBusEvent({
+        event: BUS_AUTOFIX_START_EVENT,
+        outcome: "skipped_unwired",
+        cwd: normalizeFilePath(args.cwd)
+      });
+    }
+    return;
+  }
+  const busEmit = resolution.emit;
+  try {
+    const paths = args.paths.map((p) => normalizeFilePath(p));
+    const payload = {
+      v: BUS_AUTOFIX_START_VERSION,
+      source: "dm-lens",
+      cwd: normalizeFilePath(args.cwd),
+      paths,
+      fileCount: paths.length,
+      eligibleCount: args.eligibleCount
+    };
+    busEmit(BUS_AUTOFIX_START_EVENT, payload);
+    hasLoggedAutofixStartFailure = false;
+    logBusEvent({
+      event: BUS_AUTOFIX_START_EVENT,
+      outcome: "emitted",
+      cwd: payload.cwd,
+      fileCount: payload.fileCount
+    });
+  } catch (err) {
+    logBusEvent({
+      event: BUS_AUTOFIX_START_EVENT,
+      outcome: "emit_failed",
+      cwd: normalizeFilePath(args.cwd),
+      error: String(err),
+      ctxSource: resolution.ctxSource
+    });
+    if (!hasLoggedAutofixStartFailure) {
+      hasLoggedAutofixStartFailure = true;
+      recordStaleBusFailure(BUS_AUTOFIX_START_EVENT, err);
+      args.dbg?.(`format-events-publish: dmlens:autofix:start emit failed (further failures suppressed): ${err}`);
+    }
+  }
+}

package/extensions/dm-lens/dist/clients/format-service.js

@@ -0,0 +1,154 @@
+import { logExtension } from "./extension-log.js";
+import * as path from "node:path";
+import { recordFormatter } from "./widget-state.js";
+import { FileTime } from "./file-time.js";
+import { loadFormatters } from "./formatters-lazy.js";
+import { bounded } from "./deadline-utils.js";
+const DEFAULT_FORMATTER_CONCURRENCY = 1;
+
+export class FormatService {
+  fileTime;
+  enabled;
+  constructor(sessionID, enabled = true) {
+    this.fileTime = new FileTime(sessionID);
+    this.enabled = enabled;
+  }
+  async formatFile(filePath, options = {}) {
+    const absolutePath = path.resolve(filePath);
+    const cwd = path.dirname(absolutePath);
+    if (options.skip || !this.enabled) {
+      return {
+        filePath: absolutePath,
+        formatters: [],
+        anyChanged: false,
+        allSucceeded: true
+      };
+    }
+    if (this.fileTime.hasChanged(absolutePath)) {
+      logExtension({
+        subsystem: "format",
+        level: "warn",
+        message: `File ${absolutePath} modified externally, skipping format`,
+        metadata: { filePath: absolutePath }
+      });
+      return {
+        filePath: absolutePath,
+        formatters: [],
+        anyChanged: false,
+        allSucceeded: false
+      };
+    }
+    const formatters = options.formatters ? await this.getFormattersByName(options.formatters) : await (await loadFormatters()).getFormattersForFile(absolutePath, cwd);
+    if (formatters.length === 0) {
+      return {
+        filePath: absolutePath,
+        formatters: [],
+        anyChanged: false,
+        allSucceeded: true
+      };
+    }
+    const results = await this.runFormattersWithConcurrency(absolutePath, formatters, DEFAULT_FORMATTER_CONCURRENCY, options.signal, options.budgetMs, options.hook);
+    this.fileTime.read(absolutePath);
+    for (const [index, result] of results.entries()) {
+      recordFormatter(absolutePath, formatters[index]?.name ?? "unknown", result.changed, result.success, result.outcome);
+    }
+    const anyChanged = results.some((r) => r.changed);
+    const allSucceeded = results.every((r) => r.success);
+    return {
+      filePath: absolutePath,
+      formatters: results.map((r, i) => ({
+        name: formatters[i].name,
+        success: r.success,
+        changed: r.changed,
+        ...r.error === undefined ? {} : { error: r.error },
+        outcome: r.outcome
+      })),
+      anyChanged,
+      allSucceeded
+    };
+  }
+  async runFormattersWithConcurrency(filePath, formatters, _concurrency = DEFAULT_FORMATTER_CONCURRENCY, signal, budgetMs = 30000, hook = "tool_result_edit") {
+    const results = [];
+    const startedAt = Date.now();
+    for (const formatter of formatters) {
+      const remainingMs = budgetMs - (Date.now() - startedAt);
+      if (remainingMs <= 0) {
+        results.push({
+          success: false,
+          changed: false,
+          outcome: "failed",
+          error: `Formatter aggregate budget exhausted before ${formatter.name}`
+        });
+        continue;
+      }
+      try {
+        const result = await bounded(loadFormatters().then(({ formatFile }) => formatFile(filePath, formatter)), {
+          ms: remainingMs,
+          signal,
+          hook,
+          label: "formatter-aggregate"
+        });
+        if (result)
+          results.push(result);
+        else if (signal?.aborted) {
+          break;
+        } else {
+          results.push({
+            success: false,
+            changed: false,
+            outcome: "failed",
+            error: `Formatter ${formatter.name} exceeded aggregate budget`
+          });
+          break;
+        }
+      } catch (error) {
+        results.push({
+          success: false,
+          changed: false,
+          outcome: "failed",
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return results;
+  }
+  async getFormattersByName(names) {
+    const { listAllFormatters, ...formatters } = await loadFormatters();
+    const allNames = listAllFormatters();
+    return names.filter((name) => allNames.includes(name)).map((name) => {
+      const camel = name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+      const key = `${camel}Formatter`;
+      return formatters[key];
+    }).filter(Boolean);
+  }
+  assertUnchanged(filePath) {
+    this.fileTime.assert(filePath);
+  }
+  hasChanged(filePath) {
+    return this.fileTime.hasChanged(filePath);
+  }
+  recordRead(filePath) {
+    this.fileTime.read(filePath);
+  }
+  clearCache() {
+    loadFormatters().then(({ clearFormatterRuntimeState }) => clearFormatterRuntimeState());
+  }
+}
+let globalFormatService = null;
+let currentSessionID = null;
+export function getFormatService(sessionID, enabled = true) {
+  const shouldCreateNew = !globalFormatService || sessionID && sessionID !== currentSessionID;
+  if (shouldCreateNew) {
+    globalFormatService = new FormatService(sessionID ?? "default", enabled);
+    currentSessionID = sessionID ?? "default";
+  }
+  return globalFormatService;
+}
+export function resetFormatService() {
+  loadFormatters().then(({ clearFormatterRuntimeState }) => clearFormatterRuntimeState());
+  globalFormatService = null;
+  currentSessionID = null;
+}
+export function clearFormatServiceAndFileState() {
+  resetFormatService();
+}

package/extensions/dm-lens/dist/clients/formatters-lazy.js

@@ -0,0 +1,8 @@
+import { createLazyImport } from "./lazy-import.js";
+const lazyFormatters = createLazyImport(() => import("./formatters.js"));
+export function warmFormatters() {
+  return lazyFormatters.get();
+}
+export function loadFormatters() {
+  return warmFormatters();
+}