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

package/vendor/mcp-server/index.js

@@ -25120,6 +25120,7 @@ __export(dist_exports, {
   buildThoughtChatMessage: () => buildThoughtChatMessage,
   buildToolChatMessage: () => buildToolChatMessage,
   buildUserChatMessage: () => buildUserChatMessage,
+  cancelTask: () => cancelTask,
   claimNextTask: () => claimNextTask,
   classifyChatMessageVisibility: () => classifyChatMessageVisibility,
   classifyHotChatSessionsForSubscriptionFlush: () => classifyHotChatSessionsForSubscriptionFlush,
@@ -25163,6 +25164,7 @@ __export(dist_exports, {
   getLogLevel: () => getLogLevel,
   getMesh: () => getMesh,
   getMeshByRepo: () => getMeshByRepo,
+  getMeshQueueStats: () => getMeshQueueStats,
   getNpmExecOptions: () => getNpmExecOptions,
   getQueue: () => getQueue,
   getRecentActivity: () => getRecentActivity,
@@ -25231,6 +25233,7 @@ __export(dist_exports, {
   registerExtensionProviders: () => registerExtensionProviders,
   removeNode: () => removeNode,
   removeWorktree: () => removeWorktree,
+  requeueTask: () => requeueTask,
   resetConfig: () => resetConfig,
   resetDebugRuntimeConfig: () => resetDebugRuntimeConfig,
   resetState: () => resetState,
@@ -26029,6 +26032,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()
   };
@@ -26046,9 +26050,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);
+    targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetNodeId === nodeId && !q.targetSessionId);
+  }
+  if (targetIdx === -1) {
+    targetIdx = queue.findIndex((q) => q.status === "pending" && !q.targetNodeId && !q.targetSessionId);
   }
   if (targetIdx === -1) return null;
   const entry = queue[targetIdx];
@@ -26068,6 +26077,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--) {
@@ -26086,7 +26129,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
+    }))
   };
 }
 function setLogLevel(level) {
@@ -26245,6 +26295,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);
 }
@@ -26256,38 +26309,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);
@@ -26334,20 +26423,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");
     }
@@ -26357,13 +26493,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) {
@@ -26376,8 +26514,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;
@@ -26472,12 +26610,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)
     }
   });
 }
@@ -26496,15 +26636,17 @@ 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
@@ -33701,11 +33843,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) {
@@ -34532,9 +34676,6 @@ function buildCoordinatorDelegatedCliLaunchOptions(input) {
   const cliType = String(input.cliType || "").trim();
   const cliArgs = Array.isArray(input.cliArgs) ? [...input.cliArgs] : [];
   const env2 = { ...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));
   }
