@adhdev/daemon-core 0.9.77-rc.31 → 0.9.77-rc.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.77-rc.31",
+  "version": "0.9.77-rc.33",
   "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',
@@ -145,13 +153,17 @@ export function triggerMeshQueue(components: DaemonComponents, meshId: string) {
         const settings = state.settings as Record<string, unknown> || {};
         
         const instMeshId = readNonEmptyString(settings.meshNodeFor);
-        if (instMeshId !== meshId && !settings.launchedByCoordinator) continue;
+        if (instMeshId !== meshId) continue;
 
         const nodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
         if (!nodeId) continue;
 
-        // Is it idle? (online and waiting for input)
-        if (state.status !== 'idle' && state.status !== 'stopped' && state.activeChat?.status !== 'waiting_input') continue;
+        // Only genuinely idle live sessions can pull work. Restored/stopped
+        // records are kept for transcript/recovery visibility, but assigning
+        // queue items to them strands tasks in assigned/pending without chat.
+        const status = readNonEmptyString(state.status).toLowerCase();
+        if (['stopped', 'failed', 'terminated', 'exited', 'closed'].includes(status)) continue;
+        if (status !== 'idle' && state.activeChat?.status !== 'waiting_input') continue;
 
         const sessionId = state.instanceId;
         const providerType = state.type || readNonEmptyString(settings.providerType);
@@ -229,7 +241,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 +255,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 +291,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 +313,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 +335,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 +448,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

@@ -84,6 +84,14 @@ 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 runtime session