@adhdev/daemon-core 0.9.82-rc.421 → 0.9.82-rc.423

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

@@ -84,15 +84,30 @@ export declare class ProviderInstanceManager {
     updateInstanceSettings(providerType: string, settings: Record<string, any>): number;
     /** Stamp a mesh assignment on a single instance (used by mesh_send_task
      *  --direct so the worker's completion event has a coordinator routing
-     *  marker in state.settings). Returns true if the instance existed and
-     *  the stamp was applied. */
+     *  marker in state.settings). Returns `{ stamped: true }` when the stamp was
+     *  applied, or `{ stamped: false, reason }` when it was refused — the instance
+     *  was missing / has no attach method, or the DOUBLE-DISPATCH idempotence guard
+     *  fired (the same task is already running on another live session here). */
     attachMeshAssignmentToInstance(instanceId: string, assignment: {
         meshId: string;
         nodeId?: string;
         taskId?: string;
         coordinatorDaemonId?: string;
         coordinatorSessionId?: string;
-    }): boolean;
+    }): {
+        stamped: boolean;
+        reason?: string;
+    };
+    /**
+     * DOUBLE-DISPATCH support: the id of another LIVE, actively-working instance that already
+     * holds (meshId, taskId), or null. "Live working" = stamped with this exact mesh+task AND
+     * currently mid-turn / booting toward it (generating / waiting on approval-or-choice /
+     * starting) — NOT idle, stopped, or errored. A stale/dead/idle holder is deliberately
+     * ignored so a legitimate re-dispatch (e.g. after a dispatch failure) is never blocked.
+     * The instance being stamped (excludeInstanceId) is skipped so re-stamping the same
+     * session stays idempotent. O(n) over instances — the count is small.
+     */
+    private findLiveWorkingTaskHolder;
     /** Clear a mesh assignment after the dispatched task reaches a terminal
      *  state (generating_completed / stopped / failed). */
     detachMeshAssignmentFromInstance(instanceId: string): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.421",
+  "version": "0.9.82-rc.423",
   "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.421",
+    "@adhdev/mesh-shared": "0.9.82-rc.423",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/cli-manager.ts

@@ -1535,14 +1535,22 @@ export class DaemonCliManager {
                     const meshContext = (args as any)?.meshContext;
                     if (meshContext && typeof meshContext === 'object' && typeof meshContext.meshId === 'string' && meshContext.meshId) {
                         const targetInstanceId = key;
+                        let stampResult: { stamped: boolean; reason?: string } | undefined;
                         try {
-                            this.deps.getInstanceManager()?.attachMeshAssignmentToInstance(targetInstanceId, {
+                            stampResult = this.deps.getInstanceManager()?.attachMeshAssignmentToInstance(targetInstanceId, {
                                 meshId: meshContext.meshId,
                                 ...(typeof meshContext.nodeId === 'string' && meshContext.nodeId ? { nodeId: meshContext.nodeId } : {}),
                                 ...(typeof meshContext.taskId === 'string' && meshContext.taskId ? { taskId: meshContext.taskId } : {}),
                                 ...(typeof meshContext.coordinatorDaemonId === 'string' && meshContext.coordinatorDaemonId ? { coordinatorDaemonId: meshContext.coordinatorDaemonId } : {}),
                             });
-                        } catch { /* best-effort */ }
+                        } catch { /* best-effort — stamping is a routing aid, not a hard requirement */ }
+                        // DOUBLE-DISPATCH stamp guard: the instance manager refused this stamp because
+                        // the SAME task is already running on another live session on this daemon.
+                        // Sending the prompt anyway would double-execute the task — fail closed so the
+                        // coordinator does not duplicate the work onto a second session.
+                        if (stampResult && stampResult.stamped === false && stampResult.reason === 'task_already_stamped_on_live_instance') {
+                            throw new Error(`Refusing duplicate mesh dispatch: task ${meshContext.taskId} is already being worked by a live session on this daemon`);
+                        }
                     }
                     const input = normalizeInputEnvelope(args?.input ? { input: args.input } : args);
                     const provider = this.providerLoader.resolve(agentType) || this.providerLoader.getMeta(agentType);

package/src/mesh/mesh-queue-assignment.ts

@@ -1098,6 +1098,47 @@ function liveSessionCountForNode(components: DaemonComponents, meshId: string, n
     }).length;
 }
 