@@ -35478,7 +35619,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 {
@@ -35545,7 +35688,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 {
@@ -35567,6 +35712,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,
@@ -35574,12 +35735,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 {
@@ -35608,11 +35764,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;
@@ -40855,7 +41027,8 @@ async function initDaemonComponents(config2) {
     cdpManagers,
     sessionRegistry,
     detectedIdes: detectedIdesRef,
-    refreshProviderAvailability
+    refreshProviderAvailability,
+    dispatchMeshCommand: config2.dispatchMeshCommand
   };
   setupMeshEventForwarding(components);
   return components;
@@ -40913,7 +41086,7 @@ async function shutdownDaemonComponents(components) {
   }
   cdpManagers.clear();
 }
-var path4, import_promises4, import_fs3, import_child_process, import_util3, import_os2, import_path, import_fs4, import_crypto2, import_fs5, import_path2, import_crypto3, import_fs6, import_path3, import_crypto4, import_events2, import_fs7, import_path4, import_crypto5, fs2, path8, os22, os8, os9, path14, import_child_process2, os10, path15, os11, import_child_process3, import_fs8, import_promises5, path, import_util4, import_promises6, path22, path32, fs, os4, path5, import_crypto6, path6, path7, import_fs9, import_path5, import_child_process4, import_fs10, import_os3, path9, import_child_process5, os32, path10, import_fs11, os42, import_child_process6, http, crypto2, fs3, path11, os5, fs4, os6, path12, import_crypto7, fs5, path13, os7, os13, path18, crypto4, import_fs12, import_child_process7, os12, path16, crypto3, fs6, import_module, path17, import_stream2, import_child_process8, import_child_process9, net2, os15, path20, fs7, path19, os14, fs8, path21, os16, import_child_process10, import_crypto8, import_fs13, import_module2, os17, import_path6, os18, import_child_process11, import_child_process12, fs9, os19, path222, import_os4, import_path7, fs10, fs11, path23, os20, import_child_process13, import_os5, http2, fs15, path27, fs12, path24, fs13, path25, fs14, path26, os21, import_child_process14, __defProp2, __getOwnPropDesc2, __getOwnPropNames2, __hasOwnProp2, __require2, __esm2, __export2, __copyProps2, __toCommonJS2, DEFAULT_MESH_POLICY, init_repo_mesh_types, git_worktree_exports, execFileAsync2, WORKTREE_DIR_NAME, GIT_TIMEOUT_MS, GIT_MAX_BUFFER, init_git_worktree, config_exports, DEFAULT_CONFIG, MACHINE_ID_PREFIX, init_config, mesh_config_exports, SESSION_CLEANUP_MODES, SPAWNED_SESSION_VISIBILITY_MODES, init_mesh_config, coordinator_prompt_exports, TOOLS_SECTION, TOOL_EXPOSURE_PREFLIGHT_SECTION, WORKFLOW_SECTION, init_coordinator_prompt, mesh_ledger_exports, LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, RECENT_FAILURE_WINDOW_MS, meshLedgerEvents, init_mesh_ledger, init_mesh_work_queue, LEVEL_NUM, LEVEL_LABEL, currentLevel, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, currentDate, currentLogFile, writeCount, RING_BUFFER_SIZE, ringBuffer, origConsoleLog, origConsoleError, origConsoleWarn, LOG, interceptorInstalled, LOG_PATH, init_logger, mesh_events_exports, MAX_PENDING_EVENTS, pendingMeshCoordinatorEvents, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, init_mesh_events, NORMAL_TRACE_BUFFER_SIZE, DEV_TRACE_BUFFER_SIZE, DEFAULT_CONFIG2, currentConfig, init_debug_config, DEFAULT_BINDING_CANDIDATES, cachedBinding, cachedBindingError, GhosttyVtTerminalBackend, init_ghostty_vt_backend, TerminalCtor, XtermTerminalBackend, init_xterm_backend, DEFAULT_SCROLLBACK, loggedTerminalBackends, TerminalScreen, init_terminal_screen, init_spawn_env, cachedPty, NodePtyRuntimeTransport, NodePtyTransportFactory, init_pty_transport, TerminalTranscriptAccumulator, buildCliSpawnEnv, init_provider_cli_shared, init_provider_cli_parse, init_provider_cli_config, init_provider_cli_runtime, provider_cli_adapter_exports, ProviderCliAdapter, init_provider_cli_adapter, execFileAsync, DEFAULT_TIMEOUT_MS, DEFAULT_MAX_BUFFER, GitCommandError, DEFAULT_MAX_FILES, DEFAULT_MAX_BYTES, summarizeGitStatus, InMemoryGitSnapshotStore, DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS, MIN_GIT_WORKSPACE_POLL_INTERVAL_MS, GitWorkspaceMonitor, GIT_COMMAND_NAMES, SNAPSHOT_REASONS, FAILURE_REASONS, defaultSnapshotStore, defaultGitCommandServices, BUSY_STATUSES, TERMINAL_STATUSES, TurnSnapshotTracker, MAX_WORKSPACES, MAX_ACTIVITY, MAX_SAVED_SESSIONS, DEFAULT_STATE, BUILTIN_IDE_DEFINITIONS, registeredIDEs, LIVE_LIFECYCLES, DEFAULT_ACTIVE_CHAT_POLL_STATUSES, DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS, LIVE_RUNTIME_LIFECYCLES, DaemonCdpManager, CdpDomHandlers, DEFAULT_MONITOR_CONFIG, StatusMonitor, BUILTIN_CHAT_MESSAGE_KINDS, CHAT_MESSAGE_VISIBILITIES, CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES, CHAT_MESSAGE_AUDIENCES, CHAT_MESSAGE_SOURCES, CHAT_MESSAGE_ACTIVITY_SOURCES, CHAT_MESSAGE_INTERNAL_SOURCES, KNOWN_CHAT_MESSAGE_KINDS, CHAT_MESSAGE_KIND_ALIASES, EXPLICIT_HIDDEN_VISIBILITIES, EXPLICIT_VISIBLE_VISIBILITIES, HIDDEN_AUDIENCES, ACTIVITY_SOURCE_SET, INTERNAL_SOURCE_SET, HISTORY_DIR, RETAIN_DAYS, SAVED_HISTORY_INDEX_VERSION, SAVED_HISTORY_INDEX_FILE, SAVED_HISTORY_INDEX_LOCK_SUFFIX, SAVED_HISTORY_INDEX_LOCK_WAIT_MS, SAVED_HISTORY_INDEX_LOCK_STALE_MS, SAVED_HISTORY_INDEX_LOCK_POLL_MS, SAVED_HISTORY_ROLLUP_THRESHOLD_BYTES, savedHistorySessionCache, savedHistoryFileSummaryCache, savedHistoryBackgroundRefresh, savedHistoryRollupInFlight, ChatHistoryWriter, IDE_PROVIDER_SESSION_CAPABILITIES_BASE, EXTENSION_PROVIDER_SESSION_CAPABILITIES_BASE, ExtensionProviderInstance, VALID_STATUSES, VALID_ROLES, VALID_BUBBLE_STATES, VALID_TURN_STATUSES, DEFAULT_APPROVAL_POSITIVE_HINTS, IdeProviderInstance, DEFAULT_CDP_SCAN_INTERVAL_MS, DEFAULT_CDP_DISCOVERY_INTERVAL_MS, DEFAULT_STATUS_INITIAL_REPORT_DELAY_MS, DEFAULT_STATUS_SERVER_REPORT_INTERVAL_MS, DEFAULT_STATUS_P2P_REPORT_INTERVAL_MS, MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS, DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS, MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS, DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS, DEFAULT_SESSION_HOST_READY_TIMEOUT_MS, STANDALONE_CDP_SCAN_INTERVAL_MS, DaemonCdpScanner, DaemonCdpInitializer, WORKING_STATUSES, FULL_STATUS_ACTIVE_CHAT_OPTIONS, LIVE_STATUS_ACTIVE_CHAT_OPTIONS, STATUS_MODAL_MESSAGE_LIMIT, STATUS_MODAL_BUTTON_LIMIT, VALID_INPUT_MEDIA_TYPES, VALID_INPUT_STRATEGIES, TEXT_ONLY_MESSAGE_INPUT_SUPPORT, IDE_SESSION_CAPABILITIES, EXTENSION_SESSION_CAPABILITIES, PTY_SESSION_CAPABILITIES, CLI_CHAT_SESSION_CAPABILITIES, ACP_SESSION_CAPABILITIES, globalStore, RECENT_SEND_WINDOW_MS, READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS, HERMES_CLI_STARTING_SEND_SETTLE_MS, recentSendByTarget, DEFAULT_DEBUG_SANITIZE_OPTIONS, SECRET_KEY_PATTERN, KEY_TO_VK, COMMAND_DEBUG_LEVELS, DaemonCommandHandler, IMAGE_MIME_EXTENSIONS, MATERIALIZED_IMAGE_MAX_AGE_MS, MATERIALIZED_IMAGE_CLEANUP_INTERVAL_MS, lastMaterializedImageCleanupAt, CachedDatabaseSync, CliProviderInstance, AcpProviderInstance, chalkModule, chalkApi, COORDINATOR_DELEGATED_ENV_UNSETS, DaemonCliManager, VALID_CAPABILITY_MEDIA_TYPES, VALID_INPUT_STRATEGIES2, KNOWN_PROVIDER_FIELDS, VALUE_CONTROL_TYPES, ProviderLoader, _providerLoader, LOG_DIR2, MAX_FILE_SIZE, MAX_DAYS, SENSITIVE_KEYS, currentDate2, currentFile, writeCount2, SKIP_COMMANDS, DEFAULT_SERVER_NAME, DEFAULT_ADHDEV_MCP_COMMAND, HERMES_CLI_TYPE, HERMES_MCP_CONFIG_PATH, READ_DEBUG_ENABLED, recentReadDebugSignatureBySession, UPGRADE_HELPER_ENV, CHANNEL_NPM_TAG, CHANNEL_SERVER_URL, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter, DaemonStatusReporter, DEFAULT_DAEMON_PORT, DAEMON_WS_PATH, ProviderStreamAdapter, DaemonAgentStreamManager, AgentStreamPoller, ProviderInstanceManager, ARCHIVE_PATH, MAX_ENTRIES_PER_PROVIDER, VersionArchive, DEV_SERVER_PORT, DevServer, SessionHostRuntimeTransport, SessionHostPtyTransportFactory, DEFAULT_SESSION_HOST_APP_NAME, DEFAULT_STANDALONE_SESSION_HOST_APP_NAME, STARTUP_TIMEOUT_MS, STARTUP_POLL_MS, SessionHostCompatibilityError, EXTENSION_CATALOG, SessionRegistry;
+var path4, import_promises4, import_fs3, import_child_process, import_util3, import_os2, import_path, import_fs4, import_crypto2, import_fs5, import_path2, import_crypto3, import_fs6, import_path3, import_crypto4, import_events2, import_fs7, import_path4, import_crypto5, fs2, path8, os22, os8, os9, path14, import_child_process2, os10, path15, os11, import_child_process3, import_fs8, import_promises5, path, import_util4, import_promises6, path22, path32, fs, os4, path5, import_crypto6, path6, path7, import_fs9, import_path5, import_child_process4, import_fs10, import_os3, path9, import_child_process5, os32, path10, import_fs11, os42, import_child_process6, http, crypto2, fs3, path11, os5, fs4, os6, path12, import_crypto7, fs5, path13, os7, os13, path18, crypto4, import_fs12, import_child_process7, os12, path16, crypto3, fs6, import_module, path17, import_stream2, import_child_process8, import_child_process9, net2, os15, path20, fs7, path19, os14, fs8, path21, os16, import_child_process10, import_crypto8, import_fs13, import_module2, os17, import_path6, os18, import_child_process11, import_child_process12, fs9, os19, path222, import_os4, import_path7, fs10, fs11, path23, os20, import_child_process13, import_os5, http2, fs15, path27, fs12, path24, fs13, path25, fs14, path26, os21, import_child_process14, __defProp2, __getOwnPropDesc2, __getOwnPropNames2, __hasOwnProp2, __require2, __esm2, __export2, __copyProps2, __toCommonJS2, DEFAULT_MESH_POLICY, init_repo_mesh_types, git_worktree_exports, execFileAsync2, WORKTREE_DIR_NAME, GIT_TIMEOUT_MS, GIT_MAX_BUFFER, init_git_worktree, config_exports, DEFAULT_CONFIG, MACHINE_ID_PREFIX, init_config, mesh_config_exports, SESSION_CLEANUP_MODES, SPAWNED_SESSION_VISIBILITY_MODES, init_mesh_config, coordinator_prompt_exports, TOOLS_SECTION, TOOL_EXPOSURE_PREFLIGHT_SECTION, WORKFLOW_SECTION, init_coordinator_prompt, mesh_ledger_exports, LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, RECENT_FAILURE_WINDOW_MS, meshLedgerEvents, init_mesh_ledger, mesh_work_queue_exports, init_mesh_work_queue, LEVEL_NUM, LEVEL_LABEL, currentLevel, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, currentDate, currentLogFile, writeCount, RING_BUFFER_SIZE, ringBuffer, origConsoleLog, origConsoleError, origConsoleWarn, LOG, interceptorInstalled, LOG_PATH, init_logger, mesh_events_exports, remoteIdleSessions, MAX_PENDING_EVENTS, pendingMeshCoordinatorEvents, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, init_mesh_events, NORMAL_TRACE_BUFFER_SIZE, DEV_TRACE_BUFFER_SIZE, DEFAULT_CONFIG2, currentConfig, init_debug_config, DEFAULT_BINDING_CANDIDATES, cachedBinding, cachedBindingError, GhosttyVtTerminalBackend, init_ghostty_vt_backend, TerminalCtor, XtermTerminalBackend, init_xterm_backend, DEFAULT_SCROLLBACK, loggedTerminalBackends, TerminalScreen, init_terminal_screen, init_spawn_env, cachedPty, NodePtyRuntimeTransport, NodePtyTransportFactory, init_pty_transport, TerminalTranscriptAccumulator, buildCliSpawnEnv, init_provider_cli_shared, init_provider_cli_parse, init_provider_cli_config, init_provider_cli_runtime, provider_cli_adapter_exports, ProviderCliAdapter, init_provider_cli_adapter, execFileAsync, DEFAULT_TIMEOUT_MS, DEFAULT_MAX_BUFFER, GitCommandError, DEFAULT_MAX_FILES, DEFAULT_MAX_BYTES, summarizeGitStatus, InMemoryGitSnapshotStore, DEFAULT_GIT_WORKSPACE_POLL_INTERVAL_MS, MIN_GIT_WORKSPACE_POLL_INTERVAL_MS, GitWorkspaceMonitor, GIT_COMMAND_NAMES, SNAPSHOT_REASONS, FAILURE_REASONS, defaultSnapshotStore, defaultGitCommandServices, BUSY_STATUSES, TERMINAL_STATUSES, TurnSnapshotTracker, MAX_WORKSPACES, MAX_ACTIVITY, MAX_SAVED_SESSIONS, DEFAULT_STATE, BUILTIN_IDE_DEFINITIONS, registeredIDEs, LIVE_LIFECYCLES, DEFAULT_ACTIVE_CHAT_POLL_STATUSES, DEFAULT_CHAT_TAIL_RECENT_MESSAGE_GRACE_MS, LIVE_RUNTIME_LIFECYCLES, DaemonCdpManager, CdpDomHandlers, DEFAULT_MONITOR_CONFIG, StatusMonitor, BUILTIN_CHAT_MESSAGE_KINDS, CHAT_MESSAGE_VISIBILITIES, CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES, CHAT_MESSAGE_AUDIENCES, CHAT_MESSAGE_SOURCES, CHAT_MESSAGE_ACTIVITY_SOURCES, CHAT_MESSAGE_INTERNAL_SOURCES, KNOWN_CHAT_MESSAGE_KINDS, CHAT_MESSAGE_KIND_ALIASES, EXPLICIT_HIDDEN_VISIBILITIES, EXPLICIT_VISIBLE_VISIBILITIES, HIDDEN_AUDIENCES, ACTIVITY_SOURCE_SET, INTERNAL_SOURCE_SET, HISTORY_DIR, RETAIN_DAYS, SAVED_HISTORY_INDEX_VERSION, SAVED_HISTORY_INDEX_FILE, SAVED_HISTORY_INDEX_LOCK_SUFFIX, SAVED_HISTORY_INDEX_LOCK_WAIT_MS, SAVED_HISTORY_INDEX_LOCK_STALE_MS, SAVED_HISTORY_INDEX_LOCK_POLL_MS, SAVED_HISTORY_ROLLUP_THRESHOLD_BYTES, savedHistorySessionCache, savedHistoryFileSummaryCache, savedHistoryBackgroundRefresh, savedHistoryRollupInFlight, ChatHistoryWriter, IDE_PROVIDER_SESSION_CAPABILITIES_BASE, EXTENSION_PROVIDER_SESSION_CAPABILITIES_BASE, ExtensionProviderInstance, VALID_STATUSES, VALID_ROLES, VALID_BUBBLE_STATES, VALID_TURN_STATUSES, DEFAULT_APPROVAL_POSITIVE_HINTS, IdeProviderInstance, DEFAULT_CDP_SCAN_INTERVAL_MS, DEFAULT_CDP_DISCOVERY_INTERVAL_MS, DEFAULT_STATUS_INITIAL_REPORT_DELAY_MS, DEFAULT_STATUS_SERVER_REPORT_INTERVAL_MS, DEFAULT_STATUS_P2P_REPORT_INTERVAL_MS, MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS, DEFAULT_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS, MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS, DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS, DEFAULT_SESSION_HOST_READY_TIMEOUT_MS, STANDALONE_CDP_SCAN_INTERVAL_MS, DaemonCdpScanner, DaemonCdpInitializer, WORKING_STATUSES, FULL_STATUS_ACTIVE_CHAT_OPTIONS, LIVE_STATUS_ACTIVE_CHAT_OPTIONS, STATUS_MODAL_MESSAGE_LIMIT, STATUS_MODAL_BUTTON_LIMIT, VALID_INPUT_MEDIA_TYPES, VALID_INPUT_STRATEGIES, TEXT_ONLY_MESSAGE_INPUT_SUPPORT, IDE_SESSION_CAPABILITIES, EXTENSION_SESSION_CAPABILITIES, PTY_SESSION_CAPABILITIES, CLI_CHAT_SESSION_CAPABILITIES, ACP_SESSION_CAPABILITIES, globalStore, RECENT_SEND_WINDOW_MS, READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS, HERMES_CLI_STARTING_SEND_SETTLE_MS, recentSendByTarget, DEFAULT_DEBUG_SANITIZE_OPTIONS, SECRET_KEY_PATTERN, KEY_TO_VK, COMMAND_DEBUG_LEVELS, DaemonCommandHandler, IMAGE_MIME_EXTENSIONS, MATERIALIZED_IMAGE_MAX_AGE_MS, MATERIALIZED_IMAGE_CLEANUP_INTERVAL_MS, lastMaterializedImageCleanupAt, CachedDatabaseSync, CliProviderInstance, AcpProviderInstance, chalkModule, chalkApi, COORDINATOR_DELEGATED_ENV_UNSETS, DaemonCliManager, VALID_CAPABILITY_MEDIA_TYPES, VALID_INPUT_STRATEGIES2, KNOWN_PROVIDER_FIELDS, VALUE_CONTROL_TYPES, ProviderLoader, _providerLoader, LOG_DIR2, MAX_FILE_SIZE, MAX_DAYS, SENSITIVE_KEYS, currentDate2, currentFile, writeCount2, SKIP_COMMANDS, DEFAULT_SERVER_NAME, DEFAULT_ADHDEV_MCP_COMMAND, HERMES_CLI_TYPE, HERMES_MCP_CONFIG_PATH, READ_DEBUG_ENABLED, recentReadDebugSignatureBySession, UPGRADE_HELPER_ENV, CHANNEL_NPM_TAG, CHANNEL_SERVER_URL, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter, DaemonStatusReporter, DEFAULT_DAEMON_PORT, DAEMON_WS_PATH, ProviderStreamAdapter, DaemonAgentStreamManager, AgentStreamPoller, ProviderInstanceManager, ARCHIVE_PATH, MAX_ENTRIES_PER_PROVIDER, VersionArchive, DEV_SERVER_PORT, DevServer, SessionHostRuntimeTransport, SessionHostPtyTransportFactory, DEFAULT_SESSION_HOST_APP_NAME, DEFAULT_STANDALONE_SESSION_HOST_APP_NAME, STARTUP_TIMEOUT_MS, STARTUP_POLL_MS, SessionHostCompatibilityError, EXTENSION_CATALOG, SessionRegistry;
 var init_dist2 = __esm({
   "../daemon-core/dist/index.mjs"() {
     "use strict";
@@ -41246,6 +41419,17 @@ Follow these recovery rules:
         meshLedgerEvents = new import_events2.EventEmitter();
       }
     });
+    mesh_work_queue_exports = {};
+    __export2(mesh_work_queue_exports, {
+      cancelTask: () => cancelTask,
+      claimNextTask: () => claimNextTask,
+      enqueueTask: () => enqueueTask,
+      getMeshQueueStats: () => getMeshQueueStats,
+      getQueue: () => getQueue,
+      requeueTask: () => requeueTask,
+      updateSessionTaskStatus: () => updateSessionTaskStatus,
+      updateTaskStatus: () => updateTaskStatus
+    });
     init_mesh_work_queue = __esm2({
       "src/mesh/mesh-work-queue.ts"() {
         "use strict";
@@ -41325,12 +41509,15 @@ Follow these recovery rules:
         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 = {
@@ -41865,6 +42052,8 @@ Follow these recovery rules:
           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 = "";
@@ -41943,7 +42132,7 @@ ${lastSnapshot}`;
           }
           getFreshParsedStatusCache() {
             const cached2 = this.parsedStatusCache;
-            if (cached2 && cached2.responseBuffer === this.responseBuffer && cached2.currentTurnScope === this.currentTurnScope && cached2.recentOutputBuffer === this.recentOutputBuffer && cached2.accumulatedBuffer === this.accumulatedBuffer && cached2.screenText === this.lastScreenText && cached2.currentStatus === this.currentStatus && cached2.activeModal === this.activeModal && cached2.cliName === this.cliName) {
+            if (cached2 && cached2.responseBuffer === this.responseBuffer && cached2.currentTurnScope === this.currentTurnScope && cached2.recentOutputBuffer === this.recentOutputBuffer && cached2.accumulatedBuffer === this.accumulatedBuffer && cached2.accumulatedRawBuffer === this.accumulatedRawBuffer && cached2.screenText === this.lastScreenText && cached2.currentStatus === this.currentStatus && cached2.activeModal === this.activeModal && cached2.cliName === this.cliName) {
               return cached2.result;
             }
             return null;
@@ -42046,6 +42235,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(", ")}]`);
           }
@@ -42163,6 +42353,7 @@ ${lastSnapshot}`;
               this.ready = false;
               this.startupParseGate = false;
               this.spawnAt = 0;
+              this.scriptState = null;
               this.onStatusChange?.();
             });
             this.spawnAt = Date.now();
@@ -42916,6 +43107,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`;
@@ -42936,7 +43132,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) {
@@ -42950,7 +43149,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,
@@ -42969,7 +43168,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,
@@ -43025,7 +43224,7 @@ ${lastSnapshot}`;
             const screenText = this.readTerminalScreenText();
             const parseScreenText = this.getParseScreenText(screenText);
             const cached2 = this.parsedStatusCache;
-            if (cached2 && cached2.responseBuffer === this.responseBuffer && cached2.currentTurnScope === this.currentTurnScope && cached2.recentOutputBuffer === this.recentOutputBuffer && cached2.accumulatedBuffer === this.accumulatedBuffer && cached2.screenText === parseScreenText && cached2.currentStatus === this.currentStatus && cached2.activeModal === this.activeModal && cached2.cliName === this.cliName) {
+            if (cached2 && cached2.responseBuffer === this.responseBuffer && cached2.currentTurnScope === this.currentTurnScope && cached2.recentOutputBuffer === this.recentOutputBuffer && cached2.accumulatedBuffer === this.accumulatedBuffer && cached2.accumulatedRawBuffer === this.accumulatedRawBuffer && cached2.screenText === parseScreenText && cached2.currentStatus === this.currentStatus && cached2.activeModal === this.activeModal && cached2.cliName === this.cliName) {
               return cached2.result;
             }
             const parsed = this.runParseSession();
@@ -43053,6 +43252,7 @@ ${lastSnapshot}`;
               currentTurnScope: this.currentTurnScope,
               recentOutputBuffer: this.recentOutputBuffer,
               accumulatedBuffer: this.accumulatedBuffer,
+              accumulatedRawBuffer: this.accumulatedRawBuffer,
               screenText: parseScreenText,
               currentStatus: this.currentStatus,
               activeModal: this.activeModal,
@@ -43077,7 +43277,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 } : {}
             }));
