@adhdev/daemon-core 0.9.70 → 0.9.72

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

@@ -0,0 +1,2 @@
+import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+export declare function setupMeshEventForwarding(components: DaemonComponents): void;

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

@@ -95,6 +95,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private completedDebounceTimer;
     private completedDebouncePending;
     private enforceFreshSessionLaunchIfNeeded;
+    private maybeAutoApproveStatus;
     private detectStatusTransition;
     private pushEvent;
     private flushEvents;

package/dist/shared-types.d.ts

@@ -287,6 +287,7 @@ export interface SessionEntry {
     completionMarker?: string;
     seenCompletionMarker?: string;
     surfaceHidden?: boolean;
+    settings?: Record<string, any>;
 }
 /**
  * Compact session metadata stored in UserSessionDO and reused by server-side
@@ -324,6 +325,7 @@ export interface CompactSessionEntry {
     controlValues?: Record<string, string | number | boolean>;
     providerControls?: ProviderControlSchema[];
     summaryMetadata?: ProviderSummaryMetadata;
+    settings?: Record<string, any>;
 }
 export type VersionUpdateReason = 'force_update_below' | 'major_minor_mismatch' | 'patch_mismatch' | 'daemon_ahead';
 /** Available provider information */

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.9.70",
+  "version": "0.9.72",
   "description": "ADHDev local session host core \u2014 session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.70",
+  "version": "0.9.72",
   "description": "ADHDev daemon core \u2014 CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/boot/daemon-lifecycle.ts

@@ -36,6 +36,7 @@ import { loadConfig } from '../config/config.js';
 import type { PtyTransportFactory } from '../cli-adapters/pty-transport.js';
 import type { IdeProviderInstance } from '../providers/ide-provider-instance.js';
 import { createDefaultGitCommandServices } from '../git/git-commands.js';
+import { setupMeshEventForwarding } from '../mesh/mesh-events.js';
 
 // ─── Init Config ───
 
@@ -317,7 +318,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
     // 10. Start instance ticking
     instanceManager.startTicking(config.tickIntervalMs ?? 5_000);
 
