@adhdev/daemon-core 0.9.82-rc.332 → 0.9.82-rc.333

package/dist/index.mjs

@@ -311,10 +311,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "2466d8b001000d509eb9058a0c51ec6f383741ed" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "2466d8b0" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.332" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-20T01:55:54.421Z" : void 0);
+  const commit = readInjected(true ? "5d9635b2a6476691469ecfe32b26a17e13484b2b" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "5d9635b2" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.333" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-20T02:23:56.856Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -582,10 +582,10 @@ async function getGitRepoStatus(workspace, options = {}) {
   } catch (error) {
     const gitError = error instanceof GitCommandError ? error : new GitCommandError("git_command_failed", "Failed to read Git status", { cause: error });
     if (isTransientGitFailure(gitError)) {
-      const cached2 = lastKnownGoodStatus.get(workspace);
-      if (cached2) {
+      const cached3 = lastKnownGoodStatus.get(workspace);
+      if (cached3) {
         return {
-          ...cached2,
+          ...cached3,
           lastCheckedAt,
           upstreamStatus: "unavailable",
           error: gitError.stderr || gitError.message,
@@ -708,9 +708,9 @@ function resolveChangeImpactConfigForRepo(repoRoot, options) {
     return { config: null, sourceKey: "no-repo-root" };
   }
   const loaded = loadChangeImpactConfig(repoRoot);
-  const cached2 = changeImpactConfigCache.get(repoRoot);
-  if (cached2 && cached2.sourceKey === loaded.sourceKey) {
-    return { config: cached2.config, sourceKey: loaded.sourceKey };
+  const cached3 = changeImpactConfigCache.get(repoRoot);
+  if (cached3 && cached3.sourceKey === loaded.sourceKey) {
+    return { config: cached3.config, sourceKey: loaded.sourceKey };
   }
   const config = loaded.sourceType === "repo_file" ? loaded.config ?? null : null;
   changeImpactConfigCache.set(repoRoot, { sourceKey: loaded.sourceKey, config });
@@ -2536,6 +2536,46 @@ Follow these recovery rules:
   }
 });
 
+// src/system/load-better-sqlite3.ts
+import { createRequire } from "module";
+function loadBetterSqlite3() {
+  if (cached2) return cached2;
+  const errors = [];
+  if (typeof __require === "function") {
+    try {
+      cached2 = __require("better-sqlite3");
+      return cached2;
+    } catch (e) {
+      errors.push(e);
+    }
+  }
+  try {
+    const metaUrl = typeof import.meta?.url === "string" ? import.meta.url : void 0;
+    if (metaUrl) {
+      cached2 = createRequire(metaUrl)("better-sqlite3");
+      return cached2;
+    }
+  } catch (e) {
+    errors.push(e);
+  }
+  try {
+    cached2 = createRequire(`${process.cwd()}/__adhdev_better_sqlite3_loader__.js`)(
+      "better-sqlite3"
+    );
+    return cached2;
+  } catch (e) {
+    errors.push(e);
+  }
+  const detail = errors.map((e) => e instanceof Error ? e.message : String(e)).join("; ");
+  throw new Error(`Failed to load better-sqlite3: ${detail}`);
+}
+var cached2;
+var init_load_better_sqlite3 = __esm({
+  "src/system/load-better-sqlite3.ts"() {
+    "use strict";
+  }
+});
+
 // src/mesh/mesh-ledger.ts
 var mesh_ledger_exports = {};
 __export(mesh_ledger_exports, {
@@ -2969,8 +3009,8 @@ function readLedgerFromStore(meshId) {
 }
 function getCachedRawEntries(meshId) {
   const now = Date.now();
-  const cached2 = ledgerReadCache.get(meshId);
-  if (cached2 && now - cached2.cachedAt < LEDGER_CACHE_TTL_MS) return cached2.entries;
+  const cached3 = ledgerReadCache.get(meshId);
+  if (cached3 && now - cached3.cachedAt < LEDGER_CACHE_TTL_MS) return cached3.entries;
   let entries;
   try {
     entries = readLedgerFromStore(meshId);
@@ -3849,11 +3889,9 @@ var init_mesh_work_queue = __esm({
 // src/mesh/mesh-runtime-store.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync6, renameSync as renameSync2, statSync as statSync4 } from "fs";
 import { dirname as dirname2, join as join8 } from "path";
-import { createRequire } from "module";
 function loadDatabaseCtor() {
   if (DatabaseCtor) return DatabaseCtor;
-  const runtimeRequire = typeof __require === "function" ? __require : createRequire(import.meta.url);
-  DatabaseCtor = runtimeRequire("better-sqlite3");
+  DatabaseCtor = loadBetterSqlite3();
   return DatabaseCtor;
 }
 function safeMeshId(meshId) {
@@ -3884,6 +3922,7 @@ var DatabaseCtor, MeshRuntimeStore;
 var init_mesh_runtime_store = __esm({
   "src/mesh/mesh-runtime-store.ts"() {
     "use strict";
+    init_load_better_sqlite3();
     init_mesh_ledger();
     init_mesh_work_queue();
     MeshRuntimeStore = class _MeshRuntimeStore {
@@ -9415,8 +9454,8 @@ function resolveCoordinatorDrainDaemonIds(components) {
 }
 function getCachedMeshByWorkspace(workspace) {
   const now = Date.now();
-  const cached2 = meshByWorkspaceCache.get(workspace);
-  if (cached2 && now - cached2.cachedAt < MESH_WORKSPACE_CACHE_TTL_MS) return cached2.mesh;
+  const cached3 = meshByWorkspaceCache.get(workspace);
+  if (cached3 && now - cached3.cachedAt < MESH_WORKSPACE_CACHE_TTL_MS) return cached3.mesh;
   const mesh = getMeshByRepo(workspace);
   meshByWorkspaceCache.set(workspace, { mesh, cachedAt: now });
   return mesh;
@@ -15260,10 +15299,10 @@ ${lastSnapshot}`;
         return this.accumulatedRawBuffer.replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, "").replace(/\x1B[P^_X][\s\S]*?(?:\x07|\x1B\\)/g, "").replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
       }
       getFreshParsedStatusCache() {
-        const cached2 = this.parsedStatusCache;
+        const cached3 = this.parsedStatusCache;
         const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
-        if (cached2 && cached2.responseBuffer === this.responseBuffer && cached2.currentTurnScope === this.engine.currentTurnScope && cached2.recentOutputBuffer === this.recentOutputBuffer && cached2.accumulatedBuffer === this.accumulatedBuffer && cached2.accumulatedRawBufferKey === accumulatedRawBufferKey && cached2.screenText === this.lastScreenText && cached2.currentStatus === this.engine.currentStatus && cached2.activeModal === this.engine.activeModal && cached2.cliName === this.cliName) {
-          return cached2.result;
+        if (cached3 && cached3.responseBuffer === this.responseBuffer && cached3.currentTurnScope === this.engine.currentTurnScope && cached3.recentOutputBuffer === this.recentOutputBuffer && cached3.accumulatedBuffer === this.accumulatedBuffer && cached3.accumulatedRawBufferKey === accumulatedRawBufferKey && cached3.screenText === this.lastScreenText && cached3.currentStatus === this.engine.currentStatus && cached3.activeModal === this.engine.activeModal && cached3.cliName === this.cliName) {
+          return cached3.result;
         }
         return null;
       }
@@ -15725,10 +15764,10 @@ ${lastSnapshot}`;
       getScriptParsedStatus() {
         const screenText = this.readTerminalScreenText();
         const parseScreenText = this.getParseScreenText(screenText);
-        const cached2 = this.parsedStatusCache;
+        const cached3 = this.parsedStatusCache;
         const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
-        if (!this.providerOwnsTranscript() && cached2 && cached2.responseBuffer === this.responseBuffer && cached2.currentTurnScope === this.engine.currentTurnScope && cached2.recentOutputBuffer === this.recentOutputBuffer && cached2.accumulatedBuffer === this.accumulatedBuffer && cached2.accumulatedRawBufferKey === accumulatedRawBufferKey && cached2.screenText === parseScreenText && cached2.currentStatus === this.engine.currentStatus && cached2.activeModal === this.engine.activeModal && cached2.cliName === this.cliName) {
-          return cached2.result;
+        if (!this.providerOwnsTranscript() && cached3 && cached3.responseBuffer === this.responseBuffer && cached3.currentTurnScope === this.engine.currentTurnScope && cached3.recentOutputBuffer === this.recentOutputBuffer && cached3.accumulatedBuffer === this.accumulatedBuffer && cached3.accumulatedRawBufferKey === accumulatedRawBufferKey && cached3.screenText === parseScreenText && cached3.currentStatus === this.engine.currentStatus && cached3.activeModal === this.engine.activeModal && cached3.cliName === this.cliName) {
+          return cached3.result;
         }
         const parsed = this.runParseSession();
         if (!parsed || !Array.isArray(parsed.messages)) {
@@ -22129,11 +22168,11 @@ var savedHistoryRollupInFlight = /* @__PURE__ */ new Set();
 var BOUNDED_TAIL_CACHE_MAX_ENTRIES = 64;
 var boundedTailReadCache = /* @__PURE__ */ new Map();
 function readBoundedTailCache(key, signature) {
-  const cached2 = boundedTailReadCache.get(key);
-  if (!cached2 || cached2.signature !== signature) return null;
+  const cached3 = boundedTailReadCache.get(key);
+  if (!cached3 || cached3.signature !== signature) return null;
   boundedTailReadCache.delete(key);
-  boundedTailReadCache.set(key, cached2);
-  return cached2.result;
+  boundedTailReadCache.set(key, cached3);
+  return cached3.result;
 }
 function writeBoundedTailCache(key, signature, result) {
   boundedTailReadCache.delete(key);
@@ -22617,9 +22656,9 @@ function computeSavedHistorySessionSummaries(agentType, dir, files, fileSignatur
   for (const file of files.slice().sort()) {
     const filePath = path14.join(dir, file);
     const signature = fileSignatures.get(file) || `${file}:missing`;
-    const cached2 = savedHistoryFileSummaryCache.get(filePath);
+    const cached3 = savedHistoryFileSummaryCache.get(filePath);
     const persisted = persistedEntries.get(file);
-    const reusableEntry = cached2?.signature === signature ? cached2 : persisted?.signature === signature ? persisted : null;
+    const reusableEntry = cached3?.signature === signature ? cached3 : persisted?.signature === signature ? persisted : null;
     const fileSummary = reusableEntry?.summary || computeSavedHistoryFileSummary(dir, file);
     const nextEntry = reusableEntry || {
       signature,
@@ -23115,16 +23154,16 @@ function readFileTailLines(filePath, needed) {
     incrementalTailCache.delete(filePath);
     return { lines: [], coversWholeFile: true };
   }
-  const cached2 = incrementalTailCache.get(filePath);
-  if (cached2) {
-    if (cached2.size === size && cached2.mtimeMs === mtimeMs) {
+  const cached3 = incrementalTailCache.get(filePath);
+  if (cached3) {
+    if (cached3.size === size && cached3.mtimeMs === mtimeMs) {
       incrementalTailCache.delete(filePath);
-      incrementalTailCache.set(filePath, cached2);
-      if (cached2.coversWholeFile || cached2.lines.length >= needed) {
-        return { lines: cached2.lines, coversWholeFile: cached2.coversWholeFile };
+      incrementalTailCache.set(filePath, cached3);
+      if (cached3.coversWholeFile || cached3.lines.length >= needed) {
+        return { lines: cached3.lines, coversWholeFile: cached3.coversWholeFile };
       }
-    } else if (size > cached2.size) {
-      const incremental = tryIncrementalTailGrowth(filePath, cached2, size, mtimeMs, needed);
+    } else if (size > cached3.size) {
+      const incremental = tryIncrementalTailGrowth(filePath, cached3, size, mtimeMs, needed);
       if (incremental) return { lines: incremental.lines, coversWholeFile: incremental.coversWholeFile };
     }
     incrementalTailCache.delete(filePath);
@@ -23150,22 +23189,22 @@ function readFileTailLines(filePath, needed) {
   storeIncrementalTailCache(filePath, result.size, result.mtimeMs, result.lines, result.coversWholeFile);
   return { lines: result.lines, coversWholeFile: result.coversWholeFile };
 }
-function tryIncrementalTailGrowth(filePath, cached2, size, mtimeMs, needed) {
+function tryIncrementalTailGrowth(filePath, cached3, size, mtimeMs, needed) {
   const fd = fs6.openSync(filePath, "r");
   try {
-    if (cached2.size > 0) {
+    if (cached3.size > 0) {
       const boundary = Buffer.alloc(1);
-      fs6.readSync(fd, boundary, 0, 1, cached2.size - 1);
+      fs6.readSync(fd, boundary, 0, 1, cached3.size - 1);
       if (boundary[0] !== 10) return null;
     }
-    const appendedLength = size - cached2.size;
+    const appendedLength = size - cached3.size;
     const appended = Buffer.alloc(appendedLength);
-    fs6.readSync(fd, appended, 0, appendedLength, cached2.size);
+    fs6.readSync(fd, appended, 0, appendedLength, cached3.size);
     const newLines = appended.toString("utf-8").split("\n");
     if (newLines.length && newLines[newLines.length - 1] === "") newLines.pop();
-    const merged = cached2.lines.concat(newLines);
+    const merged = cached3.lines.concat(newLines);
     const trimmed = merged.length > TAIL_LINES_RETAINED ? merged.slice(merged.length - TAIL_LINES_RETAINED) : merged;
-    const coversWholeFile = cached2.coversWholeFile && trimmed.length === merged.length;
+    const coversWholeFile = cached3.coversWholeFile && trimmed.length === merged.length;
     storeIncrementalTailCache(filePath, size, mtimeMs, trimmed, coversWholeFile);
     if (coversWholeFile || trimmed.length >= needed) {
       return { lines: trimmed, coversWholeFile };
@@ -23230,8 +23269,8 @@ function readChatHistory(agentType, offset = 0, limit = 30, historySessionId, ex
       const fileSignatures = buildSavedHistoryFileSignatureMap(dir, files);
       const cacheKey = `${sanitized}\0${historySessionId || ""}\0${offset}\0${limit}\0${excludeRecentCount}\0${historyBehavior?.collapseConsecutiveAssistantTurns ? "1" : "0"}`;
       const signature = buildSavedHistoryCacheSignature(files, fileSignatures);
-      const cached2 = readBoundedTailCache(cacheKey, signature);
-      if (cached2) return cached2;
+      const cached3 = readBoundedTailCache(cacheKey, signature);
+      if (cached3) return cached3;
       const numericLimit = Math.max(1, Number(limit));
       const numericOffset = Math.max(0, Number(offset));
       const numericExclude = Math.max(0, Number(excludeRecentCount));
@@ -23274,23 +23313,23 @@ function listSavedHistorySessions(agentType, options = {}, historyBehavior) {
       savedHistorySessionCache.delete(sanitized);
       return { sessions: [], hasMore: false };
     }
-    const cached2 = savedHistorySessionCache.get(sanitized);
+    const cached3 = savedHistorySessionCache.get(sanitized);
     const offset = Math.max(0, options.offset || 0);
     const limit = Math.max(1, options.limit || 30);
     const indexSignature = buildSavedHistoryIndexFileSignature(dir);
     let cacheWasInvalidated = false;
-    if (cached2) {
-      const cacheLooksPersisted = cached2.signature.startsWith("index:");
-      const cacheStillValid = cacheLooksPersisted ? cached2.signature === indexSignature : (() => {
+    if (cached3) {
+      const cacheLooksPersisted = cached3.signature.startsWith("index:");
+      const cacheStillValid = cacheLooksPersisted ? cached3.signature === indexSignature : (() => {
         const files2 = listHistoryFiles(dir);
         const fileSignatures2 = buildSavedHistoryFileSignatureMap(dir, files2);
-        return cached2.signature === buildSavedHistoryCacheSignature(files2, fileSignatures2);
+        return cached3.signature === buildSavedHistoryCacheSignature(files2, fileSignatures2);
       })();
       if (cacheStillValid) {
-        const sliced2 = cached2.summaries.slice(offset, offset + limit);
+        const sliced2 = cached3.summaries.slice(offset, offset + limit);
         return {
           sessions: sliced2,
-          hasMore: cached2.summaries.length > offset + limit
+          hasMore: cached3.summaries.length > offset + limit
         };
       }
       cacheWasInvalidated = true;
@@ -32235,6 +32274,7 @@ function collectStableSizes(when, sizes) {
 
 // src/providers/spec/native-history-executor.ts
 init_logger();
+init_load_better_sqlite3();
 import * as fs13 from "fs";
 import * as os17 from "os";
 import * as path22 from "path";
@@ -32362,7 +32402,7 @@ function executeSqlite(src, input) {
   if (!resolved || !fs13.existsSync(resolved)) return null;
   let Database;
   try {
-    Database = __require("better-sqlite3");
+    Database = loadBetterSqlite3();
   } catch {
     return null;
   }
@@ -39188,6 +39228,7 @@ function readSession3(sessionPath, sessionId, workspace) {
 }
 
 // src/providers/native-history/hermes-cli-transcript.ts
+init_load_better_sqlite3();
 import * as fs20 from "fs";
 import * as path30 from "path";
 import * as os21 from "os";
@@ -39203,7 +39244,7 @@ function statMtimeMs4(p) {
 function openDb() {
   if (!fs20.existsSync(HERMES_STATE_DB)) return null;
   try {
-    const Database = __require("better-sqlite3");
+    const Database = loadBetterSqlite3();
     return new Database(HERMES_STATE_DB, { readonly: true, fileMustExist: true });
   } catch {
     return null;
@@ -40578,8 +40619,8 @@ var ProviderLoader = class _ProviderLoader {
       return null;
     }
     registerProviderScriptRootSafely(path33.dirname(path33.dirname(providerDir)));
-    const cached2 = this.scriptsCache.get(dir);
-    if (cached2) return cached2;
+    const cached3 = this.scriptsCache.get(dir);
+    if (cached3) return cached3;
     const scriptsJs = path33.join(dir, "scripts.js");
     if (fs22.existsSync(scriptsJs)) {
       try {
@@ -43658,13 +43699,13 @@ function sanitizeInlineMesh(inlineMesh) {
     nodes
   };
 }
-function reconcileInlineMeshCache(cached2, incoming) {
-  if (!cached2 || typeof cached2 !== "object" || Array.isArray(cached2)) return incoming;
-  if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return cached2;
-  const cachedNodes = Array.isArray(cached2.nodes) ? cached2.nodes : [];
+function reconcileInlineMeshCache(cached3, incoming) {
+  if (!cached3 || typeof cached3 !== "object" || Array.isArray(cached3)) return incoming;
+  if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return cached3;
+  const cachedNodes = Array.isArray(cached3.nodes) ? cached3.nodes : [];
   const incomingNodes = Array.isArray(incoming.nodes) ? incoming.nodes : [];
-  if (!cachedNodes.length || !incomingNodes.length) return { ...cached2, ...incoming };
-  const cachedUpdatedAt = Date.parse(readStringValue(cached2.updatedAt, cached2.updated_at) || "");
+  if (!cachedNodes.length || !incomingNodes.length) return { ...cached3, ...incoming };
+  const cachedUpdatedAt = Date.parse(readStringValue(cached3.updatedAt, cached3.updated_at) || "");
   const incomingUpdatedAt = Date.parse(readStringValue(incoming.updatedAt, incoming.updated_at) || "");
   const preserveCachedMembership = Number.isFinite(cachedUpdatedAt) && (!Number.isFinite(incomingUpdatedAt) || cachedUpdatedAt > incomingUpdatedAt);
   const cachedById = /* @__PURE__ */ new Map();
@@ -43693,7 +43734,7 @@ function reconcileInlineMeshCache(cached2, incoming) {
     }
   }
   return {
-    ...cached2,
+    ...cached3,
     ...incoming,
     nodes
   };
@@ -44026,9 +44067,9 @@ var MeshGitProbeCache = class {
    */
   async probe(daemonId, workspace, probe) {
     const key = this.key(daemonId, workspace);
-    const cached2 = this.recent.get(key);
-    if (cached2 && this.now() - cached2.at < this.reuseMs) {
-      return cached2.value;
+    const cached3 = this.recent.get(key);
+    if (cached3 && this.now() - cached3.at < this.reuseMs) {
+      return cached3.value;
     }
     const existing = this.inflight.get(key);
     if (existing) return existing;
@@ -45676,13 +45717,13 @@ var DaemonCommandRouter = class {
     };
   }
   getCachedAggregateMeshStatus(meshId, mesh, options) {
-    const cached2 = this.aggregateMeshStatusCache.get(meshId);
-    if (!cached2?.snapshot || cached2.snapshot.success !== true || !Array.isArray(cached2.snapshot.nodes)) return null;
-    if (cached2.queueRevision !== getMeshQueueRevision(meshId)) return null;
-    let snapshot = this.cloneJsonValue(cached2.snapshot);
+    const cached3 = this.aggregateMeshStatusCache.get(meshId);
+    if (!cached3?.snapshot || cached3.snapshot.success !== true || !Array.isArray(cached3.snapshot.nodes)) return null;
+    if (cached3.queueRevision !== getMeshQueueRevision(meshId)) return null;
+    let snapshot = this.cloneJsonValue(cached3.snapshot);
     snapshot = this.hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options);
     if (shouldRefreshStalePendingAggregate(snapshot, options)) return null;
-    const ageMs = Math.max(0, Date.now() - cached2.builtAt);
+    const ageMs = Math.max(0, Date.now() - cached3.builtAt);
     const sourceOfTruth = snapshot.sourceOfTruth && typeof snapshot.sourceOfTruth === "object" ? snapshot.sourceOfTruth : {};
     snapshot.sourceOfTruth = {
       ...sourceOfTruth,
@@ -45693,7 +45734,7 @@ var DaemonCommandRouter = class {
         source: "memory",
         refreshReason: "memory_cache_hit",
         ageMs,
-        cachedAt: new Date(cached2.builtAt).toISOString(),
+        cachedAt: new Date(cached3.builtAt).toISOString(),
         returnedAt: (/* @__PURE__ */ new Date()).toISOString()
       }
     };
@@ -45740,9 +45781,9 @@ var DaemonCommandRouter = class {
       meshId,
       sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(inlineMesh))
     );
-    const cached2 = this.inlineMeshCache.get(meshId);
-    if (cached2) {
-      const merged = reconcileInlineMeshCache(cached2, sanitizedInlineMesh);
+    const cached3 = this.inlineMeshCache.get(meshId);
+    if (cached3) {
+      const merged = reconcileInlineMeshCache(cached3, sanitizedInlineMesh);
       this.inlineMeshCache.set(meshId, merged);
       return merged;
     }
@@ -45752,17 +45793,17 @@ var DaemonCommandRouter = class {
   async getMeshForCommand(meshId, inlineMesh, options) {
     const preferInline = options?.preferInline === true;
     if (preferInline) {
-      const cached3 = this.getCachedInlineMesh(meshId);
-      if (cached3) {
+      const cached4 = this.getCachedInlineMesh(meshId);
+      if (cached4) {
         if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
           const merged = reconcileInlineMeshCache(
-            cached3,
+            cached4,
             this.applyInlineMeshNodeTombstones(meshId, inlineMesh)
           );
           this.inlineMeshCache.set(meshId, sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(merged)));
           return { mesh: merged, inline: true, source: "inline_cache" };
         }
-        return { mesh: cached3, inline: true, source: "inline_cache" };
+        return { mesh: cached4, inline: true, source: "inline_cache" };
       }
       if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
         this.warmInlineMeshCache(meshId, inlineMesh);
@@ -45775,8 +45816,8 @@ var DaemonCommandRouter = class {
       if (mesh) return { mesh, inline: false, source: "local_config" };
     } catch {
     }
-    const cached2 = this.getCachedInlineMesh(meshId);
-    if (cached2) return { mesh: cached2, inline: true, source: "inline_cache" };
+    const cached3 = this.getCachedInlineMesh(meshId);
+    if (cached3) return { mesh: cached3, inline: true, source: "inline_cache" };
     const warmedInline = this.warmInlineMeshCache(meshId, inlineMesh);
     return warmedInline ? { mesh: warmedInline, inline: true, source: "inline_bootstrap" } : null;
   }
@@ -47206,8 +47247,8 @@ ${hintLines.join("\n")}` : "",
     const repoRootBaseRef = /* @__PURE__ */ new Map();
     const submodulePathsByRepoRoot = /* @__PURE__ */ new Map();
     const resolveBaseRef = async (repoRoot) => {
-      const cached2 = repoRootBaseRef.get(repoRoot);
-      if (cached2) return cached2;
+      const cached3 = repoRootBaseRef.get(repoRoot);
+      if (cached3) return cached3;
       let baseBranch = "main";
       try {
         const { stdout } = await execFileAsync4("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });