@adhdev/daemon-core 0.9.77-rc.2 → 0.9.77-rc.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.77-rc.2",
+  "version": "0.9.77-rc.21",
   "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

@@ -195,6 +195,8 @@ export class ProviderCliAdapter implements CliAdapter {
 
     // ─── CLI Scripts (script-based parsing) ───
     private cliScripts: CliScripts;
+    /** Per-session opaque state object created by cliScripts.createState(), reset on stop. */
+    private scriptState: unknown = null;
     private runtimeSettings: Record<string, any> = {};
     /** Full accumulated rendered PTY transcript for parser/readback use */
     private accumulatedBuffer: string = '';
@@ -477,6 +479,9 @@ export class ProviderCliAdapter implements CliAdapter {
         this.cliScripts = scripts;
         this.parsedStatusCache = null;
         this.parseErrorMessage = null;
+        // Initialize per-session state: createState() is called once here and on script reload.
+        // The returned object lives until the PTY exits (scriptState = null on exit).
+        this.scriptState = typeof scripts.createState === 'function' ? scripts.createState() : null;
         const scriptNames = listCliScriptNames(scripts);
         LOG.info('CLI', `[${this.cliType}] CLI scripts injected: [${scriptNames.join(', ')}]`);
     }
@@ -610,6 +615,7 @@ export class ProviderCliAdapter implements CliAdapter {
             this.ready = false;
             this.startupParseGate = false;
             this.spawnAt = 0;
+            this.scriptState = null;
             this.onStatusChange?.();
         });
 
@@ -1470,7 +1476,7 @@ export class ProviderCliAdapter implements CliAdapter {
                 scope: this.currentTurnScope,
                 runtimeSettings: this.runtimeSettings,
             });