-    return {
+    const components = {
         providerLoader,
         instanceManager,
         cliManager,
@@ -331,6 +332,11 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         detectedIdes: detectedIdesRef,
         refreshProviderAvailability,
     };
+
+    // 11. Setup Mesh Event Forwarding
+    setupMeshEventForwarding(components);
+
+    return components;
 }
 
 /**

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

@@ -2272,11 +2272,23 @@ export class ProviderCliAdapter implements CliAdapter {
         }
     }
 
+    private getParsedDebugState(): Record<string, any> | null {
+        if (this.startupParseGate || typeof this.cliScripts?.parseSession !== 'function') return null;
+        try {
+            const parsed = this.getScriptParsedStatus();
+            return parsed && typeof parsed === 'object' ? parsed as Record<string, any> : null;
+        } catch {
+            return null;
+        }
+    }
+
     getDebugState(): Record<string, any> {
         const screenText = sanitizeTerminalText(this.terminalScreen.getText());
         const startupModal = this.startupParseGate ? this.runParseApproval(this.recentOutputBuffer) : null;
         const effectiveStatus = this.projectEffectiveStatus(startupModal);
         const effectiveReady = this.ready || !!startupModal;
+        const parsedDebugState = this.getParsedDebugState();
+        const parsedMessages = Array.isArray(parsedDebugState?.messages) ? parsedDebugState.messages : [];
         return {
             type: this.cliType,
             name: this.cliName,
@@ -2289,8 +2301,18 @@ export class ProviderCliAdapter implements CliAdapter {
             startupParseGate: this.startupParseGate,
             spawnAt: this.spawnAt,
             workingDir: this.workingDir,
-            messages: [],
-            messageCount: 0,
+            messages: parsedMessages,
+            messageCount: parsedMessages.length,
+            parsedStatus: parsedDebugState ? {
+                id: parsedDebugState.id,
+                status: parsedDebugState.status,
+                title: parsedDebugState.title,
+                providerSessionId: parsedDebugState.providerSessionId,
+                transcriptAuthority: parsedDebugState.transcriptAuthority,
+                coverage: parsedDebugState.coverage,
+                activeModal: parsedDebugState.activeModal,
+                messageCount: parsedMessages.length,
+            } : null,
             screenText: screenText.slice(-4000),
             currentTurnScope: this.currentTurnScope,
             startupBuffer: this.startupBuffer.slice(-4000),

package/src/commands/chat-commands.ts

@@ -101,6 +101,9 @@ function getHistorySessionId(h: CommandHelpers, args: any): string | undefined {
     const explicit = typeof args?.historySessionId === 'string' ? args.historySessionId.trim() : '';
     if (explicit) return explicit;
 
+    const explicitProviderSessionId = typeof args?.providerSessionId === 'string' ? args.providerSessionId.trim() : '';
+    if (explicitProviderSessionId) return explicitProviderSessionId;
+
     const targetSessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '';
     if (!targetSessionId) return undefined;
 
@@ -779,7 +782,40 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                 ...(coverage ? { coverage } : {}),
             }, args);
         }
-        return { success: false, error: `${transport} adapter not found` };
+        const historyLimit = normalizeReadChatTailLimit(args);
+        try {
+            const agentStr = provider?.type || args?.agentType || getCurrentProviderType(h);
+            const workspace = typeof args?.workspace === 'string'
+                ? args.workspace
+                : typeof (h.currentSession as any)?.workspace === 'string'
+                    ? (h.currentSession as any).workspace
+                    : undefined;
+            const history = readProviderChatHistory(agentStr, {
+                canonicalHistory: provider?.canonicalHistory,
+                historySessionId,
+                workspace,
+                offset: 0,
+                limit: historyLimit,
+                excludeRecentCount: 0,
+                historyBehavior: provider?.historyBehavior,
+                scripts: provider?.scripts as any,
+            });
+            const historyProviderSessionId = typeof (history as any)?.providerSessionId === 'string'
+                ? (history as any).providerSessionId
+                : historySessionId;
+            return buildReadChatCommandResult({
+                messages: Array.isArray((history as any)?.messages) ? (history as any).messages : [],
+                status: 'idle',
+                ...(typeof (history as any)?.title === 'string' ? { title: (history as any).title } : {}),
+                ...(historyProviderSessionId ? { providerSessionId: historyProviderSessionId } : {}),
+                ...(((provider?.historyBehavior as any)?.transcriptAuthority === 'provider' || (provider?.historyBehavior as any)?.transcriptAuthority === 'daemon')
+                    ? { transcriptAuthority: (provider?.historyBehavior as any).transcriptAuthority }
+                    : {}),
+                coverage: 'tail',
+            }, args);
+        } catch (error: any) {
+            return { success: false, error: error?.message || `${transport} adapter not found` };
+        }
     }
 
     // Extension transport: evaluateInSession

package/src/commands/cli-manager.ts

@@ -480,7 +480,7 @@ export class DaemonCliManager {
         workingDir: string,
         cliArgs?: string[],
         initialModel?: string,
-        options?: { resumeSessionId?: string },
+        options?: { resumeSessionId?: string, settingsOverride?: Record<string, any> },
     ): Promise<{ runtimeSessionId: string; providerSessionId?: string }> {
         const trimmed = (workingDir || '').trim();
         if (!trimmed) throw new Error('working directory required');
@@ -624,7 +624,7 @@ export class DaemonCliManager {
                 resolvedDir,
                 resolvedCliArgs,
                 resolvedProvider,
-                this.providerLoader.getSettings(normalizedType),
+                { ...this.providerLoader.getSettings(normalizedType), ...(options?.settingsOverride || {}) },
                 false,
                 {
                     providerSessionId: sessionBinding.providerSessionId,
@@ -904,7 +904,7 @@ export class DaemonCliManager {
                     dir,
                     args?.cliArgs,
                     args?.initialModel,
-                    { resumeSessionId: args?.resumeSessionId },
+                    { resumeSessionId: args?.resumeSessionId, settingsOverride: args?.settings },
                 );
 
                 return {

package/src/commands/mesh-coordinator.ts

@@ -1,12 +1,20 @@
-import { join } from 'path'
+import { existsSync, realpathSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, join, resolve } from 'node:path'
 import type { ProviderModule, MeshCoordinatorMcpConfigFormat } from '../providers/contracts.js'
 
+export interface MeshCoordinatorMcpServerLaunch {
+  command: string
+  args: string[]
+}
+
 export type MeshCoordinatorSetup =
   | {
       kind: 'auto_import'
       serverName: string
       configPath: string
       configFormat?: MeshCoordinatorMcpConfigFormat
+      mcpServer: MeshCoordinatorMcpServerLaunch
     }
   | {
       kind: 'manual'
@@ -27,6 +35,8 @@ export interface ResolveMeshCoordinatorSetupOptions {
   meshId: string
   workspace: string
   adhdevMcpCommand?: string
+  adhdevMcpEntryPath?: string
+  nodeExecutable?: string
 }
 
 const DEFAULT_SERVER_NAME = 'adhdev-mesh'
@@ -56,11 +66,23 @@ export function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetup
     if (!path) {
       return { kind: 'unsupported', reason: 'Provider auto-import MCP config is missing a config path' }
     }
+    const mcpServer = resolveAdhdevMcpServerLaunch({
+      meshId,
+      nodeExecutable: options.nodeExecutable,
+      adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+    })
+    if (!mcpServer) {
+      return {
+        kind: 'unsupported',
+        reason: 'Could not resolve the ADHDev MCP server entrypoint without relying on a PATH bin shim',
+      }
+    }
     return {
       kind: 'auto_import',
       serverName,
       configPath: join(workspace, path),
       configFormat: mcpConfig.format,
+      mcpServer,
     }
   }
 
@@ -95,3 +117,62 @@ export function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetup
 function renderMeshCoordinatorTemplate(template: string, values: Record<string, string>): string {
   return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand)\s*\}\}/g, (_, key: string) => values[key] || '')
 }
+
+function resolveAdhdevMcpServerLaunch(options: {
+  meshId: string
+  nodeExecutable?: string
+  adhdevMcpEntryPath?: string
+}): MeshCoordinatorMcpServerLaunch | null {
+  const entryPath = resolveAdhdevMcpEntryPath(options.adhdevMcpEntryPath)
+  if (!entryPath) return null
+  return {
+    command: options.nodeExecutable?.trim() || process.execPath,
+    args: [entryPath, '--repo-mesh', options.meshId],
+  }
+}
+
+function resolveAdhdevMcpEntryPath(explicitPath?: string): string | null {
+  const explicit = explicitPath?.trim()
+  if (explicit) return normalizeExistingPath(explicit) || explicit
+
+  const envPath = process.env.ADHDEV_MCP_SERVER_PATH?.trim()
+  if (envPath) return normalizeExistingPath(envPath) || envPath
+
+  const candidates: string[] = []
+  const addCandidate = (candidate: string) => {
+    if (!candidates.includes(candidate)) candidates.push(candidate)
+  }
+  const addPackagedCandidates = (baseFile?: string) => {
+    if (!baseFile) return
+    const realBase = normalizeExistingPath(baseFile) || baseFile
+    const dir = dirname(realBase)
+    addCandidate(resolve(dir, '../vendor/mcp-server/index.js'))
+    addCandidate(resolve(dir, '../../vendor/mcp-server/index.js'))
+    addCandidate(resolve(dir, '../../../vendor/mcp-server/index.js'))
+  }
+
+  addPackagedCandidates(process.argv[1])
+
+  for (const candidate of candidates) {
+    const normalized = normalizeExistingPath(candidate)
+    if (normalized) return normalized
+  }
+
+  try {
+    const requireBase = process.argv[1] ? (normalizeExistingPath(process.argv[1]) || process.argv[1]) : join(process.cwd(), 'adhdev-daemon.js')
+    const req = createRequire(requireBase)
+    const resolvedModule = req.resolve('@adhdev/mcp-server')
+    return normalizeExistingPath(resolvedModule) || resolvedModule
+  } catch {
+    return null
+  }
+}
+
+function normalizeExistingPath(filePath: string): string | null {
+  try {
+    if (!existsSync(filePath)) return null
+    return realpathSync.native(filePath)
+  } catch {
+    return null
+  }
+}

package/src/commands/router.ts

@@ -1006,11 +1006,18 @@ export class DaemonCommandRouter {
                 if (!meshId) return { success: false, error: 'meshId required' };
 
                 try {
-                    const { getMesh } = await import('../config/mesh-config.js');
                     const { buildCoordinatorSystemPrompt } = await import('../mesh/coordinator-prompt.js');
-                    const mesh = getMesh(meshId);
+
+                    // Support inline mesh data from cloud (bypasses local meshes.json lookup)
+                    let mesh: any;
+                    if (args?.inlineMesh && typeof args.inlineMesh === 'object') {
+                        mesh = args.inlineMesh;
+                    } else {
+                        const { getMesh } = await import('../config/mesh-config.js');
+                        mesh = getMesh(meshId);
+                    }
                     if (!mesh) return { success: false, error: 'Mesh not found' };
-                    if (mesh.nodes.length === 0) return { success: false, error: 'No nodes in mesh' };
+                    if (!Array.isArray(mesh.nodes) || mesh.nodes.length === 0) return { success: false, error: 'No nodes in mesh' };
 
                     const workspace = mesh.nodes[0].workspace;
                     const providerMeta = this.deps.providerLoader.resolve?.(cliType) || this.deps.providerLoader.getMeta(cliType);
@@ -1074,8 +1081,8 @@ export class DaemonCommandRouter {
                         mcpServers: {
                             ...(existingMcpConfig.mcpServers || {}),
                             [coordinatorSetup.serverName]: {
-                                command: 'adhdev-mcp',
-                                args: ['--repo-mesh', meshId],
+                                command: coordinatorSetup.mcpServer.command,
+                                args: coordinatorSetup.mcpServer.args,
                             },
                         },
                     };
@@ -1090,11 +1097,24 @@ export class DaemonCommandRouter {
                         systemPrompt = `You are a Repo Mesh Coordinator for "${mesh.name}". Use the adhdev-mesh MCP tools (mesh_status, mesh_list_nodes, mesh_send_task, mesh_read_chat, mesh_launch_session, etc.) to orchestrate work across ${mesh.nodes.length} node(s).`;
                     }
 
+                    const cliArgs: string[] = [];
+                    if (systemPrompt) {
+                        cliArgs.push('--append-system-prompt', systemPrompt);
+                    }
+                    if (cliType === 'claude-cli') {
+                        cliArgs.push('--mcp-config', coordinatorSetup.configPath);
+                    }
+
                     // 3. Launch CLI session via existing cliManager
+                    // Pass coordinator system prompt via --append-system-prompt so the
+                    // CLI inherits its default behavior AND knows it is a mesh coordinator.
                     const launchResult: any = await this.deps.cliManager.handleCliCommand('launch_cli', {
                         cliType,
                         dir: workspace,
-                        initialPrompt: systemPrompt,
+                        cliArgs: cliArgs.length > 0 ? cliArgs : undefined,
+                        settings: {
+                            meshCoordinatorFor: meshId
+                        }
                     });
 
                     if (!launchResult?.success) {

package/src/mesh/mesh-events.ts

@@ -0,0 +1,61 @@
+import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+import { getMeshByRepo } from '../config/mesh-config.js';
+import { LOG } from '../logging/logger.js';
+
+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;
+        if (!instanceId) return;
+
+        // Try to find the workspace of the sub-agent
+        const sourceInstance = components.instanceManager.getInstance(instanceId);
+        if (!sourceInstance || sourceInstance.category !== 'cli') return;
+        const state = sourceInstance.getState();
+        const workspace = state.workspace;
+        if (!workspace) return;
+
+        // Find the mesh that this workspace belongs to
+        const mesh = getMeshByRepo(workspace);
+        if (!mesh) 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;
+            
+            // 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}`;
+
+        // 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.`;
+        } 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.`;
+        }
+
+        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 } });
+        }
+    });
+}

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

@@ -363,7 +363,7 @@ export class CliProviderInstance implements ProviderInstance {
             this.errorMessage = undefined;
             this.errorReason = undefined;
         }
-        const autoApproveActive = adapterStatus.status === 'waiting_approval' && this.shouldAutoApprove();
+        const autoApproveActive = this.maybeAutoApproveStatus(adapterStatus, Date.now());
         const visibleStatus = parseErrorMessage
             ? 'error'
             : (autoApproveActive ? 'generating' : adapterStatus.status);
@@ -587,19 +587,11 @@ export class CliProviderInstance implements ProviderInstance {
         this.applyProviderResponse(parsed.payload, { phase: 'immediate' });
     }
 
-    private detectStatusTransition(): void {
-        const now = Date.now();
-        // Status-change handling is a hot path: PTY output can fire it many times
-        // during long-running CLI sessions. Keep this path on adapter-owned light
-        // state only; rich provider parsing is reserved for getState/read_chat.
-        const adapterStatus = this.adapter.getStatus({ allowParse: false });
-        const parsedStatus = null;
-        const rawStatus = adapterStatus.status;
-        const autoApproveActive = rawStatus === 'waiting_approval' && this.shouldAutoApprove();
-        // Guard re-entry: onStatusChange can fire multiple times while the modal
-        // is still on screen (before the PTY absorbs the approval key). Without this
-        // flag, we'd write the approval key repeatedly — stray keys then leak into
-        // the text input once Claude Code dismisses the modal.
+    private maybeAutoApproveStatus(adapterStatus: any, now = Date.now()): boolean {
+        const autoApproveActive = adapterStatus?.status === 'waiting_approval' && this.shouldAutoApprove();
+        // Guard re-entry: onStatusChange/getState can observe the same modal multiple
+        // times while the PTY absorbs the approval key. Without this flag, repeated
+        // snapshots would write stray keys into the input once the modal dismisses.
         if (autoApproveActive && !this.autoApproveBusy) {
             this.autoApproveBusy = true;
             if (this.autoApproveBusyTimer) clearTimeout(this.autoApproveBusyTimer);
@@ -607,12 +599,25 @@ export class CliProviderInstance implements ProviderInstance {
                 this.autoApproveBusy = false;
                 this.autoApproveBusyTimer = null;
             }, 2000);
-            const { index: buttonIndex, label: buttonLabel } = pickApprovalButton(adapterStatus.activeModal?.buttons, this.provider);
-            this.recordAutoApproval(adapterStatus.activeModal?.message, buttonLabel, now);
+            const modal = adapterStatus.activeModal;
+            const { index: buttonIndex, label: buttonLabel } = pickApprovalButton(modal?.buttons, this.provider);
+            this.recordAutoApproval(modal?.message, buttonLabel, now);
             setTimeout(() => {
                 this.adapter.resolveModal(buttonIndex);
             }, 0);
         }
+        return autoApproveActive;
+    }
+
+    private detectStatusTransition(): void {
+        const now = Date.now();
+        // Status-change handling is a hot path: PTY output can fire it many times
+        // during long-running CLI sessions. Keep this path on adapter-owned light
+        // state only; rich provider parsing is reserved for getState/read_chat.
+        const adapterStatus = this.adapter.getStatus({ allowParse: false });
+        const parsedStatus = null;
+        const rawStatus = adapterStatus.status;
+        const autoApproveActive = this.maybeAutoApproveStatus(adapterStatus, now);
         const newStatus = autoApproveActive ? 'generating' : rawStatus;
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
         const chatTitle = `${this.provider.name} · ${dirName}`;

package/src/shared-types.ts

@@ -384,6 +384,7 @@ export interface SessionEntry {
     completionMarker?: string;
     seenCompletionMarker?: string;
     surfaceHidden?: boolean;
+    settings?: Record<string, any>;
 }
 
 /**
@@ -422,6 +423,7 @@ export interface CompactSessionEntry {
     controlValues?: Record<string, string | number | boolean>;
     providerControls?: ProviderControlSchema[];
     summaryMetadata?: ProviderSummaryMetadata;
+    settings?: Record<string, any>;
 }
 
 export type VersionUpdateReason =

package/src/status/builders.ts

@@ -187,6 +187,7 @@ function buildIdeWorkspaceSession(
         errorMessage: state.errorMessage,
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
+        settings: state.settings,
     };
 }
 
@@ -227,6 +228,7 @@ function buildExtensionAgentSession(
         errorMessage: ext.errorMessage,
         errorReason: ext.errorReason,
         lastUpdated: ext.lastUpdated,
+        settings: ext.settings,
     };
 }
 
@@ -306,6 +308,7 @@ function buildCliSession(state: CliProviderState, options: SessionEntryBuildOpti
         errorMessage: state.errorMessage,
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
+        settings: state.settings,
     };
 }
 
@@ -341,6 +344,7 @@ function buildAcpSession(state: AcpProviderState, options: SessionEntryBuildOpti
         errorMessage: state.errorMessage,
         errorReason: state.errorReason,
         lastUpdated: state.lastUpdated,
+        settings: state.settings,
     };
 }
 

package/src/status/reporter.ts

@@ -310,6 +310,7 @@ export class DaemonStatusReporter {
                 title: session.title,
                 cdpConnected: session.cdpConnected,
                 summaryMetadata: session.summaryMetadata,
+                settings: session.settings,
             })),
             p2p: payload.p2p,
             timestamp: now,