+/**
+ * DOUBLE-DISPATCH auto-launch gate: does this node already have a LIVE mesh session that
+ * is NOT holding an assigned queue task — i.e. one that is idle, booting toward its first
+ * claim, or in a momentary non-idle flip? Such a session WILL claim a still-pending task
+ * on its own via the idle→claim / agent:ready drain, so spawning a NEW session here only
+ * races it and yields a duplicate worker that double-stamps the same taskId (the
+ * enqueue → drain-miss → auto-launch RCA: the drain skipped a momentarily-non-idle idle
+ * session as a candidate, and the write-only nodeHasActiveAssignment gate — which only
+ * inspects status='assigned' rows — could not see the about-to-claim session either).
+ *
+ * A session that already HOLDS an assigned queue task is genuine concurrent work, not a
+ * free claimer, and is excluded — so a read-only auto-launch onto a busy-but-no-idle node
+ * is still allowed. A node with NO live mesh session at all (dead, or never launched) does
+ * not match, preserving the legitimate first-session spawn.
+ */
+function nodeHasLiveSessionPendingClaim(components: DaemonComponents, meshId: string, nodeId: string): boolean {
+    // Session ids currently holding an assigned queue task on this node — those are busy,
+    // not pending claimers, so they must NOT suppress a (read-only) launch.
+    const busySessionIds = new Set(
+        getQueue(meshId, { status: ['assigned'] as any })
+            .filter(task => daemonIdsEquivalent(task.assignedNodeId, nodeId))
+            .map(task => readNonEmptyString(task.assignedSessionId))
+            .filter(Boolean),
+    );
+    return components.instanceManager.getByCategory('cli').some((inst: any) => {
+        const state = inst.getState();
+        const settings = state.settings as Record<string, unknown> || {};
+        if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
+        const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+        // Canonical-form match (see nodeHasActiveMeshWork / liveSessionCountForNode): a
+        // daemon-id form skew must not make a present session look absent and reopen the
+        // duplicate-launch hole.
+        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
+        const status = readNonEmptyString(state.status).toLowerCase();
+        if (isTerminalSessionStatus(status)) return false; // dead → no claimer here, allow launch
+        const sessionId = readNonEmptyString(state.instanceId);
+        if (sessionId && busySessionIds.has(sessionId)) return false; // busy with its own assigned task
+        return true; // live + unassigned → will claim the pending task itself
+    });
+}
+
 function recordAutoLaunchEvent(meshId: string, args: {
     phase: 'skipped' | 'started' | 'failed' | 'completed';
     taskId: string;
@@ -1417,6 +1458,20 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
                 autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS); sweepExpiredCooldowns();
                 continue;
             }
+            // DOUBLE-DISPATCH auto-launch gate (see nodeHasLiveSessionPendingClaim): when this
+            // node already has a live session on its way to claim (idle / booting / momentary
+            // non-idle flip), do NOT spawn a second one — that session pulls the pending task
+            // via the normal idle→claim / agent:ready drain. Launching here races it and yields
+            // a duplicate worker that double-stamps the same taskId. Applies to read-only tasks
+            // too: an idle session can claim either kind, while a genuinely BUSY session (holding
+            // its own assigned task) is excluded by the helper, so a read-only launch onto a
+            // busy-but-no-idle node is still allowed. Skip with a transient (non-actionable)
+            // reason so the coordinator is not paged; the 4s reconcile retries, and once the
+            // existing session goes terminal this gate clears and a legitimate launch proceeds.
+            if (nodeHasLiveSessionPendingClaim(components, meshId, nodeId)) {
+                markAutoLaunch(meshId, task.id, { status: 'skipped', reason: 'node_has_live_session_pending_claim', nodeId });
+                continue;
+            }
             // Write tasks keep the one-active-per-node invariant (worktree isolation);
             // read-only diagnoses may auto-launch onto a node that already has an active
             // assignment. Classified by the shared isTaskReadonly predicate.

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

