@adhdev/daemon-core 0.9.77-rc.21 → 0.9.77-rc.22

package/dist/mesh/mesh-events.d.ts

@@ -8,17 +8,12 @@ export interface PendingMeshCoordinatorEvent {
 }
 /** Drain and return all pending coordinator events, clearing the queue. */
 export declare function drainPendingMeshCoordinatorEvents(): PendingMeshCoordinatorEvent[];
-export declare function tryAssignQueueTask(components: {
-    cliManager: any;
-}, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
+export declare function tryAssignQueueTask(components: DaemonComponents, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
 /**
  * Triggers a queue check for all nodes in the mesh.
  * Called when a new task is enqueued, in case nodes are already idle.
  */
-export declare function triggerMeshQueue(components: {
-    instanceManager: any;
-    cliManager: any;
-}, meshId: string): void;
+export declare function triggerMeshQueue(components: DaemonComponents, meshId: string): void;
 export declare function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>): {
     success: boolean;
     forwarded: number;

package/package.json

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

package/src/boot/daemon-lifecycle.ts

@@ -83,6 +83,9 @@ export interface DaemonInitConfig {
 
     /** Fired before send_chat is dispatched — used for turn snapshot hooks */
     onBeforeSendChat?: (params: { workspace: string; sessionId: string }) => void;
+
+    /** Relays a command to a remote mesh node daemon */
+    dispatchMeshCommand?: (daemonId: string, command: string, args: Record<string, unknown>) => Promise<any>;
 }
 
 // ─── Result ───
@@ -100,6 +103,7 @@ export interface DaemonComponents {
     sessionRegistry: SessionRegistry;
     detectedIdes: { value: IDEInfo[] };
     refreshProviderAvailability: (providerType?: string) => Promise<void>;
+    dispatchMeshCommand?: (daemonId: string, command: string, args: Record<string, unknown>) => Promise<any>;
 }
 
 export interface DaemonDevSupportOptions {
@@ -331,6 +335,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         sessionRegistry,
         detectedIdes: detectedIdesRef,
         refreshProviderAvailability,
+        dispatchMeshCommand: config.dispatchMeshCommand,
     };
 
     // 11. Setup Mesh Event Forwarding

package/src/mesh/mesh-events.ts

@@ -3,7 +3,7 @@ import { getMesh, getMeshByRepo } from '../config/mesh-config.js';
 import { LOG } from '../logging/logger.js';
 import { appendLedgerEntry, getSessionRecoveryContext } from './mesh-ledger.js';
 import type { MeshLedgerKind, SessionRecoveryContext } from './mesh-ledger.js';
-import { claimNextTask, updateSessionTaskStatus, enqueueTask } from './mesh-work-queue.js';
+import { claimNextTask, updateSessionTaskStatus, enqueueTask, updateTaskStatus } from './mesh-work-queue.js';
 
 // ---------------------------------------------------------------------------
 // MCP coordinator pending-event queue
@@ -62,7 +62,7 @@ function formatCompletionMetadata(event: Record<string, unknown>): string {
 }
 
 export function tryAssignQueueTask(
-    components: { cliManager: any },
+    components: DaemonComponents,
     meshId: string,
     nodeId: string,
     sessionId: string,
@@ -74,14 +74,37 @@ export function tryAssignQueueTask(
     }
 
     LOG.info('MeshQueue', `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
+
+    // Check if the node is remote
+    const mesh = getMesh(meshId);
+    const node = mesh?.nodes.find((n: any) => n.id === nodeId);
     
+    // If the node is explicitly remote and we have a dispatch mechanism, route via P2P
+    if (node?.daemonId && components.dispatchMeshCommand) {
+        const isLocalNode = components.cliManager.adapters.has(sessionId);
+        if (!isLocalNode) {
+            components.dispatchMeshCommand(node.daemonId, 'agent_command', {
+                targetSessionId: sessionId,
+                cliType: providerType,
+                action: 'send_chat',
+                message: task.message,
+            }).catch((e: any) => {
+                LOG.error('MeshQueue', `Failed to dispatch task via P2P to remote node ${nodeId}: ${e?.message}`);
+                updateTaskStatus(meshId, task.id, 'failed');
+            });
+            return true;
+        }
+    }
+
+    // Local routing
     components.cliManager.handleCliCommand('agent_command', {
         targetSessionId: sessionId,
         cliType: providerType,
         action: 'send_chat',
         message: task.message,
     }).catch((e: any) => {
-        LOG.error('MeshQueue', `Failed to dispatch task to node ${nodeId}: ${e?.message}`);
+        LOG.error('MeshQueue', `Failed to dispatch task locally to node ${nodeId}: ${e?.message}`);
+        updateTaskStatus(meshId, task.id, 'failed');
     });
 
     return true;
@@ -91,7 +114,7 @@ export function tryAssignQueueTask(
  * Triggers a queue check for all nodes in the mesh.
  * Called when a new task is enqueued, in case nodes are already idle.
  */
-export function triggerMeshQueue(components: { instanceManager: any; cliManager: any }, meshId: string) {
+export function triggerMeshQueue(components: DaemonComponents, meshId: string) {
     const mesh = getMesh(meshId);
     if (!mesh) return;