@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/clients/runtime-coordinator.js

@@ -3,32 +3,88 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { logCascade } from "./cascade-logger.js";
 import {
-  appendProjectChange
+  appendProjectChangeAllocated
 } from "./project-changes.js";
+import { formatDiagnostics } from "./dispatch/utils/format-utils.js";
+import {
+  inlineBlockerLines,
+  inlineBlockerSources
+} from "./inline-blocker-fields.js";
 import { normalizeMapKey, pathsEqual } from "./path-utils.js";
 import { PathKeyedMap } from "./path-keyed-map.js";
-import { BoundedLruCache } from "./bounded-cache.js";
+import { BoundedFifoMap, BoundedLruCache } from "./bounded-cache.js";
 import { PartialApplyRecordStore } from "./partial-edit-apply.js";
 import { ReadGuard } from "./read-guard.js";
 import { RUNTIME_CONFIG } from "./runtime-config.js";
 import { TurnSummaryCollector } from "./turn-summary.js";
 import { deriveProviderFromModelId } from "./model-provider.js";
 import { beginTurnContext, setTurnContextSession } from "./turn-context.js";
-import { recordDegradationOnce } from "./degradation-ledger.js";
+import {
+  incrementDegradationCount,
+  recordDegradationOnce
+} from "./degradation-ledger.js";
+import { WriteOrderingGuard, writeOrderToken } from "./write-ordering-guard.js";
+import { getProcessSingleton } from "./process-singletons.js";
+import {
+  canWriteAnalysisRoot
+} from "./analysis-root.js";
+import {
+  beginScope,
+  nextOrderTurn,
+  retireScope
+} from "./session-scope.js";
 export const MAX_PENDING_CASCADE_RUNS = 32;
+function nextTelemetrySessionId() {
+  const state = getProcessSingleton("runtime-coordinator-telemetry", 1, () => ({
+    processId: randomBytes(6).toString("hex"),
+    nextGeneration: 0
+  }));
+  return `lens-${state.processId}-${++state.nextGeneration}`;
+}
+export const MAX_CUT_ADVISORY_LANES = 16;
 const MAX_MUTATION_RECEIPTS = 512;
+function recordViewIncomplete(cwd, cause) {
+  const why = `the change log reached seq ${cause.logMaxSeq} while this runtime was at ${cause.ownSeq} (${cause.ownSeq === 0 ? "a sibling process, or a timed-out session_start read that seeded 0; see snapshot-sequence-read-timeout" : "a sibling process logged above it"})`;
+  recordDegradationOnce({
+    kind: "snapshot-view-incomplete",
+    subject: path.resolve(cwd),
+    reason: `snapshots are stamped incomplete (never fresh) until the next seed from the change log: ${why}`
+  });
+}
+const MAX_RESOLVED_BLOCKER_FILES = 10;
 const TOOL_CALL_ATTRIBUTION_CAPACITY = 256;
 const TOOL_CALL_ATTRIBUTION_TTL_MS = 5 * 60000;
 
