@adhdev/daemon-core 0.9.82-rc.180 → 0.9.82-rc.182

package/dist/providers/cli-provider-instance.d.ts

@@ -97,6 +97,26 @@ export declare class CliProviderInstance implements ProviderInstance {
     getHotChatSessionState(): HotChatSessionState;
     getSessionModalState(sessionId?: string): SessionModalState;
     updateSettings(newSettings: Record<string, any>): void;
+    /**
+     * Stamp a direct-dispatch mesh assignment on this instance.
+     * setupMeshEventForwarding reads settings.meshNodeFor + meshActiveTaskId to
+     * route generating_completed back to the originating coordinator. Without
+     * this stamp, mesh_send_task --direct targets a plain CLI session whose
+     * completion events silently drop because the forwarder has nothing to
+     * match against.
+     */
+    attachMeshAssignment(assignment: {
+        meshId: string;
+        nodeId?: string;
+        taskId?: string;
+    }): void;
+    /**
+     * Clear a previously-attached mesh assignment after the task reaches a
+     * terminal state. Leaving meshNodeFor pinned would route this session's
+     * subsequent unrelated turns (e.g. ad-hoc dashboard chats) to the
+     * coordinator as if they were task completions.
+     */
+    detachMeshAssignment(): void;
     onEvent(event: string, data?: any): void;
     recordAcknowledgedUserInput(input: InputEnvelope | string): void;
     dispose(): void;

package/dist/providers/provider-instance-manager.d.ts

@@ -82,6 +82,18 @@ export declare class ProviderInstanceManager {
      * Called when user changes settings from dashboard.
      */
     updateInstanceSettings(providerType: string, settings: Record<string, any>): number;
+    /** Stamp a mesh assignment on a single instance (used by mesh_send_task
+     *  --direct so the worker's completion event has a coordinator routing
+     *  marker in state.settings). Returns true if the instance existed and
+     *  the stamp was applied. */
+    attachMeshAssignmentToInstance(instanceId: string, assignment: {
+        meshId: string;
+        nodeId?: string;
+        taskId?: string;
+    }): boolean;
+    /** Clear a mesh assignment after the dispatched task reaches a terminal
+     *  state (generating_completed / stopped / failed). */
+    detachMeshAssignmentFromInstance(instanceId: string): boolean;
     refreshProviderDefinitions(resolveProvider: (providerType: string) => unknown): number;
     /**
     * All terminate

package/dist/providers/provider-instance.d.ts

@@ -181,6 +181,15 @@ export interface ProviderInstance {
     onEvent(event: string, data?: any): void;
     /** Update settings at runtime (called when user changes settings from dashboard) */
     updateSettings?(newSettings: Record<string, any>): void;
+    /** Stamp a direct-dispatch mesh task assignment so generating_completed
+     *  events route back to the originating coordinator. Cleared by
+     *  detachMeshAssignment when the task reaches a terminal state. */
+    attachMeshAssignment?(assignment: {
+        meshId: string;
+        nodeId?: string;
+        taskId?: string;
+    }): void;
+    detachMeshAssignment?(): void;
     /** Refresh static provider definition/scripts without restarting the live runtime. */
     refreshProviderDefinition?(provider: ProviderModule): void;
     /** cleanup */

package/dist/providers/spec/cli-adapter.d.ts

@@ -89,6 +89,8 @@ export declare class SpecCliAdapter implements CliAdapter {
     refreshProviderDefinition(): void;
     private handleEvent;
     private detectInteractivePromptFromPtyChunk;
+    private readCurrentScreenSections;
+    private readClaudeScreenAssistantMessages;
     private maybeCaptureClaudeTuiPrompt;
     private readClaudeTuiHeaders;
     private captureClaudeTuiPrompt;

package/package.json

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

package/src/commands/cli-manager.ts

@@ -1272,6 +1272,22 @@ export class DaemonCliManager {
                     } else if (currentStatus === 'starting') {
                         currentStatus = getEffectiveAgentSendStatus(adapter);
                     }
+                    // Stamp mesh direct-dispatch assignment on the target
+                    // instance BEFORE sending the prompt so the completion
+                    // event has a routing marker by the time it fires.
+                    // mesh_send_task --direct ships meshContext for plain CLI
+                    // sessions that were never launched as mesh delegates.
+                    const meshContext = (args as any)?.meshContext;
+                    if (meshContext && typeof meshContext === 'object' && typeof meshContext.meshId === 'string' && meshContext.meshId) {
+                        const targetInstanceId = key;
+                        try {
+                            this.deps.getInstanceManager()?.attachMeshAssignmentToInstance(targetInstanceId, {
+                                meshId: meshContext.meshId,
+                                ...(typeof meshContext.nodeId === 'string' && meshContext.nodeId ? { nodeId: meshContext.nodeId } : {}),
+                                ...(typeof meshContext.taskId === 'string' && meshContext.taskId ? { taskId: meshContext.taskId } : {}),
+                            });
+                        } catch { /* best-effort */ }
+                    }
                     const input = normalizeInputEnvelope(args?.input ? { input: args.input } : args);
                     const provider = this.providerLoader.resolve(agentType) || this.providerLoader.getMeta(agentType);
                     if (provider?.category === 'acp') {

package/src/mesh/mesh-events.ts

@@ -1769,25 +1769,6 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
                 }
             } catch { /* best-effort */ }
             if (!meshIdFromDirectDispatch) return;
-        } else {
-            // Plain session (no meshNodeFor / meshCoordinatorFor / launchedByCoordinator)
-            // that received a direct dispatch via mesh_send_task: the dispatcher logs
-            // the dispatch against the workspace-resolved mesh but never stamps the
-            // target session's settings. Without this fallback, the worker's
-            // generating_completed event silently drops here and task_completed
-            // never lands in the ledger — coordinator sees the task as still in
-            // flight forever. Resolve the mesh via workspace and accept the event
-            // when an active direct dispatch points at this session.
-            const workspaceMesh = getCachedMeshByWorkspace(workspace);
-            const workspaceMeshId = readNonEmptyString(workspaceMesh?.id);
-            if (workspaceMeshId) {
-                try {
-                    const activeDispatches = getActiveDirectDispatches(workspaceMeshId);
-                    if (activeDispatches.some(d => d.sessionId === instanceId) || hasUnterminalDirectDispatchLedgerEntry(workspaceMeshId, instanceId)) {
-                        meshIdFromDirectDispatch = workspaceMeshId;
-                    }
-                } catch { /* best-effort */ }
-            }
         }
 
         const meshIdFromRuntime = readNonEmptyString(settings.meshNodeFor) || meshIdFromDirectDispatch;

package/src/providers/cli-provider-instance.ts

@@ -86,6 +86,15 @@ type ExternalTranscriptProbe = {
 const COMPLETED_FINALIZATION_RETRY_MS = 1000;
 const COMPLETED_FINALIZATION_MAX_WAIT_MS = 30_000;
 
+/** Events that signal a dispatched mesh task has reached a terminal state.
+ *  Detach the mesh assignment after emitting one of these so the worker's
+ *  next unrelated turn doesn't impersonate another completion. */
+const TERMINAL_MESH_EVENTS = new Set([
+    'agent:generating_completed',
+    'agent:stopped',
+    'agent:ready',
+]);
+
 const IMAGE_MIME_EXTENSIONS: Record<string, string> = {
     'image/png': '.png',
     'image/jpeg': '.jpg',
@@ -782,6 +791,39 @@ export class CliProviderInstance implements ProviderInstance {
         });
     }
 
+    /**
+     * Stamp a direct-dispatch mesh assignment on this instance.
+     * setupMeshEventForwarding reads settings.meshNodeFor + meshActiveTaskId to
+     * route generating_completed back to the originating coordinator. Without
+     * this stamp, mesh_send_task --direct targets a plain CLI session whose
+     * completion events silently drop because the forwarder has nothing to
+     * match against.
+     */
+    attachMeshAssignment(assignment: { meshId: string; nodeId?: string; taskId?: string }): void {
+        if (!assignment?.meshId) return;
+        this.settings = {
+            ...this.settings,
+            meshNodeFor: assignment.meshId,
+            ...(assignment.nodeId ? { meshNodeId: assignment.nodeId } : {}),
+            ...(assignment.taskId ? { meshActiveTaskId: assignment.taskId } : {}),
+        };
+        this.adapter.updateRuntimeSettings?.(this.settings);
+    }
+
+    /**
+     * Clear a previously-attached mesh assignment after the task reaches a
+     * terminal state. Leaving meshNodeFor pinned would route this session's
+     * subsequent unrelated turns (e.g. ad-hoc dashboard chats) to the
+     * coordinator as if they were task completions.
+     */
+    detachMeshAssignment(): void {
+        if (!this.settings.meshNodeFor && !this.settings.meshActiveTaskId && !this.settings.meshNodeId) return;
+        const { meshNodeFor, meshNodeId, meshActiveTaskId, ...rest } = this.settings;
+        void meshNodeFor; void meshNodeId; void meshActiveTaskId;
+        this.settings = rest;
+        this.adapter.updateRuntimeSettings?.(this.settings);
+    }
+
     onEvent(event: string, data?: any): void {
         if (event === 'send_message') {
             const input = normalizeInputEnvelope(data);
@@ -1513,9 +1555,18 @@ export class CliProviderInstance implements ProviderInstance {
         };
         if (this.context?.emitProviderEvent) {
             this.context.emitProviderEvent(enrichedEvent);
-            return;
+        } else {
+            this.events.push(enrichedEvent);
+        }
+        // Auto-detach a direct-dispatch mesh assignment once the dispatched
+        // task reaches a terminal state. Leaving meshNodeFor pinned would
+        // route this session's next unrelated turn (a dashboard chat) into
+        // the coordinator as if it were the completion of another task.
+        // We schedule after the emit so the originating coordinator still
+        // observes the completion event with its routing marker intact.
+        if (TERMINAL_MESH_EVENTS.has(event.event) && this.settings.meshActiveTaskId) {
+            try { this.detachMeshAssignment(); } catch { /* best-effort */ }
         }
-        this.events.push(enrichedEvent);
     }
 
     private flushEvents(): ProviderEvent[] {

package/src/providers/provider-instance-manager.ts

@@ -306,6 +306,36 @@ export class ProviderInstanceManager {
         return updated;
     }
 
+    /** Stamp a mesh assignment on a single instance (used by mesh_send_task
+     *  --direct so the worker's completion event has a coordinator routing
+     *  marker in state.settings). Returns true if the instance existed and
+     *  the stamp was applied. */
+    attachMeshAssignmentToInstance(instanceId: string, assignment: { meshId: string; nodeId?: string; taskId?: string }): boolean {
+        const inst = this.instances.get(instanceId);
+        if (!inst || typeof inst.attachMeshAssignment !== 'function') {
+            try {
+                const { LOG } = require('../logging/logger.js');
+                LOG.warn?.('MeshDispatch', `attachMeshAssignment skipped: instance ${instanceId} ${inst ? 'has no attach method' : 'not found'}`);
+            } catch { /* noop */ }
+            return false;
+        }
+        inst.attachMeshAssignment(assignment);
+        try {
+            const { LOG } = require('../logging/logger.js');
+            LOG.info?.('MeshDispatch', `stamped mesh assignment on ${instanceId}: mesh=${assignment.meshId} node=${assignment.nodeId || ''} task=${assignment.taskId || ''}`);
+        } catch { /* noop */ }
+        return true;
+    }
+
+    /** Clear a mesh assignment after the dispatched task reaches a terminal
+     *  state (generating_completed / stopped / failed). */
+    detachMeshAssignmentFromInstance(instanceId: string): boolean {
+        const inst = this.instances.get(instanceId);
+        if (!inst || typeof inst.detachMeshAssignment !== 'function') return false;
+        inst.detachMeshAssignment();
+        return true;
+    }
+
     refreshProviderDefinitions(resolveProvider: (providerType: string) => unknown): number {
         let refreshed = 0;
         for (const instance of this.instances.values()) {

package/src/providers/provider-instance.ts

@@ -217,6 +217,12 @@ export interface ProviderInstance {
  /** Update settings at runtime (called when user changes settings from dashboard) */
     updateSettings?(newSettings: Record<string, any>): void;
 
+    /** Stamp a direct-dispatch mesh task assignment so generating_completed
+     *  events route back to the originating coordinator. Cleared by
+     *  detachMeshAssignment when the task reaches a terminal state. */
+    attachMeshAssignment?(assignment: { meshId: string; nodeId?: string; taskId?: string }): void;
+    detachMeshAssignment?(): void;
+
     /** Refresh static provider definition/scripts without restarting the live runtime. */
     refreshProviderDefinition?(provider: ProviderModule): void;
 

package/src/providers/spec/cli-adapter.ts

@@ -19,6 +19,7 @@
 'use strict';
 
 import { SpecDriver, type DashboardEvent } from './driver.js';
+import { evaluate } from './evaluator.js';
 import { loadSpec } from './loader.js';
 import type { CliSpec } from './types.js';
 import type { CliAdapter, CliAdapterStatus } from '../../cli-adapter-types.js';
@@ -164,7 +165,11 @@ export class SpecCliAdapter implements CliAdapter {
     }
 
     getScriptParsedStatus(): unknown {
-        return this.getStatus();
+        const status = this.getStatus();
+        return {
+            ...status,
+            messages: this.readClaudeScreenAssistantMessages(),
+        };
     }
 
     getPartialResponse(): string {
@@ -405,13 +410,62 @@ export class SpecCliAdapter implements CliAdapter {
         }
     }
 
+    private readCurrentScreenSections(screenText: string): Record<string, string> {
+        try {
+            const ev = evaluate(this.spec, screenText);
+            return Object.fromEntries(ev.sections.map(section => [section.id, section.text]));
+        } catch {
+            return {};
+        }
+    }
+
+    private readClaudeScreenAssistantMessages(): ChatMessage[] {
+        if (this.cliType !== 'claude-cli') return [];
+        let screenText = '';
+        try {
+            screenText = this.driver.snapshot();
+        } catch {
+            return [];
+        }
+        const sections = this.readCurrentScreenSections(screenText);
+        const body = sections.body || screenText;
+        const messages: ChatMessage[] = [];
+        const seen = new Set<string>();
+        for (const line of body.split(/\r?\n/)) {
+            const match = line.match(/^\s*⏺\s+(.+?)\s*$/);
+            const content = match?.[1]?.trim();
+            if (!content || seen.has(content)) continue;
+            seen.add(content);
+            messages.push({
+                role: 'assistant',
+                kind: 'standard',
+                content,
+                source: 'assistant_text',
+                userFacing: true,
+                bubbleState: 'final',
+            });
+        }
+        return messages;
+    }
+
     private maybeCaptureClaudeTuiPrompt(): void {
         if (this.cliType !== 'claude-cli'
             || this.activeInteractivePrompt
             || this.claudeTuiPromptCaptureInFlight) return;
         const screenText = this.driver.snapshot();
         const headers = this.readClaudeTuiHeaders(screenText);
-        if (headers.length === 0 || !screenText.includes('Enter to select')) return;
+        if (!screenText.includes('Enter to select')) return;
+        if (headers.length === 0) {
+            const prompt = detectClaudeAskUserQuestionPromptFromTuiPages([{ screenText }], {
+                promptId: `ask-user-${this.providerSessionId || 'claude'}-${Date.now()}`,
+                providerType: this.cliType,
+            });
+            if (!prompt) return;
+            this.activeInteractivePrompt = prompt;
+            this.interactivePromptTransport = 'tui';
+            this.statusCallback?.();
+            return;
+        }
         this.claudeTuiPromptCaptureInFlight = true;
         void this.captureClaudeTuiPrompt(screenText, headers).finally(() => {
             this.claudeTuiPromptCaptureInFlight = false;

package/src/providers/types/interactive-prompt.ts

@@ -137,6 +137,8 @@ export interface ClaudeInteractiveTuiPage {
   header?: string;
 }
 
+const CLAUDE_TUI_OPTION_PATTERN = /^\s*(?:[❯›>]\s*)?(\d+)\.\s+(.+?)\s*$/;
+
 function claudeTuiQuestionHeaders(screenText: string): string[] {
   const navLine = screenText.split(/\r?\n/).find(line => line.includes('✔ Submit') && /[☐☒]/.test(line));
   if (!navLine) return [];
@@ -149,6 +151,103 @@ function claudeTuiQuestionHeaders(screenText: string): string[] {
   return headers;
 }
 
+function isClaudeTuiSelectFooter(text: string): boolean {
+  return /Enter to select/i.test(text) && /Esc to cancel/i.test(text);
+}
+
+function readClaudeHeaderLine(lines: string[], beforeIndex: number): string | undefined {
+  for (let i = beforeIndex; i >= 0; i -= 1) {
+    const candidate = lines[i].trim();
+    if (!candidate) continue;
+    const match = candidate.match(/^[☐☒]\s+(.+?)\s*$/);
+    if (match?.[1]) return readString(match[1]);
+    if (/^─+$/.test(candidate)) break;
+  }
+  return undefined;
+}
+
+function readClaudeOptionDescription(lines: string[], optionLineIndex: number): string | undefined {
+  const nextLine = lines[optionLineIndex + 1];
+  const next = nextLine?.trim();
+  if (!next
+    || CLAUDE_TUI_OPTION_PATTERN.test(nextLine)
+    || /^─+$/.test(next)
+    || /^Enter to select\b/i.test(next)
+    || /^[☐☒]\s+/.test(next)) {
+    return undefined;
+  }
+  return next;
+}
+
+function parseClaudeHeaderlessInteractiveTuiQuestion(page: ClaudeInteractiveTuiPage, index: number): InteractiveQuestion | null {
+  if (!isClaudeTuiSelectFooter(page.screenText)) return null;
+  if (!/Type something\.?|Chat about this/i.test(page.screenText)) return null;
+
+  const lines = page.screenText.split(/\r?\n/);
+  let footerIndex = -1;
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (/Enter to select/i.test(lines[i])) {
+      footerIndex = i;
+      break;
+    }
+  }
+  if (footerIndex < 0) return null;
+
+  let optionBlockEnd = footerIndex - 1;
+  for (let i = footerIndex - 1; i >= 0; i -= 1) {
+    if (/^─+$/.test(lines[i].trim())) {
+      optionBlockEnd = i - 1;
+      break;
+    }
+  }
+
+  const optionLineIndexes: number[] = [];
+  for (let i = optionBlockEnd; i >= 0; i -= 1) {
+    const line = lines[i];
+    if (CLAUDE_TUI_OPTION_PATTERN.test(line)) {
+      optionLineIndexes.push(i);
+      continue;
+    }
+    if (optionLineIndexes.length > 0 && (!line.trim() || /^─+$/.test(line.trim()))) break;
+  }
+  optionLineIndexes.reverse();
+  if (optionLineIndexes.length === 0) return null;
+
+  const firstOptionIndex = optionLineIndexes[0];
+  let question = '';
+  for (let i = firstOptionIndex - 1; i >= 0; i -= 1) {
+    const candidate = lines[i].trim();
+    if (!candidate || /^─+$/.test(candidate) || /^[☐☒]\s+/.test(candidate)) continue;
+    question = candidate;
+    break;
+  }
+  if (!question) return null;
+
+  const options: InteractiveOption[] = [];
+  let allowFreeform = false;
+  for (const optionLineIndex of optionLineIndexes) {
+    const match = lines[optionLineIndex].match(CLAUDE_TUI_OPTION_PATTERN);
+    if (!match) continue;
+    const label = match[2].trim();
+    if (/^Chat about this$/i.test(label)) continue;
+    if (/^Type something\.?$/i.test(label)) allowFreeform = true;
+
+    const description = readClaudeOptionDescription(lines, optionLineIndex);
+    options.push({ label, ...(description ? { description } : {}) });
+  }
+  if (options.length === 0) return null;
+
+  const header = readString(page.header) || readClaudeHeaderLine(lines, firstOptionIndex - 1);
+  return {
+    questionId: `q${index + 1}`,
+    question,
+    ...(header ? { header } : {}),
+    multiSelect: /Space to select|toggle selections/i.test(page.screenText),
+    options,
+    ...(allowFreeform ? { allowFreeform: true } : {}),
+  };
+}
+
 function parseClaudeInteractiveTuiQuestion(page: ClaudeInteractiveTuiPage, index: number): InteractiveQuestion | null {
   const lines = page.screenText.split(/\r?\n/);
   let navIndex = -1;
@@ -158,7 +257,8 @@ function parseClaudeInteractiveTuiQuestion(page: ClaudeInteractiveTuiPage, index
       break;
     }
   }
-  if (navIndex < 0 || !page.screenText.includes('Enter to select')) return null;
+  if (navIndex < 0) return parseClaudeHeaderlessInteractiveTuiQuestion(page, index);
+  if (!page.screenText.includes('Enter to select')) return null;
 
   let question = '';
   let questionLineIndex = -1;
@@ -174,9 +274,8 @@ function parseClaudeInteractiveTuiQuestion(page: ClaudeInteractiveTuiPage, index
 
   const options: InteractiveOption[] = [];
   let allowFreeform = false;
-  const optionPattern = /^\s*(?:[❯›>]\s*)?(\d+)\.\s+(.+?)\s*$/;
   for (let i = questionLineIndex + 1; i < lines.length; i += 1) {
-    const match = lines[i].match(optionPattern);
+    const match = lines[i].match(CLAUDE_TUI_OPTION_PATTERN);
     if (!match) continue;
     const label = match[2].trim();
     if (/^Type something\.?$/i.test(label)) {
@@ -188,7 +287,7 @@ function parseClaudeInteractiveTuiQuestion(page: ClaudeInteractiveTuiPage, index
     let description: string | undefined;
     const nextLine = lines[i + 1]?.trim();
     if (nextLine
-      && !optionPattern.test(lines[i + 1])
+      && !CLAUDE_TUI_OPTION_PATTERN.test(lines[i + 1])
       && !/^─+$/.test(nextLine)
       && !/^Enter to select\b/.test(nextLine)) {
       description = nextLine;