@@ -48296,6 +48496,8 @@ ${effect.notification.body || ""}`.trim();
                 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);
@@ -53014,6 +53216,51 @@ Run 'adhdev doctor' for detailed diagnostics.`
               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() : "";
@@ -53171,7 +53418,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
                   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 {
                 }
@@ -53342,6 +53595,93 @@ Run 'adhdev doctor' for detailed diagnostics.`
                   meshCoordinatorSetup: coordinatorSetup
                 };
               }
+              if (coordinatorSetup.kind === "cli_command") {
+                let cliCmdSystemPrompt = "";
+                try {
+                  cliCmdSystemPrompt = buildCoordinatorSystemPrompt2({ mesh, coordinatorCliType: cliType });
+                } catch (error48) {
+                  const message = error48?.message || String(error48);
+                  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 (error48) {
+                  LOG.warn("MeshCoordinator", `MCP registration command failed (may be pre-registered): ${error48?.message || error48}`);
+                }
+                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 {
@@ -53396,9 +53736,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 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 {
@@ -57240,6 +57582,11 @@ function annotateRapidReadChatAdvisory(payload, options) {
 // src/tools/mesh-tools.ts
 init_dist2();
 var meshSessionProviderMetadata = /* @__PURE__ */ new Map();
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+var DUPLICATE_DISPATCH_WINDOW_MS = 6e4;
+var STALE_ASSIGNED_QUEUE_MS = 30 * 6e4;
 async function refreshMeshFromDaemon(ctx) {
   if (!(ctx.transport instanceof IpcTransport)) return;
   try {
@@ -57260,6 +57607,138 @@ async function findNodeWithRefresh(ctx, nodeId) {
   if (!refreshed) throw new Error(`Node '${nodeId}' is not a member of mesh '${ctx.mesh.name}'`);
   return refreshed;
 }
+async function findOptionalNodeWithRefresh(ctx, nodeId) {
+  const hit = ctx.mesh.nodes.find((n) => n.id === nodeId);
+  if (hit) return hit;
+  await refreshMeshFromDaemon(ctx);
+  return ctx.mesh.nodes.find((n) => n.id === nodeId) ?? null;
+}
+function hasRecentDuplicateDispatch(ctx, args) {
+  const now = Date.now();
+  const normalizedMessage = args.message.trim();
+  for (const task of getQueue(ctx.mesh.id)) {
+    const timestamp2 = new Date(task.updatedAt || task.createdAt).getTime();
+    if (!Number.isFinite(timestamp2) || now - timestamp2 > DUPLICATE_DISPATCH_WINDOW_MS) continue;
+    if (task.targetNodeId && task.targetNodeId !== args.node_id) continue;
+    if (task.assignedNodeId && task.assignedNodeId !== args.node_id) continue;
+    if (args.session_id && task.targetSessionId !== args.session_id && task.assignedSessionId !== args.session_id) continue;
+    if (task.message?.trim() === normalizedMessage) {
+      return { duplicate: true, entry: task, source: "queue" };
+    }
+  }
+  const entries = readLedgerEntries(ctx.mesh.id, { tail: 200 });
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    const entry = entries[i];
+    const timestamp2 = new Date(entry.timestamp).getTime();
+    if (Number.isFinite(timestamp2) && now - timestamp2 > DUPLICATE_DISPATCH_WINDOW_MS) break;
+    if (entry.kind !== "task_dispatched") continue;
+    if (entry.nodeId !== args.node_id) continue;
+    if (args.session_id && entry.sessionId !== args.session_id) continue;
+    if (typeof entry.payload?.message !== "string") continue;
+    if (entry.payload.message.trim() === normalizedMessage) {
+      return { duplicate: true, entry, source: "ledger" };
+    }
+  }
+  return { duplicate: false };
+}
+function buildMissingNodeReadChatRecovery(ctx, args) {
+  const entries = readLedgerEntries(ctx.mesh.id, { tail: 300 });
+  const relatedEntries = entries.filter((entry) => entry.nodeId === args.node_id || entry.sessionId === args.session_id);
+  const completedEntries = relatedEntries.filter((entry) => entry.kind === "task_completed");
+  const lastDispatch = [...relatedEntries].reverse().find((entry) => entry.kind === "task_dispatched");
+  const lastTerminal = [...relatedEntries].reverse().find((entry) => entry.kind === "task_completed" || entry.kind === "task_failed" || entry.kind === "task_stalled");
+  const lastRemoved = [...relatedEntries].reverse().find((entry) => entry.kind === "node_removed");
+  const lastLaunch = [...relatedEntries].reverse().find((entry) => entry.kind === "session_launched");
+  const providerSessionId = args.provider_session_id || readString(lastTerminal?.payload?.providerSessionId) || readString(lastLaunch?.payload?.providerSessionId) || readString(lastDispatch?.payload?.providerSessionId);
+  const finalSummary = readString(lastTerminal?.payload?.finalSummary) || readString(lastTerminal?.payload?.compactSummary) || readString(lastTerminal?.payload?.summary);
+  const ledger = {
+    taskCompletedFound: completedEntries.length > 0,
+    nodeRemovedFound: !!lastRemoved,
+    providerType: lastTerminal?.providerType || lastLaunch?.providerType || lastDispatch?.providerType,
+    providerSessionId,
+    nodeRemovedAt: lastRemoved?.timestamp,
+    sessionCleanupMode: readString(lastRemoved?.payload?.sessionCleanupMode),
+    readDebugLocator: readString(lastTerminal?.payload?.readDebugLocator) || readString(lastTerminal?.payload?.debugBundlePath)
+  };
+  if (finalSummary) {
+    return {
+      success: true,
+      compact: args.compact === true,
+      recoveredFromLedger: true,
+      nodeId: args.node_id,
+      sessionId: args.session_id,
+      summary: finalSummary,
+      ledger,
+      messages: [{ role: "assistant", content: finalSummary, isHistorical: true }]
+    };
+  }
+  return {
+    success: false,
+    recoverable: true,
+    code: "mesh_removed_node_transcript_unavailable",
+    error: `Node '${args.node_id}' is not a current member of mesh '${ctx.mesh.name}'.`,
+    nodeId: args.node_id,
+    sessionId: args.session_id,
+    providerSessionId,
+    reason: "node_not_in_current_mesh_snapshot",
+    ledger,
+    completedSessionSeenInLedger: ledger.taskCompletedFound,
+    lastDispatch: lastDispatch ? {
+      timestamp: lastDispatch.timestamp,
+      sessionId: lastDispatch.sessionId,
+      providerType: lastDispatch.providerType,
+      taskId: typeof lastDispatch.payload?.taskId === "string" ? lastDispatch.payload.taskId : void 0,
+      messagePreview: typeof lastDispatch.payload?.message === "string" ? lastDispatch.payload.message.slice(0, 500) : void 0
+    } : null,
+    lastTerminalEvent: lastTerminal ? {
+      kind: lastTerminal.kind,
+      timestamp: lastTerminal.timestamp,
+      sessionId: lastTerminal.sessionId,
+      providerType: lastTerminal.providerType,
+      taskId: typeof lastTerminal.payload?.taskId === "string" ? lastTerminal.payload.taskId : void 0,
+      payload: lastTerminal.payload
+    } : null,
+    nextSteps: [
+      providerSessionId ? `Retry mesh_read_chat with provider_session_id='${providerSessionId}' on a current live node for the same daemon if one exists.` : "If the node UI shows a provider transcript id, retry mesh_read_chat/mesh_read_debug with provider_session_id.",
+      "Use mesh_read_debug with the provider_session_id or daemon-side debug bundle locator if available.",
+      "Check mesh_task_history for task_completed and node_removed entries before redispatching; do not resend solely because transcript recovery failed.",
+      "If this node was removed with stop_and_delete, the runtime transcript may be gone; rely on the ledger summary/locator or ask the operator for the saved UI output."
+    ],
+    recoveryHints: [
+      "The worktree/node may have been removed or the mesh snapshot may be stale after task completion.",
+      "If you have a provider_session_id, retry mesh_read_chat with that value while targeting a live node for the same daemon if available.",
+      "Use mesh_read_debug with provider_session_id, or inspect the daemon/session-host history locator if the transcript has already been archived.",
+      "Avoid redispatching the same task solely because read_chat could not recover the transcript; check task_history and git status first."
+    ]
+  };
+}
+function annotateQueueStaleness(queue) {
+  const now = Date.now();
+  return queue.map((task) => {
+    const taskStatus = typeof task?.status === "string" ? task.status : void 0;
+    const annotated = {
+      ...task,
+      taskStatus,
+      dispatchedAt: task?.createdAt,
+      ...taskStatus === "assigned" ? { activeTaskId: task.id } : {},
+      ...taskStatus === "completed" || taskStatus === "failed" ? {
+        isHistorical: true,
+        completedAt: task.updatedAt
+      } : {}
+    };
+    if (taskStatus !== "assigned") return annotated;
+    const updatedAt = new Date(task.updatedAt).getTime();
+    const ageMs = Number.isFinite(updatedAt) ? now - updatedAt : null;
+    if (ageMs === null || ageMs < STALE_ASSIGNED_QUEUE_MS) return annotated;
+    return {
+      ...annotated,
+      stale: true,
+      staleAssigned: true,
+      staleReason: "assigned task has not reached a terminal state within 30 minutes",
+      assignedAgeMs: ageMs
+    };
+  });
+}
 function unwrapCommandPayload(value) {
   let current = value;
   const seen = /* @__PURE__ */ new Set();
@@ -57272,6 +57751,26 @@ function unwrapCommandPayload(value) {
   }
   return current;
 }
+function isTerminalSessionRecord(session) {
+  const status = typeof session?.status === "string" ? session.status.toLowerCase() : "";
+  const lifecycle = typeof session?.lifecycle === "string" ? session.lifecycle.toLowerCase() : "";
+  const state = typeof session?.state === "string" ? session.state.toLowerCase() : "";
+  return [status, lifecycle, state].some((value) => ["stopped", "failed", "terminated", "exited", "closed"].includes(value));
+}
+function isIdleSessionRecord(session) {
+  if (isTerminalSessionRecord(session)) return false;
+  const status = typeof session?.status === "string" ? session.status.toLowerCase() : "";
+  const chatStatus = typeof session?.activeChat?.status === "string" ? session.activeChat.status.toLowerCase() : "";
+  return status === "idle" || chatStatus === "waiting_input";
+}
+function chooseDispatchableSession(sessions, providerType, meshId, nodeId) {
+  const live = sessions.filter((session) => !isTerminalSessionRecord(session));
+  const matchingProvider = (session) => !providerType || session?.providerType === providerType || session?.cliType === providerType;
+  const meshSessions = live.filter(
+    (session) => session?.settings?.meshNodeFor === meshId || session?.settings?.meshNodeId === nodeId
+  );
+  return meshSessions.find((session) => isIdleSessionRecord(session) && matchingProvider(session)) || meshSessions.find(matchingProvider) || live.find((session) => isIdleSessionRecord(session) && matchingProvider(session)) || live.find(matchingProvider) || live.find(isIdleSessionRecord) || live[0];
+}
 function findNestedPayload(value, predicate) {
   const seen = /* @__PURE__ */ new Set();
   const stack = [{ payload: value, depth: 0 }];
@@ -57300,12 +57799,136 @@ function extractGitDiff(value) {
 function extractLaunchPayload(value) {
   return findNestedPayload(value, (payload) => Boolean(payload?.sessionId || payload?.id || payload?.runtimeSessionId));
 }
+function classifyMeshLaunchFailure(error48) {
+  const message = error48 instanceof Error ? error48.message : String(error48 || "launch failed");
+  const lower = message.toLowerCase();
+  if (lower.includes("p2p") || lower.includes("datachannel") || lower.includes("node-datachannel")) {
+    return { code: "p2p_unavailable", reason: "daemon_mesh_p2p_transport_unavailable", transport: "daemon_mesh_p2p" };
+  }
+  if (lower.includes("cannot connect to daemon ipc") || lower.includes("daemon ipc command")) {
+    return { code: "local_ipc_unavailable", reason: "local_daemon_ipc_unavailable", transport: "local_ipc" };
+  }
+  if (lower.includes("timed out") || lower.includes("timeout")) {
+    return { code: "mesh_transport_timeout", reason: "mesh_transport_timeout", transport: "mesh_transport" };
+  }
+  return { code: "mesh_launch_failed", reason: "provider_launch_failed", transport: "mesh_transport" };
+}
+function buildWorktreeCleanupHint(node) {
+  if (!node.isLocalWorktree) return void 0;
+  return {
+    tool: "mesh_remove_node",
+    args: { node_id: node.id, session_cleanup_mode: "preserve" },
+    hint: `If the worktree is no longer needed, remove the orphan worktree node with mesh_remove_node(node_id: "${node.id}").`
+  };
+}
+function buildRecoverableLaunchFailure(ctx, node, providerType, error48) {
+  const message = error48 instanceof Error ? error48.message : String(error48 || "launch failed");
+  const classified = classifyMeshLaunchFailure(error48);
+  const cleanup = buildWorktreeCleanupHint(node);
+  return {
+    success: false,
+    recoverable: true,
+    code: classified.code,
+    reason: classified.reason,
+    transport: classified.transport,
+    error: message,
+    meshId: ctx.mesh.id,
+    nodeId: node.id,
+    daemonId: node.daemonId,
+    workspace: node.workspace,
+    isLocalWorktree: node.isLocalWorktree === true,
+    worktreeBranch: node.worktreeBranch,
+    clonedFromNodeId: node.clonedFromNodeId,
+    ...providerType ? { resolvedProviderType: providerType } : {},
+    retryHint: `Retry mesh_launch_session(node_id: "${node.id}"${providerType ? `, type: "${providerType}"` : ""}) after daemon mesh transport/P2P is healthy.`,
+    ...cleanup ? { cleanup } : {},
+    nextStepHints: [
+      `Retry mesh_launch_session(node_id: "${node.id}"${providerType ? `, type: "${providerType}"` : ""}) after checking daemon/P2P health.`,
+      ...cleanup ? [`Cleanup orphan worktree node with mesh_remove_node(node_id: "${node.id}") if retry is not desired.`] : [],
+      "Run mesh_status to see the degraded reason and recovery hints before redispatching work."
+    ]
+  };
+}
+function recordRecoverableLaunchFailure(ctx, node, providerType, error48) {
+  const failure2 = buildRecoverableLaunchFailure(ctx, node, providerType, error48);
+  try {
+    appendLedgerEntry(ctx.mesh.id, {
+      kind: "recovery_attempted",
+      nodeId: node.id,
+      providerType,
+      payload: {
+        event: "session_launch_failed",
+        ...failure2
+      }
+    });
+  } catch {
+  }
+  return failure2;
+}
+function getLatestActiveLaunchFailure(meshId, nodeId) {
+  const entries = readLedgerEntries(meshId, { tail: 200 });
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    const entry = entries[i];
+    if (entry.nodeId !== nodeId) continue;
+    if (entry.kind === "session_launched" || entry.kind === "node_removed") return null;
+    if (entry.kind === "recovery_attempted" && entry.payload?.event === "session_launch_failed") {
+      return { timestamp: entry.timestamp, ...entry.payload };
+    }
+  }
+  return null;
+}
+async function ipcDispatchToRemoteAgent(ctx, node, args) {
+  const transport = ctx.transport;
+  const daemonId = node.daemonId;
+  let sessionId = args.session_id?.trim() || "";
+  const providerPriorityList = Array.isArray(node.policy?.providerPriority) ? node.policy.providerPriority : [];
+  let resolvedProviderType = args.providerType?.trim() || providerPriorityList[0] || "";
+  if (!sessionId) {
+    try {
+      const relayResult = await transport.meshCommand(daemonId, "get_status_metadata", {});
+      const innerResult = relayResult?.result ?? relayResult;
+      const statusObj = innerResult?.status ?? innerResult;
+      const sessions = Array.isArray(statusObj?.sessions) ? statusObj.sessions : [];
+      const targetSession = chooseDispatchableSession(sessions, resolvedProviderType, ctx.mesh.id, node.id);
+      if (targetSession?.id || targetSession?.sessionId) {
+        sessionId = targetSession.id || targetSession.sessionId;
+        if (!resolvedProviderType) {
+          resolvedProviderType = targetSession.providerType || targetSession.cliType || "";
+        }
+      }
+    } catch (e) {
+    }
+  }
+  if (!resolvedProviderType) {
+    return { success: false, error: `Cannot dispatch to remote node '${node.id}': providerType unknown. Set providerPriority on the node policy or call mesh_launch_session first.` };
+  }
+  try {
+    const dispatchResult = await transport.meshCommand(daemonId, "agent_command", {
+      ...sessionId ? { targetSessionId: sessionId } : {},
+      agentType: resolvedProviderType,
+      cliType: resolvedProviderType,
+      action: "send_chat",
+      message: args.message
+    });
+    const dispatchPayload = unwrapCommandPayload(dispatchResult);
+    if (dispatchPayload?.success === false || dispatchResult?.success === false) {
+      return { success: false, error: `P2P dispatch failed: ${dispatchPayload?.error || dispatchResult?.error || "agent_command rejected the task"}` };
+    }
+    return { success: true, dispatched: true, sessionId: sessionId || resolvedProviderType };
+  } catch (e) {
+    return { success: false, error: `P2P dispatch failed: ${e?.message || String(e)}` };
+  }
+}
 function resolveCoordinatorNode(ctx) {
   const preferredNodeId = typeof ctx.mesh.coordinator?.preferredNodeId === "string" ? ctx.mesh.coordinator.preferredNodeId.trim() : "";
   if (preferredNodeId) {
     const preferred = ctx.mesh.nodes.find((n) => n.id === preferredNodeId && typeof n.daemonId === "string" && n.daemonId.trim());
     if (preferred) return preferred;
   }
+  if (ctx.localMachineId) {
+    const byMachine = ctx.mesh.nodes.find((n) => n.machineId === ctx.localMachineId);
+    if (byMachine) return byMachine;
+  }
   if (ctx.localDaemonId) {
     return ctx.mesh.nodes.find((n) => n.daemonId === ctx.localDaemonId);
   }
@@ -57395,7 +58018,8 @@ function getNodeLaunchReadiness(node) {
   };
 }
 async function commandForNode(ctx, node, command, args = {}) {
-  if (ctx.transport instanceof IpcTransport && node.daemonId && node.daemonId !== ctx.localDaemonId) {
+  const isLocalNode = ctx.localMachineId && node.machineId === ctx.localMachineId || ctx.localDaemonId && node.daemonId === ctx.localDaemonId;
+  if (ctx.transport instanceof IpcTransport && node.daemonId && !isLocalNode) {
     return ctx.transport.meshCommand(node.daemonId, command, args);
   }
   if (isLocalTransport(ctx.transport)) {
@@ -57405,10 +58029,12 @@ async function commandForNode(ctx, node, command, args = {}) {
 }
 var MESH_STATUS_TOOL = {
   name: "mesh_status",
-  description: "Get the current status of all nodes in the repo mesh \u2014 health, git state, active sessions. Use this to decide which node to send work to.",
+  description: "Get the current status of all nodes in the repo mesh \u2014 health, git state, active sessions, recovery hints, and recommended next steps. Use this to decide which node to send work to or how to recover from failures.",
   inputSchema: {
     type: "object",
-    properties: {}
+    properties: {
+      _gemini_compat: { type: "string", description: "Dummy property for Gemini compatibility. Ignore this." }
+    }
   }
 };
 var MESH_LIST_NODES_TOOL = {
@@ -57416,7 +58042,9 @@ var MESH_LIST_NODES_TOOL = {
   description: "List all nodes in the mesh with their capabilities, platform, and workspace paths.",
   inputSchema: {
     type: "object",
-    properties: {}
+    properties: {
+      _gemini_compat: { type: "string", description: "Dummy property for Gemini compatibility. Ignore this." }
+    }
   }
 };
 var MESH_ENQUEUE_TASK_TOOL = {
@@ -57432,18 +58060,46 @@ var MESH_ENQUEUE_TASK_TOOL = {
 };
 var MESH_VIEW_QUEUE_TOOL = {
   name: "mesh_view_queue",
-  description: "View the current status of the mesh work queue (pending, assigned, completed, failed tasks).",
+  description: "View the current status of the mesh work queue (pending, assigned, completed, failed, cancelled tasks).",
   inputSchema: {
     type: "object",
     properties: {
       status: {
         type: "array",
         items: { type: "string" },
-        description: "Filter by task status: pending, assigned, completed, failed. Returns all if omitted."
+        description: "Filter by task status: pending, assigned, completed, failed, cancelled. Returns all if omitted."
       }
     }
   }
 };
+var MESH_QUEUE_CANCEL_TOOL = {
+  name: "mesh_queue_cancel",
+  description: "Cancel a pending/assigned/completed/failed mesh queue task without deleting audit history. Use this to retire stale queue items that target dead sessions.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      task_id: { type: "string", description: "Queue task ID to cancel." },
+      reason: { type: "string", description: "Optional operator-visible reason for cancellation." }
+    },
+    required: ["task_id"]
+  }
+};
+var MESH_QUEUE_REQUEUE_TOOL = {
+  name: "mesh_queue_requeue",
+  description: "Return a mesh queue task to pending for retry. By default clears stale assigned owner and target session so another live session can claim it.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      task_id: { type: "string", description: "Queue task ID to requeue." },
+      reason: { type: "string", description: "Optional operator-visible reason for requeueing." },
+      target_node_id: { type: "string", description: "Optional replacement target node ID." },
+      target_session_id: { type: "string", description: "Optional replacement target runtime session ID." },
+      clear_target_node: { type: "boolean", description: "When true, remove any existing target node constraint." },
+      keep_target_session: { type: "boolean", description: "When true, preserve an existing target session if target_session_id is not provided. Defaults false to avoid stale session targets." }
+    },
+    required: ["task_id"]
+  }
+};
 var MESH_SEND_TASK_TOOL = {
   name: "mesh_send_task",
   description: "Legacy push-based task assignment. Enqueues a task specifically targeted at a given node. The node will pull it immediately if idle.",
@@ -57613,6 +58269,8 @@ var ALL_MESH_TOOLS = [
   MESH_LIST_NODES_TOOL,
   MESH_ENQUEUE_TASK_TOOL,
   MESH_VIEW_QUEUE_TOOL,
+  MESH_QUEUE_CANCEL_TOOL,
+  MESH_QUEUE_REQUEUE_TOOL,
   MESH_SEND_TASK_TOOL,
   MESH_READ_CHAT_TOOL,
   MESH_READ_DEBUG_TOOL,
@@ -57630,6 +58288,7 @@ async function meshStatus(ctx) {
   await refreshMeshFromDaemon(ctx);
   const { mesh, transport } = ctx;
   const results = [];
+  const ledgerSummary = getLedgerSummary(mesh.id);
   for (const node of mesh.nodes) {
     const entry = {
       nodeId: node.id,
@@ -57663,6 +58322,45 @@ async function meshStatus(ctx) {
       entry.health = "degraded";
       entry.error = e.message;
     }
+    const recoveryContext = getSessionRecoveryContext(mesh.id, { nodeId: node.id });
+    if (recoveryContext.consecutiveNodeFailures > 0) {
+      entry.recoveryHints = {
+        consecutiveFailures: recoveryContext.consecutiveNodeFailures,
+        lastTaskMessage: recoveryContext.lastTaskMessage,
+        advice: recoveryContext.advice,
+        retryRecommended: recoveryContext.retryRecommended
+      };
+    }
+    const activeLaunchFailure = getLatestActiveLaunchFailure(mesh.id, node.id);
+    if (activeLaunchFailure && node.isLocalWorktree) {
+      entry.health = "degraded";
+      entry.degradedReason = "worktree_launch_failed";
+      entry.launchReady = false;
+      entry.launchBlockedReason = activeLaunchFailure.code || "mesh_launch_failed";
+      entry.launchBlockedMessage = activeLaunchFailure.error || "Previous worktree session launch failed";
+      entry.lastLaunchFailure = activeLaunchFailure;
+    }
+    const nextStepHints = [];
+    if (entry.degradedReason === "worktree_launch_failed") {
+      nextStepHints.push(`Retry mesh_launch_session(node_id: "${node.id}") after daemon mesh transport/P2P is healthy.`);
+      nextStepHints.push(`If retry is not desired, cleanup the orphan worktree node with mesh_remove_node(node_id: "${node.id}").`);
+    } else if (entry.health === "online" && node.isLocalWorktree) {
+      nextStepHints.push(`Merge worktree to base via mesh_refine_node(node_id: "${node.id}")`);
+    } else if (entry.health === "dirty") {
+      nextStepHints.push(`Commit changes via mesh_checkpoint(node_id: "${node.id}", message: "...")`);
+    } else if (entry.health === "degraded" && entry.error?.includes("git")) {
+      nextStepHints.push("Initialize git repository or check workspace path.");
+    }
+    if (recoveryContext.consecutiveNodeFailures > 0) {
+      if (recoveryContext.retryRecommended) {
+        nextStepHints.push(`Retry task on this node or launch a fresh session.`);
+      } else {
+        nextStepHints.push(`Consider reassigning work to a different node.`);
+      }
+    }
+    if (nextStepHints.length > 0) {
+      entry.nextStepHints = nextStepHints;
+    }
     const relatedRepos = await collectRelatedRepoStatuses(ctx, node);
     if (relatedRepos.length) entry.relatedRepos = relatedRepos;
     results.push(entry);
@@ -57676,7 +58374,7 @@ async function meshStatus(ctx) {
     nodes: results
   };
   try {
-    response.ledgerSummary = getLedgerSummary(mesh.id);
+    response.ledgerSummary = ledgerSummary;
   } catch {
   }
   if (ctx.transport instanceof IpcTransport) {
@@ -57720,12 +58418,38 @@ async function meshListNodes(ctx) {
 async function meshEnqueueTask(ctx, args) {
   try {
     const task = enqueueTask(ctx.mesh.id, args.message);
-    if (ctx.transport instanceof IpcTransport && ctx.localDaemonId) {
-      ctx.transport.meshCommand(ctx.localDaemonId, "trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
+    if (isLocalTransport(ctx.transport) && !(ctx.transport instanceof IpcTransport)) {
+      ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
       });
-    } else if (isLocalTransport(ctx.transport)) {
+      return JSON.stringify({ success: true, taskId: task.id, status: task.status });
+    }
+    if (ctx.transport instanceof IpcTransport) {
       ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
       });
+      const dispatchPromises = [];
+      for (const node of ctx.mesh.nodes) {
+        const isLocalNode = ctx.localMachineId && node.machineId === ctx.localMachineId || ctx.localDaemonId && node.daemonId === ctx.localDaemonId;
+        if (isLocalNode || !node.daemonId) continue;
+        dispatchPromises.push(
+          ipcDispatchToRemoteAgent(ctx, node, { message: args.message }).then((result) => {
+            if (result.success) {
+              try {
+                appendLedgerEntry(ctx.mesh.id, {
+                  kind: "task_dispatched",
+                  nodeId: node.id,
+                  sessionId: result.sessionId,
+                  payload: { message: args.message, via: "p2p_direct", taskId: task.id }
+                });
+              } catch {
+              }
+            }
+          }).catch(() => {
+          })
+        );
+      }
+      Promise.all(dispatchPromises).catch(() => {
+      });
+      return JSON.stringify({ success: true, taskId: task.id, status: task.status });
     }
     return JSON.stringify({ success: true, taskId: task.id, status: task.status });
   } catch (e) {
@@ -57734,8 +58458,51 @@ async function meshEnqueueTask(ctx, args) {
 }
 async function meshViewQueue(ctx, args) {
   try {
-    const queue = getQueue(ctx.mesh.id, { status: args.status });
-    return JSON.stringify({ success: true, queue }, null, 2);
+    const queue = annotateQueueStaleness(getQueue(ctx.mesh.id, { status: args.status }));
+    const staleAssignedTasks = queue.filter((task) => task?.status === "assigned" && task?.staleAssigned);
+    return JSON.stringify({
+      success: true,
+      queue,
+      staleAssignedTasks,
+      staleAssignedCount: staleAssignedTasks.length,
+      // Back-compat alias for callers already reading the first hardening payload.
+      staleAssignments: staleAssignedTasks
+    }, null, 2);
+  } catch (e) {
+    return JSON.stringify({ success: false, error: e.message });
+  }
+}
+async function meshQueueCancel(ctx, args) {
+  try {
+    const taskId = (args.task_id || args.taskId || "").trim();
+    if (!taskId) return JSON.stringify({ success: false, error: "task_id required" });
+    const task = cancelTask(ctx.mesh.id, taskId, { reason: args.reason });
+    if (!task) return JSON.stringify({ success: false, error: `Queue task '${taskId}' not found` });
+    return JSON.stringify({ success: true, task }, null, 2);
+  } catch (e) {
+    return JSON.stringify({ success: false, error: e.message });
+  }
+}
+async function meshQueueRequeue(ctx, args) {
+  try {
+    const taskId = (args.task_id || args.taskId || "").trim();
+    if (!taskId) return JSON.stringify({ success: false, error: "task_id required" });
+    const targetNodeId = (args.target_node_id || args.targetNodeId || "").trim() || void 0;
+    const targetSessionId = (args.target_session_id || args.targetSessionId || "").trim() || void 0;
+    const keepTargetSession = args.keep_target_session === true || args.keepTargetSession === true;
+    const task = requeueTask(ctx.mesh.id, taskId, {
+      reason: args.reason,
+      targetNodeId,
+      targetSessionId,
+      clearTargetNode: args.clear_target_node === true || args.clearTargetNode === true,
+      clearTargetSession: targetSessionId ? false : !keepTargetSession
+    });
+    if (!task) return JSON.stringify({ success: false, error: `Queue task '${taskId}' not found` });
+    if (isLocalTransport(ctx.transport)) {
+      ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
+      });
+    }
+    return JSON.stringify({ success: true, task }, null, 2);
   } catch (e) {
     return JSON.stringify({ success: false, error: e.message });
   }
@@ -57745,6 +58512,24 @@ async function meshSendTask(ctx, args) {
   if (node.policy?.readOnly) {
     return JSON.stringify({ error: `Node '${args.node_id}' is read-only` });
   }
+  const duplicate = hasRecentDuplicateDispatch(ctx, args);
+  if (duplicate.duplicate) {
+    return JSON.stringify({
+      success: true,
+      duplicate: true,
+      dispatched: false,
+      warning: "Duplicate mesh_send_task suppressed: the same node/session/message was dispatched recently.",
+      nodeId: args.node_id,
+      sessionId: args.session_id,
+      source: duplicate.source,
+      previousDispatch: duplicate.entry ? {
+        id: duplicate.entry.id,
+        timestamp: duplicate.entry.timestamp || duplicate.entry.updatedAt || duplicate.entry.createdAt,
+        nodeId: duplicate.entry.nodeId || duplicate.entry.targetNodeId || duplicate.entry.assignedNodeId,
+        sessionId: duplicate.entry.sessionId || duplicate.entry.targetSessionId || duplicate.entry.assignedSessionId
+      } : void 0
+    });
+  }
   try {
     if (!isLocalTransport(ctx.transport) && node.daemonId) {
       const res = await ctx.transport.meshEnqueueTask(node.daemonId, {
@@ -57754,11 +58539,66 @@ async function meshSendTask(ctx, args) {
       });
       return JSON.stringify(res);
     }
-    const task = enqueueTask(ctx.mesh.id, args.message, { targetNodeId: args.node_id });
-    if (ctx.transport instanceof IpcTransport && node.daemonId && node.daemonId !== ctx.localDaemonId) {
-      ctx.transport.meshCommand(node.daemonId, "trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
+    const isLocalNode = ctx.localMachineId && node.machineId === ctx.localMachineId || ctx.localDaemonId && node.daemonId === ctx.localDaemonId;
+    if (ctx.transport instanceof IpcTransport && node.daemonId && !isLocalNode) {
+      const cached2 = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id || ""));
+      const result = await ipcDispatchToRemoteAgent(ctx, node, {
+        session_id: args.session_id,
+        message: args.message,
+        providerType: cached2?.providerType
       });
-    } else if (isLocalTransport(ctx.transport)) {
+      if (result.success) {
+        const dispatchedSessionId = args.session_id || result.sessionId;
+        try {
+          appendLedgerEntry(ctx.mesh.id, {
+            kind: "task_dispatched",
+            nodeId: args.node_id,
+            sessionId: dispatchedSessionId,
+            payload: {
+              message: args.message,
+              via: "p2p_direct",
+              ...dispatchedSessionId ? { targetSessionId: dispatchedSessionId } : {}
+            }
+          });
+        } catch {
+        }
+      }
+      return JSON.stringify({ ...result, nodeId: args.node_id, dispatched: result.success === true });
+    }
+    if (args.session_id && isLocalTransport(ctx.transport)) {
+      const cached2 = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id));
+      const dispatchResult = await commandForNode(ctx, node, "agent_command", {
+        targetSessionId: args.session_id,
+        ...cached2?.providerType ? { agentType: cached2.providerType, cliType: cached2.providerType, providerType: cached2.providerType } : {},
+        action: "send_chat",
+        message: args.message
+      });
+      const dispatchPayload = unwrapCommandPayload(dispatchResult);
+      if (dispatchPayload?.success === false || dispatchResult?.success === false) {
+        return JSON.stringify({
+          success: false,
+          nodeId: args.node_id,
+          sessionId: args.session_id,
+          error: dispatchPayload?.error || dispatchResult?.error || "agent_command rejected the task"
+        });
+      }
+      try {
+        appendLedgerEntry(ctx.mesh.id, {
+          kind: "task_dispatched",
+          nodeId: args.node_id,
+          sessionId: args.session_id,
+          providerType: cached2?.providerType,
+          payload: { message: args.message, via: "local_direct" }
+        });
+      } catch {
+      }
+      return JSON.stringify({ success: true, dispatched: true, nodeId: args.node_id, sessionId: args.session_id });
+    }
+    const task = enqueueTask(ctx.mesh.id, args.message, {
+      targetNodeId: args.node_id,
+      targetSessionId: args.session_id
+    });
+    if (isLocalTransport(ctx.transport) || ctx.transport instanceof IpcTransport) {
       ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
       });
     }
@@ -57768,7 +58608,10 @@ async function meshSendTask(ctx, args) {
   }
 }
 async function meshReadChat(ctx, args) {
-  const node = await findNodeWithRefresh(ctx, args.node_id);
+  const node = await findOptionalNodeWithRefresh(ctx, args.node_id);
+  if (!node) {
+    return JSON.stringify(buildMissingNodeReadChatRecovery(ctx, args), null, 2);
+  }
   if (isLocalTransport(ctx.transport)) {
     const cached2 = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id));
     const providerSessionId = typeof args.provider_session_id === "string" && args.provider_session_id.trim() ? args.provider_session_id.trim() : cached2?.providerSessionId;
@@ -57871,19 +58714,28 @@ async function meshLaunchSession(ctx, args) {
     const coordinatorNode = resolveCoordinatorNode(ctx);
     const coordinatorDaemonId = coordinatorNode?.daemonId || ctx.localDaemonId;
     const spawnedSessionVisibility = readSpawnedSessionVisibility(ctx.mesh.policy);
-    const result = await commandForNode(ctx, node, "launch_cli", {
-      cliType: resolvedProviderType,
-      dir: node.workspace,
-      settings: {
-        meshNodeFor: ctx.mesh.id,
-        meshNodeId: args.node_id,
-        spawnedSessionVisibility,
-        ...coordinatorDaemonId ? { meshCoordinatorDaemonId: coordinatorDaemonId } : {},
-        ...coordinatorNode?.id ? { meshCoordinatorNodeId: coordinatorNode.id } : {},
-        launchedByCoordinator: true
-      }
-    });
+    let result;
+    try {
+      result = await commandForNode(ctx, node, "launch_cli", {
+        cliType: resolvedProviderType,
+        dir: node.workspace,
+        settings: {
+          meshNodeFor: ctx.mesh.id,
+          meshNodeId: args.node_id,
+          spawnedSessionVisibility,
+          ...coordinatorDaemonId ? { meshCoordinatorDaemonId: coordinatorDaemonId } : {},
+          ...coordinatorNode?.id ? { meshCoordinatorNodeId: coordinatorNode.id } : {},
+          launchedByCoordinator: true
+        }
+      });
+    } catch (e) {
+      return JSON.stringify(recordRecoverableLaunchFailure(ctx, node, resolvedProviderType, e), null, 2);
+    }
     const launchPayload = extractLaunchPayload(result);
+    if (launchPayload?.success === false || result?.success === false) {
+      const launchError = new Error(launchPayload?.error || result?.error || "launch_cli rejected the session launch");
+      return JSON.stringify(recordRecoverableLaunchFailure(ctx, node, resolvedProviderType, launchError), null, 2);
+    }
     const runtimeSessionId = typeof launchPayload?.sessionId === "string" ? launchPayload.sessionId : typeof launchPayload?.id === "string" ? launchPayload.id : typeof launchPayload?.runtimeSessionId === "string" ? launchPayload.runtimeSessionId : "";
     const providerSessionId = typeof launchPayload?.providerSessionId === "string" && launchPayload.providerSessionId.trim() ? launchPayload.providerSessionId.trim() : void 0;
     if (runtimeSessionId) {
@@ -57902,7 +58754,8 @@ async function meshLaunchSession(ctx, args) {
       });
     } catch {
     }
-    if (ctx.transport instanceof IpcTransport && node.daemonId && node.daemonId !== ctx.localDaemonId) {
+    const isLocalNode = ctx.localMachineId && node.machineId === ctx.localMachineId || ctx.localDaemonId && node.daemonId === ctx.localDaemonId;
+    if (ctx.transport instanceof IpcTransport && node.daemonId && !isLocalNode) {
       ctx.transport.meshCommand(node.daemonId, "trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
       });
     } else if (isLocalTransport(ctx.transport)) {
@@ -57952,7 +58805,7 @@ async function meshLaunchSession(ctx, args) {
       }
       return JSON.stringify({ ...res, resolvedProviderType }, null, 2);
     } catch (e) {
-      return JSON.stringify({ success: false, error: e.message });
+      return JSON.stringify(recordRecoverableLaunchFailure(ctx, node, resolvedProviderType, e), null, 2);
     }
   } else {
     return JSON.stringify({ error: "Cloud mesh launch_session requires node daemonId" });
@@ -59840,6 +60693,15 @@ async function startMcpServer(opts) {
       process.exit(1);
     }
     let localDaemonId;
+    let localMachineId;
+    if (transport instanceof LocalTransport || transport instanceof IpcTransport) {
+      try {
+        const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_dist2(), dist_exports));
+        const cfg = loadConfig2();
+        if (cfg.registeredMachineId) localMachineId = cfg.registeredMachineId;
+      } catch {
+      }
+    }
     if (transport instanceof IpcTransport) {
       try {
         const statusResult = await transport.getStatus();
@@ -59848,7 +60710,7 @@ async function startMcpServer(opts) {
       } catch {
       }
     }
-    const meshCtx = { mesh, transport, ...localDaemonId ? { localDaemonId } : {} };
+    const meshCtx = { mesh, transport, ...localDaemonId ? { localDaemonId } : {}, ...localMachineId ? { localMachineId } : {} };
     const coordinatorPrompt = await buildMeshModeCoordinatorPrompt(mesh);
     const server2 = new import_server.Server(
       { name: "adhdev-mcp-server", version: "0.9.76" },
@@ -59888,6 +60750,12 @@ async function startMcpServer(opts) {
           case "mesh_view_queue":
             text = await meshViewQueue(meshCtx, a);
             break;
+          case "mesh_queue_cancel":
+            text = await meshQueueCancel(meshCtx, a);
+            break;
+          case "mesh_queue_requeue":
+            text = await meshQueueRequeue(meshCtx, a);
+            break;
           case "mesh_send_task":
             text = await meshSendTask(meshCtx, a);
             break;