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

package/dist/index.js

@@ -30036,10 +30036,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "a6ef3a58ea926c6fa42f5ec53fae14e0bd5cac1b" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "a6ef3a58" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = 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:33.289Z" : 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 version2 = 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:24:25.156Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -30307,10 +30307,10 @@ var require_dist3 = __commonJS({
       } catch (error48) {
         const gitError = error48 instanceof GitCommandError ? error48 : new GitCommandError("git_command_failed", "Failed to read Git status", { cause: error48 });
         if (isTransientGitFailure(gitError)) {
-          const cached22 = lastKnownGoodStatus.get(workspace);
-          if (cached22) {
+          const cached3 = lastKnownGoodStatus.get(workspace);
+          if (cached3) {
             return {
-              ...cached22,
+              ...cached3,
               lastCheckedAt,
               upstreamStatus: "unavailable",
               error: gitError.stderr || gitError.message,
@@ -30433,9 +30433,9 @@ var require_dist3 = __commonJS({
         return { config: null, sourceKey: "no-repo-root" };
       }
       const loaded = loadChangeImpactConfig(repoRoot);
-      const cached22 = changeImpactConfigCache.get(repoRoot);
-      if (cached22 && cached22.sourceKey === loaded.sourceKey) {
-        return { config: cached22.config, sourceKey: loaded.sourceKey };
+      const cached3 = changeImpactConfigCache.get(repoRoot);
+      if (cached3 && cached3.sourceKey === loaded.sourceKey) {
+        return { config: cached3.config, sourceKey: loaded.sourceKey };
       }
       const config2 = loaded.sourceType === "repo_file" ? loaded.config ?? null : null;
       changeImpactConfigCache.set(repoRoot, { sourceKey: loaded.sourceKey, config: config2 });
@@ -32279,6 +32279,47 @@ Follow these recovery rules:
 4. **Always record what happened**: After handling a failure, briefly note the outcome in your report to the user.`;
       }
     });
+    function loadBetterSqlite3() {
+      if (cached22) return cached22;
+      const errors = [];
+      if (typeof require === "function") {
+        try {
+          cached22 = require("better-sqlite3");
+          return cached22;
+        } catch (e) {
+          errors.push(e);
+        }
+      }
+      try {
+        const metaUrl = typeof import_meta?.url === "string" ? import_meta.url : void 0;
+        if (metaUrl) {
+          cached22 = (0, import_module.createRequire)(metaUrl)("better-sqlite3");
+          return cached22;
+        }
+      } catch (e) {
+        errors.push(e);
+      }
+      try {
+        cached22 = (0, import_module.createRequire)(`${process.cwd()}/__adhdev_better_sqlite3_loader__.js`)(
+          "better-sqlite3"
+        );
+        return cached22;
+      } 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;
+    var import_meta;
+    var cached22;
+    var init_load_better_sqlite3 = __esm2({
+      "src/system/load-better-sqlite3.ts"() {
+        "use strict";
+        import_module = require("module");
+        import_meta = {};
+      }
+    });
     var mesh_ledger_exports = {};
     __export2(mesh_ledger_exports, {
       MAX_LEDGER_SLICE_LIMIT: () => MAX_LEDGER_SLICE_LIMIT,
@@ -32707,8 +32748,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     }
     function getCachedRawEntries(meshId) {
       const now = Date.now();
-      const cached22 = ledgerReadCache.get(meshId);
-      if (cached22 && now - cached22.cachedAt < LEDGER_CACHE_TTL_MS) return cached22.entries;
+      const cached3 = ledgerReadCache.get(meshId);
+      if (cached3 && now - cached3.cachedAt < LEDGER_CACHE_TTL_MS) return cached3.entries;
       let entries;
       try {
         entries = readLedgerFromStore(meshId);
@@ -33612,8 +33653,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     });
     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) {
@@ -33642,8 +33682,6 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
     }
     var import_fs5;
     var import_path5;
-    var import_module;
-    var import_meta;
     var DatabaseCtor;
     var MeshRuntimeStore;
     var init_mesh_runtime_store = __esm2({
@@ -33651,10 +33689,9 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         "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;
@@ -39194,8 +39231,8 @@ Next step: ${nextStep}`;
     }
     function getCachedMeshByWorkspace(workspace) {
       const now = Date.now();
-      const cached22 = meshByWorkspaceCache.get(workspace);
-      if (cached22 && now - cached22.cachedAt < MESH_WORKSPACE_CACHE_TTL_MS) return cached22.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;
@@ -40445,6 +40482,21 @@ Next step: ${nextStep}`;
           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),
@@ -41347,7 +41399,8 @@ Next step: ${nextStep}`;
         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;
     }
@@ -41436,9 +41489,16 @@ Next step: ${nextStep}`;
       }
       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) {
+            LOG2.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;
@@ -45038,10 +45098,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 cached22 = this.parsedStatusCache;
+            const cached3 = this.parsedStatusCache;
             const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
-            if (cached22 && cached22.responseBuffer === this.responseBuffer && cached22.currentTurnScope === this.engine.currentTurnScope && cached22.recentOutputBuffer === this.recentOutputBuffer && cached22.accumulatedBuffer === this.accumulatedBuffer && cached22.accumulatedRawBufferKey === accumulatedRawBufferKey && cached22.screenText === this.lastScreenText && cached22.currentStatus === this.engine.currentStatus && cached22.activeModal === this.engine.activeModal && cached22.cliName === this.cliName) {
-              return cached22.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;
           }
@@ -45503,10 +45563,10 @@ ${lastSnapshot}`;
           getScriptParsedStatus() {
             const screenText = this.readTerminalScreenText();
             const parseScreenText = this.getParseScreenText(screenText);
-            const cached22 = this.parsedStatusCache;
+            const cached3 = this.parsedStatusCache;
             const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
-            if (!this.providerOwnsTranscript() && cached22 && cached22.responseBuffer === this.responseBuffer && cached22.currentTurnScope === this.engine.currentTurnScope && cached22.recentOutputBuffer === this.recentOutputBuffer && cached22.accumulatedBuffer === this.accumulatedBuffer && cached22.accumulatedRawBufferKey === accumulatedRawBufferKey && cached22.screenText === parseScreenText && cached22.currentStatus === this.engine.currentStatus && cached22.activeModal === this.engine.activeModal && cached22.cliName === this.cliName) {
-              return cached22.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)) {
@@ -45753,6 +45813,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()) {
+              LOG2.info("CLI", `[${this.cliType}] force-send held \u2014 session parked on approval modal (status=${this.engine.currentStatus})`);
+              return;
+            }
             LOG2.info("CLI", `[${this.cliType}] force-sending prompt while status=${this.engine.currentStatus}`);
             await this.writeToPty(content + this.sendKey);
             this.onStatusChange?.();
@@ -52187,11 +52251,11 @@ ${cleanBody}`;
     var BOUNDED_TAIL_CACHE_MAX_ENTRIES = 64;
     var boundedTailReadCache = /* @__PURE__ */ new Map();
     function readBoundedTailCache(key, signature) {
-      const cached22 = boundedTailReadCache.get(key);
-      if (!cached22 || cached22.signature !== signature) return null;
+      const cached3 = boundedTailReadCache.get(key);
+      if (!cached3 || cached3.signature !== signature) return null;
       boundedTailReadCache.delete(key);
-      boundedTailReadCache.set(key, cached22);
-      return cached22.result;
+      boundedTailReadCache.set(key, cached3);
+      return cached3.result;
     }
     function writeBoundedTailCache(key, signature, result) {
       boundedTailReadCache.delete(key);
@@ -52675,9 +52739,9 @@ ${cleanBody}`;
       for (const file2 of files.slice().sort()) {
         const filePath = path14.join(dir, file2);
         const signature = fileSignatures.get(file2) || `${file2}:missing`;
-        const cached22 = savedHistoryFileSummaryCache.get(filePath);
+        const cached3 = savedHistoryFileSummaryCache.get(filePath);
         const persisted = persistedEntries.get(file2);
-        const reusableEntry = cached22?.signature === signature ? cached22 : persisted?.signature === signature ? persisted : null;
+        const reusableEntry = cached3?.signature === signature ? cached3 : persisted?.signature === signature ? persisted : null;
         const fileSummary = reusableEntry?.summary || computeSavedHistoryFileSummary(dir, file2);
         const nextEntry = reusableEntry || {
           signature,
@@ -53173,16 +53237,16 @@ ${cleanBody}`;
         incrementalTailCache.delete(filePath);
         return { lines: [], coversWholeFile: true };
       }
-      const cached22 = incrementalTailCache.get(filePath);
-      if (cached22) {
-        if (cached22.size === size && cached22.mtimeMs === mtimeMs) {
+      const cached3 = incrementalTailCache.get(filePath);
+      if (cached3) {
+        if (cached3.size === size && cached3.mtimeMs === mtimeMs) {
           incrementalTailCache.delete(filePath);
-          incrementalTailCache.set(filePath, cached22);
-          if (cached22.coversWholeFile || cached22.lines.length >= needed) {
-            return { lines: cached22.lines, coversWholeFile: cached22.coversWholeFile };
+          incrementalTailCache.set(filePath, cached3);
+          if (cached3.coversWholeFile || cached3.lines.length >= needed) {
+            return { lines: cached3.lines, coversWholeFile: cached3.coversWholeFile };
           }
-        } else if (size > cached22.size) {
-          const incremental = tryIncrementalTailGrowth(filePath, cached22, 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);
@@ -53208,22 +53272,22 @@ ${cleanBody}`;
       storeIncrementalTailCache(filePath, result.size, result.mtimeMs, result.lines, result.coversWholeFile);
       return { lines: result.lines, coversWholeFile: result.coversWholeFile };
     }
-    function tryIncrementalTailGrowth(filePath, cached22, size, mtimeMs, needed) {
+    function tryIncrementalTailGrowth(filePath, cached3, size, mtimeMs, needed) {
       const fd = fs6.openSync(filePath, "r");
       try {
-        if (cached22.size > 0) {
+        if (cached3.size > 0) {
           const boundary = Buffer.alloc(1);
-          fs6.readSync(fd, boundary, 0, 1, cached22.size - 1);
+          fs6.readSync(fd, boundary, 0, 1, cached3.size - 1);
           if (boundary[0] !== 10) return null;
         }
-        const appendedLength = size - cached22.size;
+        const appendedLength = size - cached3.size;
         const appended = Buffer.alloc(appendedLength);
-        fs6.readSync(fd, appended, 0, appendedLength, cached22.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 = cached22.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 = cached22.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 };
@@ -53288,8 +53352,8 @@ ${cleanBody}`;
           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 cached22 = readBoundedTailCache(cacheKey, signature);
-          if (cached22) return cached22;
+          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));
@@ -53332,23 +53396,23 @@ ${cleanBody}`;
           savedHistorySessionCache.delete(sanitized);
           return { sessions: [], hasMore: false };
         }
-        const cached22 = 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 (cached22) {
-          const cacheLooksPersisted = cached22.signature.startsWith("index:");
-          const cacheStillValid = cacheLooksPersisted ? cached22.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 cached22.signature === buildSavedHistoryCacheSignature(files2, fileSignatures2);
+            return cached3.signature === buildSavedHistoryCacheSignature(files2, fileSignatures2);
           })();
           if (cacheStillValid) {
-            const sliced2 = cached22.summaries.slice(offset, offset + limit);
+            const sliced2 = cached3.summaries.slice(offset, offset + limit);
             return {
               sessions: sliced2,
-              hasMore: cached22.summaries.length > offset + limit
+              hasMore: cached3.summaries.length > offset + limit
             };
           }
           cacheWasInvalidated = true;
@@ -62208,6 +62272,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
     var os17 = __toESM2(require("os"));
     var path222 = __toESM2(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;
@@ -62332,7 +62397,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
       if (!resolved || !fs13.existsSync(resolved)) return null;
       let Database;
       try {
-        Database = require("better-sqlite3");
+        Database = loadBetterSqlite3();
       } catch {
         return null;
       }
@@ -64484,6 +64549,35 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         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);
@@ -64491,6 +64585,10 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           const promptText = buildCliStructuredInputPrompt(input);
           if (promptText) {
             const force = data?.force === true;
+            if (force && this.isModalParked()) {
+              LOG2.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) => {
               LOG2.warn("CLI", `[${this.type}] send_message failed: ${e?.message || e}`);
             });
@@ -69083,6 +69181,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     var fs20 = __toESM2(require("fs"));
     var path30 = __toESM2(require("path"));
     var os21 = __toESM2(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) {
@@ -69095,7 +69194,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     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;
@@ -70466,8 +70565,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
           return null;
         }
         registerProviderScriptRootSafely(path332.dirname(path332.dirname(providerDir)));
-        const cached22 = this.scriptsCache.get(dir);
-        if (cached22) return cached22;
+        const cached3 = this.scriptsCache.get(dir);
+        if (cached3) return cached3;
         const scriptsJs = path332.join(dir, "scripts.js");
         if (fs222.existsSync(scriptsJs)) {
           try {
@@ -73514,13 +73613,13 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         nodes
       };
     }
-    function reconcileInlineMeshCache(cached22, incoming) {
-      if (!cached22 || typeof cached22 !== "object" || Array.isArray(cached22)) return incoming;
-      if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return cached22;
-      const cachedNodes = Array.isArray(cached22.nodes) ? cached22.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 { ...cached22, ...incoming };
-      const cachedUpdatedAt = Date.parse(readStringValue(cached22.updatedAt, cached22.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();
@@ -73549,7 +73648,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         }
       }
       return {
-        ...cached22,
+        ...cached3,
         ...incoming,
         nodes
       };
@@ -73882,9 +73981,9 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
        */
       async probe(daemonId, workspace, probe) {
         const key = this.key(daemonId, workspace);
-        const cached22 = this.recent.get(key);
-        if (cached22 && this.now() - cached22.at < this.reuseMs) {
-          return cached22.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;
@@ -75532,13 +75631,13 @@ ${mergeTreeErr?.stderr || ""}`;
         };
       }
       getCachedAggregateMeshStatus(meshId, mesh, options) {
-        const cached22 = this.aggregateMeshStatusCache.get(meshId);
-        if (!cached22?.snapshot || cached22.snapshot.success !== true || !Array.isArray(cached22.snapshot.nodes)) return null;
-        if (cached22.queueRevision !== getMeshQueueRevision(meshId)) return null;
-        let snapshot = this.cloneJsonValue(cached22.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() - cached22.builtAt);
+        const ageMs = Math.max(0, Date.now() - cached3.builtAt);
         const sourceOfTruth = snapshot.sourceOfTruth && typeof snapshot.sourceOfTruth === "object" ? snapshot.sourceOfTruth : {};
         snapshot.sourceOfTruth = {
           ...sourceOfTruth,
@@ -75549,7 +75648,7 @@ ${mergeTreeErr?.stderr || ""}`;
             source: "memory",
             refreshReason: "memory_cache_hit",
             ageMs,
-            cachedAt: new Date(cached22.builtAt).toISOString(),
+            cachedAt: new Date(cached3.builtAt).toISOString(),
             returnedAt: (/* @__PURE__ */ new Date()).toISOString()
           }
         };
@@ -75596,9 +75695,9 @@ ${mergeTreeErr?.stderr || ""}`;
           meshId,
           sanitizeInlineMesh(normalizeInlineMeshNodeIdentity(inlineMesh))
         );
-        const cached22 = this.inlineMeshCache.get(meshId);
-        if (cached22) {
-          const merged = reconcileInlineMeshCache(cached22, sanitizedInlineMesh);
+        const cached3 = this.inlineMeshCache.get(meshId);
+        if (cached3) {
+          const merged = reconcileInlineMeshCache(cached3, sanitizedInlineMesh);
           this.inlineMeshCache.set(meshId, merged);
           return merged;
         }
@@ -75608,17 +75707,17 @@ ${mergeTreeErr?.stderr || ""}`;
       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);
@@ -75631,8 +75730,8 @@ ${mergeTreeErr?.stderr || ""}`;
           if (mesh) return { mesh, inline: false, source: "local_config" };
         } catch {
         }
-        const cached22 = this.getCachedInlineMesh(meshId);
-        if (cached22) return { mesh: cached22, 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;
       }
@@ -77062,8 +77161,8 @@ ${hintLines.join("\n")}` : "",
         const repoRootBaseRef = /* @__PURE__ */ new Map();
         const submodulePathsByRepoRoot = /* @__PURE__ */ new Map();
         const resolveBaseRef = async (repoRoot) => {
-          const cached22 = repoRootBaseRef.get(repoRoot);
-          if (cached22) return cached22;
+          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" });