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

package/dist/providers/cli-provider-instance.d.ts

@@ -134,6 +134,21 @@ export declare class CliProviderInstance implements ProviderInstance {
      * coordinator as if they were task completions.
      */
     detachMeshAssignment(): void;
+    /**
+     * 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(): 'waiting_choice' | 'waiting_approval' | null;
+    /** True when this session is parked on a modal awaiting a human answer. */
+    isModalParked(): boolean;
     onEvent(event: string, data?: any): void;
     recordAcknowledgedUserInput(input: InputEnvelope | string): void;
     dispose(): void;

package/dist/system/load-better-sqlite3.d.ts

@@ -0,0 +1,21 @@
+import type BetterSqlite3 from 'better-sqlite3';
+/**
+ * Load the `better-sqlite3` constructor in a way that survives every runtime the
+ * daemon ships in.
+ *
+ * The naive `typeof require === 'function' ? require : createRequire(import.meta.url)`
+ * is unsafe inside the daemon-cloud bundle: esbuild emits CJS output but, for any
+ * chunk that touches `import.meta.url`, it shims the local `require` with a stub
+ * that THROWS `Dynamic require of "..." is not supported`. That stub is still
+ * `typeof === 'function'`, so the ternary picks it and the call throws — it never
+ * reaches the `createRequire` fallback. The failure surfaced as `mesh_send_task`
+ * crashing the whole tool call instead of gracefully degrading.
+ *
+ * The robust approach is to ATTEMPT the real `require` and CATCH the esbuild stub's
+ * throw, then fall back to `createRequire`. We try multiple resolution bases so the
+ * load works whether the code runs as:
+ *   - a genuine CJS module (bare `require` works),
+ *   - an esbuild CJS bundle with the throwing `require` shim (createRequire(import.meta.url)),
+ *   - a pure ESM module where `require` is undefined (createRequire(import.meta.url)).
+ */
+export declare function loadBetterSqlite3(): typeof BetterSqlite3;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.331",
+  "version": "0.9.82-rc.333",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.331",
+    "@adhdev/mesh-shared": "0.9.82-rc.333",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/cli-adapters/provider-cli-adapter.ts

@@ -1285,6 +1285,18 @@ export class ProviderCliAdapter implements CliAdapter {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
         const content = String(text || '');
         if (!content.trim()) return;
+        // Modal-park guard (defense-in-depth — the primary guard is at the
+        // cli-provider-instance force-forward chokepoint). A force-write writes raw
+        // keystrokes into the PTY, bypassing the busy send-guard. If the session is
+        // parked on a tool-consent modal, the modal's key handler eats those bytes
+        // and silently resolves an approval the user never made. Hold the write and
+        // let the mesh reconcile loop redeliver once the modal is resolved. We only
+        // hold for an actionable approval modal; plain generating is still force-written
+        // (that is the deadlock the force path exists to break).
+        if (this.engine.currentStatus === 'waiting_approval' || this.engine.hasActionableApproval()) {
+            LOG.info('CLI', `[${this.cliType}] force-send held — 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?.();

package/src/mesh/mesh-events-coordinator.ts

@@ -1870,6 +1870,21 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
             targetSessionId: readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.instanceId),
             providerType: readNonEmptyString(payload.providerType),
             providerSessionId: readNonEmptyString(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: readNonEmptyString(payload.workspace) || readNonEmptyString(payload.workspaceName),
+            workspaceName: readNonEmptyString(payload.workspaceName) || readNonEmptyString(payload.workspace),
+            sessionTitle: readNonEmptyString(payload.sessionTitle),
+            sessionStatus: readNonEmptyString(payload.sessionStatus),
+            sessionChatStatus: readNonEmptyString(payload.sessionChatStatus),
+            providerName: readNonEmptyString(payload.providerName),
+            ...(payload.sessionSettings && typeof payload.sessionSettings === 'object' && !Array.isArray(payload.sessionSettings) ? { sessionSettings: payload.sessionSettings } : {}),
             finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary),
             jobId: readNonEmptyString(payload.jobId),
             interactionId: readNonEmptyString(payload.interactionId),

package/src/mesh/mesh-reconcile-loop.ts

@@ -98,6 +98,13 @@ interface LiveCoordinator {
     meshId: string;
     instance: ReturnType<DaemonComponents['instanceManager']['getInstance']>;
     idle: boolean;
+    // True when the coordinator session is parked on a harness modal awaiting a
+    // human answer — claude-cli AskUserQuestion (waiting_choice) or a tool-consent
+    // prompt (waiting_approval). A force-inject into such a session would write raw
+    // keystrokes the modal key handler consumes, silently selecting a choice the
+    // user never made (data corruption). PHASE 2 excludes these from force-inject
+    // and leaves the event queued for a later (modal-resolved) tick.
+    modalParked: boolean;
 }
 
 // The set of coordinator-daemon ids THIS daemon answers to when draining the
@@ -193,7 +200,12 @@ function findLiveCoordinators(components: DaemonComponents): LiveCoordinator[] {
         const meshId = readNonEmptyString(settings.meshCoordinatorFor);
         if (!meshId) continue;
         const status = readNonEmptyString(state.status).toLowerCase();
-        out.push({ meshId, instance: inst, idle: status === 'idle' });
+        // getState() overlays the modal-park statuses: an active AskUserQuestion
+        // prompt surfaces as waiting_choice, a tool-consent prompt as waiting_approval.
+        // Lowercase literal compare — the SessionStatus enum is forked across modules
+        // and waiting_choice is absent from some of them (see cli-provider-instance).
+        const modalParked = status === 'waiting_choice' || status === 'waiting_approval';
+        out.push({ meshId, instance: inst, idle: status === 'idle', modalParked });
     }
     return out;
 }
@@ -390,10 +402,34 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
         //       tick — injecting them would be noise mid-generation. Both drains mark the
         //       consumed rows drained=1 atomically, so the pull path can't re-deliver.
         const idleCoordinators = meshCoordinators.filter(c => c.idle);
-        const generatingCoordinators = meshCoordinators.filter(c => !c.idle);
+        // A coordinator parked on a harness modal (waiting_choice / waiting_approval)
+        // is non-idle, so it would otherwise be treated as a force-inject target. It
+        // must NOT be: a force-inject writes raw keystrokes into the PTY, which the
+        // modal's key handler consumes and silently resolves to a choice the user
+        // never made. Force-inject is only safe into a coordinator parked in plain
+        // `generating` (the deadlock the force path exists to break). So generating
+        // targets are the non-idle, non-modal-parked coordinators.
+        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;
 
+        // ── modal-blocked short-circuit (MUST precede the drain) ──────────────────
+        // When the ONLY coordinators for this mesh are modal-parked (no idle, no plain
+        // generating target), there is nowhere safe to deliver. We skip-and-requeue:
+        // by NOT draining we leave the events at drained=0 in the queue, so a later tick
+        // (once the modal is resolved and the coordinator returns to idle/generating)
+        // delivers them. This short-circuit MUST run BEFORE drainPendingMeshCoordinatorEvents
+        // — the drain marks rows drained=1 atomically, which would lose the events for a
+        // coordinator that is only transiently blocked. (Note: generating is still
+        // force-injected via generatingCoordinators — we never block the deadlock-break.)
+        if (targetCoordinators.length === 0) {
+            if (modalParkedCoordinators.length > 0) {
+                LOG.info('MeshReconcile', `Reconcile skip → modal-parked: holding pending event(s) for mesh ${meshId} (${modalParkedCoordinators.length} coordinator(s) awaiting a modal answer; events left queued)`);
+            }
+            continue;
+        }
+
         // O(1) guard: skip the drain entirely when the queue is empty.
         if (store) {
             try {

package/src/mesh/mesh-runtime-store.ts

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, statSync } from 'fs';
 import { dirname, join } from 'path';
-import { createRequire } from 'module';
+import { loadBetterSqlite3 } from '../system/load-better-sqlite3.js';
 import { getLedgerDir } from './mesh-ledger.js';
 import { nodeSatisfiesRequiredTags } from './mesh-work-queue.js';
 import type { MeshTaskStatus, MeshWorkQueueEntry } from './mesh-work-queue.js';
@@ -11,10 +11,7 @@ let DatabaseCtor: typeof BetterSqlite3 | undefined;
 
 function loadDatabaseCtor(): typeof BetterSqlite3 {
     if (DatabaseCtor) return DatabaseCtor;
-    const runtimeRequire = typeof require === 'function'
-        ? require
-        : createRequire(import.meta.url);
-    DatabaseCtor = runtimeRequire('better-sqlite3') as typeof BetterSqlite3;
+    DatabaseCtor = loadBetterSqlite3() as typeof BetterSqlite3;
     return DatabaseCtor;
 }
 

package/src/providers/cli-provider-instance.ts

@@ -905,6 +905,37 @@ export class CliProviderInstance implements ProviderInstance {
         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(): 'waiting_choice' | 'waiting_approval' | null {
+        if (this.activeInteractivePrompt) return 'waiting_choice';
+        let adapterStatus: { status?: string };
+        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(): boolean {
+        return this.resolveModalParkStatus() !== null;
+    }
+
     onEvent(event: string, data?: any): void {
         if (event === 'send_message') {
             const input = normalizeInputEnvelope(data);
@@ -917,6 +948,20 @@ export class CliProviderInstance implements ProviderInstance {
                 // Without it the message is queued and only flushed on the coordinator's
                 // own idle transition — which never happens until it receives the message.
                 const force = data?.force === true;
+                // Modal guard: a force-inject still writes raw keystrokes into the PTY,
+                // bypassing the busy send-guard. If the coordinator is parked on a
+                // harness modal (claude-cli AskUserQuestion → waiting_choice, or a
+                // tool-consent waiting_approval), those keystrokes are consumed by the
+                // modal's key handler and silently select a choice the user never made
+                // (data corruption). Hold the force-inject in that narrow window —
+                // the event stays queued and the reconcile loop redelivers it on the
+                // next tick once the modal is resolved. We ONLY hold for the two modal
+                // states; generating is still force-injected (that is the deadlock the
+                // force path exists to break — see mesh-events-coordinator).
+                if (force && this.isModalParked()) {
+                    LOG.info('CLI', `[${this.type}] force send_message held — coordinator parked on modal (${this.resolveModalParkStatus()})`);
+                    return;
+                }
                 void this.adapter.sendMessage(promptText, force ? { force: true } : {}).catch((e: any) => {
                     LOG.warn('CLI', `[${this.type}] send_message failed: ${e?.message || e}`);
                 });

package/src/providers/native-history/hermes-cli-transcript.ts

@@ -19,6 +19,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
+import { loadBetterSqlite3 } from '../../system/load-better-sqlite3.js';
 
 export interface NativeHistoryMessage {
     id: string;
@@ -61,8 +62,7 @@ function statMtimeMs(p: string): number {
 function openDb(): any | null {
     if (!fs.existsSync(HERMES_STATE_DB)) return null;
     try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const Database = require('better-sqlite3');
+        const Database = loadBetterSqlite3();
         return new Database(HERMES_STATE_DB, { readonly: true, fileMustExist: true });
     } catch {
         return null;

package/src/providers/spec/native-history-executor.ts

@@ -22,6 +22,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { LOG } from '../../logging/logger.js';
+import { loadBetterSqlite3 } from '../../system/load-better-sqlite3.js';
 import type {
     NativeHistoryConfig,
     NativeHistoryJsonlSource,
@@ -253,8 +254,7 @@ function executeSqlite(src: NativeHistorySqliteSource, input: NativeHistoryInput
 
     let Database: any;
     try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        Database = require('better-sqlite3');
+        Database = loadBetterSqlite3();
     } catch { return null; }
 
     let db: any;

package/src/system/load-better-sqlite3.ts

@@ -0,0 +1,68 @@
+import { createRequire } from 'module';
+import type BetterSqlite3 from 'better-sqlite3';
+
+let cached: typeof BetterSqlite3 | undefined;
+
+/**
+ * Load the `better-sqlite3` constructor in a way that survives every runtime the
+ * daemon ships in.
+ *
+ * The naive `typeof require === 'function' ? require : createRequire(import.meta.url)`
+ * is unsafe inside the daemon-cloud bundle: esbuild emits CJS output but, for any
+ * chunk that touches `import.meta.url`, it shims the local `require` with a stub
+ * that THROWS `Dynamic require of "..." is not supported`. That stub is still
+ * `typeof === 'function'`, so the ternary picks it and the call throws — it never
+ * reaches the `createRequire` fallback. The failure surfaced as `mesh_send_task`
+ * crashing the whole tool call instead of gracefully degrading.
+ *
+ * The robust approach is to ATTEMPT the real `require` and CATCH the esbuild stub's
+ * throw, then fall back to `createRequire`. We try multiple resolution bases so the
+ * load works whether the code runs as:
+ *   - a genuine CJS module (bare `require` works),
+ *   - an esbuild CJS bundle with the throwing `require` shim (createRequire(import.meta.url)),
+ *   - a pure ESM module where `require` is undefined (createRequire(import.meta.url)).
+ */
+export function loadBetterSqlite3(): typeof BetterSqlite3 {
+    if (cached) return cached;
+
+    const errors: unknown[] = [];
+
+    // 1) Real CJS require, when present and not the esbuild throwing shim.
+    if (typeof require === 'function') {
+        try {
+            cached = require('better-sqlite3') as typeof BetterSqlite3;
+            return cached;
+        } catch (e) {
+            // Either the esbuild "Dynamic require is not supported" shim, or a
+            // genuine resolution failure. Fall through to createRequire.
+            errors.push(e);
+        }
+    }
+
+    // 2) createRequire anchored at this module's URL (works in ESM and in esbuild
+    //    CJS bundles, where import.meta.url is rewritten to a usable value).
+    try {
+        const metaUrl = typeof import.meta?.url === 'string' ? import.meta.url : undefined;
+        if (metaUrl) {
+            cached = createRequire(metaUrl)('better-sqlite3') as typeof BetterSqlite3;
+            return cached;
+        }
+    } catch (e) {
+        errors.push(e);
+    }
+
+    // 3) Last resort: createRequire anchored at the current working directory.
+    try {
+        cached = createRequire(`${process.cwd()}/__adhdev_better_sqlite3_loader__.js`)(
+            'better-sqlite3',
+        ) as typeof BetterSqlite3;
+        return cached;
+    } 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}`);
+}