@@ -308,23 +308,64 @@ export class ProviderInstanceManager {
 
     /** Stamp a mesh assignment on a single instance (used by mesh_send_task
      *  --direct so the worker's completion event has a coordinator routing
-     *  marker in state.settings). Returns true if the instance existed and
-     *  the stamp was applied. */
-    attachMeshAssignmentToInstance(instanceId: string, assignment: { meshId: string; nodeId?: string; taskId?: string; coordinatorDaemonId?: string; coordinatorSessionId?: string }): boolean {
+     *  marker in state.settings). Returns `{ stamped: true }` when the stamp was
+     *  applied, or `{ stamped: false, reason }` when it was refused — the instance
+     *  was missing / has no attach method, or the DOUBLE-DISPATCH idempotence guard
+     *  fired (the same task is already running on another live session here). */
+    attachMeshAssignmentToInstance(instanceId: string, assignment: { meshId: string; nodeId?: string; taskId?: string; coordinatorDaemonId?: string; coordinatorSessionId?: string }): { stamped: boolean; reason?: string } {
         const inst = this.instances.get(instanceId);
         if (!inst || typeof inst.attachMeshAssignment !== 'function') {
-            try {
-                const { LOG } = require('../logging/logger.js');
-                LOG.warn?.('MeshDispatch', `attachMeshAssignment skipped: instance ${instanceId} ${inst ? 'has no attach method' : 'not found'}`);
-            } catch { /* noop */ }
-            return false;
+            LOG.warn('MeshDispatch', `attachMeshAssignment skipped: instance ${instanceId} ${inst ? 'has no attach method' : 'not found'}`);
+            return { stamped: false, reason: inst ? 'instance_has_no_attach_method' : 'instance_not_found' };
+        }
+        // DOUBLE-DISPATCH stamp idempotence guard (defense in depth): refuse to stamp this
+        // (meshId, taskId) onto a SECOND instance when a DIFFERENT, still-live and actively
+        // working instance already holds the exact same task. Two sessions carrying one taskId
+        // double-execute the work (the auto-launch race RCA: a delayed claim by the original
+        // session plus the new session's post-boot claim sequentially stamp the same task —
+        // the atomic claim only blocks SIMULTANEOUS claims). A stale/dead/idle prior holder is
+        // NOT a conflict — a legitimate re-dispatch after a dispatch failure must still stamp.
+        if (assignment.taskId) {
+            const conflict = this.findLiveWorkingTaskHolder(assignment.meshId, assignment.taskId, instanceId);
+            if (conflict) {
+                LOG.warn('MeshDispatch', `attachMeshAssignment refused: task ${assignment.taskId} (mesh ${assignment.meshId}) is already being worked by live session ${conflict} — skipping duplicate stamp on ${instanceId}`);
+                return { stamped: false, reason: 'task_already_stamped_on_live_instance' };
+            }
         }
         inst.attachMeshAssignment(assignment);
-        try {
-            const { LOG } = require('../logging/logger.js');
-            LOG.info?.('MeshDispatch', `stamped mesh assignment on ${instanceId}: mesh=${assignment.meshId} node=${assignment.nodeId || ''} task=${assignment.taskId || ''} coordinator=${assignment.coordinatorDaemonId || ''}`);
-        } catch { /* noop */ }
-        return true;
+        LOG.info('MeshDispatch', `stamped mesh assignment on ${instanceId}: mesh=${assignment.meshId} node=${assignment.nodeId || ''} task=${assignment.taskId || ''} coordinator=${assignment.coordinatorDaemonId || ''}`);
+        return { stamped: true };
+    }
+
+    /**
+     * DOUBLE-DISPATCH support: the id of another LIVE, actively-working instance that already
+     * holds (meshId, taskId), or null. "Live working" = stamped with this exact mesh+task AND
+     * currently mid-turn / booting toward it (generating / waiting on approval-or-choice /
+     * starting) — NOT idle, stopped, or errored. A stale/dead/idle holder is deliberately
+     * ignored so a legitimate re-dispatch (e.g. after a dispatch failure) is never blocked.
+     * The instance being stamped (excludeInstanceId) is skipped so re-stamping the same
+     * session stays idempotent. O(n) over instances — the count is small.
+     */
+    private findLiveWorkingTaskHolder(meshId: string, taskId: string, excludeInstanceId: string): string | null {
+        // Mid-turn / booting statuses (top-level or activeChat). Anything else — idle, stopped,
+        // error — is not a live worker actively holding the task.
+        const working = new Set(['generating', 'waiting_approval', 'waiting_choice', 'starting', 'streaming', 'working', 'no_progress', 'long_generating']);
+        for (const [id, inst] of this.instances) {
+            if (id === excludeInstanceId) continue;
+            let state: ProviderState;
+            try {
+                state = inst.getState();
+            } catch {
+                continue;
+            }
+            const settings = (state.settings as Record<string, unknown>) || {};
+            if (settings.meshNodeFor !== meshId) continue;
+            if (settings.meshActiveTaskId !== taskId) continue;
+            const status = (typeof state.status === 'string' ? state.status : '').toLowerCase();
+            const chatStatus = (typeof state.activeChat?.status === 'string' ? state.activeChat.status : '').toLowerCase();
+            if (working.has(status) || working.has(chatStatus)) return id;
+        }
+        return null;
     }
 
     /** Clear a mesh assignment after the dispatched task reaches a terminal