@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

@@ -1,129 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,230 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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

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