@duckmind/dm-linux-x64 0.65.5 → 0.65.6

package/extensions/dm-lens/dist/clients/mutating-tool.js

@@ -0,0 +1,377 @@
+import { BoundedFifoMap } from "./bounded-cache.js";
+import { resolveHashlineAnchor } from "./hashline-anchor.js";
+import { lookupLearnedMutatingTool } from "./mutation-attribution.js";
+import { boundedIndexesForCount, createReadGuardEditBatchSummary, logReadGuardEvent } from "./read-guard-logger.js";
+const BUILTIN_MUTATING_TOOLS = new Map([
+  ["write", "write"],
+  ["edit", "edit"]
+]);
+const BLOCKED_MARKER = "\uD83D\uDD34 BLOCKED —";
+export function isMutatingToolName(toolName) {
+  return BUILTIN_MUTATING_TOOLS.has(toolName);
+}
+export function getBuiltinMutatingToolNames() {
+  return [...BUILTIN_MUTATING_TOOLS.keys()];
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" ? value : {};
+}
+function resolveMutationPath(input) {
+  for (const key of ["path", "filePath", "file_path"]) {
+    const value = input[key];
+    if (typeof value === "string" && value.length > 0)
+      return value;
+  }
+  return;
+}
+export function readMutationPathField(event) {
+  return resolveMutationPath(asRecord(event?.input));
+}
+function parseHashlineAnchor(anchor) {
+  if (typeof anchor !== "string")
+    return;
+  const trimmed = anchor.trim();
+  const separator = trimmed.indexOf(":");
+  const lineText = separator === -1 ? trimmed : trimmed.slice(0, separator);
+  if (!/^\d+$/.test(lineText))
+    return;
+  const line = Number(lineText);
+  return Number.isInteger(line) && line > 0 ? line : undefined;
+}
+function combineRanges(ranges) {
+  const starts = ranges.map(([start]) => start);
+  const ends = ranges.map(([, end]) => end);
+  return {
+    touchedLines: [Math.min(...starts), Math.max(...ends)],
+    editRanges: ranges.length > 1 ? ranges : undefined
+  };
+}
+function blockedByAdapter(args) {
+  const indexes = boundedIndexesForCount(args.operationCount);
+  const editBatchSummary = createReadGuardEditBatchSummary({
+    requestedIndexes: indexes,
+    requestedTotal: args.operationCount,
+    rejectedReasons: indexes.map((index) => ({
+      index,
+      code: "preflight_blocked"
+    })),
+    rejectedTotal: args.operationCount,
+    durationMs: 0,
+    terminalStatus: "blocked"
+  });
+  if (args.ctx.filePath && !args.ctx.recognizeOnly) {
+    logReadGuardEvent({
+      event: "edit_preflight_blocked",
+      correlationId: args.ctx.correlationId,
+      sessionId: args.ctx.sessionId,
+      filePath: args.ctx.filePath,
+      metadata: {
+        tool: "edit",
+        source: args.adapterSource,
+        reasonKind: args.reasonKind,
+        operationCount: args.operationCount,
+        errorCount: args.errors.length,
+        errors: args.errors.slice(0, 10)
+      }
+    });
+    logReadGuardEvent({
+      event: "edit_batch_summary",
+      correlationId: args.ctx.correlationId,
+      filePath: args.ctx.filePath,
+      metadata: { tool: "edit", editBatchSummary }
+    });
+  }
+  return {
+    touchedLines: undefined,
+    preflightError: `${BLOCKED_MARKER} ${args.title}
+
+${args.errors.join(`
+`)}
+
+${args.retryHint}`,
+    editBatchSummary
+  };
+}
+function logTouchedLines(args) {
+  if (!args.ctx.filePath || args.ctx.recognizeOnly)
+    return;
+  logReadGuardEvent({
+    event: "touched_lines_detected",
+    correlationId: args.ctx.correlationId,
+    sessionId: args.ctx.sessionId,
+    filePath: args.ctx.filePath,
+    metadata: {
+      tool: "edit",
+      source: args.adapterSource,
+      touchedLines: args.result.touchedLines,
+      editRanges: args.result.editRanges,
+      operationCount: args.operationCount,
+      ...args.extra
+    }
+  });
+}
+function isHashlineOperation(value) {
+  const op = asRecord(value);
+  return op.set_line !== undefined || op.replace_lines !== undefined || op.replace_symbol !== undefined;
+}
+function getHashlineOperations(input) {
+  const operations = Array.isArray(input.operations) ? input.operations : Array.isArray(input.ops) ? input.ops : isHashlineOperation(input) ? [input] : undefined;
+  if (operations === undefined || operations.length === 0)
+    return;
+  return operations.some(isHashlineOperation) ? operations : undefined;
+}
+const hashlineReadmapAdapter = (input, ctx) => {
+  const operations = getHashlineOperations(input);
+  if (operations === undefined)
+    return;
+  const ranges = [];
+  const errors = [];
+  for (let index = 0;index < operations.length; index += 1) {
+    const op = asRecord(operations[index]);
+    if (op.set_line) {
+      const payload = asRecord(op.set_line);
+      const line = parseHashlineAnchor(payload.anchor);
+      if (!line) {
+        errors.push(`operation[${index}].set_line.anchor is malformed`);
+        continue;
+      }
+      ranges.push([line, line]);
+      continue;
+    }
+    if (op.replace_lines) {
+      const payload = asRecord(op.replace_lines);
+      const start = parseHashlineAnchor(payload.start_anchor);
+      const end = parseHashlineAnchor(payload.end_anchor);
+      if (!start || !end) {
+        errors.push(`operation[${index}].replace_lines anchors are malformed`);
+        continue;
+      }
+      if (start > end) {
+        errors.push(`operation[${index}].replace_lines range is inverted`);
+        continue;
+      }
+      ranges.push([start, end]);
+      continue;
+    }
+    if (op.replace_symbol) {
+      errors.push(`operation[${index}].replace_symbol cannot be resolved safely yet; use line anchors or a native ranged edit`);
+      continue;
+    }
+    errors.push(`operation[${index}] is not a recognized hashline edit`);
+  }
+  if (errors.length > 0) {
+    const target = ctx.filePath ? `\`${ctx.filePath}\`` : "the file";
+    return blockedByAdapter({
+      adapterSource: "hashline_edit",
+      reasonKind: "unsupported_hashline_edit_target",
+      title: "Unsupported hashline edit target",
+      errors,
+      operationCount: operations.length,
+      retryHint: `Re-read ${target} to get current #line anchors, then retry using set_line / replace_lines with those anchors — or use a native ranged edit.`,
+      ctx
+    });
+  }
+  if (ranges.length === 0)
+    return;
+  const result = combineRanges(ranges);
+  logTouchedLines({
+    adapterSource: ranges.length === 1 && ranges[0][0] === ranges[0][1] ? "hashline_set_line" : "hashline_replace_lines",
+    result,
+    operationCount: operations.length,
+    ctx
+  });
+  return result;
+};
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function readHashlineProReplace(input) {
+  if (typeof input.remove_from !== "string" || typeof input.remove_to !== "string" || !isStringArray(input.replacement_lines)) {
+    return;
+  }
+  return { removeFrom: input.remove_from, removeTo: input.remove_to };
+}
+function readHashlineProInsert(input) {
+  if (typeof input.anchor !== "string" || input.anchor.length === 0)
+    return;
+  if (input.direction !== "before" && input.direction !== "after")
+    return;
+  if (!isStringArray(input.lines))
+    return;
+  return { anchor: input.anchor, direction: input.direction };
+}
+function anchorUnresolved(field, failure) {
+  return `${field}:${failure}`;
+}
+const hashlineEditProAdapter = (input, ctx) => {
+  const replace = readHashlineProReplace(input);
+  if (replace) {
+    if (ctx.recognizeOnly || !ctx.filePath) {
+      return {
+        touchedLines: undefined,
+        unresolvedReason: ctx.recognizeOnly ? "replace:recognize_only" : "replace:no_file_path"
+      };
+    }
+    const from = resolveHashlineAnchor(ctx.filePath, replace.removeFrom);
+    const to = resolveHashlineAnchor(ctx.filePath, replace.removeTo);
+    if (from.line === undefined || to.line === undefined) {
+      return {
+        touchedLines: undefined,
+        unresolvedReason: from.line === undefined ? anchorUnresolved("remove_from", from.failure ?? "anchor_not_found") : anchorUnresolved("remove_to", to.failure ?? "anchor_not_found")
+      };
+    }
+    const result = combineRanges([
+      [Math.min(from.line, to.line), Math.max(from.line, to.line)]
+    ]);
+    logTouchedLines({
+      adapterSource: "hashline_pro_replace",
+      result,
+      operationCount: 1,
+      ctx,
+      extra: {
+        anchors: [replace.removeFrom, replace.removeTo],
+        swapped: from.line > to.line
+      }
+    });
+    return result;
+  }
+  const insert = readHashlineProInsert(input);
+  if (insert) {
+    if (ctx.recognizeOnly || !ctx.filePath) {
+      return {
+        touchedLines: undefined,
+        unresolvedReason: ctx.recognizeOnly ? "insert:recognize_only" : "insert:no_file_path"
+      };
+    }
+    const anchor = resolveHashlineAnchor(ctx.filePath, insert.anchor);
+    if (anchor.line === undefined) {
+      return {
+        touchedLines: undefined,
+        unresolvedReason: anchorUnresolved("anchor", anchor.failure ?? "anchor_not_found")
+      };
+    }
+    const result = combineRanges([[anchor.line, anchor.line]]);
+    logTouchedLines({
+      adapterSource: "hashline_pro_insert",
+      result,
+      operationCount: 1,
+      ctx,
+      extra: { direction: insert.direction, anchors: [insert.anchor] }
+    });
+    return result;
+  }
+  return;
+};
+const RESOLVED_RANGE_CARRY_LIMIT = 64;
+const RESOLVED_RANGE_CARRY = new BoundedFifoMap(RESOLVED_RANGE_CARRY_LIMIT);
+function readToolCallId(event) {
+  const id = event?.toolCallId;
+  return typeof id === "string" && id.length > 0 ? id : undefined;
+}
+function carryResolvedRanges(event, result) {
+  const toolCallId = readToolCallId(event);
+  if (!toolCallId || result.touchedLines === undefined)
+    return;
+  RESOLVED_RANGE_CARRY.set(toolCallId, {
+    touchedLines: result.touchedLines,
+    editRanges: result.editRanges
+  });
+}
+function readCarriedRanges(event) {
+  const toolCallId = readToolCallId(event);
+  return toolCallId ? RESOLVED_RANGE_CARRY.get(toolCallId) : undefined;
+}
+export function _resetMutationRangeCarryForTests() {
+  RESOLVED_RANGE_CARRY.clear();
+}
+export function _carryResolvedRangesForTests(toolCallId, touchedLines) {
+  carryResolvedRanges({ toolCallId }, { touchedLines, editRanges: undefined });
+}
+export function _hasCarriedRangeForTests(toolCallId) {
+  return readCarriedRanges({ toolCallId }) !== undefined;
+}
+export const RESOLVED_RANGE_CARRY_LIMIT_FOR_TESTS = RESOLVED_RANGE_CARRY_LIMIT;
+export const MUTATION_SHAPE_ADAPTERS = [
+  { name: "hashline-readmap", kind: "edit", resolve: hashlineReadmapAdapter },
+  { name: "hashline-edit-pro", kind: "edit", resolve: hashlineEditProAdapter }
+];
+function readToolName(event) {
+  const name = event?.toolName;
+  return typeof name === "string" && name.length > 0 ? name : undefined;
+}
+export const DM_LENS_SYNTHETIC_MUTATION_FIELD = "piLensSyntheticMutation";
+export function classifyMutatingTool(event, ctx = {}) {
+  const toolName = readToolName(event);
+  if (toolName === undefined)
+    return;
+  const input = asRecord(event.input);
+  const builtinKind = BUILTIN_MUTATING_TOOLS.get(toolName);
+  const syntheticSource = event[DM_LENS_SYNTHETIC_MUTATION_FIELD];
+  const builtinProvenance = syntheticSource === "bash" ? "bash-derived" : "builtin";
+  if (builtinKind === "write") {
+    return {
+      toolName,
+      path: resolveMutationPath(input),
+      kind: "write",
+      provenance: builtinProvenance
+    };
+  }
+  for (const adapter of MUTATION_SHAPE_ADAPTERS) {
+    let resolved = adapter.resolve(input, ctx);
+    if (resolved === undefined)
+      continue;
+    if (resolved.touchedLines !== undefined) {
+      carryResolvedRanges(event, resolved);
+    } else if (!resolved.preflightError) {
+      const carried = readCarriedRanges(event);
+      if (carried)
+        resolved = { ...resolved, ...carried, unresolvedReason: undefined };
+    }
+    return {
+      toolName,
+      path: resolveMutationPath(input),
+      kind: adapter.kind,
+      touchedLines: resolved.touchedLines,
+      editRanges: resolved.editRanges,
+      preflightError: resolved.preflightError,
+      editBatchSummary: resolved.editBatchSummary,
+      unresolvedReason: resolved.unresolvedReason,
+      provenance: builtinKind !== undefined ? builtinProvenance : "declared",
+      source: adapter.name
+    };
+  }
+  if (builtinKind !== undefined) {
+    return {
+      toolName,
+      path: resolveMutationPath(input),
+      kind: builtinKind,
+      provenance: builtinProvenance
+    };
+  }
+  const learnedPath = resolveMutationPath(input);
+  if (learnedPath !== undefined) {
+    const learned = lookupLearnedMutatingTool(toolName);
+    if (learned !== undefined) {
+      return {
+        toolName,
+        path: learnedPath,
+        kind: "edit",
+        provenance: "learned",
+        source: `attribution:${learned}`
+      };
+    }
+  }
+  return;
+}
+export function classifyBridgeMutation(entry) {
+  const provenance = entry.provenance === "observed" || entry.provenance === "settled-sweep" ? entry.provenance : "bridge";
+  return {
+    toolName: entry.consumer ?? "unknown",
+    path: entry.filePath,
+    kind: entry.kind,
+    touchedLines: entry.touchedLines,
+    editRanges: entry.editRanges,
+    provenance,
+    source: provenance === "bridge" ? "mutation-bridge" : "observed-mutation"
+  };
+}

