@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

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

@@ -0,0 +1,1117 @@
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { logCascade } from "./cascade-logger.js";
+import { 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 { 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 { 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());
+  _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 = [];
+  _cascadeSessionStats = {
+    runs: 0,
+    diagnosticsSurfaced: 0,
+    coldSnapshotTouches: 0
+  };
+  _complexityBaselines = new Map;
+  _fixedThisTurn = new PathKeyedMap(normalizeMapKey);
+  _writtenThisTurn = new PathKeyedMap(normalizeMapKey);
+  _autofixDemotedThisTurn = new PathKeyedMap(normalizeMapKey);
+  _reportedThisTurn = new Set;
+  _mutationReceipts = [];
+  _droppedMutationReceipts = 0;
+  _projectRulesScan = {
+    rules: [],
+    hasCustomRules: false
+  };
+  _telemetrySessionId = nextTelemetrySessionId();
+  _lifecycleReason;
+  _hasStableSessionId = false;
+  _telemetryModel = "unknown";
+  _telemetryModelId = "";
+  _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;
+  _gitGuardHasBlockers = false;
+  _gitGuardSummary = "";
+  _gitGuardCacheUnknownReason;
+  callGraph = null;
+  wordIndex = null;
+  _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);
+  _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()) {
+    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();
+    this._cachedExports.clear();
+    this.wordIndex = null;
+    this._startupScansInFlight.clear();
+    this._cascadeRuns = [];
+    this._cutAdvisoryItems.clear();
+    this._pendingCascadeRuns = [];
+    this._turnEndCascadeSettleStarts.clear();
+    this._cascadeSessionStats = {
+      runs: 0,
+      diagnosticsSurfaced: 0,
+      coldSnapshotTouches: 0
+    };
+    this._fixedThisTurn.clear();
+    this._writtenThisTurn.clear();
+    this._autofixDemotedThisTurn.clear();
+    this._reportedThisTurn.clear();
+    this._mutationReceipts = [];
+    this._droppedMutationReceipts = 0;
+    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();
+    this._gitGuardHasBlockers = false;
+    this._gitGuardSummary = "";
+    this._gitGuardCacheUnknownReason = undefined;
+    this._readGuard = null;
+    this._pendingDeferredMutations.clear();
+    this._toolCallAttributions.clear();
+    this._readWidenings.clear();
+    this._lspReadWarmState.clear();
+    this._pendingInlineBlockers.clear();
+    this._inlineBlockerWriteOrder.clear();
+    this._resolvedBlockerFilesThisTurn.clear();
+    this._resolvedBlockerFilesDropped = 0;
+    this._turnSummary.clear();
+    this.partialApplyRecords.clear();
+  }
+  get sessionStartedAt() {
+    return this._sessionStartedAt;
+  }
+  get cascadeSessionStats() {
+    return this._cascadeSessionStats;
+  }
+  recordCascadeRun(diagnosticsSurfaced, coldSnapshotTouches) {
+    this._cascadeSessionStats.runs += 1;
+    this._cascadeSessionStats.diagnosticsSurfaced += diagnosticsSurfaced;
+    this._cascadeSessionStats.coldSnapshotTouches += coldSnapshotTouches;
+  }
+  applyInlineBlockerPolicyVerdicts(suppressedFilePaths) {
+    const suppressed = new Set(suppressedFilePaths.map((filePath) => path.resolve(filePath)));
+    let changed = 0;
+    for (const [key, entry] of this._pendingInlineBlockers.entries()) {
+      const policySuppressed = suppressed.has(path.resolve(entry.filePath));
+      if ((entry.policySuppressed ?? false) === policySuppressed)
+        continue;
+      this._pendingInlineBlockers.set(key, { ...entry, policySuppressed });
+      changed += 1;
+    }
+    return changed;
+  }
+  updateGitGuardStatus(hasBlockers, output) {
+    const blocking = this.getInlineBlockersSnapshot().filter((entry) => !entry.policySuppressed);
+    this._gitGuardHasBlockers = hasBlockers || blocking.length > 0;
+    if (!this._gitGuardHasBlockers) {
+      this._gitGuardSummary = "";
+      return;
+    }
+    const firstLine = output.split(`
+`).map((line) => line.trim()).find((line) => line.length > 0);
+    const summaries = blocking.map((entry) => entry.summary.trim()).filter(Boolean);
+    this._gitGuardSummary = (summaries[0] ?? firstLine ?? "Unresolved blockers detected").slice(0, 160);
+  }
+  get gitGuardHasBlockers() {
+    return this._gitGuardHasBlockers;
+  }
+  get gitGuardSummary() {
+    return this._gitGuardSummary;
+  }
+  markGitGuardCacheUnknown(reason) {
+    this._gitGuardCacheUnknownReason = reason;
+  }
+  clearGitGuardCacheUnknown() {
+    this._gitGuardCacheUnknownReason = undefined;
+  }
+  get gitGuardCacheUnknownReason() {
+    return this._gitGuardCacheUnknownReason;
+  }
+  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) {
+        logCascade({
+          phase: "cascade_carry_over_drop",
+          filePath: run.filePath,
+          neighborCount: run.neighborCount,
+          diagnosticCount: run.diagnosticCount,
+          metadata: { carriedTurns, turnIndex: this._turnIndex }
+        });
+        return [];
+      }
+      return [{ ...run, carriedTurns }];
+    });
+    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();
+    this._writtenThisTurn.clear();
+    this._autofixDemotedThisTurn.clear();
+  }
+  recordProjectMutation(args) {
+    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;
+    }
+    this._mutationReceipts.push({
+      seq: projectSeq,
+      filePath: key,
+      source: args.source,
+      turnIndex: this._turnIndex,
+      ts: Date.now()
+    });
+    return { projectSeq, fileSeq };
+  }
+  getMutationsSince(seq) {
+    return this._mutationReceipts.filter((r) => r.seq > seq).map((r) => ({ ...r }));
+  }
+  get droppedMutationReceiptCount() {
+    return this._droppedMutationReceipts;
+  }
+  recordMutationToolReceipt(filePath, kind) {
+    if (kind === "write") {
+      this._writtenThisTurn.set(filePath, true);
+    } else if (this._writtenThisTurn.has(filePath)) {
+      this._autofixDemotedThisTurn.set(filePath, true);
+      this._fixedThisTurn.delete(filePath);
+    }
+    return {
+      autofixMode: kind === "edit" || this._autofixDemotedThisTurn.has(filePath) ? "deferred" : "immediate"
+    };
+  }
+  get reportedThisTurn() {
+    return this._reportedThisTurn;
+  }
+  nextWriteIndex() {
+    this._writeIndex += 1;
+    return this._writeIndex;
+  }
+  peekWriteIndex() {
+    return this._writeIndex;
+  }
+  nextWriteOrderToken() {
+    return writeOrderToken(this._writeOrderTurn, this.nextWriteIndex());
+  }
+  setTelemetryIdentity(identity) {
+    if (identity.sessionId && identity.sessionId.trim()) {
+      this._telemetrySessionId = identity.sessionId.trim();
+      setTurnContextSession(this._telemetrySessionId);
+    }
+    const model = identity.model?.trim();
+    const provider = identity.provider?.trim();
+    if (model && provider) {
+      this._telemetryModel = `${provider}/${model}`;
+    } else if (model) {
+      this._telemetryModel = model;
+    } else if (provider) {
+      this._telemetryModel = provider;
+    }
+    if (model)
+      this._telemetryModelId = model;
+    if (provider) {
+      this._telemetryProvider = provider;
+      this._telemetryProviderIsExplicit = true;
+    } else if (model && !this._telemetryProviderIsExplicit) {
+      this._telemetryProvider = deriveProviderFromModelId(model);
+    }
+  }
+  get telemetrySessionId() {
+    return this._telemetrySessionId;
+  }
+  setSessionLifecycle(args) {
+    if (args.sessionId && args.sessionId.trim()) {
+      this._telemetrySessionId = args.sessionId.trim();
+      this._hasStableSessionId = true;
+    }
+    this._lifecycleReason = args.reason;
+  }
+  get sessionLifecycleReason() {
+    return this._lifecycleReason;
+  }
+  get hasStableSessionId() {
+    return this._hasStableSessionId;
+  }
+  get telemetryModel() {
+    return this._telemetryModel;
+  }
+  get telemetryModelId() {
+    return this._telemetryModelId;
+  }
+  get telemetryProviderId() {
+    return this._telemetryProvider;
+  }
+  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, 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();
+    for (const [filePath, seq] of fileSeqByPath ?? []) {
+      this._fileSeq.set(normalizeMapKey(path.resolve(filePath)), Math.max(0, seq));
+    }
+  }
+  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);
+    this._fileLastProjectSeq.set(key, this._projectSeq);
+    return { projectSeq: this._projectSeq, fileSeq, key };
+  }
+  getFilesChangedSince(seq) {
+    const changed = [];
+    for (const [key, lastSeq] of this._fileLastProjectSeq) {
+      if (lastSeq > seq)
+        changed.push(key);
+    }
+    return changed;
+  }
+  getFileSeq(filePath) {
+    return this._fileSeq.get(normalizeMapKey(path.resolve(filePath))) ?? 0;
+  }
+  getFileSeqEntries() {
+    return [...this._fileSeq.entries()];
+  }
+  get sessionGeneration() {
+    return this._scope.scopeId;
+  }
+  get sessionScope() {
+    return this._scope;
+  }
+  captureSessionGeneration() {
+    return this._scope.capture();
+  }
+  isCurrentSession(generation) {
+    return this._scope.scopeId === generation && this._scope.isLive();
+  }
+  markStartupScanInFlight(name, generation) {
+    this._startupScansInFlight.set(name, generation);
+  }
+  clearStartupScanInFlight(name, generation) {
+    const owner = this._startupScansInFlight.get(name);
+    if (owner === generation) {
+      this._startupScansInFlight.delete(name);
+    }
+  }
+  isStartupScanInFlight(name) {
+    return this._startupScansInFlight.has(name);
+  }
+  formatPipelineCrashNotice(filePath, err) {
+    const key = path.resolve(filePath);
+    const count = (this._pipelineCrashCounts.get(key) ?? 0) + 1;
+    this._pipelineCrashCounts.set(key, count);
+    const message = err instanceof Error ? err.message : String(err);
+    const shortMessage = message.split(`
+`)[0].slice(0, 220);
+    const shouldSurface = count <= RUNTIME_CONFIG.crashNotice.alwaysShowFirstN || count % RUNTIME_CONFIG.crashNotice.showEveryNth === 0;
+    if (!shouldSurface)
+      return "";
+    return [
+      "⚠️ dm-lens pipeline crashed while analyzing this write.",
+      `File: ${path.basename(filePath)} | crash count this session: ${count}`,
+      `Error: ${shortMessage}`,
+      "Recovery: LSP service was reset. If this repeats, rerun with --no-lsp and report the file + stack."
+    ].join(`
+`);
+  }
+  getCrashEntries() {
+    return Array.from(this._pipelineCrashCounts.entries());
+  }
+  get projectRoot() {
+    return this._projectRoot;
+  }
+  set projectRoot(value) {
+    this._projectRoot = normalizeMapKey(value);
+  }
+  get errorDebtBaseline() {
+    return this._errorDebtBaseline;
+  }
+  set errorDebtBaseline(value) {
+    this._errorDebtBaseline = value;
+  }
+  get cachedExports() {
+    return this._cachedExports;
+  }
+  appendCascadeRun(run) {
+    this._cascadeRuns.push(run);
+  }
+  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;
+    }
+    recordDegradationOnce({
+      kind: "cascade-pending-cap",
+      subject: "runtime-coordinator",
+      reason: `deferred cascade admission capped at ${MAX_PENDING_CASCADE_RUNS}`
+    });
+    p.then((run) => generation.guardedWrite(run.filePath, () => this.appendCascadeRun(run))).catch(() => {});
+  }
+  getTurnEndCascadeSettleStart() {
+    let latest;
+    for (const start of this._turnEndCascadeSettleStarts.values())
+      latest = start;
+    return latest;
+  }
+  async settleCascadeRuns(maxWaitMs, settleOptions = {}) {
+    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) {
+      this._turnEndCascadeSettleStarts.set(settleToken, Date.now());
+    }
+    try {
+      const tracked = pending.map((p) => {
+        const entry = { done: false, promise: p };
+        entry.promise = p.then((run) => {
+          entry.done = true;
+          entry.run = run;
+          return run;
+        });
+        return entry;
+      });
+      const timeout = new Promise((resolve) => {
+        setTimeout(resolve, maxWaitMs).unref?.();
+      });
+      await Promise.race([
+        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) {
+        const { run } = entry;
+        if (entry.done && run) {
+          commit(run.filePath, () => this.appendCascadeRun(run));
+          settled += 1;
+        } else {
+          commit("cascade-pending", () => this._pendingCascadeRuns.push(entry.promise));
+          timedOut += 1;
+        }
+      }
+      return { settled, timedOut };
+    } finally {
+      if (settleToken !== undefined) {
+        this._turnEndCascadeSettleStarts.delete(settleToken);
+      }
+    }
+  }
+  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 = [];
+    return runs;
+  }
+  hasCascadeRuns() {
+    return this._cascadeRuns.length > 0;
+  }
+  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,
+      recordedAtMs,
+      stale: false,
+      ...contentBaseline ? {
+        recordedSize: contentBaseline.size,
+        recordedHash: contentBaseline.sha256
+      } : {}
+    });
+    return recordedAtMs;
+  }
+  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);
+    const existing = this._pendingInlineBlockers.get(key);
+    if (!existing || existing.stale)
+      return false;
+    this._pendingInlineBlockers.set(key, {
+      ...existing,
+      stale: true,
+      staleReason: reason
+    });
+    return true;
+  }
+  setInlineBlockerPastEofStale(filePath, isPastEof) {
+    const key = path.resolve(filePath);
+    const existing = this._pendingInlineBlockers.get(key);
+    if (!existing)
+      return false;
+    if (existing.stale && existing.staleReason !== "past-eof")
+      return false;
+    const currentlyPastEof = !!existing.stale && existing.staleReason === "past-eof";
+    if (currentlyPastEof === isPastEof)
+      return false;
+    this._pendingInlineBlockers.set(key, {
+      ...existing,
+      stale: isPastEof,
+      staleReason: isPastEof ? "past-eof" : undefined
+    });
+    return true;
+  }
+  setInlineBlockerSelfDriftStale(filePath, isSelfDrift) {
+    const key = path.resolve(filePath);
+    const existing = this._pendingInlineBlockers.get(key);
+    if (!existing)
+      return false;
+    if (existing.stale && existing.staleReason !== "self-drift")
+      return false;
+    const currentlySelfDrift = !!existing.stale && existing.staleReason === "self-drift";
+    if (currentlySelfDrift === isSelfDrift)
+      return false;
+    const { staleReason: _cleared, ...rest } = existing;
+    this._pendingInlineBlockers.set(key, {
+      ...rest,
+      stale: isSelfDrift,
+      ...isSelfDrift ? { staleReason: "self-drift" } : {}
+    });
+    return true;
+  }
+  retireDemotedPastEofBlocker(filePath, deadLines) {
+    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;
+    if (!existing.stale)
+      return;
+    return (existing.staleReason ?? "past-eof") === "past-eof" ? key : undefined;
+  }
+  peekInlineBlockerStaleDeliveryCount(filePath) {
+    const key = path.resolve(filePath);
+    return this._pendingInlineBlockers.get(key)?.staleDeliveryCount ?? 0;
+  }
+  incrementInlineBlockerStaleDelivery(filePath) {
+    const key = path.resolve(filePath);
+    const existing = this._pendingInlineBlockers.get(key);
+    if (!existing)
+      return 0;
+    const next = (existing.staleDeliveryCount ?? 0) + 1;
+    this._pendingInlineBlockers.set(key, {
+      ...existing,
+      staleDeliveryCount: next
+    });
+    return next;
+  }
+  retireDemotedDependencyDriftBlocker(filePath) {
+    const key = path.resolve(filePath);
+    const existing = this._pendingInlineBlockers.get(key);
+    if (!existing)
+      return false;
+    if (!existing.stale)
+      return false;
+    if (existing.staleReason !== "dependency-drift")
+      return false;
+    this._pendingInlineBlockers.delete(key);
+    return true;
+  }
+  retireInlineBlockerOnConfirmedClean(filePath, confirmedAtWriteOrder, coveredSources) {
+    const key = path.resolve(filePath);
+    const existing = this._pendingInlineBlockers.get(key);
+    if (!existing)
+      return false;
+    if (existing.writeOrder !== undefined && confirmedAtWriteOrder !== undefined && confirmedAtWriteOrder <= existing.writeOrder) {
+      return false;
+    }
+    if (!existing.sources || existing.sources.length === 0)
+      return false;
+    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()) {
+      if (fs.existsSync(displayPath))
+        survivors.push([displayPath, value]);
+    }
+    if (survivors.length !== this._pendingInlineBlockers.size) {
+      this._pendingInlineBlockers.clear();
+      for (const [displayPath, value] of survivors) {
+        this._pendingInlineBlockers.set(displayPath, value);
+      }
+    }
+  }
+  getInlineBlockersSnapshot() {
+    this.reconcileInlineBlockers();
+    return [...this._pendingInlineBlockers.values()];
+  }
+  consumeInlineBlockers() {
+    const entries = this.getInlineBlockersSnapshot();
+    this._pendingInlineBlockers.clear();
+    return entries;
+  }
+  turnSession(sessionId) {
+    return sessionId ?? this._telemetrySessionId;
+  }
+  recordActionableWarnings(warnings, sessionId) {
+    this._actionableWarningsThisTurn.add(this.turnSession(sessionId), warnings);
+  }
+  peekActionableWarnings(sessionId) {
+    return this._actionableWarningsThisTurn.peek(this.turnSession(sessionId));
+  }
+  clearActionableWarnings(sessionId) {
+    this._actionableWarningsThisTurn.clear(this.turnSession(sessionId));
+  }
+  recordCodeQualityWarnings(warnings, sessionId) {
+    this._codeQualityWarningsThisTurn.add(this.turnSession(sessionId), warnings);
+  }
+  peekCodeQualityWarnings(sessionId) {
+    return this._codeQualityWarningsThisTurn.peek(this.turnSession(sessionId));
+  }
+  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;
+  }
+  get complexityBaselines() {
+    return this._complexityBaselines;
+  }
+  get fixedThisTurn() {
+    const facade = {
+      add: (filePath) => {
+        this._fixedThisTurn.set(filePath, true);
+        return facade;
+      },
+      has: (filePath) => this._fixedThisTurn.has(filePath),
+      delete: (filePath) => this._fixedThisTurn.delete(filePath),
+      clear: () => this._fixedThisTurn.clear()
+    };
+    return facade;
+  }
+  get projectRulesScan() {
+    return this._projectRulesScan;
+  }
+  set projectRulesScan(value) {
+    this._projectRulesScan = value;
+  }
+  get readGuard() {
+    this._readGuard ??= new ReadGuard(this._telemetrySessionId, {}, this._scope);
+    return this._readGuard;
+  }
+  recordToolCallAttribution(toolCallId, attribution) {
+    this._toolCallAttributions.set(toolCallId, {
+      ...attribution,
+      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)
+      return;
+    this._toolCallAttributions.delete(toolCallId);
+    if (Date.now() - attribution.recordedAt > TOOL_CALL_ATTRIBUTION_TTL_MS) {
+      return;
+    }
+    return attribution;
+  }
+  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;
+      existing.turnStateCwd = turnStateCwd;
+      existing.toolNames.add(toolName);
+      existing.kinds.add(kind);
+      existing.queuedTurnIndex = this._turnIndex;
+      existing.queuedTurnId = `${this._telemetrySessionId}:${this._turnIndex}`;
+      existing.ownerSessionId = ownerSessionId;
+      existing.originCwd = resolvedOriginCwd;
+      return addedKind;
+    }
+    this._pendingDeferredMutations.set(key, {
+      filePath: key,
+      cwd,
+      turnStateCwd,
+      firstTouchedAt: now,
+      lastTouchedAt: now,
+      toolNames: new Set([toolName]),
+      kinds: new Set([kind]),
+      queuedTurnIndex: this._turnIndex,
+      queuedTurnId: `${this._telemetrySessionId}:${this._turnIndex}`,
+      ownerSessionId,
+      originCwd: resolvedOriginCwd,
+      readGuardBranchEpoch
+    });
+    return true;
+  }
+  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;
+  }
+  get pendingDeferredMutationCount() {
+    return this._pendingDeferredMutations.size;
+  }
+  consumeDeferredFormatFiles() {
+    const records = [...this._pendingDeferredMutations.values()];
+    this._pendingDeferredMutations.clear();
+    return records;
+  }
+  claimDeferredFormatFiles(currentSessionId, now, staleAfterMs, currentOriginCwd) {
+    const claimed = [];
+    const staleClaimed = [];
+    const deferredToOwner = [];
+    const droppedOrphans = [];
+    for (const [key, record] of this._pendingDeferredMutations) {
+      const sameSession = record.ownerSessionId === undefined || currentSessionId === undefined || record.ownerSessionId === currentSessionId;
+      if (sameSession) {
+        claimed.push(record);
+        this._pendingDeferredMutations.delete(key);
+        continue;
+      }
+      const age = now - record.lastTouchedAt;
+      if (age > staleAfterMs) {
+        const originMatches = currentOriginCwd === undefined || pathsEqual(record.originCwd, currentOriginCwd);
+        if (originMatches) {
+          this._pendingDeferredMutations.delete(key);
+          staleClaimed.push(record);
+        } else {
+          droppedOrphans.push(record);
+        }
+        continue;
+      }
+      deferredToOwner.push(record);
+    }
+    return { claimed, staleClaimed, deferredToOwner, droppedOrphans };
+  }
+  requeueDeferredFormatFiles(records) {
+    for (const record of records) {
+      const key = path.resolve(record.filePath);
+      const existing = this._pendingDeferredMutations.get(key);
+      if (existing) {
+        for (const kind of record.kinds)
+          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, {
+        ...record,
+        kinds: new Set(record.kinds),
+        toolNames: new Set(record.toolNames)
+      });
+    }
+  }
+  claimDeferredMutations(currentSessionId, now, staleAfterMs, currentOriginCwd) {
+    return this.claimDeferredFormatFiles(currentSessionId, now, staleAfterMs, currentOriginCwd);
+  }
+  requeueDeferredMutations(records) {
+    this.requeueDeferredFormatFiles(records);
+  }
+  shouldWarmLspOnRead(filePath, maxAgeMs = 120000) {
+    const state = this._lspReadWarmState.get(path.resolve(filePath));
+    if (!state)
+      return true;
+    if (state.status === "warming")
+      return false;
+    return Date.now() - state.ts > maxAgeMs;
+  }
+  markLspReadWarmStarted(filePath) {
+    this._lspReadWarmState.set(path.resolve(filePath), {
+      status: "warming",
+      ts: Date.now()
+    });
+  }
+  markLspReadWarmCompleted(filePath) {
+    this._lspReadWarmState.set(path.resolve(filePath), {
+      status: "ready",
+      ts: Date.now()
+    });
+  }
+  clearLspReadWarmState(filePath) {
+    this._lspReadWarmState.delete(path.resolve(filePath));
+  }
+}
+export function readHostModelIdentity(ctx) {
+  try {
+    const model = ctx?.model;
+    return {
+      model: typeof model?.id === "string" ? model.id : undefined,
+      provider: typeof model?.provider === "string" ? model.provider : undefined
+    };
+  } catch {
+    return {};
+  }
+}