-            const session = this.cliScripts.parseSession({ ...input, tail, tailScreen: buildCliScreenSnapshot(tail) });
+            const session = this.cliScripts.parseSession(this.scriptState, { ...input, tail, tailScreen: buildCliScreenSnapshot(tail) });
             this.parseErrorMessage = null;
             return session && typeof session === 'object' ? session : null;
         } catch (e: any) {
@@ -1485,7 +1491,7 @@ export class ProviderCliAdapter implements CliAdapter {
         if (!this.cliScripts?.detectStatus) return null;
         try {
             const screenText = this.terminalScreen.getText();
-            const status = this.cliScripts.detectStatus({
+            const status = this.cliScripts.detectStatus(this.scriptState, {
                 tail: text.slice(-500),
                 screenText,
                 rawBuffer: this.accumulatedRawBuffer,
@@ -1505,7 +1511,7 @@ export class ProviderCliAdapter implements CliAdapter {
         try {
             const screenText = this.terminalScreen.getText();
             const buffer = screenText || this.accumulatedBuffer;
-            return this.cliScripts.parseApproval({
+            return this.cliScripts.parseApproval(this.scriptState, {
                 buffer,
                 screenText,
                 rawBuffer: this.accumulatedRawBuffer,
@@ -1640,7 +1646,7 @@ export class ProviderCliAdapter implements CliAdapter {
             scope: this.currentTurnScope,
             runtimeSettings: this.runtimeSettings,
         });
-        return await Promise.resolve(fn({
+        return await Promise.resolve(fn(this.scriptState, {
             ...input,
             args: args && typeof args === 'object' ? { ...args } : {},
         }));

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

@@ -48,11 +48,21 @@ export interface ParsedSession {
 }
 
 export interface CliScripts {
-    parseSession?: (input: CliScriptInput & { tail?: string; tailScreen?: CliScreenSnapshot }) => ParsedSession | null;
-    detectStatus?: (input: CliStatusInput) => string | null;
-    parseApproval?: (input: CliApprovalInput) => { message: string; buttons: string[] } | null;
+    /**
+     * Optional state factory. Called once per CLI session start (or script reload).
+     * The returned object is passed as the first argument to detectStatus, parseApproval,
+     * and parseSession on every invocation, allowing scripts to maintain per-session state
+     * (e.g. last-seen status, approval fingerprints, stability counters).
+     *
+     * Scripts that don't define createState() receive null as the state argument,
+     * making this change fully backward compatible.
+     */
+    createState?: () => unknown;
+    parseSession?: (state: unknown, input: CliScriptInput & { tail?: string; tailScreen?: CliScreenSnapshot }) => ParsedSession | null;
+    detectStatus?: (state: unknown, input: CliStatusInput) => string | null;
+    parseApproval?: (state: unknown, input: CliApprovalInput) => { message: string; buttons: string[] } | null;
     resolveAction?: (data: any) => string;
-    [name: string]: ((input: any) => any) | undefined;
+    [name: string]: ((state: unknown, input: any) => any) | ((data: any) => any) | (() => unknown) | undefined;
 }
 
 export interface CliScreenLine {

package/src/commands/cli-manager.ts

@@ -177,10 +177,6 @@ export function buildCoordinatorDelegatedCliLaunchOptions(
     const cliArgs = Array.isArray(input.cliArgs) ? [...input.cliArgs] : [];
     const env: Record<string, string> = { ...(input.env || {}), ...COORDINATOR_DELEGATED_ENV_UNSETS };
 
-    if (cliType === 'hermes-cli' && !hasCliArg(cliArgs, '--ignore-user-config')) {
-        cliArgs.unshift('--ignore-user-config');
-    }
-
     if (cliType === 'claude-cli' && !hasCliArg(cliArgs, '--mcp-config')) {
         cliArgs.unshift('--mcp-config', ensureEmptyDelegatedMcpConfig(input.workspace));
     }

package/src/commands/mesh-coordinator.ts

@@ -28,6 +28,15 @@ export type MeshCoordinatorSetup =
       instructions: string
       template: string
     }
+  | {
+      /** Provider registers MCP via its own CLI command (e.g. `codex mcp add` / `gemini mcp add`). */
+      kind: 'cli_command'
+      serverName: string
+      /** The rendered shell command to execute before launching the coordinator session. */
+      command: string
+      requiresRestart: boolean
+      instructions: string
+    }
   | {
       kind: 'unsupported'
       reason: string
@@ -152,6 +161,24 @@ export function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetup
     if (!instructions || !template?.trim()) {
       return { kind: 'unsupported', reason: 'Provider manual MCP setup is missing instructions or template' }
     }
+    const renderedTemplate = renderMeshCoordinatorTemplate(template, {
+      meshId,
+      workspace,
+      serverName,
+      adhdevMcpCommand: options.adhdevMcpCommand || DEFAULT_ADHDEV_MCP_COMMAND,
+    })
+    // Detect if the template is a runnable CLI command (single line, no YAML/JSON structure).
+    // If so, use cli_command kind so the daemon can execute it automatically.
+    const isCliCommand = !renderedTemplate.trim().includes('\n') && !renderedTemplate.trim().startsWith('{')
+    if (isCliCommand) {
+      return {
+        kind: 'cli_command',
+        serverName,
+        command: renderedTemplate.trim(),
+        requiresRestart: mcpConfig.requiresRestart === true,
+        instructions: instructions,
+      }
+    }
     return {
       kind: 'manual',
       serverName,
@@ -159,12 +186,7 @@ export function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetup
       configPathCommand: mcpConfig.configPathCommand,
       requiresRestart: mcpConfig.requiresRestart === true,
       instructions,
-      template: renderMeshCoordinatorTemplate(template, {
-        meshId,
-        workspace,
-        serverName,
-        adhdevMcpCommand: options.adhdevMcpCommand || DEFAULT_ADHDEV_MCP_COMMAND,
-      }),
+      template: renderedTemplate,
     }
   }
 

package/src/commands/router.ts

@@ -1711,6 +1711,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 {

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/mesh/mesh-events.ts

@@ -37,6 +37,7 @@ const MESH_COORDINATOR_EVENTS = new Set([
     'agent:generating_completed',
     'agent:waiting_approval',
     'agent:stopped',
+    'agent:ready',
     'monitor:long_generating',
 ]);
 
@@ -68,7 +69,9 @@ export function tryAssignQueueTask(
     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}`);
     
@@ -76,7 +79,7 @@ export function tryAssignQueueTask(
         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}`);
     });
@@ -164,6 +167,7 @@ function buildMeshSystemMessage(args: {
 function injectMeshSystemMessage(components: DaemonComponents, args: {
     meshId: string;
     sourceInstanceId?: string;
+    nodeId?: string;
     nodeLabel: string;
     event: string;
     metadataEvent: Record<string, unknown>;
@@ -171,7 +175,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
     // ── Task Queue & Ledger ──
     if (args.event === 'agent:generating_completed') {
         const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
-        const nodeId = readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+        const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         const providerType = readNonEmptyString(args.metadataEvent.providerType);
         
         if (sessionId) {
@@ -183,6 +187,16 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                 }, 500);
             }
         }
+    } else if (args.event === 'agent:ready') {
+        const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
+        const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+        const providerType = readNonEmptyString(args.metadataEvent.providerType);
+        
+        if (sessionId && nodeId && providerType) {
+            setTimeout(() => {
+                tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
+            }, 500);
+        }
     } else if (args.event === 'agent:stopped') {
         const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
         if (sessionId) {
@@ -195,7 +209,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         try {
             appendLedgerEntry(args.meshId, {
                 kind: ledgerKind,
-                nodeId: readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
+                nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
                 sessionId: readNonEmptyString(args.metadataEvent.targetSessionId) || undefined,
                 providerType: readNonEmptyString(args.metadataEvent.providerType) || undefined,
                 payload: {
@@ -219,7 +233,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
 
             recoveryContext = getSessionRecoveryContext(args.meshId, {
                 sessionId: readNonEmptyString(args.metadataEvent.targetSessionId) || undefined,
-                nodeId: readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
+                nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined,
                 maxRetries,
             });
             recoveryContext.failedProviderType = readNonEmptyString(args.metadataEvent.providerType) || null;
@@ -327,6 +341,7 @@ 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: {
@@ -374,6 +389,7 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
         // 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 +399,7 @@ export function setupMeshEventForwarding(components: DaemonComponents) {
         injectMeshSystemMessage(components, {
             meshId,
             sourceInstanceId: instanceId,
+            nodeId: resolvedNodeId,
             nodeLabel,
             event: event.event,
             metadataEvent: event,

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

@@ -833,6 +833,8 @@ export class CliProviderInstance implements ProviderInstance {
                         this.completedDebounceTimer = null;
                     }, 3000);
                 }
+            } else if (newStatus === 'idle' && this.lastStatus === 'starting') {
+                this.pushEvent({ event: 'agent:ready', chatTitle, timestamp: now });
             } else if (newStatus === 'stopped') {
                 // Cancel any pending debounce
                 if (this.generatingDebounceTimer) { clearTimeout(this.generatingDebounceTimer); this.generatingDebounceTimer = null; }