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

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.41",
   "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;
+        accumulatedRawBufferKey: string;
         screenText: string;
         currentStatus: CliSessionStatus['status'];
         activeModal: { message: string; buttons: string[] } | null;
@@ -297,14 +300,23 @@ export class ProviderCliAdapter implements CliAdapter {
         this.lastScreenSnapshotReadAt = Number.NEGATIVE_INFINITY;
     }
 
+    private getAccumulatedRawBufferCacheKey(): string {
+        return this.accumulatedRawBuffer
+            .replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, '')
+            .replace(/\x1B[P^_X][\s\S]*?(?:\x07|\x1B\\)/g, '')
+            .replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+    }
+
     private getFreshParsedStatusCache(): any | null {
         const cached = this.parsedStatusCache;
+        const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
         if (
             cached
             && cached.responseBuffer === this.responseBuffer
             && cached.currentTurnScope === this.currentTurnScope
             && cached.recentOutputBuffer === this.recentOutputBuffer
             && cached.accumulatedBuffer === this.accumulatedBuffer
+            && cached.accumulatedRawBufferKey === accumulatedRawBufferKey
             && cached.screenText === this.lastScreenText
             && cached.currentStatus === this.currentStatus
             && cached.activeModal === this.activeModal
@@ -477,6 +489,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 +625,7 @@ export class ProviderCliAdapter implements CliAdapter {
             this.ready = false;
             this.startupParseGate = false;
             this.spawnAt = 0;
+            this.scriptState = null;
             this.onStatusChange?.();
         });
 
@@ -1450,6 +1466,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 +1494,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 +1512,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 +1532,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,
@@ -1570,12 +1597,14 @@ export class ProviderCliAdapter implements CliAdapter {
         const screenText = this.readTerminalScreenText();
         const parseScreenText = this.getParseScreenText(screenText);
         const cached = this.parsedStatusCache;
+        const accumulatedRawBufferKey = this.getAccumulatedRawBufferCacheKey();
         if (
             cached
             && cached.responseBuffer === this.responseBuffer
             && cached.currentTurnScope === this.currentTurnScope
             && cached.recentOutputBuffer === this.recentOutputBuffer
             && cached.accumulatedBuffer === this.accumulatedBuffer
+            && cached.accumulatedRawBufferKey === accumulatedRawBufferKey
             && cached.screenText === parseScreenText
             && cached.currentStatus === this.currentStatus
             && cached.activeModal === this.activeModal
@@ -1615,6 +1644,7 @@ export class ProviderCliAdapter implements CliAdapter {
             currentTurnScope: this.currentTurnScope,
             recentOutputBuffer: this.recentOutputBuffer,
             accumulatedBuffer: this.accumulatedBuffer,
+            accumulatedRawBufferKey,
             screenText: parseScreenText,
             currentStatus: this.currentStatus,
             activeModal: this.activeModal,
@@ -1640,7 +1670,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