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

package/dist/index.mjs

@@ -973,6 +973,17 @@ var init_mesh_ledger = __esm({
 });
 
 // src/mesh/mesh-work-queue.ts
+var mesh_work_queue_exports = {};
+__export(mesh_work_queue_exports, {
+  cancelTask: () => cancelTask,
+  claimNextTask: () => claimNextTask,
+  enqueueTask: () => enqueueTask,
+  getMeshQueueStats: () => getMeshQueueStats,
+  getQueue: () => getQueue,
+  requeueTask: () => requeueTask,
+  updateSessionTaskStatus: () => updateSessionTaskStatus,
+  updateTaskStatus: () => updateTaskStatus
+});
 import { existsSync as existsSync6, writeFileSync as writeFileSync3, readFileSync as readFileSync4 } from "fs";
 import { join as join6 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
@@ -1002,6 +1013,7 @@ function enqueueTask(meshId, message, opts) {
     message,
     status: "pending",
     targetNodeId: opts?.targetNodeId,
+    targetSessionId: opts?.targetSessionId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -1019,9 +1031,14 @@ function getQueue(meshId, opts) {
 }
 function claimNextTask(meshId, nodeId, sessionId) {
   const queue = readQueue(meshId);
-  let targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetNodeId === nodeId);
+  const hasActiveAssignment = queue.some((q) => q.status === "assigned" && (q.assignedSessionId === sessionId || q.assignedNodeId === nodeId));
+  if (hasActiveAssignment) return null;
+  let targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetSessionId === sessionId);
+  if (targetIdx === -1) {
+    targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetNodeId === nodeId && !q.targetSessionId);
+  }
   if (targetIdx === -1) {
-    targetIdx = queue.findIndex((q) => q.status === "pending" && !q.targetNodeId);
+    targetIdx = queue.findIndex((q) => q.status === "pending" && !q.targetNodeId && !q.targetSessionId);
   }
   if (targetIdx === -1) return null;
   const entry = queue[targetIdx];
@@ -1041,6 +1058,40 @@ function updateTaskStatus(meshId, taskId, status) {
   writeQueue(meshId, queue);
   return queue[idx];
 }