package/extensions/dm-lens/dist/clients/mutation-attribution.js

@@ -0,0 +1,168 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writeFileAtomic } from "./atomic-write.js";
+import { recordDegradationOnce } from "./degradation-ledger.js";
+import { BoundedFifoMap } from "./bounded-cache.js";
+import { getProjectDataDir } from "./file-utils.js";
+import { getProcessSingleton } from "./process-singletons.js";
+const MUTATION_ATTRIBUTION_FILE_VERSION = 1;
+export const MUTATION_ATTRIBUTION_FILE = "observed-mutating-tools.json";
+const PERSIST_AFTER_OBSERVATIONS = 2;
+export const CLEAN_OBSERVATION_ARM_LIMIT = 2;
+export const DEATTRIBUTE_AFTER_CLEAN_OBSERVATIONS = 3;
+const MUTATION_ATTRIBUTION_MAX_TOOLS = 64;
+const ATTRIBUTION_FAMILY = "mutation-attribution";
+const ATTRIBUTION_VERSION = 2;
+function state() {
+  return getProcessSingleton(ATTRIBUTION_FAMILY, ATTRIBUTION_VERSION, () => ({
+    session: new BoundedFifoMap(MUTATION_ATTRIBUTION_MAX_TOOLS),
+    fromDisk: undefined,
+    primedCwd: undefined
+  }));
+}
+function observationFor(toolName) {
+  const current = state().session.get(toolName);
+  if (current)
+    return current;
+  const created = {
+    mutating: 0,
+    clean: 0,
+    cleanRun: 0,
+    unverifiable: 0,
+    persisted: false
+  };
+  state().session.set(toolName, created);
+  return created;
+}
+function attributionFilePath(cwd) {
+  return path.join(getProjectDataDir(cwd), MUTATION_ATTRIBUTION_FILE);
+}
+function isPersistedEntry(entry) {
+  const candidate = entry;
+  return typeof candidate?.name === "string" && candidate.name.length > 0 && typeof candidate.observations === "number";
+}
+function readPersisted(cwd) {
+  try {
+    const raw = fs.readFileSync(attributionFilePath(cwd), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== MUTATION_ATTRIBUTION_FILE_VERSION)
+      return;
+    if (!Array.isArray(parsed.tools))
+      return;
+    return {
+      version: MUTATION_ATTRIBUTION_FILE_VERSION,
+      tools: parsed.tools.filter(isPersistedEntry).slice(0, MUTATION_ATTRIBUTION_MAX_TOOLS).map((entry) => ({
+        name: entry.name,
+        observations: entry.observations,
+        lastSeen: typeof entry.lastSeen === "number" ? entry.lastSeen : 0
+      }))
+    };
+  } catch {
+    return;
+  }
+}
+export function primePersistedMutationAttribution(cwd) {
+  const current = state();
+  current.primedCwd = cwd;
+  current.fromDisk = new Set;
+  if (!cwd)
+    return;
+  const file = readPersisted(cwd);
+  if (!file)
+    return;
+  for (const entry of file.tools)
+    current.fromDisk.add(entry.name);
+}
+export function lookupLearnedMutatingTool(toolName) {
+  const current = state();
+  if ((current.session.get(toolName)?.mutating ?? 0) > 0)
+    return "session";
+  return current.fromDisk?.has(toolName) === true ? "persisted" : undefined;
+}
+export function isProvisionalLearnedAttribution(toolName) {
+  const current = state();
+  if (current.fromDisk?.has(toolName) === true)
+    return false;
+  const observation = current.session.get(toolName);
+  if (!observation || observation.persisted)
+    return false;
+  return observation.mutating > 0 && observation.mutating < PERSIST_AFTER_OBSERVATIONS;
+}
+export function shouldArmObservationForTool(toolName) {
+  const observation = state().session.get(toolName);
+  if ((observation?.mutating ?? 0) > 0)
+    return isProvisionalLearnedAttribution(toolName);
+  if (state().fromDisk?.has(toolName) === true)
+    return false;
+  return (observation?.clean ?? 0) < CLEAN_OBSERVATION_ARM_LIMIT;
+}
+export function noteObservedMutation(toolName, cwd) {
+  const observation = observationFor(toolName);
+  observation.mutating += 1;
+  observation.clean = 0;
+  observation.cleanRun = 0;
+  recordDegradationOnce({
+    kind: "unclassified-mutating-tool",
+    subject: toolName,
+    reason: "tool mutated a tracked file but matched no built-in name and no mutation shape adapter; classified by disk observation (#2430)"
+  });
+  let persisted = false;
+  if (observation.mutating >= PERSIST_AFTER_OBSERVATIONS && !observation.persisted) {
+    persisted = persistAttribution(toolName, cwd, observation.mutating);
+    observation.persisted = persisted;
+  }
+  return { observations: observation.mutating, persisted };
+}
+export function noteObservedClean(toolName) {
+  const observation = observationFor(toolName);
+  observation.clean += 1;
+  observation.cleanRun += 1;
+  if (observation.mutating > 0 && !observation.persisted && observation.cleanRun >= DEATTRIBUTE_AFTER_CLEAN_OBSERVATIONS) {
+    observation.mutating = 0;
+    observation.clean = 0;
+    observation.cleanRun = 0;
+  }
+}
+export function noteObservedUnverifiable(toolName) {
+  const observation = observationFor(toolName);
+  observation.unverifiable += 1;
+  observation.cleanRun = 0;
+}
+function persistAttribution(toolName, cwd, observations) {
+  const root = cwd ?? state().primedCwd;
+  if (!root)
+    return false;
+  try {
+    const existing = readPersisted(root) ?? {
+      version: MUTATION_ATTRIBUTION_FILE_VERSION,
+      tools: []
+    };
+    const tools = existing.tools.filter((entry) => entry.name !== toolName);
+    tools.push({ name: toolName, observations, lastSeen: Date.now() });
+    tools.sort((a, b) => a.lastSeen - b.lastSeen);
+    const bounded = tools.slice(-MUTATION_ATTRIBUTION_MAX_TOOLS);
+    const dir = getProjectDataDir(root);
+    fs.mkdirSync(dir, { recursive: true });
+    writeFileAtomic(path.join(dir, MUTATION_ATTRIBUTION_FILE), JSON.stringify({
+      version: MUTATION_ATTRIBUTION_FILE_VERSION,
+      tools: bounded
+    }));
+    state().fromDisk?.add(toolName);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export function resetMutationAttribution() {
+  const current = state();
+  current.session.clear();
+  current.fromDisk = undefined;
+  current.primedCwd = undefined;
+}
+export function _mutationAttributionSnapshotForTests() {
+  const current = state();
+  return {
+    session: current.session.entriesArray().map(([name, obs]) => [name, { ...obs }]),
+    fromDisk: current.fromDisk ? [...current.fromDisk] : undefined
+  };
+}

package/extensions/dm-lens/dist/clients/mutation-bridge.js

@@ -0,0 +1,102 @@
+import { classifyBridgeMutation } from "./mutating-tool.js";
+import { noteMutationHandled } from "./observed-mutation.js";
+import { getProcessBridge, registerProcessBridge } from "./process-bridge.js";
+export const MUTATION_BRIDGE_KEY = Symbol.for("dm-lens:mutation-bridge");
+function isValidRange(value) {
+  if (!Array.isArray(value) || value.length !== 2)
+    return false;
+  const [start, end] = value;
+  return typeof start === "number" && typeof end === "number" && Number.isInteger(start) && Number.isInteger(end) && start >= 1 && end >= start;
+}
+export function isValidMutationEntry(entry) {
+  if (typeof entry !== "object" || entry === null)
+    return false;
+  const e = entry;
+  if (typeof e["filePath"] !== "string" || e["filePath"] === "")
+    return false;
+  const kind = e["kind"];
+  if (kind !== "write" && kind !== "edit")
+    return false;
+  if (e["touchedLines"] !== undefined && !isValidRange(e["touchedLines"]))
+    return false;
+  const editRanges = e["editRanges"];
+  if (editRanges !== undefined) {
+    if (!Array.isArray(editRanges) || editRanges.length === 0)
+      return false;
+    if (!editRanges.every(isValidRange))
+      return false;
+  }
+  if (e["consumer"] !== undefined && typeof e["consumer"] !== "string")
+    return false;
+  if (e["importsChanged"] !== undefined && typeof e["importsChanged"] !== "boolean")
+    return false;
+  if (e["deferAutofix"] !== undefined && typeof e["deferAutofix"] !== "boolean")
+    return false;
+  const provenance = e["provenance"];
+  if (provenance !== undefined && provenance !== "observed" && provenance !== "settled-sweep")
+    return false;
+  return true;
+}
+function resolveChangedRange(classification, deps, filePath) {
+  if (classification.touchedLines) {
+    const [start, end] = classification.touchedLines;
+    return { start, end };
+  }
+  if (classification.editRanges && classification.editRanges.length > 0) {
+    const starts = classification.editRanges.map(([start]) => start);
+    const ends = classification.editRanges.map(([, end]) => end);
+    return { start: Math.min(...starts), end: Math.max(...ends) };
+  }
+  return { start: 1, end: Math.max(1, deps.countFileLines(filePath)) };
+}
+export function recordMutationThroughSeam(entry, deps) {
+  if (!isValidMutationEntry(entry)) {
+    deps.dbg?.("mutation_bridge: dropped malformed entry");
+    return false;
+  }
+  if (!deps.isRecordable(entry.filePath)) {
+    deps.dbg?.(`mutation_bridge: out of scope ${entry.filePath}`);
+    return false;
+  }
+  const classification = classifyBridgeMutation(entry);
+  const filePath = entry.filePath;
+  const runtime = deps.getRuntime();
+  const projectRoot = deps.getProjectRoot();
+  const dispatchCwd = deps.getDispatchCwd(filePath);
+  try {
+    if (deps.shouldStampReadGuard?.() ?? true) {
+      runtime.readGuard?.recordWritten?.(filePath);
+    }
+    const changedRange = resolveChangedRange(classification, deps, filePath);
+    deps.getCacheManager().addModifiedRange?.(filePath, changedRange, entry.importsChanged ?? false, projectRoot, runtime.telemetrySessionId);
+    runtime.recordProjectMutation?.({
+      filePath,
+      source: `agent-tool:${classification.toolName}`,
+      cwd: projectRoot,
+      changedRange,
+      onAppendError: (err) => deps.dbg?.(`mutation_bridge: change log append failed: ${err}`)
+    });
+    noteMutationHandled(filePath);
+    if (entry.deferAutofix !== false) {
+      for (const kind of ["autofix", "format"]) {
+        runtime.deferMutation?.(filePath, dispatchCwd, classification.toolName, projectRoot, kind, runtime.telemetrySessionId, projectRoot);
+      }
+    }
+  } catch (err) {
+    deps.dbg?.(`mutation_bridge: recording failed for ${filePath}: ${err}`);
+    return false;
+  }
+  return true;
+}
+export function registerMutationBridge(deps) {
+  registerProcessBridge(MUTATION_BRIDGE_KEY, () => ({
+    version: 1,
+    recordMutation(entry) {
+      return recordMutationThroughSeam(entry, deps);
+    }
+  }));
+}
+export function getMutationBridge() {
+  const candidate = getProcessBridge(MUTATION_BRIDGE_KEY, 1);
+  return typeof candidate?.recordMutation === "function" ? candidate : undefined;
+}