+class TurnWarningsBySession {
+  bySession = new Map;
+  add(sessionId, items) {
+    let partition = this.bySession.get(sessionId);
+    if (!partition) {
+      partition = new Map;
+      this.bySession.set(sessionId, partition);
+    }
+    for (const item of items)
+      partition.set(item.id, item);
+  }
+  peek(sessionId) {
+    return [...this.bySession.get(sessionId)?.values() ?? []];
+  }
+  clear(sessionId) {
+    this.bySession.delete(sessionId);
+  }
+}
+
 export class RuntimeCoordinator {
   _projectRoot = normalizeMapKey(process.cwd());
-  _sessionGeneration = 0;
+  _scope = beginScope({ role: "primary" });
+  _coordinatorId = this._scope.scopeId;
   _sessionStartedAt = Date.now();
   _errorDebtBaseline = null;
   _pipelineCrashCounts = new Map;
   _cachedExports = new Map;
   _startupScansInFlight = new Map;
   _cascadeRuns = [];
+  _cutAdvisoryItems = new BoundedFifoMap(MAX_CUT_ADVISORY_LANES);
   _turnEndCascadeSettleStarts = new Map;
   _nextCascadeSettleToken = 0;
   _pendingCascadeRuns = [];
@@ -48,7 +104,7 @@ export class RuntimeCoordinator {
     rules: [],
     hasCustomRules: false
   };
-  _telemetrySessionId = `lens-${Date.now().toString(36)}`;
+  _telemetrySessionId = nextTelemetrySessionId();
   _lifecycleReason;
   _hasStableSessionId = false;
   _telemetryModel = "unknown";
@@ -56,8 +112,14 @@ export class RuntimeCoordinator {
   _telemetryProvider = "";
   _telemetryProviderIsExplicit = false;
   _turnIndex = 0;
+  _writeOrderTurn = 0;
   _writeIndex = 0;
+  _foreignTurnKeys = new Map;
+  _foreignTurns = 0;
+  _turnStarts = 0;
   _projectSeq = 0;
+  _viewMissingThrough = 0;
+  _viewLogEntries = 0;
   _turnStartProjectSeq = 0;
   _fileSeq = new Map;
   _fileLastProjectSeq = new Map;
@@ -69,14 +131,24 @@ export class RuntimeCoordinator {
   _readGuard = null;
   _pendingDeferredMutations = new PathKeyedMap(normalizeMapKey);
   _toolCallAttributions = new BoundedLruCache(TOOL_CALL_ATTRIBUTION_CAPACITY);
+  _readWidenings = new BoundedLruCache(TOOL_CALL_ATTRIBUTION_CAPACITY);
   _lspReadWarmState = new Map;
   _pendingInlineBlockers = new PathKeyedMap(normalizeMapKey);
-  _actionableWarningsThisTurn = new Map;
-  _codeQualityWarningsThisTurn = new Map;
+  _inlineBlockerWriteOrder = new WriteOrderingGuard;
+  _resolvedBlockerFilesThisTurn = new PathKeyedMap(normalizeMapKey);
+  _resolvedBlockerFilesDropped = 0;
+  _actionableWarningsThisTurn = new TurnWarningsBySession;
+  _codeQualityWarningsThisTurn = new TurnWarningsBySession;
   _turnSummary = new TurnSummaryCollector;
   partialApplyRecords = new PartialApplyRecordStore;
   resetForSession(startedAt = Date.now()) {
-    this._sessionGeneration += 1;
+    const previous = this._scope;
+    retireScope(previous, "superseded");
+    this._scope = beginScope({
+      role: "primary",
+      parentScopeId: previous.scopeId,
+      coordinatorId: this._coordinatorId
+    });
     this._sessionStartedAt = startedAt;
     this._complexityBaselines.clear();
     this._pipelineCrashCounts.clear();
@@ -84,6 +156,7 @@ export class RuntimeCoordinator {
     this.wordIndex = null;
     this._startupScansInFlight.clear();
     this._cascadeRuns = [];
+    this._cutAdvisoryItems.clear();
     this._pendingCascadeRuns = [];
     this._turnEndCascadeSettleStarts.clear();
     this._cascadeSessionStats = {
@@ -97,15 +170,20 @@ export class RuntimeCoordinator {
     this._reportedThisTurn.clear();
     this._mutationReceipts = [];
     this._droppedMutationReceipts = 0;
-    this._telemetrySessionId = `lens-${Date.now().toString(36)}-${randomBytes(4).toString("hex")}`;
+    this._actionableWarningsThisTurn.clear(this._telemetrySessionId);
+    this._codeQualityWarningsThisTurn.clear(this._telemetrySessionId);
+    this._telemetrySessionId = nextTelemetrySessionId();
     this._hasStableSessionId = false;
     this._telemetryModel = "unknown";
     this._telemetryModelId = "";
     this._telemetryProvider = "";
     this._telemetryProviderIsExplicit = false;
     this._turnIndex = 0;
+    this._turnStarts = 0;
     this._writeIndex = 0;
     this._projectSeq = 0;
+    this._viewMissingThrough = 0;
+    this._viewLogEntries = 0;
     this._turnStartProjectSeq = 0;
     this._fileSeq.clear();
     this._fileLastProjectSeq.clear();
@@ -115,10 +193,12 @@ export class RuntimeCoordinator {
     this._readGuard = null;
     this._pendingDeferredMutations.clear();
     this._toolCallAttributions.clear();
+    this._readWidenings.clear();
     this._lspReadWarmState.clear();
     this._pendingInlineBlockers.clear();
-    this._actionableWarningsThisTurn.clear();
-    this._codeQualityWarningsThisTurn.clear();
+    this._inlineBlockerWriteOrder.clear();
+    this._resolvedBlockerFilesThisTurn.clear();
+    this._resolvedBlockerFilesDropped = 0;
     this._turnSummary.clear();
     this.partialApplyRecords.clear();
   }
@@ -138,7 +218,7 @@ export class RuntimeCoordinator {
     let changed = 0;
     for (const [key, entry] of this._pendingInlineBlockers.entries()) {
       const policySuppressed = suppressed.has(path.resolve(entry.filePath));
-      if (!!entry.policySuppressed === policySuppressed)
+      if ((entry.policySuppressed ?? false) === policySuppressed)
         continue;
       this._pendingInlineBlockers.set(key, { ...entry, policySuppressed });
       changed += 1;
@@ -172,7 +252,17 @@ export class RuntimeCoordinator {
   get gitGuardCacheUnknownReason() {
     return this._gitGuardCacheUnknownReason;
   }
-  beginTurn() {
+  beginTurn(sessionId) {
+    this._turnStarts += 1;
+    const turnSession = this.turnSession(sessionId);
+    if (turnSession !== this._telemetrySessionId) {
+      beginTurnContext(turnSession);
+      this._foreignTurns += 1;
+      this._foreignTurnKeys.set(turnSession, this._turnIndex + this._foreignTurns / (this._foreignTurns + 1));
+      this._actionableWarningsThisTurn.clear(turnSession);
+      this._codeQualityWarningsThisTurn.clear(turnSession);
+      return;
+    }
     this._cascadeRuns = this._cascadeRuns.flatMap((run) => {
       const carriedTurns = (run.carriedTurns ?? 0) + 1;
       if (carriedTurns > 1) {
@@ -187,10 +277,11 @@ export class RuntimeCoordinator {
       }
       return [{ ...run, carriedTurns }];
     });
-    this._actionableWarningsThisTurn.clear();
-    this._codeQualityWarningsThisTurn.clear();
+    this._actionableWarningsThisTurn.clear(turnSession);
+    this._codeQualityWarningsThisTurn.clear(turnSession);
     this._turnStartProjectSeq = this._projectSeq;
     this._turnIndex += 1;
+    this._writeOrderTurn = nextOrderTurn();
     beginTurnContext(this._telemetrySessionId);
     this._writeIndex = 0;
     this._reportedThisTurn.clear();
@@ -198,7 +289,32 @@ export class RuntimeCoordinator {
     this._autofixDemotedThisTurn.clear();
   }
   recordProjectMutation(args) {
-    const { projectSeq, fileSeq, key } = this.bumpFileSeq(args.filePath);
+    let logged;
+    if (args.cwd !== undefined) {
+      try {
+        const cwd = args.cwd;
+        appendProjectChangeAllocated(cwd, (logMaxSeq) => {
+          const ownSeq = this._projectSeq;
+          logged = this.bumpFileSeq(args.filePath, logMaxSeq);
+          if (this._viewMissingThrough > 0) {
+            recordViewIncomplete(cwd, { ownSeq, logMaxSeq });
+          }
+          return {
+            seq: logged.projectSeq,
+            timestamp: new Date().toISOString(),
+            sessionId: this.telemetrySessionId,
+            turnIndex: this.turnIndex,
+            source: args.source,
+            filePath: path.resolve(args.filePath),
+            fileSeq: logged.fileSeq,
+            changedRange: args.changedRange
+          };
+        });
+      } catch (err) {
+        args.onAppendError?.(err);
+      }
+    }
+    const { projectSeq, fileSeq, key } = logged ?? this.bumpFileSeq(args.filePath);
     if (this._mutationReceipts.length >= MAX_MUTATION_RECEIPTS) {
       this._mutationReceipts.shift();
       this._droppedMutationReceipts += 1;
@@ -210,22 +326,6 @@ export class RuntimeCoordinator {
       turnIndex: this._turnIndex,
       ts: Date.now()
     });
-    if (args.cwd !== undefined) {
-      try {
-        appendProjectChange(args.cwd, {
-          seq: projectSeq,
-          timestamp: new Date().toISOString(),
-          sessionId: this.telemetrySessionId,
-          turnIndex: this.turnIndex,
-          source: args.source,
-          filePath: path.resolve(args.filePath),
-          fileSeq,
-          changedRange: args.changedRange
-        });
-      } catch (err) {
-        args.onAppendError?.(err);
-      }
-    }
     return { projectSeq, fileSeq };
   }
   getMutationsSince(seq) {
@@ -255,6 +355,9 @@ export class RuntimeCoordinator {
   peekWriteIndex() {
     return this._writeIndex;
   }
+  nextWriteOrderToken() {
+    return writeOrderToken(this._writeOrderTurn, this.nextWriteIndex());
+  }
   setTelemetryIdentity(identity) {
     if (identity.sessionId && identity.sessionId.trim()) {
       this._telemetrySessionId = identity.sessionId.trim();
@@ -306,14 +409,28 @@ export class RuntimeCoordinator {
   get turnIndex() {
     return this._turnIndex;
   }
+  get turnStartCount() {
+    return this._turnStarts;
+  }
+  get writeOrderTurn() {
+    return this._writeOrderTurn;
+  }
   get projectSeq() {
     return this._projectSeq;
   }
+  get viewMissesLoggedEntries() {
+    return this._viewMissingThrough > 0;
+  }
+  get viewLogEntries() {
+    return this._viewLogEntries;
+  }
   get turnStartProjectSeq() {
     return this._turnStartProjectSeq;
   }
-  seedProjectSequence(projectSeq, fileSeqByPath) {
+  seedProjectSequence(projectSeq, fileSeqByPath, logEntries = 0) {
     this._projectSeq = Math.max(0, Math.floor(projectSeq));
+    this._viewMissingThrough = 0;
+    this._viewLogEntries = logEntries;
     this._turnStartProjectSeq = this._projectSeq;
     this._fileSeq.clear();
     this._fileLastProjectSeq.clear();
@@ -321,8 +438,22 @@ export class RuntimeCoordinator {
       this._fileSeq.set(normalizeMapKey(path.resolve(filePath)), Math.max(0, seq));
     }
   }
-  bumpFileSeq(filePath) {
+  mergeProjectSequence(projectSeq, fileSeqByPath, logEntries = 0) {
+    this._projectSeq = Math.max(this._projectSeq, Math.floor(projectSeq));
+    this._viewLogEntries = Math.max(this._viewLogEntries, logEntries);
+    for (const [filePath, seq] of fileSeqByPath) {
+      const key = normalizeMapKey(path.resolve(filePath));
+      this._fileSeq.set(key, Math.max(this._fileSeq.get(key) ?? 0, seq));
+    }
+    if (projectSeq >= this._viewMissingThrough)
+      this._viewMissingThrough = 0;
+  }
+  bumpFileSeq(filePath, logMaxSeq = 0) {
     const key = normalizeMapKey(path.resolve(filePath));
+    if (logMaxSeq > this._projectSeq) {
+      this._projectSeq = logMaxSeq;
+      this._viewMissingThrough = Math.max(this._viewMissingThrough, logMaxSeq);
+    }
     this._projectSeq += 1;
     const fileSeq = (this._fileSeq.get(key) ?? 0) + 1;
     this._fileSeq.set(key, fileSeq);
@@ -344,10 +475,16 @@ export class RuntimeCoordinator {
     return [...this._fileSeq.entries()];
   }
   get sessionGeneration() {
-    return this._sessionGeneration;
+    return this._scope.scopeId;
+  }
+  get sessionScope() {
+    return this._scope;
+  }
+  captureSessionGeneration() {
+    return this._scope.capture();
   }
   isCurrentSession(generation) {
-    return this._sessionGeneration === generation;
+    return this._scope.scopeId === generation && this._scope.isLive();
   }
   markStartupScanInFlight(name, generation) {
     this._startupScansInFlight.set(name, generation);
@@ -400,7 +537,11 @@ export class RuntimeCoordinator {
   appendCascadeRun(run) {
     this._cascadeRuns.push(run);
   }
-  appendCascadePromise(p) {
+  appendCascadePromise(p, generation, filePath, analysisRootMode = "session") {
+    if (!canWriteAnalysisRoot(analysisRootMode))
+      return;
+    if (generation.guardedWrite(filePath, () => true) === undefined)
+      return;
     if (this._pendingCascadeRuns.length < MAX_PENDING_CASCADE_RUNS) {
       this._pendingCascadeRuns.push(p);
       return;
@@ -410,7 +551,7 @@ export class RuntimeCoordinator {
       subject: "runtime-coordinator",
       reason: `deferred cascade admission capped at ${MAX_PENDING_CASCADE_RUNS}`
     });
-    p.then((run) => this.appendCascadeRun(run)).catch(() => {});
+    p.then((run) => generation.guardedWrite(run.filePath, () => this.appendCascadeRun(run))).catch(() => {});
   }
   getTurnEndCascadeSettleStart() {
     let latest;
@@ -422,6 +563,9 @@ export class RuntimeCoordinator {
     const pending = this._pendingCascadeRuns;
     if (pending.length === 0)
       return { settled: 0, timedOut: 0 };
+    const { generation } = settleOptions;
+    if (generation && generation.guardedWrite("cascade-settle", () => true) === undefined)
+      return { settled: 0, timedOut: 0 };
     this._pendingCascadeRuns = [];
     const settleToken = settleOptions.trackTurnEndClock ? ++this._nextCascadeSettleToken : undefined;
     if (settleToken !== undefined) {
@@ -444,14 +588,21 @@ export class RuntimeCoordinator {
         Promise.allSettled(tracked.map((t) => t.promise)),
         timeout
       ]);
+      const commit = (subject, write) => {
+        if (generation)
+          generation.guardedWrite(subject, write);
+        else
+          write();
+      };
       let settled = 0;
       let timedOut = 0;
       for (const entry of tracked) {
-        if (entry.done && entry.run) {
-          this.appendCascadeRun(entry.run);
+        const { run } = entry;
+        if (entry.done && run) {
+          commit(run.filePath, () => this.appendCascadeRun(run));
           settled += 1;
         } else {
-          this._pendingCascadeRuns.push(entry.promise);
+          commit("cascade-pending", () => this._pendingCascadeRuns.push(entry.promise));
           timedOut += 1;
         }
       }
@@ -462,6 +613,17 @@ export class RuntimeCoordinator {
       }
     }
   }
+  parkCutAdvisoryItems(lane, items) {
+    this._cutAdvisoryItems.delete(lane);
+    if (items.length === 0)
+      return [];
+    return this._cutAdvisoryItems.set(lane, [...items]).map(([key]) => key);
+  }
+  takeCutAdvisoryItems(lane) {
+    const items = this._cutAdvisoryItems.get(lane);
+    this._cutAdvisoryItems.delete(lane);
+    return items ?? [];
+  }
   consumeCascadeRuns() {
     const runs = this._cascadeRuns;
     this._cascadeRuns = [];
@@ -470,12 +632,16 @@ export class RuntimeCoordinator {
   hasCascadeRuns() {
     return this._cascadeRuns.length > 0;
   }
-  recordInlineBlockers(filePath, summary, writeIndex, sources, lines, contentBaseline, diagnostics) {
-    const recordedAtMs = Date.now();
+  recordInlineBlockers(filePath, summary, writeIndex, sources, lines, contentBaseline, diagnostics, orderTurn = this._writeOrderTurn, recordedAtMs = Date.now()) {
+    const writeOrder = writeOrderToken(orderTurn, writeIndex);
+    if (!this._inlineBlockerWriteOrder.shouldWrite(normalizeMapKey(filePath), writeOrder))
+      return;
+    this._resolvedBlockerFilesThisTurn.delete(filePath);
     this._pendingInlineBlockers.set(path.resolve(filePath), {
       filePath,
       summary,
       writeIndex,
+      writeOrder,
       sources,
       lines,
       diagnostics,
@@ -488,8 +654,73 @@ export class RuntimeCoordinator {
     });
     return recordedAtMs;
   }
-  clearInlineBlockers(filePath) {
+  recordDeferredInlineBlockers(filePath, blocking, analysed) {
+    const key = path.resolve(filePath);
+    const existing = this._pendingInlineBlockers.get(key);
+    if (existing && !existing.diagnostics)
+      return 0;
+    const identity = (d) => JSON.stringify([d.tool, d.id, d.line, d.message]);
+    const known = new Set((existing?.diagnostics ?? []).map(identity));
+    const added = blocking.flatMap((d) => known.has(identity(d)) ? [] : [d]);
+    if (added.length === 0)
+      return 0;
+    const diagnostics = [...existing?.diagnostics ?? [], ...added];
+    this._pendingInlineBlockers.set(key, {
+      ...existing ?? {
+        filePath,
+        recordedAtMs: analysed.recordedAtMs,
+        stale: false,
+        ...analysed.contentBaseline ? {
+          recordedSize: analysed.contentBaseline.size,
+          recordedHash: analysed.contentBaseline.sha256
+        } : {}
+      },
+      summary: formatDiagnostics(diagnostics, "blocking").trim(),
+      diagnostics,
+      sources: [
+        ...new Set([
+          ...existing?.sources ?? [],
+          ...inlineBlockerSources(added)
+        ])
+      ],
+      lines: [
+        ...existing?.lines ?? [],
+        ...inlineBlockerLines(added, filePath)
+      ],
+      policySuppressed: false
+    });
+    return added.length;
+  }
+  noteResolvedBlockerFile(record, retiringWriteOrder, confirmedClean) {
+    if (!this._resolvedBlockerFilesThisTurn.has(record.filePath) && this._resolvedBlockerFilesThisTurn.size >= MAX_RESOLVED_BLOCKER_FILES) {
+      this._resolvedBlockerFilesDropped += 1;
+      return;
+    }
+    this._resolvedBlockerFilesThisTurn.set(record.filePath, {
+      filePath: record.filePath,
+      blockerCount: record.diagnostics?.length ?? record.lines?.length ?? 1,
+      writeIndex: confirmedClean || retiringWriteOrder === undefined ? undefined : retiringWriteOrder % 2 ** 32,
+      confirmedClean,
+      turnIndex: this._turnIndex
+    });
+  }
+  clearInlineBlockers(filePath, writeIndex, orderTurn = this._writeOrderTurn, analysis) {
+    const existing = this._pendingInlineBlockers.get(path.resolve(filePath));
+    if (existing && analysis && !analysis.authored && analysis.sha256 !== undefined && existing.recordedHash === analysis.sha256) {
+      incrementDegradationCount({
+        kind: "blocker-clear-refused",
+        subject: normalizeMapKey(filePath),
+        reason: "an analysis without authorship read the bytes an authored verdict is about; its clean result does not retire the record (#4137)"
+      });
+      return false;
+    }
+    if (!this._inlineBlockerWriteOrder.shouldWrite(normalizeMapKey(filePath), writeOrderToken(orderTurn, writeIndex)))
+      return false;
+    if (existing) {
+      this.noteResolvedBlockerFile(existing, writeOrderToken(orderTurn, writeIndex), false);
+    }
     this._pendingInlineBlockers.delete(path.resolve(filePath));
+    return true;
   }
   markInlineBlockerStale(filePath, reason = "dependency-drift") {
     const key = path.resolve(filePath);
@@ -539,18 +770,25 @@ export class RuntimeCoordinator {
     return true;
   }
   retireDemotedPastEofBlocker(filePath, deadLines) {
-    if (deadLines.length === 0)
+    const key = this.pastEofRetireKey(filePath, deadLines);
+    if (key === undefined)
       return false;
+    this._pendingInlineBlockers.delete(key);
+    return true;
+  }
+  wouldRetireDemotedPastEofBlocker(filePath, deadLines) {
+    return this.pastEofRetireKey(filePath, deadLines) !== undefined;
+  }
+  pastEofRetireKey(filePath, deadLines) {
+    if (deadLines.length === 0)
+      return;
     const key = path.resolve(filePath);
     const existing = this._pendingInlineBlockers.get(key);
     if (!existing)
-      return false;
+      return;
     if (!existing.stale)
-      return false;
-    if ((existing.staleReason ?? "past-eof") !== "past-eof")
-      return false;
-    this._pendingInlineBlockers.delete(key);
-    return true;
+      return;
+    return (existing.staleReason ?? "past-eof") === "past-eof" ? key : undefined;
   }
   peekInlineBlockerStaleDeliveryCount(filePath) {
     const key = path.resolve(filePath);
@@ -580,12 +818,12 @@ export class RuntimeCoordinator {
     this._pendingInlineBlockers.delete(key);
     return true;
   }
-  retireInlineBlockerOnConfirmedClean(filePath, confirmedAtWriteIndex, coveredSources) {
+  retireInlineBlockerOnConfirmedClean(filePath, confirmedAtWriteOrder, coveredSources) {
     const key = path.resolve(filePath);
     const existing = this._pendingInlineBlockers.get(key);
     if (!existing)
       return false;
-    if (existing.writeIndex !== undefined && confirmedAtWriteIndex !== undefined && confirmedAtWriteIndex <= existing.writeIndex) {
+    if (existing.writeOrder !== undefined && confirmedAtWriteOrder !== undefined && confirmedAtWriteOrder <= existing.writeOrder) {
       return false;
     }
     if (!existing.sources || existing.sources.length === 0)
@@ -593,9 +831,29 @@ export class RuntimeCoordinator {
     const covered = new Set(coveredSources ?? []);
     if (!existing.sources.every((source) => covered.has(source)))
       return false;
+    this.noteResolvedBlockerFile(existing, undefined, true);
     this._pendingInlineBlockers.delete(key);
     return true;
   }
+  hasResolvedBlockerFiles() {
+    return this._resolvedBlockerFilesThisTurn.size > 0;
+  }
+  consumeResolvedBlockerFiles(holdBack) {
+    const files = [];
+    const held = [];
+    for (const entry of this._resolvedBlockerFilesThisTurn.values()) {
+      (holdBack(entry) ? held : files).push(entry);
+    }
+    this._resolvedBlockerFilesThisTurn.clear();
+    for (const entry of held) {
+      this._resolvedBlockerFilesThisTurn.set(entry.filePath, entry);
+    }
+    if (files.length === 0)
+      return { files, dropped: 0 };
+    const dropped = this._resolvedBlockerFilesDropped;
+    this._resolvedBlockerFilesDropped = 0;
+    return { files, dropped };
+  }
   reconcileInlineBlockers() {
     const survivors = [];
     for (const [displayPath, value] of this._pendingInlineBlockers.entries()) {
@@ -618,27 +876,48 @@ export class RuntimeCoordinator {
     this._pendingInlineBlockers.clear();
     return entries;
   }
-  recordActionableWarnings(warnings) {
-    for (const warning of warnings) {
-      this._actionableWarningsThisTurn.set(warning.id, warning);
-    }
+  turnSession(sessionId) {
+    return sessionId ?? this._telemetrySessionId;
   }
-  peekActionableWarnings() {
-    return [...this._actionableWarningsThisTurn.values()];
+  recordActionableWarnings(warnings, sessionId) {
+    this._actionableWarningsThisTurn.add(this.turnSession(sessionId), warnings);
   }
-  clearActionableWarnings() {
-    this._actionableWarningsThisTurn.clear();
+  peekActionableWarnings(sessionId) {
+    return this._actionableWarningsThisTurn.peek(this.turnSession(sessionId));
   }
-  recordCodeQualityWarnings(warnings) {
-    for (const warning of warnings) {
-      this._codeQualityWarningsThisTurn.set(warning.id, warning);
-    }
+  clearActionableWarnings(sessionId) {
+    this._actionableWarningsThisTurn.clear(this.turnSession(sessionId));
+  }
+  recordCodeQualityWarnings(warnings, sessionId) {
+    this._codeQualityWarningsThisTurn.add(this.turnSession(sessionId), warnings);
   }
-  peekCodeQualityWarnings() {
-    return [...this._codeQualityWarningsThisTurn.values()];
+  peekCodeQualityWarnings(sessionId) {
+    return this._codeQualityWarningsThisTurn.peek(this.turnSession(sessionId));
   }
-  clearCodeQualityWarnings() {
-    this._codeQualityWarningsThisTurn.clear();
+  clearCodeQualityWarnings(sessionId) {
+    this._codeQualityWarningsThisTurn.clear(this.turnSession(sessionId));
+  }
+  turnKey(sessionId) {
+    const turnSession = this.turnSession(sessionId);
+    if (turnSession === this._telemetrySessionId)
+      return this._turnIndex;
+    return this._foreignTurnKeys.get(turnSession) ?? this._turnIndex;
+  }
+  isLiveTurnKey(key) {
+    if (key === this._turnIndex)
+      return true;
+    for (const live of this._foreignTurnKeys.values())
+      if (live === key)
+        return true;
+    return false;
+  }
+  forgetTurnSession(sessionId) {
+    const turnSession = this.turnSession(sessionId);
+    if (turnSession === this._telemetrySessionId)
+      return;
+    this._foreignTurnKeys.delete(turnSession);
+    this._actionableWarningsThisTurn.clear(turnSession);
+    this._codeQualityWarningsThisTurn.clear(turnSession);
   }
   get turnSummary() {
     return this._turnSummary;
@@ -665,7 +944,7 @@ export class RuntimeCoordinator {
     this._projectRulesScan = value;
   }
   get readGuard() {
-    this._readGuard ??= new ReadGuard(this._telemetrySessionId);
+    this._readGuard ??= new ReadGuard(this._telemetrySessionId, {}, this._scope);
     return this._readGuard;
   }
   recordToolCallAttribution(toolCallId, attribution) {
@@ -674,6 +953,24 @@ export class RuntimeCoordinator {
       recordedAt: Date.now()
     });
   }
+  recordReadWidening(toolCallId, widening) {
+    this._readWidenings.set(toolCallId, widening);
+  }
+  takeReadWidening(toolCallId) {
+    const widening = this._readWidenings.get(toolCallId);
+    this._readWidenings.delete(toolCallId);
+    return widening;
+  }
+  markToolCallEditInPlace(toolCallId) {
+    const attribution = this._toolCallAttributions.get(toolCallId);
+    if (attribution)
+      attribution.editInPlace = true;
+  }
+  markToolCallFileTimeStale(toolCallId) {
+    const attribution = this._toolCallAttributions.get(toolCallId);
+    if (attribution)
+      attribution.fileTimeStale = true;
+  }
   takeToolCallAttribution(toolCallId) {
     const attribution = this._toolCallAttributions.get(toolCallId);
     if (attribution === undefined)
@@ -684,12 +981,15 @@ export class RuntimeCoordinator {
     }
     return attribution;
   }
-  deferMutation(filePath, cwd, toolName, turnStateCwd, kind, ownerSessionId, originCwd) {
+  deferMutation(filePath, cwd, toolName, turnStateCwd, kind, ownerSessionId, originCwd, readGuardBranchEpoch = this.readGuard.currentBranchEpoch, analysisRootMode = "session") {
+    if (!canWriteAnalysisRoot(analysisRootMode))
+      return false;
     const key = path.resolve(filePath);
     const now = Date.now();
     const resolvedOriginCwd = originCwd ?? turnStateCwd;
     const existing = this._pendingDeferredMutations.get(key);
     if (existing) {
+      existing.readGuardBranchEpoch = Math.max(existing.readGuardBranchEpoch, readGuardBranchEpoch);
       const addedKind = !existing.kinds.has(kind);
       existing.lastTouchedAt = now;
       existing.cwd = cwd;
@@ -713,12 +1013,23 @@ export class RuntimeCoordinator {
       queuedTurnIndex: this._turnIndex,
       queuedTurnId: `${this._telemetrySessionId}:${this._turnIndex}`,
       ownerSessionId,
-      originCwd: resolvedOriginCwd
+      originCwd: resolvedOriginCwd,
+      readGuardBranchEpoch
     });
     return true;
   }
-  deferFormat(filePath, cwd, toolName, turnStateCwd, ownerSessionId, originCwd) {
-    return this.deferMutation(filePath, cwd, toolName, turnStateCwd, "format", ownerSessionId, originCwd);
+  deferFormat(filePath, cwd, toolName, turnStateCwd, ownerSessionId, originCwd, analysisRootMode = "session") {
+    return this.deferMutation(filePath, cwd, toolName, turnStateCwd, "format", ownerSessionId, originCwd, undefined, analysisRootMode);
+  }
+  deferredFormatIdentity(filePath) {
+    const record = this._pendingDeferredMutations.get(path.resolve(filePath));
+    if (!record || !record.kinds.has("format"))
+      return;
+    return {
+      ownerSessionId: record.ownerSessionId,
+      turnIndex: record.queuedTurnIndex,
+      batchId: record.queuedTurnId
+    };
   }
   get pendingDeferredFormatCount() {
     return this._pendingDeferredMutations.size;
@@ -767,6 +1078,7 @@ export class RuntimeCoordinator {
           existing.kinds.add(kind);
         for (const toolName of record.toolNames)
           existing.toolNames.add(toolName);
+        existing.readGuardBranchEpoch = Math.max(existing.readGuardBranchEpoch, record.readGuardBranchEpoch);
         continue;
       }
       this._pendingDeferredMutations.set(key, {