+function cancelTask(meshId, taskId, opts) {
+  const queue = readQueue(meshId);
+  const idx = queue.findIndex((q) => q.id === taskId);
+  if (idx === -1) return null;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  queue[idx].status = "cancelled";
+  queue[idx].updatedAt = now;
+  queue[idx].cancelledAt = now;
+  if (opts?.reason) queue[idx].cancelReason = opts.reason;
+  writeQueue(meshId, queue);
+  return queue[idx];
+}
+function requeueTask(meshId, taskId, opts) {
+  const queue = readQueue(meshId);
+  const idx = queue.findIndex((q) => q.id === taskId);
+  if (idx === -1) return null;
+  const entry = queue[idx];
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  entry.status = "pending";
+  delete entry.assignedNodeId;
+  delete entry.assignedSessionId;
+  delete entry.cancelledAt;
+  delete entry.cancelReason;
+  if (opts?.clearTargetNode) delete entry.targetNodeId;
+  if (typeof opts?.targetNodeId === "string") entry.targetNodeId = opts.targetNodeId;
+  if (opts?.clearTargetSession !== false) delete entry.targetSessionId;
+  if (typeof opts?.targetSessionId === "string") entry.targetSessionId = opts.targetSessionId;
+  entry.updatedAt = now;
+  entry.requeuedAt = now;
+  entry.requeueCount = (entry.requeueCount || 0) + 1;
+  if (opts?.reason) entry.requeueReason = opts.reason;
+  writeQueue(meshId, queue);
+  return entry;
+}
 function updateSessionTaskStatus(meshId, sessionId, status) {
   const queue = readQueue(meshId);
   for (let i = queue.length - 1; i >= 0; i--) {
@@ -1059,7 +1110,14 @@ function getMeshQueueStats(meshId) {
     pending: queue.filter((q) => q.status === "pending").length,
     assigned: queue.filter((q) => q.status === "assigned").length,
     completed: queue.filter((q) => q.status === "completed").length,
-    failed: queue.filter((q) => q.status === "failed").length
+    failed: queue.filter((q) => q.status === "failed").length,
+    cancelled: queue.filter((q) => q.status === "cancelled").length,
+    activeAssignments: queue.filter((q) => q.status === "assigned").map((q) => ({
+      id: q.id,
+      nodeId: q.assignedNodeId,
+      sessionId: q.assignedSessionId,
+      message: q.message
+    }))
   };
 }
 var init_mesh_work_queue = __esm({
@@ -1298,6 +1356,9 @@ function drainPendingMeshCoordinatorEvents() {
 function readNonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
 }
+function resolveEventSessionId(event, fallback) {
+  return readNonEmptyString(event.targetSessionId) || readNonEmptyString(event.sessionId) || readNonEmptyString(event.instanceId) || readNonEmptyString(fallback);
+}
 function isMeshCoordinatorEvent(eventName) {
   return typeof eventName === "string" && MESH_COORDINATOR_EVENTS.has(eventName);
 }
@@ -1309,38 +1370,74 @@ function formatCompletionMetadata(event) {
   ].filter(Boolean);
   return parts.length > 0 ? ` (${parts.join("; ")})` : "";
 }
+function getMeshWithCache(components, meshId) {
+  const localMesh = getMesh(meshId);
+  if (localMesh) return localMesh;
+  return components.router?.getCachedInlineMesh(meshId);
+}
 function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
   const task = claimNextTask(meshId, nodeId, sessionId);
-  if (!task) return false;
+  if (!task) {
+    return false;
+  }
   LOG.info("MeshQueue", `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
+  const mesh = getMeshWithCache(components, meshId);
+  const node = mesh?.nodes.find((n) => n.id === nodeId);
+  if (node?.daemonId && components.dispatchMeshCommand) {
+    const isLocalNode = components.cliManager.adapters.has(sessionId);
+    if (!isLocalNode) {
+      components.dispatchMeshCommand(node.daemonId, "agent_command", {
+        targetSessionId: sessionId,
+        cliType: providerType,
+        action: "send_chat",
+        message: task.message
+      }).catch((e) => {
+        LOG.error("MeshQueue", `Failed to dispatch task via P2P to remote node ${nodeId}: ${e?.message}`);
+        updateTaskStatus(meshId, task.id, "failed");
+      });
+      return true;
+    }
+  }
   components.cliManager.handleCliCommand("agent_command", {
     targetSessionId: sessionId,
     cliType: providerType,
     action: "send_chat",
-    input: task.message
+    message: task.message
   }).catch((e) => {
-    LOG.error("MeshQueue", `Failed to dispatch task to node ${nodeId}: ${e?.message}`);
+    LOG.error("MeshQueue", `Failed to dispatch task locally to node ${nodeId}: ${e?.message}`);
+    updateTaskStatus(meshId, task.id, "failed");
   });
   return true;
 }
 function triggerMeshQueue(components, meshId) {
-  const mesh = getMesh(meshId);
+  const mesh = getMeshWithCache(components, meshId);
   if (!mesh) return;
   const cliInstances = components.instanceManager.getByCategory("cli");
   for (const inst of cliInstances) {
     const state = inst.getState();
     const settings = state.settings || {};
     const instMeshId = readNonEmptyString(settings.meshNodeFor);
-    if (instMeshId !== meshId && !settings.launchedByCoordinator) continue;
+    if (instMeshId !== meshId) continue;
     const nodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
     if (!nodeId) continue;
-    if (state.status !== "idle" && state.status !== "stopped" && state.activeChat?.status !== "waiting_input") continue;
+    const status = readNonEmptyString(state.status).toLowerCase();
+    if (["stopped", "failed", "terminated", "exited", "closed"].includes(status)) continue;
+    if (status !== "idle" && state.activeChat?.status !== "waiting_input") continue;
     const sessionId = state.instanceId;
     const providerType = state.type || readNonEmptyString(settings.providerType);
     if (providerType) {
       tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType);
     }
   }
+  for (const [key, idle] of remoteIdleSessions.entries()) {
+    const node = mesh.nodes.find((n) => n.id === idle.nodeId);
+    if (node) {
+      const assigned = tryAssignQueueTask(components, meshId, idle.nodeId, idle.sessionId, idle.providerType);
+      if (assigned) {
+        remoteIdleSessions.delete(key);
+      }
+    }
+  }
 }
 function buildMeshSystemMessage(args) {
   const metadata = formatCompletionMetadata(args.metadataEvent);
@@ -1387,20 +1484,67 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
   return "";
 }
 function injectMeshSystemMessage(components, args) {
+  let completedTaskForLedger = null;
   if (args.event === "agent:generating_completed") {
-    const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
-    const nodeId = readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+    const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
+    const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
     const providerType = readNonEmptyString(args.metadataEvent.providerType);
     if (sessionId) {
-      updateSessionTaskStatus(args.meshId, sessionId, "completed");
+      const completedTask = updateSessionTaskStatus(args.meshId, sessionId, "completed");
+      completedTaskForLedger = completedTask ? { id: completedTask.id } : null;
       if (nodeId && providerType) {
         setTimeout(() => {
           tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
         }, 500);
       }
     }
+  } else if (args.event === "agent:ready") {
+    const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
+    const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+    const providerType = readNonEmptyString(args.metadataEvent.providerType);
+    const completedTask = sessionId ? updateSessionTaskStatus(args.meshId, sessionId, "completed") : null;
+    if (completedTask) {
+      completedTaskForLedger = { id: completedTask.id };
+      try {
+        appendLedgerEntry(args.meshId, {
+          kind: "task_completed",
+          nodeId: nodeId || void 0,
+          sessionId,
+          providerType: providerType || void 0,
+          payload: {
+            event: args.event,
+            nodeLabel: args.nodeLabel,
+            taskId: completedTask.id,
+            completedViaReady: true,
+            providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0,
+            finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0
+          }
+        });
+      } catch (e) {
+        LOG.warn("MeshLedger", `Failed to record task_completed from ready: ${e?.message || e}`);
+      }
+    }
+    if (sessionId && nodeId && providerType) {
+      remoteIdleSessions.set(`${nodeId}:${sessionId}`, { nodeId, sessionId, providerType });
+      setTimeout(() => {
+        const assigned = tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
+        if (assigned) {
+          remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+        }
+      }, 500);
+    }
+  } else if (args.event === "agent:generating_started") {
+    const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
+    const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+    if (sessionId && nodeId) {
+      remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+    }
   } else if (args.event === "agent:stopped") {
-    const sessionId = readNonEmptyString(args.metadataEvent.targetSessionId);
+    const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
+    const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+    if (sessionId && nodeId) {
+      remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+    }
     if (sessionId) {
       updateSessionTaskStatus(args.meshId, sessionId, "failed");
     }
@@ -1410,13 +1554,15 @@ function injectMeshSystemMessage(components, args) {
     try {
       appendLedgerEntry(args.meshId, {
         kind: ledgerKind,
-        nodeId: readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || void 0,
-        sessionId: readNonEmptyString(args.metadataEvent.targetSessionId) || void 0,
+        nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || void 0,
+        sessionId: resolveEventSessionId(args.metadataEvent, args.sourceInstanceId) || void 0,
         providerType: readNonEmptyString(args.metadataEvent.providerType) || void 0,
         payload: {
           event: args.event,
           nodeLabel: args.nodeLabel,
-          providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0
+          taskId: completedTaskForLedger?.id || void 0,
+          providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0,
+          finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0
         }
       });
     } catch (e) {
@@ -1429,8 +1575,8 @@ function injectMeshSystemMessage(components, args) {
       const mesh = getMesh(args.meshId);
       const maxRetries = mesh?.policy?.maxTaskRetries ?? 1;
       recoveryContext = getSessionRecoveryContext(args.meshId, {
-        sessionId: readNonEmptyString(args.metadataEvent.targetSessionId) || void 0,
-        nodeId: readNonEmptyString(args.metadataEvent.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || void 0,
+        sessionId: resolveEventSessionId(args.metadataEvent, args.sourceInstanceId) || void 0,
+        nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || void 0,
         maxRetries
       });
       recoveryContext.failedProviderType = readNonEmptyString(args.metadataEvent.providerType) || null;
@@ -1525,12 +1671,14 @@ function handleMeshForwardEvent(components, payload) {
   const nodeLabel = nodeId ? `Node '${nodeId}'` : workspace ? `Agent at ${workspace}` : "Remote agent";
   return injectMeshSystemMessage(components, {
     meshId,
+    nodeId,
     nodeLabel,
     event: eventName,
     metadataEvent: {
-      targetSessionId: readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId),
+      targetSessionId: readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.instanceId),
       providerType: readNonEmptyString(payload.providerType),
-      providerSessionId: readNonEmptyString(payload.providerSessionId)
+      providerSessionId: readNonEmptyString(payload.providerSessionId),
+      finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary)
     }
   });
 }
@@ -1549,22 +1697,24 @@ function setupMeshEventForwarding(components) {
     const meshIdFromRuntime = readNonEmptyString(settings.meshNodeFor);
     const isMeshDelegate = Boolean(meshIdFromRuntime || settings.launchedByCoordinator);
     if (!isMeshDelegate) return;
-    const mesh = meshIdFromRuntime ? getMesh(meshIdFromRuntime) : getMeshByRepo(workspace);
+    const mesh = meshIdFromRuntime ? getMeshWithCache(components, meshIdFromRuntime) : getMeshByRepo(workspace);
     const meshId = meshIdFromRuntime || readNonEmptyString(mesh?.id);
     if (!meshId) return;
     const targetNode = mesh?.nodes?.find((n) => n.workspace === workspace);
     const runtimeNodeId = readNonEmptyString(settings.meshNodeId);
+    const resolvedNodeId = targetNode?.id || runtimeNodeId;
     const nodeLabel = targetNode ? `Node '${targetNode.id}'` : runtimeNodeId ? `Node '${runtimeNodeId}'` : `Agent at ${workspace}`;
     injectMeshSystemMessage(components, {
       meshId,
       sourceInstanceId: instanceId,
+      nodeId: resolvedNodeId,
       nodeLabel,
       event: event.event,
       metadataEvent: event
     });
   });
 }
-var MAX_PENDING_EVENTS, pendingMeshCoordinatorEvents, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND;
+var remoteIdleSessions, MAX_PENDING_EVENTS, pendingMeshCoordinatorEvents, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND;
 var init_mesh_events = __esm({
   "src/mesh/mesh-events.ts"() {
     "use strict";
@@ -1572,12 +1722,15 @@ var init_mesh_events = __esm({
     init_logger();
     init_mesh_ledger();
     init_mesh_work_queue();
+    remoteIdleSessions = /* @__PURE__ */ new Map();
     MAX_PENDING_EVENTS = 50;
     pendingMeshCoordinatorEvents = [];
     MESH_COORDINATOR_EVENTS = /* @__PURE__ */ new Set([
+      "agent:generating_started",
       "agent:generating_completed",
       "agent:waiting_approval",
       "agent:stopped",
+      "agent:ready",
       "monitor:long_generating"
     ]);
     EVENT_TO_LEDGER_KIND = {
@@ -2695,6 +2848,8 @@ var init_provider_cli_adapter = __esm({
       statusHistory = [];
       // ─── CLI Scripts (script-based parsing) ───
       cliScripts;
+      /** Per-session opaque state object created by cliScripts.createState(), reset on stop. */
+      scriptState = null;
       runtimeSettings = {};
       /** Full accumulated rendered PTY transcript for parser/readback use */
       accumulatedBuffer = "";
@@ -2771,9 +2926,13 @@ ${lastSnapshot}`;
         this.lastScreenChangeAt = 0;
         this.lastScreenSnapshotReadAt = Number.NEGATIVE_INFINITY;
       }
+      getAccumulatedRawBufferCacheKey() {
+        return this.accumulatedRawBuffer.replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, "").replace(/\x1B[P^_X][\s\S]*?(?:\x07|\x1B\\)/g, "").replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
+      }
       getFreshParsedStatusCache() {
         const cached = this.parsedStatusCache;
-        if (cached && cached.responseBuffer === this.responseBuffer && cached.currentTurnScope === this.currentTurnScope && cached.recentOutputBuffer === this.recentOutputBuffer && cached.accumulatedBuffer === this.accumulatedBuffer && cached.screenText === this.lastScreenText && cached.currentStatus === this.currentStatus && cached.activeModal === this.activeModal && cached.cliName === this.cliName) {
+        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 && cached.cliName === this.cliName) {
           return cached.result;
         }
         return null;
@@ -2876,6 +3035,7 @@ ${lastSnapshot}`;
         this.cliScripts = scripts;
         this.parsedStatusCache = null;
         this.parseErrorMessage = null;
+        this.scriptState = typeof scripts.createState === "function" ? scripts.createState() : null;
         const scriptNames = listCliScriptNames(scripts);
         LOG.info("CLI", `[${this.cliType}] CLI scripts injected: [${scriptNames.join(", ")}]`);
       }
@@ -2993,6 +3153,7 @@ ${lastSnapshot}`;
           this.ready = false;
           this.startupParseGate = false;
           this.spawnAt = 0;
+          this.scriptState = null;
           this.onStatusChange?.();
         });
         this.spawnAt = Date.now();
