@adhdev/daemon-core 0.9.76-rc.30 → 0.9.76-rc.31

package/package.json

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

package/src/mesh/mesh-events.ts

@@ -1,52 +1,75 @@
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
-import { getMeshByRepo } from '../config/mesh-config.js';
+import { getMesh, getMeshByRepo } from '../config/mesh-config.js';
 import { LOG } from '../logging/logger.js';
 
+function readNonEmptyString(value: unknown): string {
+    return typeof value === 'string' && value.trim() ? value.trim() : '';
+}
+
+function formatCompletionMetadata(event: Record<string, unknown>): string {
+    const parts = [
+        readNonEmptyString(event.targetSessionId) ? `session_id=${readNonEmptyString(event.targetSessionId)}` : '',
+        readNonEmptyString(event.providerType) ? `provider=${readNonEmptyString(event.providerType)}` : '',
+        readNonEmptyString(event.providerSessionId) ? `provider_session_id=${readNonEmptyString(event.providerSessionId)}` : '',
+    ].filter(Boolean);
+    return parts.length > 0 ? ` (${parts.join('; ')})` : '';
+}
+
 export function setupMeshEventForwarding(components: DaemonComponents) {
     components.instanceManager.onEvent((event) => {
         // We only care about agent sub-session completion or waiting approval
         if (event.event !== 'agent:generating_completed' && event.event !== 'agent:waiting_approval') return;
-        
-        const instanceId = event.instanceId as string;
+
+        const instanceId = readNonEmptyString(event.instanceId);
         if (!instanceId) return;
 
-        // Try to find the workspace of the sub-agent
+        // Try to find the workspace and mesh metadata of the sub-agent.
         const sourceInstance = components.instanceManager.getInstance(instanceId);
         if (!sourceInstance || sourceInstance.category !== 'cli') return;
         const state = sourceInstance.getState();
-        const workspace = state.workspace;
+        const workspace = readNonEmptyString(state.workspace);
         if (!workspace) return;
+        const settings = state.settings && typeof state.settings === 'object' ? state.settings as Record<string, unknown> : {};
+        const meshIdFromRuntime = readNonEmptyString(settings.meshNodeFor);
 
-        // Find the mesh that this workspace belongs to
-        const mesh = getMeshByRepo(workspace);
-        if (!mesh) return;
+        // Prefer runtime mesh metadata: delegated mesh-node agents can come from inline/cloud meshes
+        // that are not present in local meshes.json. Fall back to persisted mesh lookup for legacy sessions.
+        const mesh = meshIdFromRuntime ? getMesh(meshIdFromRuntime) : getMeshByRepo(workspace);
+        const meshId = meshIdFromRuntime || readNonEmptyString(mesh?.id);
+        if (!meshId) return;
 
         // Find the coordinator session(s)
         const allInstances = components.instanceManager.getByCategory('cli');
         const coordinatorInstances = allInstances.filter((inst) => {
             const instState = inst.getState();
-            
+
             // The coordinator session was launched with meshCoordinatorFor setting
-            if (instState.settings?.meshCoordinatorFor !== mesh.id) return false;
-            
+            if (instState.settings?.meshCoordinatorFor !== meshId) return false;
+
             // Exclude the source instance itself (just in case)
             if (instState.instanceId === instanceId) return false;
-            
+
             return true;
         });
 
         if (coordinatorInstances.length === 0) return;
 
-        // Determine node label
-        const targetNode = mesh.nodes.find((n) => n.workspace === workspace);
-        const nodeLabel = targetNode ? `Node '${targetNode.id}'` : `Agent at ${workspace}`;
+        // Determine node label. Inline/cloud meshes may be unavailable here, so preserve runtime node id.
+        const targetNode = mesh?.nodes?.find((n: any) => n.workspace === workspace);
+        const runtimeNodeId = readNonEmptyString(settings.meshNodeId);
+        const nodeLabel = targetNode
+            ? `Node '${targetNode.id}'`
+            : runtimeNodeId
+                ? `Node '${runtimeNodeId}'`
+                : `Agent at ${workspace}`;
+        const metadata = formatCompletionMetadata(event);
 
         // Construct a system message in English
         let messageText = '';
         if (event.event === 'agent:generating_completed') {
-            messageText = `[System] ${nodeLabel} has completed its task and is now idle. You may use mesh_read_chat to review its progress.`;
+            messageText = `[System] ${nodeLabel} has completed its task and is now idle${metadata}. You may use mesh_read_chat to review its progress.`;
         } else if (event.event === 'agent:waiting_approval') {
-            messageText = `[System] ${nodeLabel} is waiting for approval to proceed. You may use mesh_read_chat and mesh_approve to handle it.`;
+            messageText = `[System] ${nodeLabel} is waiting for approval to proceed${metadata}. You may use mesh_read_chat and mesh_approve to handle it.`;
         }
 
         if (!messageText) return;