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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.330",
+  "version": "0.9.82-rc.332",
   "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.330",
+    "@adhdev/mesh-shared": "0.9.82-rc.332",
     "@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/config/mesh-config.ts

@@ -175,7 +175,7 @@ function mergeMeshPolicy(base: RepoMeshPolicy | undefined, patch: Partial<RepoMe
         policy.sessionCleanupOnNodeRemove = 'preserve';
     }
     if (!SPAWNED_SESSION_VISIBILITY_MODES.has(String(policy.spawnedSessionVisibility))) {
-        policy.spawnedSessionVisibility = 'visible';
+        policy.spawnedSessionVisibility = DEFAULT_MESH_POLICY.spawnedSessionVisibility;
     }
     // Load-balancing: normalize the scheduling strategy so an invalid/blank value
     // falls back to 'first_eligible' (strict no-change). Only persist the field when

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/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/repo-mesh-types.ts

@@ -342,7 +342,10 @@ export const DEFAULT_MESH_POLICY: RepoMeshPolicy = {
     requireApprovalForDestructiveGit: true,
     dirtyWorkspaceBehavior: 'warn',
     maxParallelTasks: 2,
-    spawnedSessionVisibility: 'visible',
+    // Coordinator-spawned worker sessions default to hidden so the dashboard is not
+    // flooded with mesh noise tabs/notifications. Users can still surface or unmute
+    // any specific session manually; that override is preserved per-device.
+    spawnedSessionVisibility: 'hidden',
     delegatedWorkerAutoApprove: true,
     sessionCleanupOnNodeRemove: 'preserve',
     autoFastForward: { enabled: true },

package/src/status/reporter.ts

@@ -319,6 +319,9 @@ export class DaemonStatusReporter {
                 cdpConnected: session.cdpConnected,
                 summaryMetadata: session.summaryMetadata,
                 settings: session.settings,
+                // Forward surfaceHidden so the server can gate push notifications for
+                // coordinator-hidden sessions (the WS path is the only one the server sees).
+                surfaceHidden: session.surfaceHidden,
             })),
             p2p: payload.p2p,
             timestamp: now,