@@ -3746,6 +3907,11 @@ ${lastSnapshot}`;
         };
       }
       // ─── Script Execution ──────────────────────────
+      invokeCliScript(script, input) {
+        const hasStateFactory = typeof this.cliScripts?.createState === "function";
+        const expectsStateArgument = hasStateFactory || this.scriptState !== null || script.length >= 2;
+        return expectsStateArgument ? script(this.scriptState, input) : script(input);
+      }
       runParseSession() {
         if (typeof this.cliScripts?.parseSession !== "function") {
           this.parseErrorMessage = `${this.cliType} parseSession unavailable`;
@@ -3766,7 +3932,10 @@ ${lastSnapshot}`;
             scope: this.currentTurnScope,
             runtimeSettings: this.runtimeSettings
           });
-          const session = this.cliScripts.parseSession({ ...input, tail, tailScreen: buildCliScreenSnapshot(tail) });
+          const session = this.invokeCliScript(
+            this.cliScripts.parseSession,
+            { ...input, tail, tailScreen: buildCliScreenSnapshot(tail) }
+          );
           this.parseErrorMessage = null;
           return session && typeof session === "object" ? session : null;
         } catch (e) {
@@ -3780,7 +3949,7 @@ ${lastSnapshot}`;
         if (!this.cliScripts?.detectStatus) return null;
         try {
           const screenText = this.terminalScreen.getText();
-          const status = this.cliScripts.detectStatus({
+          const status = this.invokeCliScript(this.cliScripts.detectStatus, {
             tail: text.slice(-500),
             screenText,
             rawBuffer: this.accumulatedRawBuffer,
@@ -3799,7 +3968,7 @@ ${lastSnapshot}`;
         try {
           const screenText = this.terminalScreen.getText();
           const buffer = screenText || this.accumulatedBuffer;
-          return this.cliScripts.parseApproval({
+          return this.invokeCliScript(this.cliScripts.parseApproval, {
             buffer,
             screenText,
             rawBuffer: this.accumulatedRawBuffer,
@@ -3855,7 +4024,8 @@ ${lastSnapshot}`;
         const screenText = this.readTerminalScreenText();
         const parseScreenText = this.getParseScreenText(screenText);
         const cached = this.parsedStatusCache;
-        if (cached && cached.responseBuffer === this.responseBuffer && cached.currentTurnScope === this.currentTurnScope && cached.recentOutputBuffer === this.recentOutputBuffer && cached.accumulatedBuffer === this.accumulatedBuffer && cached.screenText === parseScreenText && cached.currentStatus === this.currentStatus && cached.activeModal === this.activeModal && cached.cliName === this.cliName) {
+        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 && cached.cliName === this.cliName) {
           return cached.result;
         }
         const parsed = this.runParseSession();
@@ -3883,6 +4053,7 @@ ${lastSnapshot}`;
           currentTurnScope: this.currentTurnScope,
           recentOutputBuffer: this.recentOutputBuffer,
           accumulatedBuffer: this.accumulatedBuffer,
+          accumulatedRawBufferKey,
           screenText: parseScreenText,
           currentStatus: this.currentStatus,
           activeModal: this.activeModal,
@@ -3907,7 +4078,7 @@ ${lastSnapshot}`;
           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 } : {}
         }));
@@ -14983,11 +15154,13 @@ async function handleOpenPanel(h, args) {
 async function handlePtyInput(h, args) {
   const { cliType, data, targetSessionId } = args || {};
   if (!data) return { success: false, error: "data required" };
+  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 };
 }
 function handlePtyResize(_h, args) {
@@ -16617,6 +16790,8 @@ var CliProviderInstance = class {
             this.completedDebounceTimer = null;
           }, 3e3);
         }
+      } else if (newStatus === "idle" && this.lastStatus === "starting") {
+        this.pushEvent({ event: "agent:ready", chatTitle, timestamp: now });
       } else if (newStatus === "stopped") {
         if (this.generatingDebounceTimer) {
           clearTimeout(this.generatingDebounceTimer);
@@ -18365,9 +18540,6 @@ function buildCoordinatorDelegatedCliLaunchOptions(input) {
   const cliType = String(input.cliType || "").trim();
   const cliArgs = Array.isArray(input.cliArgs) ? [...input.cliArgs] : [];
   const env = { ...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));
   }
@@ -21613,7 +21785,9 @@ function resolveHermesMeshCoordinatorSetup(options) {
   const mcpServer = resolveAdhdevMcpServerLaunch({
     meshId: options.meshId,
     nodeExecutable: options.nodeExecutable,
-    adhdevMcpEntryPath: options.adhdevMcpEntryPath
+    adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+    adhdevMcpTransport: options.adhdevMcpTransport,
+    adhdevMcpPort: options.adhdevMcpPort
   });
   if (!mcpServer) {
     return {
@@ -21680,7 +21854,9 @@ function resolveMeshCoordinatorSetup(options) {
     const mcpServer = resolveAdhdevMcpServerLaunch({
       meshId,
       nodeExecutable: options.nodeExecutable,
-      adhdevMcpEntryPath: options.adhdevMcpEntryPath
+      adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+      adhdevMcpTransport: options.adhdevMcpTransport,
+      adhdevMcpPort: options.adhdevMcpPort
     });
     if (!mcpServer) {
       return {
@@ -21702,6 +21878,22 @@ function resolveMeshCoordinatorSetup(options) {
     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
+    });
+    const isCliCommand = !renderedTemplate.trim().includes("\n") && !renderedTemplate.trim().startsWith("{");
+    if (isCliCommand) {
+      return {
+        kind: "cli_command",
+        serverName,
+        command: renderedTemplate.trim(),
+        requiresRestart: mcpConfig.requiresRestart === true,
+        instructions
+      };
+    }
     return {
       kind: "manual",
       serverName,
@@ -21709,12 +21901,7 @@ function resolveMeshCoordinatorSetup(options) {
       configPathCommand: mcpConfig.configPathCommand,
       requiresRestart: mcpConfig.requiresRestart === true,
       instructions,
-      template: renderMeshCoordinatorTemplate(template, {
-        meshId,
-        workspace,
-        serverName,
-        adhdevMcpCommand: options.adhdevMcpCommand || DEFAULT_ADHDEV_MCP_COMMAND
-      })
+      template: renderedTemplate
     };
   }
   return {
@@ -21743,11 +21930,27 @@ function resolveAdhdevMcpServerLaunch(options) {
   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 !== void 0) args.push("--port", String(port));
   return {
     command: nodeExecutable,
-    args: [entryPath, "--mode", "ipc", "--repo-mesh", options.meshId]
+    args
   };
 }
+function resolveMcpTransport(explicitTransport) {
+  if (explicitTransport === "local" || explicitTransport === "ipc") return explicitTransport;
+  const envTransport = process.env.ADHDEV_COORDINATOR_MCP_TRANSPORT?.trim();
+  return envTransport === "local" ? "local" : "ipc";
+}
+function resolveMcpPort(explicitPort) {
+  if (typeof explicitPort === "number" && Number.isInteger(explicitPort) && explicitPort > 0) return explicitPort;
+  const raw = process.env.ADHDEV_COORDINATOR_MCP_PORT?.trim();
+  if (!raw) return void 0;
+  const parsed = Number(raw);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+}
 function resolveMcpNodeExecutable(explicitExecutable) {
   const explicit = explicitExecutable?.trim();
   if (explicit) return explicit;
@@ -22588,6 +22791,34 @@ function loadHermesCoordinatorBaseConfig(targetConfigPath) {
   const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
   return { config: baseConfig, sourceHome, sourceConfigPath };
 }
+function stripHermesCoordinatorTempModelProviderOverrides(config) {
+  const {
+    model: _model,
+    provider: _provider,
+    default_model: _defaultModel,
+    defaultProvider: _defaultProvider,
+    default_provider: _defaultProviderSnake,
+    modelProvider: _modelProvider,
+    model_provider: _modelProviderSnake,
+    ...sanitized
+  } = config;
+  const delegation = sanitized.delegation;
+  if (delegation && typeof delegation === "object" && !Array.isArray(delegation)) {
+    const {
+      model: _delegationModel,
+      provider: _delegationProvider,
+      modelProvider: _delegationModelProvider,
+      model_provider: _delegationModelProviderSnake,
+      ...delegationRest
+    } = delegation;
+    if (Object.keys(delegationRest).length > 0) {
+      sanitized.delegation = delegationRest;
+    } else {
+      delete sanitized.delegation;
+    }
+  }
+  return sanitized;
+}
 function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
   if (pathResolve(sourceHome) === pathResolve(targetHome)) return;
   for (const fileName of [".env", "auth.json"]) {
@@ -23568,6 +23799,51 @@ var DaemonCommandRouter = class {
           return { success: false, error: e.message };
         }
       }
+      case "get_mesh_queue": {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        if (!meshId) return { success: false, error: "meshId required" };
+        try {
+          const { getQueue: getQueue2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
+          const status = Array.isArray(args?.status) ? args.status.map((s) => typeof s === "string" ? s.trim() : "").filter(Boolean) : void 0;
+          const queue = getQueue2(meshId, { status });
+          return { success: true, queue };
+        } catch (e) {
+          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: cancelTask2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
+          const reason = typeof args?.reason === "string" ? args.reason : void 0;
+          const task = cancelTask2(meshId, taskId, { reason });
+          if (!task) return { success: false, error: `Queue task '${taskId}' not found` };
+          return { success: true, task };
+        } catch (e) {
+          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: requeueTask2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
+          const task = requeueTask2(meshId, taskId, {
+            reason: typeof args?.reason === "string" ? args.reason : void 0,
+            targetNodeId: typeof args?.targetNodeId === "string" ? args.targetNodeId.trim() : void 0,
+            targetSessionId: typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : void 0,
+            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) {
+          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() : "";
@@ -23725,7 +24001,13 @@ var DaemonCommandRouter = class {
               appendLedgerEntry2(meshId, {
                 kind: "node_removed",
                 nodeId,
-                payload: { worktree: !!node?.isLocalWorktree, sessionCleanupMode }
+                payload: {
+                  worktree: !!node?.isLocalWorktree,
+                  sessionCleanupMode,
+                  workspace: typeof node?.workspace === "string" ? node.workspace : void 0,
+                  daemonId: typeof node?.daemonId === "string" ? node.daemonId : void 0,
+                  worktreeBranch: typeof node?.worktreeBranch === "string" ? node.worktreeBranch : void 0
+                }
               });
             } catch {
             }
@@ -23896,6 +24178,93 @@ var DaemonCommandRouter = class {
               meshCoordinatorSetup: coordinatorSetup
             };
           }
+          if (coordinatorSetup.kind === "cli_command") {
+            let cliCmdSystemPrompt = "";
+            try {
+              cliCmdSystemPrompt = buildCoordinatorSystemPrompt2({ mesh, coordinatorCliType: cliType });
+            } catch (error) {
+              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
+              };
+            }
+            try {
+              const { execFileSync: execCmdSync } = await import("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: 15e3 });
+            } catch (error) {
+              LOG.warn("MeshCoordinator", `MCP registration command failed (may be pre-registered): ${error?.message || error}`);
+            }
+            const cliCmdArgs = [];
+            const cliCmdEnv = {};
+            if (cliCmdSystemPrompt) {
+              if (cliType === "codex-cli") {
+                cliCmdArgs.push("-c", `developer_instructions=${JSON.stringify(cliCmdSystemPrompt)}`);
+              } else if (cliType === "gemini-cli") {
+                try {
+                  const { writeFileSync: wfs, existsSync: efs, readFileSync: rfs } = await import("fs");
+                  const geminiMdPath = `${workspace}/GEMINI.md`;
+                  const marker = "<!-- adhdev-mesh-coordinator-prompt -->";
+                  const markerEnd = "<!-- /adhdev-mesh-coordinator-prompt -->";
+                  const block = `${marker}
+${cliCmdSystemPrompt}
+${markerEnd}`;
+                  if (efs(geminiMdPath)) {
+                    const existing = rfs(geminiMdPath, "utf-8");
+                    const replaced = existing.replace(
+                      new RegExp(`${marker}[\\s\\S]*?${markerEnd}`, "g"),
+                      block
+                    );
+                    wfs(geminiMdPath, replaced.includes(marker) ? replaced : `${existing}
+
+${block}`);
+                  } else {
+                    wfs(geminiMdPath, block);
+                  }
+                  LOG.info("MeshCoordinator", `Wrote coordinator prompt to ${workspace}/GEMINI.md`);
+                } catch (e) {
+                  LOG.warn("MeshCoordinator", `Could not write GEMINI.md: ${e?.message || e}`);
+                }
+              }
+            }
+            const cliCmdLaunch = await this.deps.cliManager.handleCliCommand("launch_cli", {
+              cliType,
+              dir: workspace,
+              cliArgs: cliCmdArgs.length > 0 ? cliCmdArgs : void 0,
+              env: Object.keys(cliCmdEnv).length > 0 ? cliCmdEnv : void 0,
+              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: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+              appendLedgerEntry2(meshId, {
+                kind: "coordinator_started",
+                sessionId: cliCmdLaunch.sessionId || cliCmdLaunch.id,
+                providerType: cliType,
+                payload: { workspace }
+              });
+            } catch {
+            }
+            return {
+              success: true,
+              meshId,
+              cliType,
+              workspace,
+              sessionId: cliCmdLaunch.sessionId || cliCmdLaunch.id,
+              mcpRegistered: true
+            };
+          }
           const configFormat = coordinatorSetup.configFormat;
           if (configFormat !== "claude_mcp_json" && configFormat !== "hermes_config_yaml") {
             return {
@@ -23950,9 +24319,11 @@ var DaemonCommandRouter = class {
             args: coordinatorSetup.mcpServer.args
           };
           if (args?.inlineMesh) {
+            const modeArgIndex = coordinatorSetup.mcpServer.args.findIndex((value) => 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"
             };
           }
           try {
@@ -23971,7 +24342,8 @@ var DaemonCommandRouter = class {
           if (hadExistingMcpConfig) {
             try {
               const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync17(mcpConfigPath, "utf-8"), configFormat);
-              existingMcpConfig = { ...existingMcpConfig, ...parsedExistingMcpConfig };
+              const existingCoordinatorConfig = hermesManualFallback ? stripHermesCoordinatorTempModelProviderOverrides(parsedExistingMcpConfig) : parsedExistingMcpConfig;
+              existingMcpConfig = { ...existingMcpConfig, ...existingCoordinatorConfig };
               copyFileSync4(mcpConfigPath, mcpConfigPath + ".backup");
             } catch (error) {
               LOG.error("MeshCoordinator", `Failed to parse existing MCP config ${mcpConfigPath}: ${error?.message || error}`);
@@ -31999,7 +32371,8 @@ async function initDaemonComponents(config) {
     cdpManagers,
     sessionRegistry,
     detectedIdes: detectedIdesRef,
-    refreshProviderAvailability
+    refreshProviderAvailability,
+    dispatchMeshCommand: config.dispatchMeshCommand
   };
   setupMeshEventForwarding(components);
   return components;
@@ -32130,6 +32503,7 @@ export {
   buildThoughtChatMessage,
   buildToolChatMessage,
   buildUserChatMessage,
+  cancelTask,
   claimNextTask,
   classifyChatMessageVisibility,
   classifyHotChatSessionsForSubscriptionFlush,
@@ -32173,6 +32547,7 @@ export {
   getLogLevel,
   getMesh,
   getMeshByRepo,
+  getMeshQueueStats,
   getNpmExecOptions,
   getQueue,
   getRecentActivity,
@@ -32241,6 +32616,7 @@ export {
   registerExtensionProviders,
   removeNode,
   removeWorktree,
+  requeueTask,
   resetConfig,
   resetDebugRuntimeConfig,
   resetState,