@adhdev/daemon-core 0.9.77-rc.4 → 0.9.77-rc.41

package/src/commands/router.ts

@@ -154,6 +154,35 @@ function loadHermesCoordinatorBaseConfig(targetConfigPath: string): { config: Re
     return { config: baseConfig, sourceHome, sourceConfigPath };
 }
 
+function stripHermesCoordinatorTempModelProviderOverrides(config: Record<string, any>): Record<string, any> {
+    const {
+        model: _model,
+        provider: _provider,
+        default_model: _defaultModel,
+        defaultProvider: _defaultProvider,
+        default_provider: _defaultProviderSnake,
+        modelProvider: _modelProvider,
+        model_provider: _modelProviderSnake,
+        ...sanitized
+    } = config;
+    const delegation = sanitized.delegation;
+    if (delegation && typeof delegation === 'object' && !Array.isArray(delegation)) {
+        const {
+            model: _delegationModel,
+            provider: _delegationProvider,
+            modelProvider: _delegationModelProvider,
+            model_provider: _delegationModelProviderSnake,
+            ...delegationRest
+        } = delegation;
+        if (Object.keys(delegationRest).length > 0) {
+            sanitized.delegation = delegationRest;
+        } else {
+            delete sanitized.delegation;
+        }
+    }
+    return sanitized;
+}
+
 function copyHermesCoordinatorCredentialFiles(sourceHome: string, targetHome: string) {
     if (pathResolve(sourceHome) === pathResolve(targetHome)) return;
     for (const fileName of ['.env', 'auth.json']) {
@@ -332,7 +361,7 @@ export class DaemonCommandRouter {
         this.deps = deps;
     }
 
-    private getCachedInlineMesh(meshId: string, inlineMesh?: unknown): any | undefined {
+    public getCachedInlineMesh(meshId: string, inlineMesh?: unknown): any | undefined {
         if (inlineMesh && typeof inlineMesh === 'object') {
             this.inlineMeshCache.set(meshId, inlineMesh as any);
             return inlineMesh as any;
@@ -1331,6 +1360,56 @@ 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 'cancel_mesh_queue_task': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                const taskId = typeof args?.taskId === 'string' ? args.taskId.trim() : '';
+                if (!meshId || !taskId) return { success: false, error: 'meshId and taskId required' };
+                try {
+                    const { cancelTask } = await import('../mesh/mesh-work-queue.js');
+                    const reason = typeof args?.reason === 'string' ? args.reason : undefined;
+                    const task = cancelTask(meshId, taskId, { reason });
+                    if (!task) return { success: false, error: `Queue task '${taskId}' not found` };
+                    return { success: true, task };
+                } catch (e: any) {
+                    return { success: false, error: e.message };
+                }
+            }
+
+            case 'requeue_mesh_queue_task': {
+                const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+                const taskId = typeof args?.taskId === 'string' ? args.taskId.trim() : '';
+                if (!meshId || !taskId) return { success: false, error: 'meshId and taskId required' };
+                try {
+                    const { requeueTask } = await import('../mesh/mesh-work-queue.js');
+                    const task = requeueTask(meshId, taskId, {
+                        reason: typeof args?.reason === 'string' ? args.reason : undefined,
+                        targetNodeId: typeof args?.targetNodeId === 'string' ? args.targetNodeId.trim() : undefined,
+                        targetSessionId: typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : undefined,
+                        clearTargetNode: args?.clearTargetNode === true,
+                        clearTargetSession: args?.clearTargetSession !== false,
+                    });
+                    if (!task) return { success: false, error: `Queue task '${taskId}' not found` };
+                    return { success: true, task };
+                } 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() : '';
@@ -1519,7 +1598,13 @@ export class DaemonCommandRouter {
                             appendLedgerEntry(meshId, {
                                 kind: 'node_removed',
                                 nodeId,
-                                payload: { worktree: !!node?.isLocalWorktree, sessionCleanupMode },
+                                payload: {
+                                    worktree: !!node?.isLocalWorktree,
+                                    sessionCleanupMode,
+                                    workspace: typeof node?.workspace === 'string' ? node.workspace : undefined,
+                                    daemonId: typeof node?.daemonId === 'string' ? node.daemonId : undefined,
+                                    worktreeBranch: typeof node?.worktreeBranch === 'string' ? node.worktreeBranch : undefined,
+                                },
                             });
                         } catch { /* ledger append is best-effort */ }
                     }
@@ -1711,6 +1796,105 @@ export class DaemonCommandRouter {
                         };
                     }
 
+                    // ─── CLI-command MCP registration (Codex, Gemini CLI) ───────────
+                    if (coordinatorSetup.kind === 'cli_command') {
+                        // Build coordinator prompt first — fail closed on errors.
+                        let cliCmdSystemPrompt = '';
+                        try {
+                            cliCmdSystemPrompt = buildCoordinatorSystemPrompt({ mesh, coordinatorCliType: cliType });
+                        } catch (error: any) {
+                            const message = error?.message || String(error);
+                            LOG.error('MeshCoordinator', `Failed to build coordinator prompt: ${message}`);
+                            return {
+                                success: false,
+                                code: 'mesh_coordinator_prompt_failed',
+                                error: `Failed to build Repo Mesh coordinator prompt: ${message}`,
+                                meshId, cliType, workspace,
+                            };
+                        }
+
+                        // Run the provider's MCP registration command.
+                        try {
+                            const { execFileSync: execCmdSync } = await import('node:child_process');
+                            const cmdParts = coordinatorSetup.command.trim().split(/\s+/);
+                            const [regCmd, ...regArgs] = cmdParts;
+                            LOG.info('MeshCoordinator', `Running MCP registration: ${coordinatorSetup.command}`);
+                            execCmdSync(regCmd, regArgs, { stdio: 'pipe', timeout: 15_000 });
+                        } catch (error: any) {
+                            // Non-fatal — server may already be registered (providers return exit 1 on duplicate).
+                            LOG.warn('MeshCoordinator', `MCP registration command failed (may be pre-registered): ${error?.message || error}`);
+                        }
+
+                        // Inject system prompt using provider-native methods.
+                        // Codex: -c 'instructions="..."' CLI config override
+                        // Gemini: write GEMINI.md to workspace (auto-loaded as context)
+                        const cliCmdArgs: string[] = [];
+                        const cliCmdEnv: Record<string, string> = {};
+                        if (cliCmdSystemPrompt) {
+                            if (cliType === 'codex-cli') {
+                                // Codex reads `developer_instructions` from config.toml as system instructions.
+                                // The -c flag overrides a config key for this session only.
+                                cliCmdArgs.push('-c', `developer_instructions=${JSON.stringify(cliCmdSystemPrompt)}`);
+                            } else if (cliType === 'gemini-cli') {
+                                // Gemini CLI auto-loads GEMINI.md from CWD as project context.
+                                // Write a temporary GEMINI.md to the workspace before launch.
+                                try {
+                                    const { writeFileSync: wfs, existsSync: efs, readFileSync: rfs } = await import('node:fs');
+                                    const geminiMdPath = `${workspace}/GEMINI.md`;
+                                    const marker = '<!-- adhdev-mesh-coordinator-prompt -->';
+                                    const markerEnd = '<!-- /adhdev-mesh-coordinator-prompt -->';
+                                    const block = `${marker}\n${cliCmdSystemPrompt}\n${markerEnd}`;
+                                    if (efs(geminiMdPath)) {
+                                        const existing = rfs(geminiMdPath, 'utf-8');
+                                        // Replace existing block or append
+                                        const replaced = existing.replace(
+                                            new RegExp(`${marker}[\\s\\S]*?${markerEnd}`, 'g'),
+                                            block,
+                                        );
+                                        wfs(geminiMdPath, replaced.includes(marker) ? replaced : `${existing}\n\n${block}`);
+                                    } else {
+                                        wfs(geminiMdPath, block);
+                                    }
+                                    LOG.info('MeshCoordinator', `Wrote coordinator prompt to ${workspace}/GEMINI.md`);
+                                } catch (e: any) {
+                                    LOG.warn('MeshCoordinator', `Could not write GEMINI.md: ${e?.message || e}`);
+                                }
+                            }
+                        }
+
+                        const cliCmdLaunch: any = await this.deps.cliManager.handleCliCommand('launch_cli', {
+                            cliType,
+                            dir: workspace,
+                            cliArgs: cliCmdArgs.length > 0 ? cliCmdArgs : undefined,
+                            env: Object.keys(cliCmdEnv).length > 0 ? cliCmdEnv : undefined,
+                            settings: { meshCoordinatorFor: meshId },
+                        });
+
+                        if (!cliCmdLaunch?.success) {
+                            return { success: false, error: cliCmdLaunch?.error || 'Failed to launch CLI session' };
+                        }
+
+                        LOG.info('MeshCoordinator', `Launched ${cliType} coordinator (cli_command) for mesh ${meshId}`);
+                        try {
+                            const { appendLedgerEntry } = await import('../mesh/mesh-ledger.js');
+                            appendLedgerEntry(meshId, {
+                                kind: 'coordinator_started',
+                                sessionId: cliCmdLaunch.sessionId || cliCmdLaunch.id,
+                                providerType: cliType,
+                                payload: { workspace },
+                            });
+                        } catch { /* best-effort */ }
+
+                        return {
+                            success: true,
+                            meshId,
+                            cliType,
+                            workspace,
+                            sessionId: cliCmdLaunch.sessionId || cliCmdLaunch.id,
+                            mcpRegistered: true,
+                        };
+                    }
+
                     const configFormat = coordinatorSetup.configFormat as MeshCoordinatorConfigFormat;
                     if (configFormat !== 'claude_mcp_json' && configFormat !== 'hermes_config_yaml') {
                         return {
@@ -1777,9 +1961,11 @@ export class DaemonCommandRouter {
                         args: coordinatorSetup.mcpServer.args,
                     };
                     if (args?.inlineMesh) {
+                        const modeArgIndex = coordinatorSetup.mcpServer.args.findIndex((value: string) => value === '--mode');
+                        const mcpTransport = modeArgIndex >= 0 ? coordinatorSetup.mcpServer.args[modeArgIndex + 1] : 'ipc';
                         mcpServerEntry.env = {
                             ADHDEV_INLINE_MESH: JSON.stringify(mesh),
-                            ADHDEV_MCP_TRANSPORT: 'ipc',
+                            ADHDEV_MCP_TRANSPORT: mcpTransport === 'local' ? 'local' : 'ipc',
                         };
                     }
 
@@ -1801,7 +1987,10 @@ export class DaemonCommandRouter {
                     if (hadExistingMcpConfig) {
                         try {
                             const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync(mcpConfigPath, 'utf-8'), configFormat);
-                            existingMcpConfig = { ...existingMcpConfig, ...parsedExistingMcpConfig };
+                            const existingCoordinatorConfig = hermesManualFallback
+                                ? stripHermesCoordinatorTempModelProviderOverrides(parsedExistingMcpConfig)
+                                : parsedExistingMcpConfig;
+                            existingMcpConfig = { ...existingMcpConfig, ...existingCoordinatorConfig };
                             copyFileSync(mcpConfigPath, mcpConfigPath + '.backup');
                         } catch (error: any) {
                             LOG.error('MeshCoordinator', `Failed to parse existing MCP config ${mcpConfigPath}: ${error?.message || error}`);

package/src/commands/stream-commands.ts

@@ -113,11 +113,18 @@ export async function handleOpenPanel(h: CommandHelpers, args: any): Promise<Com
 export async function handlePtyInput(h: CommandHelpers, args: any): Promise<CommandResult> {
     const { cliType, data, targetSessionId } = args || {};
     if (!data) return { success: false, error: 'data required' };
+
+    // Filter out VT100/VT420 Device Attributes responses (e.g. \x1b[?1;2c or \x1b[>0;276;0c)
+    // These are echoed by xterm.js in the dashboard in response to \x1b[c queries
+    // and pollute the CLI input buffer.
+    const cleanData = typeof data === 'string' ? data.replace(/\x1b\[[?>][0-9;]*c/g, '') : data;
+    if (!cleanData) return { success: true };
+
     const adapter = h.getCliAdapter(targetSessionId || cliType);
     if (!adapter || typeof adapter.writeRaw !== 'function') {
         return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || 'unknown'}` };
     }
-    await adapter.writeRaw(data);
+    await adapter.writeRaw(cleanData);
     return { success: true };
 }
 

package/src/index.ts

@@ -154,8 +154,8 @@ export { appendLedgerEntry, readLedgerEntries, getLedgerSummary, getLedgerDir, g
 export type { MeshLedgerEntry, MeshLedgerKind, MeshLedgerSummary, ReadLedgerOptions, SessionRecoveryContext } from './mesh/mesh-ledger.js';
 
 // ── Mesh Work Queue (GUPP) ──
-export { enqueueTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus } from './mesh/mesh-work-queue.js';
-export type { MeshWorkQueueEntry, MeshTaskStatus } from './mesh/mesh-work-queue.js';
+export { enqueueTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats } from './mesh/mesh-work-queue.js';
+export type { MeshWorkQueueEntry, MeshTaskStatus, MeshWorkQueueStats } from './mesh/mesh-work-queue.js';
 
 // ── Mesh Events ──
 export { triggerMeshQueue } from './mesh/mesh-events.js';

package/src/mesh/mesh-events.ts

@@ -3,7 +3,20 @@ 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';
+
+// ---------------------------------------------------------------------------
+// Remote Node Idle Session Tracking
+// ---------------------------------------------------------------------------
+// Tracks remote sessions that emitted 'agent:ready' so triggerMeshQueue 
+// can assign tasks to them.
+// ---------------------------------------------------------------------------
+interface RemoteIdleSession {
+    nodeId: string;
+    sessionId: string;
+    providerType: string;
+}
+const remoteIdleSessions = new Map<string, RemoteIdleSession>(); // key: `${nodeId}:${sessionId}`
 
 // ---------------------------------------------------------------------------
 // MCP coordinator pending-event queue
@@ -33,10 +46,19 @@ 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',
+    'agent:ready',
     'monitor:long_generating',
 ]);
 
@@ -60,25 +82,57 @@ function formatCompletionMetadata(event: Record<string, unknown>): string {
     return parts.length > 0 ? ` (${parts.join('; ')})` : '';
 }
 
+function getMeshWithCache(components: DaemonComponents, meshId: string): any | undefined {
+    const localMesh = getMesh(meshId);
+    if (localMesh) return localMesh;
+    return components.router?.getCachedInlineMesh(meshId);
+}
+
+
 export function tryAssignQueueTask(
-    components: { cliManager: any },
+    components: DaemonComponents,
     meshId: string,
     nodeId: string,
     sessionId: string,
     providerType: string
 ): boolean {
     const task = claimNextTask(meshId, nodeId, sessionId);
-    if (!task) return false;
+    if (!task) {
+        return false;
+    }
 
     LOG.info('MeshQueue', `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
+
+    // Check if the node is remote
+    const mesh = getMeshWithCache(components, 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',
-        input: task.message,
+        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;
@@ -88,8 +142,8 @@ 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) {
-    const mesh = getMesh(meshId);
+export function triggerMeshQueue(components: DaemonComponents, meshId: string) {
+    const mesh = getMeshWithCache(components, meshId);
     if (!mesh) return;
 
     // Find all CLI instances that belong to this mesh and are idle
@@ -99,13 +153,17 @@ export function triggerMeshQueue(components: { instanceManager: any; cliManager:
         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);
@@ -115,6 +173,18 @@ export function triggerMeshQueue(components: { instanceManager: any; cliManager:
             tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType);
         }
     }
+
+    // Also check known idle remote sessions
+    for (const [key, idle] of remoteIdleSessions.entries()) {
+        // Find if this node is in the same mesh
+        const node = mesh.nodes.find((n: any) => n.id === idle.nodeId);
+        if (node) {
+            const assigned = tryAssignQueueTask(components, meshId, idle.nodeId, idle.sessionId, idle.providerType);
+            if (assigned) {
+                remoteIdleSessions.delete(key);
+            }
+        }
+    }
 }
 
 function buildMeshSystemMessage(args: {
@@ -164,18 +234,21 @@ function buildMeshSystemMessage(args: {
 function injectMeshSystemMessage(components: DaemonComponents, args: {
     meshId: string;
     sourceInstanceId?: string;
+    nodeId?: string;
     nodeLabel: string;
     event: string;
     metadataEvent: Record<string, unknown>;
 }) {
     // ── Task Queue & Ledger ──
+    let completedTaskForLedger: { id?: string } | null = null;
     if (args.event === 'agent:generating_completed') {
-        const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
-        const nodeId = readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+        const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
+        const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         const providerType = readNonEmptyString(args.metadataEvent.providerType);
         
         if (sessionId) {
-            updateSessionTaskStatus(args.meshId, sessionId, 'completed');
+            const completedTask = updateSessionTaskStatus(args.meshId, sessionId, 'completed');
+            completedTaskForLedger = completedTask ? { id: completedTask.id } : null;
             if (nodeId && providerType) {
                 // Short delay to allow completion event to propagate before pulling next
                 setTimeout(() => {
@@ -183,8 +256,56 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                 }, 500);
             }
         }
+    } else if (args.event === 'agent:ready') {
+        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) {
+            completedTaskForLedger = { id: completedTask.id };
+            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,
+                        finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || 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 });
+            setTimeout(() => {
+                const assigned = tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
+                if (assigned) {
+                    remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+                }
+            }, 500);
+        }
+    } else if (args.event === 'agent:generating_started') {
+        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}`);
+        }
         if (sessionId) {
             updateSessionTaskStatus(args.meshId, sessionId, 'failed');
         }
@@ -195,13 +316,15 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         try {
             appendLedgerEntry(args.meshId, {
                 kind: ledgerKind,
-                nodeId: readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
-                sessionId: readNonEmptyString(args.metadataEvent.targetSessionId) || undefined,
+                nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
+                sessionId: resolveEventSessionId(args.metadataEvent, args.sourceInstanceId) || undefined,
                 providerType: readNonEmptyString(args.metadataEvent.providerType) || undefined,
                 payload: {
                     event: args.event,
                     nodeLabel: args.nodeLabel,
+                    taskId: completedTaskForLedger?.id || undefined,
                     providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
+                    finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
                 },
             });
         } catch (e: any) {
@@ -218,8 +341,8 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             const maxRetries = mesh?.policy?.maxTaskRetries ?? 1;
 
             recoveryContext = getSessionRecoveryContext(args.meshId, {
-                sessionId: readNonEmptyString(args.metadataEvent.targetSessionId) || undefined,
-                nodeId: readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
+                sessionId: resolveEventSessionId(args.metadataEvent, args.sourceInstanceId) || undefined,
+                nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
                 maxRetries,
             });
             recoveryContext.failedProviderType = readNonEmptyString(args.metadataEvent.providerType) || null;
@@ -327,12 +450,14 @@ export function handleMeshForwardEvent(components: DaemonComponents, payload: Re
     const nodeLabel = nodeId ? `Node '${nodeId}'` : workspace ? `Agent at ${workspace}` : 'Remote agent';
     return injectMeshSystemMessage(components, {
         meshId,
+        nodeId,
         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),
+            finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary),
         },
     });
 }
@@ -367,13 +492,14 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
         const isMeshDelegate = Boolean(meshIdFromRuntime || settings.launchedByCoordinator);
         if (!isMeshDelegate) return;
 
-        const mesh = meshIdFromRuntime ? getMesh(meshIdFromRuntime) : getMeshByRepo(workspace);
+        const mesh = meshIdFromRuntime ? getMeshWithCache(components, meshIdFromRuntime) : getMeshByRepo(workspace);
         const meshId = meshIdFromRuntime || readNonEmptyString(mesh?.id);
         if (!meshId) return;
 
         // 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 resolvedNodeId = targetNode?.id || runtimeNodeId;
         const nodeLabel = targetNode
             ? `Node '${targetNode.id}'`
             : runtimeNodeId
@@ -383,6 +509,7 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
         injectMeshSystemMessage(components, {
             meshId,
             sourceInstanceId: instanceId,
+            nodeId: resolvedNodeId,
             nodeLabel,
             event: event.event,
             metadataEvent: event,