@adhdev/daemon-core 0.9.77-rc.30 → 0.9.77-rc.32

package/dist/mesh/mesh-work-queue.d.ts

@@ -6,6 +6,8 @@ export interface MeshWorkQueueEntry {
     status: MeshTaskStatus;
     /** If specified, only this node can claim the task (used by legacy mesh_send_task) */
     targetNodeId?: string;
+    /** If specified, only this runtime session can claim the task */
+    targetSessionId?: string;
     /** The node that actually claimed and is executing the task */
     assignedNodeId?: string;
     /** The session currently executing the task */
@@ -18,6 +20,7 @@ export interface MeshWorkQueueEntry {
  */
 export declare function enqueueTask(meshId: string, message: string, opts?: {
     targetNodeId?: string;
+    targetSessionId?: string;
 }): MeshWorkQueueEntry;
 /**
  * Get all tasks in the queue, optionally filtered by status.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.77-rc.30",
+  "version": "0.9.77-rc.32",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/router.ts

@@ -1331,6 +1331,21 @@ export class DaemonCommandRouter {
                 }
             }
 
+            case 'get_mesh_queue': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                if (!meshId) return { success: false, error: 'meshId required' };
+                try {
+                    const { getQueue } = await import('../mesh/mesh-work-queue.js');
+                    const status = Array.isArray(args?.status)
+                        ? args.status.map((s: any) => typeof s === 'string' ? s.trim() : '').filter(Boolean)
+                        : undefined;
+                    const queue = getQueue(meshId, { status: status as any });
+                    return { success: true, queue };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
             case 'add_mesh_node': {
                 const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
                 const workspace = typeof args?.workspace === 'string' ? args.workspace.trim() : '';

package/src/mesh/mesh-events.ts

@@ -46,7 +46,15 @@ function readNonEmptyString(value: unknown): string {
     return typeof value === 'string' && value.trim() ? value.trim() : '';
 }
 
+function resolveEventSessionId(event: Record<string, unknown>, fallback?: unknown): string {
+    return readNonEmptyString(event.targetSessionId)
+        || readNonEmptyString(event.sessionId)
+        || readNonEmptyString(event.instanceId)
+        || readNonEmptyString(fallback);
+}
+
 const MESH_COORDINATOR_EVENTS = new Set([
+    'agent:generating_started',
     'agent:generating_completed',
     'agent:waiting_approval',
     'agent:stopped',
@@ -229,7 +237,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
 }) {
     // ── Task Queue & Ledger ──
     if (args.event === 'agent:generating_completed') {
-        const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
+        const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
         const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         const providerType = readNonEmptyString(args.metadataEvent.providerType);
         
@@ -243,9 +251,31 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             }
         }
     } else if (args.event === 'agent:ready') {
-        const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
+        const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
         const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         const providerType = readNonEmptyString(args.metadataEvent.providerType);
+        const completedTask = sessionId
+            ? updateSessionTaskStatus(args.meshId, sessionId, 'completed')
+            : null;
+        if (completedTask) {
+            try {
+                appendLedgerEntry(args.meshId, {
+                    kind: 'task_completed',
+                    nodeId: nodeId || undefined,
+                    sessionId,
+                    providerType: providerType || undefined,
+                    payload: {
+                        event: args.event,
+                        nodeLabel: args.nodeLabel,
+                        taskId: completedTask.id,
+                        completedViaReady: true,
+                        providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
+                    },
+                });
+            } catch (e: any) {
+                LOG.warn('MeshLedger', `Failed to record task_completed from ready: ${e?.message || e}`);
+            }
+        }
         
         if (sessionId && nodeId && providerType) {
             remoteIdleSessions.set(`${nodeId}:${sessionId}`, { nodeId, sessionId, providerType });
@@ -257,13 +287,13 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             }, 500);
         }
     } else if (args.event === 'agent:generating_started') {
-        const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
+        const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
         const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         if (sessionId && nodeId) {
             remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
         }
     } else if (args.event === 'agent:stopped') {
-        const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
+        const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
         const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         if (sessionId && nodeId) {
             remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
@@ -279,7 +309,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             appendLedgerEntry(args.meshId, {
                 kind: ledgerKind,
                 nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
-                sessionId: readNonEmptyString(args.metadataEvent.targetSessionId) || undefined,
+                sessionId: resolveEventSessionId(args.metadataEvent, args.sourceInstanceId) || undefined,
                 providerType: readNonEmptyString(args.metadataEvent.providerType) || undefined,
                 payload: {
                     event: args.event,
@@ -301,7 +331,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             const maxRetries = mesh?.policy?.maxTaskRetries ?? 1;
 
             recoveryContext = getSessionRecoveryContext(args.meshId, {
-                sessionId: readNonEmptyString(args.metadataEvent.targetSessionId) || undefined,
+                sessionId: resolveEventSessionId(args.metadataEvent, args.sourceInstanceId) || undefined,
                 nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
                 maxRetries,
             });
@@ -414,7 +444,7 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
         nodeLabel,
         event: eventName,
         metadataEvent: {
-            targetSessionId: readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId),
+            targetSessionId: readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.instanceId),
             providerType: readNonEmptyString(payload.providerType),
             providerSessionId: readNonEmptyString(payload.providerSessionId),
         },

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

@@ -12,6 +12,8 @@ export interface MeshWorkQueueEntry {
     status: MeshTaskStatus;
     /** If specified, only this node can claim the task (used by legacy mesh_send_task) */
     targetNodeId?: string;
+    /** If specified, only this runtime session can claim the task */
+    targetSessionId?: string;
     /** The node that actually claimed and is executing the task */
     assignedNodeId?: string;
     /** The session currently executing the task */
@@ -47,7 +49,7 @@ function writeQueue(meshId: string, queue: MeshWorkQueueEntry[]): void {
 export function enqueueTask(
     meshId: string,
     message: string,
-    opts?: { targetNodeId?: string }
+    opts?: { targetNodeId?: string; targetSessionId?: string }
 ): MeshWorkQueueEntry {
     const queue = readQueue(meshId);
     const entry: MeshWorkQueueEntry = {
@@ -56,6 +58,7 @@ export function enqueueTask(
         message,
         status: 'pending',
         targetNodeId: opts?.targetNodeId,
+        targetSessionId: opts?.targetSessionId,
         createdAt: new Date().toISOString(),
         updatedAt: new Date().toISOString(),
     };
@@ -81,13 +84,25 @@ export function getQueue(meshId: string, opts?: { status?: MeshTaskStatus[] }):
  */
 export function claimNextTask(meshId: string, nodeId: string, sessionId: string): MeshWorkQueueEntry | null {
     const queue = readQueue(meshId);
+
+    // A worker must finish or fail its current queued assignment before it can
+    // claim another one. maxParallelTasks limits total mesh concurrency; it is
+    // not permission for one node/session to accumulate multiple assigned items.
+    const hasActiveAssignment = queue.some(q => q.status === 'assigned' && (
+        q.assignedSessionId === sessionId || q.assignedNodeId === nodeId
+    ));
+    if (hasActiveAssignment) return null;
     
     // Find highest priority task:
-    // 1. Pending tasks explicitly targeted at this node
-    // 2. Pending tasks with no target node
-    let targetIdx = queue.findIndex(q => q.status === 'pending' && q.targetNodeId === nodeId);
+    // 1. Pending tasks explicitly targeted at this runtime session
+    // 2. Pending tasks explicitly targeted at this node (but not another session)
+    // 3. Pending tasks with no target node/session
+    let targetIdx = queue.findIndex(q => q.status === 'pending' && q.targetSessionId === sessionId);
+    if (targetIdx === -1) {
+        targetIdx = queue.findIndex(q => q.status === 'pending' && q.targetNodeId === nodeId && !q.targetSessionId);
+    }
     if (targetIdx === -1) {
-        targetIdx = queue.findIndex(q => q.status === 'pending' && !q.targetNodeId);
+        targetIdx = queue.findIndex(q => q.status === 'pending' && !q.targetNodeId && !q.targetSessionId);
     }
 
     if (targetIdx === -1) return null;