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

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

@@ -1,2 +1,11 @@
 import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+export declare function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>): {
+    success: boolean;
+    forwarded: number;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    forwarded?: undefined;
+};
 export declare function setupMeshEventForwarding(components: DaemonComponents): void;

package/package.json

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

package/src/cli-adapters/provider-cli-adapter.ts

@@ -1857,9 +1857,13 @@ export class ProviderCliAdapter implements CliAdapter {
             };
             this.recordTrace('submit_echo_missing', diagnostic);
             if (this.requirePromptEchoBeforeSubmit) {
-                const message = `${this.cliName} prompt echo was not observed on the PTY screen before submit`;
-                LOG.warn('CLI', `[${this.cliType}] ${message} elapsed=${elapsed}ms maxEchoWaitMs=${state.maxEchoWaitMs} screen=${JSON.stringify(diagnostic.screenText).slice(0, 240)}`);
-                completion.rejectOnce(new Error(message));
+                // At this point the prompt text write already completed. Rejecting without
+                // a submit key can leave the delegated CLI with an unsent prompt sitting at
+                // the input line, which makes later coordinator sends appear stuck. Prefer a
+                // guarded submit after the full echo wait; the existing stuck-submit retry
+                // will send a delayed follow-up Enter if the prompt remains visible.
+                LOG.warn('CLI', `[${this.cliType}] prompt echo was not observed before submit; sending guarded submit key anyway elapsed=${elapsed}ms maxEchoWaitMs=${state.maxEchoWaitMs} screen=${JSON.stringify(diagnostic.screenText).slice(0, 240)}`);
+                this.submitSendKey(state, completion);
                 return;
             }
             LOG.warn('CLI', `[${this.cliType}] prompt echo was not observed before submit; sending submit key anyway elapsed=${elapsed}ms maxEchoWaitMs=${state.maxEchoWaitMs}`);

package/src/commands/router.ts

@@ -36,6 +36,7 @@ import { createInteractionId, getRecentDebugTrace, recordDebugTrace } from '../l
 import { getSessionHostSurfaceKind, partitionSessionHostRecords } from '../session-host/runtime-surface.js';
 import { createHermesManualMeshCoordinatorSetup, resolveMeshCoordinatorSetup } from './mesh-coordinator.js';
 import { buildSessionEntries } from '../status/builders.js';
+import { handleMeshForwardEvent } from '../mesh/mesh-events.js';
 import { buildMachineInfo, buildStatusSnapshot } from '../status/snapshot.js';
 import { getSessionCompletionMarker } from '../status/snapshot.js';
 import { execNpmCommandSync, resolveCurrentGlobalInstallSurface, spawnDetachedDaemonUpgradeHelper } from './upgrade-helper.js';
@@ -471,6 +472,10 @@ export class DaemonCommandRouter {
     private async executeDaemonCommand(cmd: string, args: any): Promise<CommandRouterResult | null> {
         switch (cmd) {
             // ─── CLI / ACP commands ───
+            case 'mesh_forward_event': {
+                return handleMeshForwardEvent({ instanceManager: this.deps.instanceManager } as any, args as Record<string, unknown>);
+            }
+
             case 'launch_cli':
             case 'stop_cli':
             case 'set_cli_view_mode':

package/src/mesh/mesh-events.ts

@@ -15,6 +15,75 @@ function formatCompletionMetadata(event: Record<string, unknown>): string {
     return parts.length > 0 ? ` (${parts.join('; ')})` : '';
 }
 
+function buildMeshSystemMessage(args: {
+    event: string;
+    nodeLabel: string;
+    metadataEvent: Record<string, unknown>;
+}): string {
+    const metadata = formatCompletionMetadata(args.metadataEvent);
+    if (args.event === 'agent:generating_completed') {
+        return `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}. You may use mesh_read_chat to review its progress.`;
+    }
+    if (args.event === 'agent:waiting_approval') {
+        return `[System] ${args.nodeLabel} is waiting for approval to proceed${metadata}. You may use mesh_read_chat and mesh_approve to handle it.`;
+    }
+    return '';
+}
+
+function injectMeshSystemMessage(components: DaemonComponents, args: {
+    meshId: string;
+    sourceInstanceId?: string;
+    nodeLabel: string;
+    event: string;
+    metadataEvent: Record<string, unknown>;
+}) {
+    const coordinatorInstances = components.instanceManager.getByCategory('cli').filter((inst) => {
+        const instState = inst.getState();
+        if (instState.settings?.meshCoordinatorFor !== args.meshId) return false;
+        if (args.sourceInstanceId && instState.instanceId === args.sourceInstanceId) return false;
+        return true;
+    });
+
+    if (coordinatorInstances.length === 0) return { success: true, forwarded: 0 };
+
+    const messageText = buildMeshSystemMessage({
+        event: args.event,
+        nodeLabel: args.nodeLabel,
+        metadataEvent: args.metadataEvent,
+    });
+    if (!messageText) return { success: false, error: 'unsupported mesh event' };
+
+    for (const coord of coordinatorInstances) {
+        const coordState = coord.getState();
+        LOG.info('MeshEvents', `Forwarding mesh event to coordinator ${coordState.instanceId}`);
+        coord.onEvent('send_message', { input: { text: messageText, textFallback: messageText } });
+    }
+    return { success: true, forwarded: coordinatorInstances.length };
+}
+
+export function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>) {
+    const eventName = readNonEmptyString(payload.event);
+    if (eventName !== 'agent:generating_completed' && eventName !== 'agent:waiting_approval') {
+        return { success: false, error: 'unsupported mesh event' };
+    }
+    const meshId = readNonEmptyString(payload.meshId);
+    if (!meshId) return { success: false, error: 'meshId required' };
+
+    const nodeId = readNonEmptyString(payload.nodeId);
+    const workspace = readNonEmptyString(payload.workspace);
+    const nodeLabel = nodeId ? `Node '${nodeId}'` : workspace ? `Agent at ${workspace}` : 'Remote agent';
+    return injectMeshSystemMessage(components, {
+        meshId,
+        nodeLabel,
+        event: eventName,
+        metadataEvent: {
+            targetSessionId: readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId),
+            providerType: readNonEmptyString(payload.providerType),
+            providerSessionId: readNonEmptyString(payload.providerSessionId),
+        },
+    });
+}
+
 export function setupMeshEventForwarding(components: DaemonComponents) {
     components.instanceManager.onEvent((event) => {
         // We only care about agent sub-session completion or waiting approval
@@ -38,22 +107,6 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
         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 !== 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. 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);
@@ -62,23 +115,13 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
             : 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${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${metadata}. You may use mesh_read_chat and mesh_approve to handle it.`;
-        }
 
-        if (!messageText) return;
-
-        // Inject the message into the coordinator sessions
-        for (const coord of coordinatorInstances) {
-            const coordState = coord.getState();
-            LOG.info('MeshEvents', `Forwarding event from ${workspace} to coordinator ${coordState.instanceId}`);
-            coord.onEvent('send_message', { input: { text: messageText, textFallback: messageText } });
-        }
+        injectMeshSystemMessage(components, {
+            meshId,
+            sourceInstanceId: instanceId,
+            nodeLabel,
+            event: event.event,
+            metadataEvent: event,
+        });
     });
 }