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

package/dist/index.js

@@ -316,10 +316,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "a6ef3a58ea926c6fa42f5ec53fae14e0bd5cac1b" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "a6ef3a58" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.331" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-20T00:34:05.737Z" : 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;
 }
@@ -587,10 +587,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,
@@ -713,9 +713,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 });
@@ -2541,6 +2541,47 @@ Follow these recovery rules:
   }
 });
 
+// src/system/load-better-sqlite3.ts
+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 = (0, import_module.createRequire)(metaUrl)("better-sqlite3");
+      return cached2;
+    }
+  } catch (e) {
+    errors.push(e);
+  }
+  try {
+    cached2 = (0, import_module.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 import_module, import_meta, cached2;
+var init_load_better_sqlite3 = __esm({
+  "src/system/load-better-sqlite3.ts"() {
+    "use strict";
+    import_module = require("module");
+    import_meta = {};
+  }
+});
+
 // src/mesh/mesh-ledger.ts
 var mesh_ledger_exports = {};
 __export(mesh_ledger_exports, {
@@ -2970,8 +3011,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);
@@ -3854,8 +3895,7 @@ var init_mesh_work_queue = __esm({
 // src/mesh/mesh-runtime-store.ts
 function loadDatabaseCtor() {
   if (DatabaseCtor) return DatabaseCtor;
-  const runtimeRequire = typeof require === "function" ? require : (0, import_module.createRequire)(import_meta.url);
-  DatabaseCtor = runtimeRequire("better-sqlite3");
+  DatabaseCtor = loadBetterSqlite3();
   return DatabaseCtor;
 }
 function safeMeshId(meshId) {
@@ -3882,16 +3922,15 @@ function meshRuntimeStorePath() {
   }
   return nextPath;
 }
-var import_fs5, import_path5, import_module, import_meta, DatabaseCtor, MeshRuntimeStore;
+var import_fs5, import_path5, DatabaseCtor, MeshRuntimeStore;
 var init_mesh_runtime_store = __esm({
   "src/mesh/mesh-runtime-store.ts"() {
     "use strict";
     import_fs5 = require("fs");
     import_path5 = require("path");
-    import_module = require("module");
+    init_load_better_sqlite3();
     init_mesh_ledger();
     init_mesh_work_queue();
-    import_meta = {};
     MeshRuntimeStore = class _MeshRuntimeStore {
       static instance;
       db;
@@ -9418,8 +9457,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;
@@ -10669,6 +10708,21 @@ function handleMeshForwardEvent(components, payload) {
       targetSessionId: readNonEmptyString2(payload.targetSessionId) || readNonEmptyString2(payload.sessionId) || readNonEmptyString2(payload.instanceId),
       providerType: readNonEmptyString2(payload.providerType),
       providerSessionId: readNonEmptyString2(payload.providerSessionId),
+      // Carry the session identity fields the worker provider event emits so the
+      // coordinator's mirror (updateMeshOwnedSession) gets a real workspace/title/
+      // settings. Without these the remote-relay hop reconstructs metadataEvent with
+      // an empty workspace, and the dashboard flaps to the generic
+      // "Terminal (Mesh Node)" title (and degrades the provider label) between live
+      // events and the periodic get_status_metadata snapshot. The local in-process
+      // forward path (onMeshCoordinatorEventForwarded) already preserves these; this
+      // mirrors them for the remote-only relay path.
+      workspace: readNonEmptyString2(payload.workspace) || readNonEmptyString2(payload.workspaceName),
+      workspaceName: readNonEmptyString2(payload.workspaceName) || readNonEmptyString2(payload.workspace),
+      sessionTitle: readNonEmptyString2(payload.sessionTitle),
+      sessionStatus: readNonEmptyString2(payload.sessionStatus),
+      sessionChatStatus: readNonEmptyString2(payload.sessionChatStatus),
+      providerName: readNonEmptyString2(payload.providerName),
+      ...payload.sessionSettings && typeof payload.sessionSettings === "object" && !Array.isArray(payload.sessionSettings) ? { sessionSettings: payload.sessionSettings } : {},
       finalSummary: readNonEmptyString2(payload.finalSummary) || readNonEmptyString2(payload.summary),
       jobId: readNonEmptyString2(payload.jobId),
       interactionId: readNonEmptyString2(payload.interactionId),
@@ -11549,7 +11603,8 @@ function findLiveCoordinators(components) {
     const meshId = readNonEmptyString2(settings.meshCoordinatorFor);
     if (!meshId) continue;
     const status = readNonEmptyString2(state.status).toLowerCase();
-    out.push({ meshId, instance: inst, idle: status === "idle" });
+    const modalParked = status === "waiting_choice" || status === "waiting_approval";
+    out.push({ meshId, instance: inst, idle: status === "idle", modalParked });
   }
   return out;
 }
@@ -11638,9 +11693,16 @@ async function runMeshReconcileTick(components) {
   }
   for (const [meshId, meshCoordinators] of byMesh) {
     const idleCoordinators = meshCoordinators.filter((c) => c.idle);
-    const generatingCoordinators = meshCoordinators.filter((c) => !c.idle);
+    const generatingCoordinators = meshCoordinators.filter((c) => !c.idle && !c.modalParked);
+    const modalParkedCoordinators = meshCoordinators.filter((c) => !c.idle && c.modalParked);
     const targetCoordinators = idleCoordinators.length > 0 ? idleCoordinators : generatingCoordinators;
     const forceOnly = idleCoordinators.length === 0;
+    if (targetCoordinators.length === 0) {
+      if (modalParkedCoordinators.length > 0) {
+        LOG.info("MeshReconcile", `Reconcile skip \u2192 modal-parked: holding pending event(s) for mesh ${meshId} (${modalParkedCoordinators.length} coordinator(s) awaiting a modal answer; events left queued)`);
+      }
+      continue;
+    }
     if (store) {
       try {
         if (store.pendingEventCount(meshId) === 0) continue;
@@ -15242,10 +15304,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;
       }
@@ -15707,10 +15769,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)) {
@@ -15957,6 +16019,10 @@ ${lastSnapshot}`;
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
         const content = String(text || "");
         if (!content.trim()) return;
+        if (this.engine.currentStatus === "waiting_approval" || this.engine.hasActionableApproval()) {
+          LOG.info("CLI", `[${this.cliType}] force-send held \u2014 session parked on approval modal (status=${this.engine.currentStatus})`);
+          return;
+        }
         LOG.info("CLI", `[${this.cliType}] force-sending prompt while status=${this.engine.currentStatus}`);
         await this.writeToPty(content + this.sendKey);
         this.onStatusChange?.();
@@ -22462,11 +22528,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);
@@ -22950,9 +23016,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,
@@ -23448,16 +23514,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);
@@ -23483,22 +23549,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 };
@@ -23563,8 +23629,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));
@@ -23607,23 +23673,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;
@@ -32571,6 +32637,7 @@ var fs13 = __toESM(require("fs"));
 var os17 = __toESM(require("os"));
 var path22 = __toESM(require("path"));
 init_logger();
+init_load_better_sqlite3();
 var UUID_RE = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
 function executeNativeHistory(cfg, input) {
   if (!cfg?.source) return null;
@@ -32695,7 +32762,7 @@ function executeSqlite(src, input) {
   if (!resolved || !fs13.existsSync(resolved)) return null;
   let Database;
   try {
-    Database = require("better-sqlite3");
+    Database = loadBetterSqlite3();
   } catch {
     return null;
   }
@@ -34861,6 +34928,35 @@ var CliProviderInstance = class _CliProviderInstance {
     this.settings = rest;
     this.adapter.updateRuntimeSettings?.(this.settings);
   }
+  /**
+   * The resolved modal-park status of this session, or null when it is not
+   * parked on a modal awaiting a human answer. Mirrors the overlay logic in
+   * getState(): an active AskUserQuestion interactive prompt resolves to
+   * waiting_choice; otherwise the adapter's waiting_approval (tool consent)
+   * counts — UNLESS auto-approve will dismiss it, in which case the session is
+   * effectively generating and is NOT modal-parked. This is the single signal
+   * the mesh force-inject guard consults, and the same status string the
+   * reconcile loop reads off get_status_metadata. Lowercase literals only —
+   * the SessionStatus enum is forked across modules and waiting_choice is
+   * absent from some of them.
+   */
+  resolveModalParkStatus() {
+    if (this.activeInteractivePrompt) return "waiting_choice";
+    let adapterStatus;
+    try {
+      adapterStatus = this.adapter.getStatus({ allowParse: false });
+    } catch {
+      return null;
+    }
+    if (adapterStatus.status === "waiting_approval" && !this.shouldAutoApprove()) {
+      return "waiting_approval";
+    }
+    return null;
+  }
+  /** True when this session is parked on a modal awaiting a human answer. */
+  isModalParked() {
+    return this.resolveModalParkStatus() !== null;
+  }
   onEvent(event, data) {
     if (event === "send_message") {
       const input = normalizeInputEnvelope(data);
@@ -34868,6 +34964,10 @@ var CliProviderInstance = class _CliProviderInstance {
       const promptText = buildCliStructuredInputPrompt(input);
       if (promptText) {
         const force = data?.force === true;
+        if (force && this.isModalParked()) {
+          LOG.info("CLI", `[${this.type}] force send_message held \u2014 coordinator parked on modal (${this.resolveModalParkStatus()})`);
+          return;
+        }
         void this.adapter.sendMessage(promptText, force ? { force: true } : {}).catch((e) => {
           LOG.warn("CLI", `[${this.type}] send_message failed: ${e?.message || e}`);
         });
@@ -39486,6 +39586,7 @@ function readSession3(sessionPath, sessionId, workspace) {
 var fs20 = __toESM(require("fs"));
 var path30 = __toESM(require("path"));
 var os21 = __toESM(require("os"));
+init_load_better_sqlite3();
 var HERMES_STATE_DB = path30.join(os21.homedir(), ".hermes", "state.db");
 var HERMES_LEGACY_SESSIONS_DIR = path30.join(os21.homedir(), ".hermes", "sessions");
 function statMtimeMs4(p) {
@@ -39498,7 +39599,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;
@@ -40873,8 +40974,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 {
@@ -43953,13 +44054,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();
@@ -43988,7 +44089,7 @@ function reconcileInlineMeshCache(cached2, incoming) {
     }
   }
   return {
-    ...cached2,
+    ...cached3,
     ...incoming,
     nodes
   };
@@ -44321,9 +44422,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;
@@ -45971,13 +46072,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,
@@ -45988,7 +46089,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()
       }
     };
@@ -46035,9 +46136,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;
     }
@@ -46047,17 +46148,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);
@@ -46070,8 +46171,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;
   }
@@ -47501,8 +47602,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" });