@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

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

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

@@ -1,102 +0,0 @@
-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;
-}