@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/clients/module-report.js

@@ -9,6 +9,7 @@ import {
 } from "./call-graph.js";
 import { resolveImportToFiles } from "./review-graph/import-resolvers.js";
 import { buildSymbolId } from "./review-graph/symbol-id.js";
+import { classifyTreeSitterWasmError } from "./tree-sitter-client.js";
 import {
   getSharedTreeSitterClient,
   resolveTreeSitterLanguage
@@ -84,8 +85,13 @@ async function extractFile(absPath, languageId, content) {
       let callbackError;
       try {
         callbacks = extractCallbacks(tree.rootNode, owners, languageId, warnings);
-      } catch (error) {
-        callbackError = diagnosticMessage(error);
+      } catch (thrown) {
+        if (classifyTreeSitterWasmError(thrown)) {
+          tsClient.reportWasmAbort(thrown);
+          callbackError = `tree-sitter wasm runtime failure (${diagnosticMessage(thrown)})`;
+        } else {
+          callbackError = diagnosticMessage(thrown);
+        }
       }
       return {
         symbols: result.symbols,
@@ -94,7 +100,7 @@ async function extractFile(absPath, languageId, content) {
         callbackError,
         warnings
       };
-    });
+    }, "module-report");
     if (!extracted.parsed) {
       return {
         symbols: [],

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

@@ -33,6 +33,13 @@ function resolveMutationPath(input) {
 export function readMutationPathField(event) {
   return resolveMutationPath(asRecord(event?.input));
 }
+export function readToolResultPathField(event) {
+  const input = asRecord(event?.input);
+  const ownPath = input["path"];
+  if (typeof ownPath === "string" && ownPath.length > 0)
+    return ownPath;
+  return classifyMutatingTool(event, { recognizeOnly: true })?.path;
+}
 function parseHashlineAnchor(anchor) {
   if (typeof anchor !== "string")
     return;
@@ -306,7 +313,7 @@ function readToolName(event) {
   return typeof name === "string" && name.length > 0 ? name : undefined;
 }
 export const DM_LENS_SYNTHETIC_MUTATION_FIELD = "piLensSyntheticMutation";
-export function classifyMutatingTool(event, ctx = {}) {
+export function classifyMutatingTool(event, ctx = {}, adapters = MUTATION_SHAPE_ADAPTERS) {
   const toolName = readToolName(event);
   if (toolName === undefined)
     return;
@@ -322,8 +329,9 @@ export function classifyMutatingTool(event, ctx = {}) {
       provenance: builtinProvenance
     };
   }
-  for (const adapter of MUTATION_SHAPE_ADAPTERS) {
+  for (const adapter of adapters) {
     let resolved = adapter.resolve(input, ctx);
+    const adapterPath = resolved?.path;
     if (resolved === undefined)
       continue;
     if (resolved.touchedLines !== undefined) {
@@ -335,7 +343,7 @@ export function classifyMutatingTool(event, ctx = {}) {
     }
     return {
       toolName,
-      path: resolveMutationPath(input),
+      path: adapterPath ?? resolveMutationPath(input),
       kind: adapter.kind,
       touchedLines: resolved.touchedLines,
       editRanges: resolved.editRanges,
@@ -377,6 +385,7 @@ export function classifyBridgeMutation(entry) {
     kind: entry.kind,
     touchedLines: entry.touchedLines,
     editRanges: entry.editRanges,
+    authorshipUnknown: entry.authorshipUnknown,
     provenance,
     source: provenance === "bridge" ? "mutation-bridge" : "observed-mutation"
   };

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

@@ -5,6 +5,7 @@ import { recordDegradationOnce } from "./degradation-ledger.js";
 import { BoundedFifoMap } from "./bounded-cache.js";
 import { getProjectDataDir } from "./file-utils.js";
 import { getProcessSingleton } from "./process-singletons.js";
+import { DM_LENS_TOOL_NAMES } from "./tool-config.js";
 const MUTATION_ATTRIBUTION_FILE_VERSION = 1;
 export const MUTATION_ATTRIBUTION_FILE = "observed-mutating-tools.json";
 const PERSIST_AFTER_OBSERVATIONS = 2;
@@ -12,6 +13,9 @@ 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";
+function isDmLensToolName(toolName) {
+  return DM_LENS_TOOL_NAMES.includes(toolName);
+}
 const ATTRIBUTION_VERSION = 2;
 function state() {
   return getProcessSingleton(ATTRIBUTION_FAMILY, ATTRIBUTION_VERSION, () => ({
@@ -74,6 +78,8 @@ export function primePersistedMutationAttribution(cwd) {
     current.fromDisk.add(entry.name);
 }
 export function lookupLearnedMutatingTool(toolName) {
+  if (isDmLensToolName(toolName))
+    return;
   const current = state();
   if ((current.session.get(toolName)?.mutating ?? 0) > 0)
     return "session";
@@ -89,6 +95,8 @@ export function isProvisionalLearnedAttribution(toolName) {
   return observation.mutating > 0 && observation.mutating < PERSIST_AFTER_OBSERVATIONS;
 }
 export function shouldArmObservationForTool(toolName) {
+  if (isDmLensToolName(toolName))
+    return false;
   const observation = state().session.get(toolName);
   if ((observation?.mutating ?? 0) > 0)
     return isProvisionalLearnedAttribution(toolName);

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

@@ -1,43 +1,69 @@
+import { recordDegradationOnce } from "./degradation-ledger.js";
 import {
   classifyBridgeMutation
 } from "./mutating-tool.js";
+import { noteAgentMutation } from "./fix-run-restore.js";
 import { noteMutationHandled } from "./observed-mutation.js";
-import { getProcessBridge, registerProcessBridge } from "./process-bridge.js";
+import {
+  getProcessBridge,
+  rebindableProcessBridgeDeps,
+  registerProcessBridge
+} from "./process-bridge.js";
+import { recordDroppedRead } from "./session-scope.js";
+import { publishFormatQueued } from "./format-events-publish.js";
 export const MUTATION_BRIDGE_KEY = Symbol.for("dm-lens:mutation-bridge");
-function isValidRange(value) {
+export 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) {
+function mutationEntryProblem(entry) {
   if (typeof entry !== "object" || entry === null)
-    return false;
+    return "entry must be an object";
   const e = entry;
   if (typeof e["filePath"] !== "string" || e["filePath"] === "")
-    return false;
+    return "filePath must be a non-empty string";
   const kind = e["kind"];
   if (kind !== "write" && kind !== "edit")
-    return false;
+    return 'kind must be "edit" or "write"';
   if (e["touchedLines"] !== undefined && !isValidRange(e["touchedLines"]))
-    return false;
+    return "touchedLines must be 1-indexed [start, end]";
   const editRanges = e["editRanges"];
   if (editRanges !== undefined) {
     if (!Array.isArray(editRanges) || editRanges.length === 0)
-      return false;
+      return "edit ranges must be a non-empty array";
     if (!editRanges.every(isValidRange))
-      return false;
+      return "edit ranges must be 1-indexed [start, end] with start <= end";
   }
   if (e["consumer"] !== undefined && typeof e["consumer"] !== "string")
-    return false;
+    return "consumer must be a string";
   if (e["importsChanged"] !== undefined && typeof e["importsChanged"] !== "boolean")
-    return false;
+    return "importsChanged must be a boolean";
   if (e["deferAutofix"] !== undefined && typeof e["deferAutofix"] !== "boolean")
-    return false;
+    return "deferAutofix must be a boolean";
   const provenance = e["provenance"];
   if (provenance !== undefined && provenance !== "observed" && provenance !== "settled-sweep")
-    return false;
-  return true;
+    return 'provenance must be "observed" or "settled-sweep"';
+  if (e["toolCallId"] !== undefined && typeof e["toolCallId"] !== "string")
+    return "toolCallId must be a string";
+  return;
+}
+export function isValidMutationEntry(entry) {
+  return mutationEntryProblem(entry) === undefined;
+}
+function resolveReadGuardBranchEpoch(value, currentEpoch) {
+  if (value === undefined)
+    return;
+  const wellFormed = typeof value === "number" && Number.isInteger(value) && value >= 0;
+  if (wellFormed && value <= currentEpoch)
+    return value;
+  recordDegradationOnce({
+    kind: "mutation-bridge-invalid-branch-epoch",
+    subject: "readGuardBranchEpoch",
+    reason: wellFormed ? `ignored a readGuardBranchEpoch above the live epoch (${value} > ${currentEpoch})` : `ignored a foreign readGuardBranchEpoch (typeof ${typeof value}) (current ${currentEpoch})`
+  });
+  return;
 }
 function resolveChangedRange(classification, deps, filePath) {
   if (classification.touchedLines) {
@@ -51,50 +77,157 @@ function resolveChangedRange(classification, deps, filePath) {
   }
   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;
+function resolveAuthorshipRanges(classification) {
+  if (classification.authorshipUnknown === true)
+    return;
+  if (classification.editRanges && classification.editRanges.length > 0)
+    return classification.editRanges;
+  if (classification.touchedLines)
+    return [classification.touchedLines];
+  return;
+}
+function rejectedOutcome(reason, detail) {
+  return { recorded: false, accepted: false, reason, detail, queued: [] };
+}
+function stampLiveMutation(ctx, stampReadGuard) {
+  const { entry, classification, runtime, filePath } = ctx;
+  const lineage = entry.lineage;
+  let sessionLive = true;
+  if (lineage !== undefined && lineage.guardedWrite(filePath, () => true) !== true) {
+    sessionLive = false;
+    if (stampReadGuard) {
+      recordDroppedRead(lineage, entry.provenance ?? classification.toolName, entry.readGuardBranchEpoch ?? lineage.branchEpoch);
+    }
   }
-  if (!deps.isRecordable(entry.filePath)) {
-    deps.dbg?.(`mutation_bridge: out of scope ${entry.filePath}`);
-    return false;
+  const stamp = sessionLive ? resolveReadGuardBranchEpoch(entry.readGuardBranchEpoch, runtime.readGuard.currentBranchEpoch) : undefined;
+  if (sessionLive && stampReadGuard) {
+    const authoredRanges = resolveAuthorshipRanges(classification);
+    runtime.readGuard.recordWritten?.(filePath, {
+      ...stamp !== undefined && { branchEpoch: stamp },
+      stampFileTime: false,
+      advanceAuthorship: entry.provenance === "observed",
+      ...authoredRanges !== undefined && { authoredRanges },
+      authorship: authoredRanges !== undefined ? "partial" : entry.kind === "write" ? "whole-file" : "unknown",
+      allowFirstAuthorship: entry.provenance !== "settled-sweep",
+      ...entry.toolCallId !== undefined && { toolCallId: entry.toolCallId }
+    });
+  }
+  return { sessionLive, stamp };
+}
+function applyTurnAndChangeLog(ctx, sessionLive) {
+  const { entry, classification, deps, runtime, filePath, projectRoot } = ctx;
+  const changedRange = resolveChangedRange(classification, deps, filePath);
+  if (sessionLive) {
+    deps.getCacheManager().addModifiedRange?.(filePath, changedRange, entry.importsChanged ?? false, projectRoot, entry.sessionId ?? 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);
+}
+function queueDeferredMutation(ctx, sessionLive, stamp, queued) {
+  const { entry, classification, runtime, filePath, projectRoot, dispatchCwd } = ctx;
+  if (!sessionLive || entry.deferAutofix === false)
+    return;
+  for (const kind of ["autofix", "format"]) {
+    const landed = runtime.deferMutation?.(filePath, dispatchCwd, classification.toolName, projectRoot, kind, runtime.telemetrySessionId, projectRoot, stamp);
+    if (landed)
+      queued.push(kind);
+  }
+}
+function runMutationBookkeeping(ctx, queued) {
+  const stampReadGuard = ctx.deps.shouldStampReadGuard?.() ?? true;
+  const { sessionLive, stamp } = stampLiveMutation(ctx, stampReadGuard);
+  applyTurnAndChangeLog(ctx, sessionLive);
+  queueDeferredMutation(ctx, sessionLive, stamp, queued);
+  return sessionLive;
+}
+export function recordMutationOutcome(entry, deps, opts) {
+  const problem = mutationEntryProblem(entry);
+  if (problem !== undefined) {
+    deps.dbg?.(`mutation_bridge: dropped malformed entry: ${problem}`);
+    return rejectedOutcome("malformed", problem);
   }
-  const classification = classifyBridgeMutation(entry);
-  const filePath = entry.filePath;
-  const runtime = deps.getRuntime();
-  const projectRoot = deps.getProjectRoot();
-  const dispatchCwd = deps.getDispatchCwd(filePath);
+  const valid = entry;
+  if (!deps.isRecordable(valid.filePath)) {
+    deps.dbg?.(`mutation_bridge: out of scope ${valid.filePath}`);
+    return rejectedOutcome("out-of-scope", valid.filePath);
+  }
+  const outcome = runAdmittedMutation(valid, deps, opts);
+  if (outcome.queued.length > 0)
+    publishQueued(valid, deps, outcome.queued);
+  return outcome;
+}
+function publishQueued(entry, deps, queued) {
+  const publish = deps.publishFormatQueued ?? publishFormatQueued;
   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}`)
+    publish({
+      filePath: entry.filePath,
+      cwd: deps.getDispatchCwd(entry.filePath),
+      tool: entry.kind,
+      kinds: [...queued],
+      ...deps.dbg !== undefined && { dbg: deps.dbg }
     });
-    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;
+    deps.dbg?.(`mutation_bridge: format-queued publish failed for ${entry.filePath}: ${err}`);
+  }
+}
+function runAdmittedMutation(entry, deps, opts) {
+  noteAgentMutation(entry.filePath);
+  const ctx = {
+    entry,
+    classification: classifyBridgeMutation(entry),
+    deps,
+    runtime: deps.getRuntime(),
+    filePath: entry.filePath,
+    projectRoot: deps.getProjectRoot(),
+    dispatchCwd: deps.getDispatchCwd(entry.filePath)
+  };
+  const queued = [];
+  let sessionLive = true;
+  try {
+    sessionLive = runMutationBookkeeping(ctx, queued);
+  } catch (err) {
+    deps.dbg?.(`mutation_bridge: recording failed for ${ctx.filePath}: ${err}`);
+    return {
+      recorded: false,
+      accepted: false,
+      reason: "bookkeeping-error",
+      detail: `${err}`,
+      queued
+    };
   }
-  return true;
+  const accepted = sessionLive || opts?.rejectStaleLineage !== true;
+  return accepted ? { recorded: true, accepted: true, queued } : { recorded: true, accepted: false, reason: "stale-lineage", queued };
 }
-export function registerMutationBridge(deps) {
+export function recordMutationThroughSeam(entry, deps) {
+  const outcome = recordMutationOutcome(entry, deps);
+  if (outcome.reason === "out-of-scope") {
+    const producer = entry?.["consumer"];
+    recordDegradationOnce({
+      kind: "mutation-bridge-out-of-scope",
+      subject: `${typeof producer === "string" ? producer : "unknown"}:out-of-scope`,
+      reason: `${outcome.detail ?? "<unknown path>"}: the producer's path is outside the project or unresolvable; bridge bookkeeping was not admitted`
+    });
+  }
+  return outcome.recorded;
+}
+const DEFAULT_ACTIVATION = Symbol("dm-lens:mutation-bridge-activation");
+export function registerMutationBridge(deps, activation = DEFAULT_ACTIVATION) {
+  const currentDeps = rebindableProcessBridgeDeps("mutation-bridge-deps", 1, activation, deps);
   registerProcessBridge(MUTATION_BRIDGE_KEY, () => ({
     version: 1,
     recordMutation(entry) {
-      return recordMutationThroughSeam(entry, deps);
+      const liveDeps = currentDeps();
+      if (!liveDeps) {
+        deps.onUnavailable?.();
+        return false;
+      }
+      return recordMutationThroughSeam(entry, liveDeps);
     }
   }));
 }

package/extensions/dm-lens/clients/ndjson-logger.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { normalizeFilePath } from "./path-utils.js";
+import { isTestProcessTargetingRealHome } from "./probe-home-state.js";
 import { redactSecrets } from "./redact/secrets.js";
 function resolve(v) {
   return typeof v === "function" ? v() : v;
@@ -68,6 +69,13 @@ export function _exitFlushersForTest() {
 export function getRegisteredLogFiles() {
   return registeredLogFiles;
 }
+export function flushAllNdjsonWriters() {
+  if (!ndjsonGlobalState)
+    return Promise.resolve();
+  return Promise.all([...ndjsonGlobalState.writers.values()].map((state) => drain(state))).then(() => {
+    return;
+  });
+}
 export function getSinkWriteFailures() {
   if (!ndjsonGlobalState)
     return [];
@@ -108,7 +116,19 @@ export function resetSinkRotations() {
     state.rotationFailures = 0;
     state.rotationRetryAfterMs = 0;
     state.optionConflictRecorded = false;
+    state.truncateRefusals = 0;
+  }
+}
+export function getSinkTruncateRefusals() {
+  if (!ndjsonGlobalState)
+    return [];
+  const result = [];
+  for (const state of ndjsonGlobalState.writers.values()) {
+    if (state.truncateRefusals > 0) {
+      result.push({ file: state.file, refusedCount: state.truncateRefusals });
+    }
   }
+  return result;
 }
 export function getSinkOptionConflicts() {
   if (!ndjsonGlobalState)
@@ -193,6 +213,8 @@ function createWriterState(file, maxBytes, backupPath) {
       existing.rotationRetryAfterMs = 0;
     if (typeof existing.optionConflictRecorded !== "boolean")
       existing.optionConflictRecorded = false;
+    if (typeof existing.truncateRefusals !== "number")
+      existing.truncateRefusals = 0;
     const optionsDiffer = existing.maxBytes !== maxBytes || existing.backupPath !== backupPath;
     if (optionsDiffer) {
       if (existing.maxBytes === undefined && maxBytes !== undefined)
@@ -221,6 +243,7 @@ function createWriterState(file, maxBytes, backupPath) {
   state.rotationFailures = 0;
   state.rotationRetryAfterMs = 0;
   state.optionConflictRecorded = false;
+  state.truncateRefusals = 0;
   globalState.writers.set(file, state);
   registerWriter(state);
   return state;
@@ -458,6 +481,16 @@ export function createNdjsonLogger(options) {
 ` });
     },
     truncate() {
+      const state = stateForCall();
+      if (isTestProcessTargetingRealHome(state.file)) {
+        if (state.truncateRefusals === 0) {
+          try {
+            process.emitWarning(`dm-lens refused to truncate the real-home log ${state.file} ` + "from a test process (pin DM_LENS_HOME for this file)", { code: "DM_LENS_LOG_SINK_TRUNCATE_REFUSED" });
+          } catch {}
+        }
+        state.truncateRefusals += 1;
+        return;
+      }
       enqueue({ kind: "truncate" });
     },
     async flush() {

package/extensions/dm-lens/clients/observed-mutation-sources.js

@@ -1,4 +1,4 @@
-import { getLSPService } from "./lsp/index.js";
+import { getLSPService } from "./lsp/capabilities.js";
 import { getMutationBridge } from "./mutation-bridge.js";
 import { getFileDiagnosticSummaries } from "./widget-state.js";
 export function collectTrackedPaths(args) {

package/extensions/dm-lens/clients/observed-mutation.js

@@ -22,6 +22,8 @@ import { lineContentHash } from "./read-guard.js";
 const OBSERVED_CAPTURE_BUDGET_MS = 200;
 export const OBSERVED_TURN_BUDGET_MS = 600;
 const OBSERVED_SETTLE_DEADLINE_MS = 50;
+let captureBudgetOverrideMs;
+let settleDeadlineOverrideMs;
 export const OBSERVED_TARGET_DIR_MAX_ENTRIES = 64;
 export const OBSERVED_TRACKED_MAX_FILES = 400;
 const OBSERVED_LEDGER_SETTLE_MS = 150;
@@ -35,7 +37,8 @@ const OBSERVED_MAX_EDIT_RANGES = 32;
 const OBSERVED_PENDING_MAX = 32;
 const OBSERVED_LEDGER_MAX = 1000;
 const OBSERVED_FAMILY = "observed-mutation-net";
-const OBSERVED_VERSION = 3;
+const OBSERVED_VERSION = 4;
+const OBSERVED_PARKED_TURNS_MAX = 8;
 function state() {
   return getProcessSingleton(OBSERVED_FAMILY, OBSERVED_VERSION, () => ({
     pending: new BoundedFifoMap(OBSERVED_PENDING_MAX),
@@ -43,6 +46,7 @@ function state() {
     handled: new BoundedSet(OBSERVED_HANDLED_MAX),
     turnIndex: -1,
     turnSpentMs: 0,
+    parkedSpendMs: new Map,
     sweepCursor: 0
   }));
 }
@@ -53,14 +57,20 @@ export function resetObservedMutationNet() {
   current.handled.clear();
   current.turnIndex = -1;
   current.turnSpentMs = 0;
+  current.parkedSpendMs.clear();
   current.sweepCursor = 0;
 }
+export function _setObservedTimeBoundsForTests(bounds) {
+  captureBudgetOverrideMs = bounds.captureMs;
+  settleDeadlineOverrideMs = bounds.settleMs;
+}
 export function _observedMutationStateForTests() {
   const current = state();
   return {
     pending: [...current.pending.keys()],
     ledger: [...current.ledger.keys()],
     handled: [...current.handled],
+    turnIndex: current.turnIndex,
     turnSpentMs: current.turnSpentMs,
     sweepCursor: current.sweepCursor
   };
@@ -86,26 +96,33 @@ export function noteMutationHandled(filePath) {
 export function hasPendingObservation(toolCallId) {
   return toolCallId !== undefined && state().pending.has(toolCallId);
 }
-function remainingTurnBudgetMs(turnIndex) {
+function budgetFor(turnIndex, isLiveTurn = () => false) {
   const current = state();
   if (current.turnIndex !== turnIndex) {
+    const parked = current.parkedSpendMs;
+    if (current.turnIndex !== -1)
+      parked.set(current.turnIndex, current.turnSpentMs);
+    current.turnSpentMs = parked.get(turnIndex) ?? 0;
+    parked.delete(turnIndex);
     current.turnIndex = turnIndex;
-    current.turnSpentMs = 0;
+    while (parked.size > OBSERVED_PARKED_TURNS_MAX) {
+      let victim;
+      for (const key of parked.keys())
+        if (!isLiveTurn(key) && (victim === undefined || key < victim))
+          victim = key;
+      parked.delete(victim ?? Math.min(...parked.keys()));
+    }
   }
-  return Math.max(0, OBSERVED_TURN_BUDGET_MS - current.turnSpentMs);
+  return current;
 }
-function chargeTurnBudget(turnIndex, spentMs) {
-  const current = state();
-  if (current.turnIndex !== turnIndex) {
-    current.turnIndex = turnIndex;
-    current.turnSpentMs = 0;
-  }
-  current.turnSpentMs += Math.max(0, spentMs);
+function remainingTurnBudgetMs(turnIndex, isLiveTurn) {
+  return Math.max(0, OBSERVED_TURN_BUDGET_MS - budgetFor(turnIndex, isLiveTurn).turnSpentMs);
+}
+function chargeTurnBudget(turnIndex, spentMs, isLiveTurn) {
+  budgetFor(turnIndex, isLiveTurn).turnSpentMs += Math.max(0, spentMs);
 }
 export function _setObservedTurnBudgetForTests(turnIndex, spentMs) {
-  const current = state();
-  current.turnIndex = turnIndex;
-  current.turnSpentMs = spentMs;
+  budgetFor(turnIndex).turnSpentMs = spentMs;
 }
 async function withBounds(work, timeoutMs, signal, site) {
   const isAborted = () => signal !== undefined && signal.aborted;
@@ -238,7 +255,7 @@ export async function armObservedMutation(args) {
     return { armed: false, reason: "not-eligible" };
   if (!args.toolCallId)
     return { armed: false, reason: "no-tool-call-id" };
-  const remaining = remainingTurnBudgetMs(args.turnIndex);
+  const remaining = remainingTurnBudgetMs(args.turnIndex, args.isLiveTurn);
   if (remaining <= 0) {
     emitBounded("observed_mutation_budget_exhausted", args.toolName, {
       filePath: args.targetPath,
@@ -252,9 +269,10 @@ export async function armObservedMutation(args) {
     return { armed: false, reason: "budget-exhausted" };
   }
   const started = Date.now();
-  const timeoutMs = Math.min(remaining, OBSERVED_CAPTURE_BUDGET_MS);
+  const timeoutMs = Math.min(remaining, captureBudgetOverrideMs ?? OBSERVED_CAPTURE_BUDGET_MS);
   const outcome = await withBounds(async () => {
     const universe = await collectObservationUniverse(args.targetPath);
+    args.onUniverse?.(universe.paths);
     const captured = await captureFileStatsForPaths(universe.paths, {
       withHashes: true,
       hashBudgetBytes: OBSERVED_HASH_BUDGET_BYTES
@@ -267,7 +285,7 @@ export async function armObservedMutation(args) {
       lineHashes
     };
   }, timeoutMs, args.signal, { hook: "tool_call", label: "armObservedMutation" });
-  chargeTurnBudget(args.turnIndex, Date.now() - started);
+  chargeTurnBudget(args.turnIndex, Date.now() - started, args.isLiveTurn);
   if (!outcome.ok) {
     emitBounded("observed_mutation_budget_exhausted", args.toolName, {
       filePath: args.targetPath,
@@ -375,12 +393,13 @@ export async function settleObservedMutation(args) {
     };
   }
   const started = Date.now();
+  const settleDeadlineMs = settleDeadlineOverrideMs ?? OBSERVED_SETTLE_DEADLINE_MS;
   const capture = await withBounds(() => captureFileStatsForPaths(pending.paths, {
     withHashes: true,
     hashBudgetBytes: OBSERVED_HASH_BUDGET_BYTES,
-    deadlineMs: started + OBSERVED_SETTLE_DEADLINE_MS,
+    deadlineMs: started + settleDeadlineMs,
     signal: args.signal
-  }), OBSERVED_SETTLE_DEADLINE_MS * 4, args.signal, { hook: "tool_result_edit", label: "settleObservedMutation" });
+  }), settleDeadlineMs * 4, args.signal, { hook: "tool_result_edit", label: "settleObservedMutation" });
   chargeTurnBudget(args.turnIndex, Date.now() - started);
   if (!capture.ok) {
     noteObservedUnverifiable(args.toolName);
@@ -440,7 +459,8 @@ export async function settleObservedMutation(args) {
       touchedLines: editRanges ? boundingBox(editRanges) : undefined,
       editRanges: editRanges && editRanges.length > 1 ? editRanges : undefined,
       consumer: args.toolName,
-      provenance: "observed"
+      provenance: "observed",
+      ...args.toolCallId !== undefined && { toolCallId: args.toolCallId }
     });
     if (accepted) {
       replayed += 1;