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

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

@@ -8,17 +8,12 @@ export interface PendingMeshCoordinatorEvent {
 }
 /** Drain and return all pending coordinator events, clearing the queue. */
 export declare function drainPendingMeshCoordinatorEvents(): PendingMeshCoordinatorEvent[];
-export declare function tryAssignQueueTask(components: {
-    cliManager: any;
-}, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
+export declare function tryAssignQueueTask(components: DaemonComponents, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
 /**
  * Triggers a queue check for all nodes in the mesh.
  * Called when a new task is enqueued, in case nodes are already idle.
  */
-export declare function triggerMeshQueue(components: {
-    instanceManager: any;
-    cliManager: any;
-}, meshId: string): void;
+export declare function triggerMeshQueue(components: DaemonComponents, meshId: string): void;
 export declare function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>): {
     success: boolean;
     forwarded: number;

package/dist/mesh/mesh-work-queue.d.ts

@@ -1,4 +1,4 @@
-export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed';
+export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';
 export interface MeshWorkQueueEntry {
     id: string;
     meshId: string;
@@ -6,10 +6,19 @@ export interface MeshWorkQueueEntry {
     status: MeshTaskStatus;
     /** If specified, only this node can claim the task (used by legacy mesh_send_task) */
     targetNodeId?: string;
+    /** If specified, only this runtime session can claim the task */
+    targetSessionId?: string;
     /** The node that actually claimed and is executing the task */
     assignedNodeId?: string;
     /** The session currently executing the task */
     assignedSessionId?: string;
+    /** Human/operator reason for terminal cancellation. */
+    cancelReason?: string;
+    cancelledAt?: string;
+    /** Human/operator reason for manually requeueing a task. */
+    requeueReason?: string;
+    requeuedAt?: string;
+    requeueCount?: number;
     createdAt: string;
     updatedAt: string;
 }
@@ -18,6 +27,7 @@ export interface MeshWorkQueueEntry {
  */
 export declare function enqueueTask(meshId: string, message: string, opts?: {
     targetNodeId?: string;
+    targetSessionId?: string;
 }): MeshWorkQueueEntry;
 /**
  * Get all tasks in the queue, optionally filtered by status.
@@ -34,6 +44,23 @@ export declare function claimNextTask(meshId: string, nodeId: string, sessionId:
  * Used when a session completes, fails, or stalls.
  */
 export declare function updateTaskStatus(meshId: string, taskId: string, status: MeshTaskStatus): MeshWorkQueueEntry | null;
+/**
+ * Mark a queue task as manually cancelled without deleting audit history.
+ */
+export declare function cancelTask(meshId: string, taskId: string, opts?: {
+    reason?: string;
+}): MeshWorkQueueEntry | null;
+/**
+ * Return a queue task to pending for retry. By default, dead session targeting
+ * and assigned ownership are cleared so stale assignments do not strand again.
+ */
+export declare function requeueTask(meshId: string, taskId: string, opts?: {
+    reason?: string;
+    targetNodeId?: string;
+    targetSessionId?: string;
+    clearTargetNode?: boolean;
+    clearTargetSession?: boolean;
+}): MeshWorkQueueEntry | null;
 /**
  * Update the status of the task currently assigned to a specific session.
  */
@@ -43,6 +70,13 @@ export interface MeshWorkQueueStats {
     assigned: number;
     completed: number;
     failed: number;
+    cancelled: number;
+    activeAssignments: Array<{
+        id: string;
+        nodeId?: string;
+        sessionId?: string;
+        message: string;
+    }>;
 }
 /**
  * Return aggregate queue statistics for the given mesh.

package/dist/shared-types.d.ts

@@ -297,6 +297,13 @@ export interface SessionEntry {
         assigned: number;
         completed: number;
         failed: number;
+        cancelled?: number;
+        activeAssignments?: Array<{
+            id: string;
+            nodeId?: string;
+            sessionId?: string;
+            message: string;
+        }>;
     };
 }
 /**
@@ -341,6 +348,13 @@ export interface CompactSessionEntry {
         assigned: number;
         completed: number;
         failed: number;
+        cancelled?: number;
+        activeAssignments?: Array<{
+            id: string;
+            nodeId?: string;
+            sessionId?: string;
+            message: string;
+        }>;
     };
 }
 export type VersionUpdateReason = 'force_update_below' | 'major_minor_mismatch' | 'patch_mismatch' | 'daemon_ahead';

package/package.json

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

package/src/boot/daemon-lifecycle.ts

@@ -83,6 +83,9 @@ export interface DaemonInitConfig {
 
     /** Fired before send_chat is dispatched — used for turn snapshot hooks */
     onBeforeSendChat?: (params: { workspace: string; sessionId: string }) => void;
+
+    /** Relays a command to a remote mesh node daemon */
+    dispatchMeshCommand?: (daemonId: string, command: string, args: Record<string, unknown>) => Promise<any>;
 }
 
 // ─── Result ───
@@ -100,6 +103,7 @@ export interface DaemonComponents {
     sessionRegistry: SessionRegistry;
     detectedIdes: { value: IDEInfo[] };
     refreshProviderAvailability: (providerType?: string) => Promise<void>;
+    dispatchMeshCommand?: (daemonId: string, command: string, args: Record<string, unknown>) => Promise<any>;
 }
 
 export interface DaemonDevSupportOptions {
@@ -331,6 +335,7 @@ export async function initDaemonComponents(config: DaemonInitConfig): Promise<Da
         sessionRegistry,
         detectedIdes: detectedIdesRef,
         refreshProviderAvailability,
+        dispatchMeshCommand: config.dispatchMeshCommand,
     };
 
     // 11. Setup Mesh Event Forwarding

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 = '';
@@ -223,6 +225,7 @@ export class ProviderCliAdapter implements CliAdapter {
         currentTurnScope: TurnParseScope | null;
         recentOutputBuffer: string;
         accumulatedBuffer: string;
+        accumulatedRawBuffer: string;
         screenText: string;
         currentStatus: CliSessionStatus['status'];
         activeModal: { message: string; buttons: string[] } | null;
@@ -305,6 +308,7 @@ export class ProviderCliAdapter implements CliAdapter {
             && cached.currentTurnScope === this.currentTurnScope
             && cached.recentOutputBuffer === this.recentOutputBuffer
             && cached.accumulatedBuffer === this.accumulatedBuffer
+            && cached.accumulatedRawBuffer === this.accumulatedRawBuffer
             && cached.screenText === this.lastScreenText
             && cached.currentStatus === this.currentStatus
             && cached.activeModal === this.activeModal
@@ -477,6 +481,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 +617,7 @@ export class ProviderCliAdapter implements CliAdapter {
             this.ready = false;
             this.startupParseGate = false;
             this.spawnAt = 0;
+            this.scriptState = null;
             this.onStatusChange?.();
         });
 
@@ -1450,6 +1458,14 @@ export class ProviderCliAdapter implements CliAdapter {
 
  // ─── Script Execution ──────────────────────────
 
+    private invokeCliScript<T>(script: Function, input: any): T {
+        const hasStateFactory = typeof this.cliScripts?.createState === 'function';
+        const expectsStateArgument = hasStateFactory || this.scriptState !== null || script.length >= 2;
+        return expectsStateArgument
+            ? script(this.scriptState, input)
+            : script(input);
+    }
+
     private runParseSession(): ParsedSession | null {
         if (typeof this.cliScripts?.parseSession !== 'function') {
             this.parseErrorMessage = `${this.cliType} parseSession unavailable`;
@@ -1470,7 +1486,10 @@ export class ProviderCliAdapter implements CliAdapter {
                 scope: this.currentTurnScope,
                 runtimeSettings: this.runtimeSettings,
             });
-            const session = this.cliScripts.parseSession({ ...input, tail, tailScreen: buildCliScreenSnapshot(tail) });
+            const session = this.invokeCliScript<ParsedSession | null>(
+                this.cliScripts.parseSession,
+                { ...input, tail, tailScreen: buildCliScreenSnapshot(tail) },
+            );
             this.parseErrorMessage = null;
             return session && typeof session === 'object' ? session : null;
         } catch (e: any) {
@@ -1485,7 +1504,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.invokeCliScript<string | null>(this.cliScripts.detectStatus, {
                 tail: text.slice(-500),
                 screenText,
                 rawBuffer: this.accumulatedRawBuffer,
@@ -1505,7 +1524,7 @@ export class ProviderCliAdapter implements CliAdapter {
         try {
             const screenText = this.terminalScreen.getText();
             const buffer = screenText || this.accumulatedBuffer;
-            return this.cliScripts.parseApproval({
+            return this.invokeCliScript<{ message: string; buttons: string[] } | null>(this.cliScripts.parseApproval, {
                 buffer,
                 screenText,
                 rawBuffer: this.accumulatedRawBuffer,
@@ -1576,6 +1595,7 @@ export class ProviderCliAdapter implements CliAdapter {
             && cached.currentTurnScope === this.currentTurnScope
             && cached.recentOutputBuffer === this.recentOutputBuffer
             && cached.accumulatedBuffer === this.accumulatedBuffer
+            && cached.accumulatedRawBuffer === this.accumulatedRawBuffer
             && cached.screenText === parseScreenText
             && cached.currentStatus === this.currentStatus
             && cached.activeModal === this.activeModal
@@ -1615,6 +1635,7 @@ export class ProviderCliAdapter implements CliAdapter {
             currentTurnScope: this.currentTurnScope,
             recentOutputBuffer: this.recentOutputBuffer,
             accumulatedBuffer: this.accumulatedBuffer,
+            accumulatedRawBuffer: this.accumulatedRawBuffer,
             screenText: parseScreenText,
             currentStatus: this.currentStatus,
             activeModal: this.activeModal,
@@ -1640,7 +1661,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
@@ -41,6 +50,8 @@ export interface ResolveMeshCoordinatorSetupOptions {
   adhdevMcpCommand?: string
   adhdevMcpEntryPath?: string
   nodeExecutable?: string
+  adhdevMcpTransport?: 'local' | 'ipc'
+  adhdevMcpPort?: number
 }
 
 const DEFAULT_SERVER_NAME = 'adhdev-mesh'
@@ -58,6 +69,8 @@ function resolveHermesMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetupO
     meshId: options.meshId,
     nodeExecutable: options.nodeExecutable,
     adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+    adhdevMcpTransport: options.adhdevMcpTransport,
+    adhdevMcpPort: options.adhdevMcpPort,
   })
   if (!mcpServer) {
     return {
@@ -130,6 +143,8 @@ export function resolveMeshCoordinatorSetup(options: ResolveMeshCoordinatorSetup
       meshId,
       nodeExecutable: options.nodeExecutable,
       adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+      adhdevMcpTransport: options.adhdevMcpTransport,
+      adhdevMcpPort: options.adhdevMcpPort,
     })
     if (!mcpServer) {
       return {
@@ -152,6 +167,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 +192,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,
     }
   }
 
@@ -196,17 +224,37 @@ function resolveAdhdevMcpServerLaunch(options: {
   meshId: string
   nodeExecutable?: string
   adhdevMcpEntryPath?: string
+  adhdevMcpTransport?: 'local' | 'ipc'
+  adhdevMcpPort?: number
 }): MeshCoordinatorMcpServerLaunch | null {
   const entryPath = resolveAdhdevMcpEntryPath(options.adhdevMcpEntryPath)
   if (!entryPath) return null
   const nodeExecutable = resolveMcpNodeExecutable(options.nodeExecutable)
   if (!nodeExecutable) return null
+  const transport = resolveMcpTransport(options.adhdevMcpTransport)
+  const args = [entryPath, '--mode', transport, '--repo-mesh', options.meshId]
+  const port = resolveMcpPort(options.adhdevMcpPort)
+  if (port !== undefined) args.push('--port', String(port))
   return {
     command: nodeExecutable,
-    args: [entryPath, '--mode', 'ipc', '--repo-mesh', options.meshId],
+    args,
   }
 }
 
+function resolveMcpTransport(explicitTransport?: 'local' | 'ipc'): 'local' | 'ipc' {
+  if (explicitTransport === 'local' || explicitTransport === 'ipc') return explicitTransport
+  const envTransport = process.env.ADHDEV_COORDINATOR_MCP_TRANSPORT?.trim()
+  return envTransport === 'local' ? 'local' : 'ipc'
+}
+
+function resolveMcpPort(explicitPort?: number): number | undefined {
+  if (typeof explicitPort === 'number' && Number.isInteger(explicitPort) && explicitPort > 0) return explicitPort
+  const raw = process.env.ADHDEV_COORDINATOR_MCP_PORT?.trim()
+  if (!raw) return undefined
+  const parsed = Number(raw)
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined
+}
+
 function resolveMcpNodeExecutable(explicitExecutable?: string): string | null {
   const explicit = explicitExecutable?.trim()
   if (explicit) return explicit

package/src/commands/router.ts

@@ -332,7 +332,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 +1331,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 +1569,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 +1767,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 +1932,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',
                         };
                     }
 

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';