@duckmind/dm-linux-x64 0.65.5 → 0.65.6

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

@@ -0,0 +1,817 @@
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { logCascade } from "./cascade-logger.js";
+import { appendProjectChange } from "./project-changes.js";
+import { normalizeMapKey, pathsEqual } from "./path-utils.js";
+import { PathKeyedMap } from "./path-keyed-map.js";
+import { 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";
+export const MAX_PENDING_CASCADE_RUNS = 32;
+const MAX_MUTATION_RECEIPTS = 512;
+const TOOL_CALL_ATTRIBUTION_CAPACITY = 256;
+const TOOL_CALL_ATTRIBUTION_TTL_MS = 5 * 60000;
+
+export class RuntimeCoordinator {
+  _projectRoot = normalizeMapKey(process.cwd());
+  _sessionGeneration = 0;
+  _sessionStartedAt = Date.now();
+  _errorDebtBaseline = null;
+  _pipelineCrashCounts = new Map;
+  _cachedExports = new Map;
+  _startupScansInFlight = new Map;
+  _cascadeRuns = [];
+  _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 = `lens-${Date.now().toString(36)}`;
+  _lifecycleReason;
+  _hasStableSessionId = false;
+  _telemetryModel = "unknown";
+  _telemetryModelId = "";
+  _telemetryProvider = "";
+  _telemetryProviderIsExplicit = false;
+  _turnIndex = 0;
+  _writeIndex = 0;
+  _projectSeq = 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);
+  _lspReadWarmState = new Map;
+  _pendingInlineBlockers = new PathKeyedMap(normalizeMapKey);
+  _actionableWarningsThisTurn = new Map;
+  _codeQualityWarningsThisTurn = new Map;
+  _turnSummary = new TurnSummaryCollector;
+  partialApplyRecords = new PartialApplyRecordStore;
+  resetForSession(startedAt = Date.now()) {
+    this._sessionGeneration += 1;
+    this._sessionStartedAt = startedAt;
+    this._complexityBaselines.clear();
+    this._pipelineCrashCounts.clear();
+    this._cachedExports.clear();
+    this.wordIndex = null;
+    this._startupScansInFlight.clear();
+    this._cascadeRuns = [];
+    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._telemetrySessionId = `lens-${Date.now().toString(36)}-${randomBytes(4).toString("hex")}`;
+    this._hasStableSessionId = false;
+    this._telemetryModel = "unknown";
+    this._telemetryModelId = "";
+    this._telemetryProvider = "";
+    this._telemetryProviderIsExplicit = false;
+    this._turnIndex = 0;
+    this._writeIndex = 0;
+    this._projectSeq = 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._lspReadWarmState.clear();
+    this._pendingInlineBlockers.clear();
+    this._actionableWarningsThisTurn.clear();
+    this._codeQualityWarningsThisTurn.clear();
+    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 === 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() {
+    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();
+    this._codeQualityWarningsThisTurn.clear();
+    this._turnStartProjectSeq = this._projectSeq;
+    this._turnIndex += 1;
+    beginTurnContext(this._telemetrySessionId);
+    this._writeIndex = 0;
+    this._reportedThisTurn.clear();
+    this._writtenThisTurn.clear();
+    this._autofixDemotedThisTurn.clear();
+  }
+  recordProjectMutation(args) {
+    const { projectSeq, fileSeq, key } = 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()
+    });
+    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) {
+    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;
+  }
+  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 projectSeq() {
+    return this._projectSeq;
+  }
+  get turnStartProjectSeq() {
+    return this._turnStartProjectSeq;
+  }
+  seedProjectSequence(projectSeq, fileSeqByPath) {
+    this._projectSeq = Math.max(0, Math.floor(projectSeq));
+    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));
+    }
+  }
+  bumpFileSeq(filePath) {
+    const key = normalizeMapKey(path.resolve(filePath));
+    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._sessionGeneration;
+  }
+  isCurrentSession(generation) {
+    return this._sessionGeneration === generation;
+  }
+  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) {
+    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) => 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 };
+    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
+      ]);
+      let settled = 0;
+      let timedOut = 0;
+      for (const entry of tracked) {
+        if (entry.done && entry.run) {
+          this.appendCascadeRun(entry.run);
+          settled += 1;
+        } else {
+          this._pendingCascadeRuns.push(entry.promise);
+          timedOut += 1;
+        }
+      }
+      return { settled, timedOut };
+    } finally {
+      if (settleToken !== undefined) {
+        this._turnEndCascadeSettleStarts.delete(settleToken);
+      }
+    }
+  }
+  consumeCascadeRuns() {
+    const runs = this._cascadeRuns;
+    this._cascadeRuns = [];
+    return runs;
+  }
+  hasCascadeRuns() {
+    return this._cascadeRuns.length > 0;
+  }
+  recordInlineBlockers(filePath, summary, writeIndex, sources, lines, contentBaseline, diagnostics) {
+    const recordedAtMs = Date.now();
+    this._pendingInlineBlockers.set(path.resolve(filePath), {
+      filePath,
+      summary,
+      writeIndex,
+      sources,
+      lines,
+      diagnostics,
+      recordedAtMs,
+      stale: false,
+      ...contentBaseline ? {
+        recordedSize: contentBaseline.size,
+        recordedHash: contentBaseline.sha256
+      } : {}
+    });
+    return recordedAtMs;
+  }
+  clearInlineBlockers(filePath) {
+    this._pendingInlineBlockers.delete(path.resolve(filePath));
+  }
+  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) {
+    if (deadLines.length === 0)
+      return false;
+    const key = path.resolve(filePath);
+    const existing = this._pendingInlineBlockers.get(key);
+    if (!existing)
+      return false;
+    if (!existing.stale)
+      return false;
+    if ((existing.staleReason ?? "past-eof") !== "past-eof")
+      return false;
+    this._pendingInlineBlockers.delete(key);
+    return true;
+  }
+  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, confirmedAtWriteIndex, 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) {
+      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._pendingInlineBlockers.delete(key);
+    return true;
+  }
+  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;
+  }
+  recordActionableWarnings(warnings) {
+    for (const warning of warnings) {
+      this._actionableWarningsThisTurn.set(warning.id, warning);
+    }
+  }
+  peekActionableWarnings() {
+    return [...this._actionableWarningsThisTurn.values()];
+  }
+  clearActionableWarnings() {
+    this._actionableWarningsThisTurn.clear();
+  }
+  recordCodeQualityWarnings(warnings) {
+    for (const warning of warnings) {
+      this._codeQualityWarningsThisTurn.set(warning.id, warning);
+    }
+  }
+  peekCodeQualityWarnings() {
+    return [...this._codeQualityWarningsThisTurn.values()];
+  }
+  clearCodeQualityWarnings() {
+    this._codeQualityWarningsThisTurn.clear();
+  }
+  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);
+    return this._readGuard;
+  }
+  recordToolCallAttribution(toolCallId, attribution) {
+    this._toolCallAttributions.set(toolCallId, {
+      ...attribution,
+      recordedAt: Date.now()
+    });
+  }
+  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) {
+    const key = path.resolve(filePath);
+    const now = Date.now();
+    const resolvedOriginCwd = originCwd ?? turnStateCwd;
+    const existing = this._pendingDeferredMutations.get(key);
+    if (existing) {
+      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
+    });
+    return true;
+  }
+  deferFormat(filePath, cwd, toolName, turnStateCwd, ownerSessionId, originCwd) {
+    return this.deferMutation(filePath, cwd, toolName, turnStateCwd, "format", ownerSessionId, originCwd);
+  }
+  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);
+        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 {};
+  }
+}