@duckmind/dm-linux-x64 0.66.0 → 0.66.2

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

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