@adhdev/daemon-standalone 0.9.77-rc.32 → 0.9.77-rc.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-standalone",
-  "version": "0.9.77-rc.32",
+  "version": "0.9.77-rc.34",
   "description": "ADHDev standalone daemon — embedded HTTP/WS server for local dashboard",
   "main": "dist/index.js",
   "bin": {

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,
@@ -25231,6 +25232,7 @@ __export(dist_exports, {
   registerExtensionProviders: () => registerExtensionProviders,
   removeNode: () => removeNode,
   removeWorktree: () => removeWorktree,
+  requeueTask: () => requeueTask,
   resetConfig: () => resetConfig,
   resetDebugRuntimeConfig: () => resetDebugRuntimeConfig,
   resetState: () => resetState,
@@ -26074,6 +26076,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--) {
@@ -26092,7 +26128,8 @@ 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
   };
 }
 function setLogLevel(level) {
@@ -26312,10 +26349,12 @@ function triggerMeshQueue(components, meshId) {
     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) {
@@ -41348,10 +41387,12 @@ Follow these recovery rules:
     });
     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
     });
@@ -53144,6 +53185,39 @@ Run 'adhdev doctor' for detailed diagnostics.`
               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() : "";
@@ -57489,6 +57563,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 }];
@@ -57529,18 +57623,12 @@ async function ipcDispatchToRemoteAgent(ctx, node, args) {
       const innerResult = relayResult?.result ?? relayResult;
       const statusObj = innerResult?.status ?? innerResult;
       const sessions = Array.isArray(statusObj?.sessions) ? statusObj.sessions : [];
-      const meshSessions = sessions.filter(
-        (s) => s?.settings?.meshNodeFor === ctx.mesh.id || s?.settings?.meshNodeId === node.id || s?.settings?.launchedByCoordinator === true
-      );
-      const targetSession = meshSessions[0] || sessions.find(
-        (s) => !resolvedProviderType || s?.providerType === resolvedProviderType || s?.cliType === resolvedProviderType
-      ) || sessions[0];
+      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 || "";
         }
-      } else {
       }
     } catch (e) {
     }
@@ -57549,13 +57637,17 @@ async function ipcDispatchToRemoteAgent(ctx, node, args) {
     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 {
-    await transport.meshCommand(daemonId, "agent_command", {
+    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)}` };
@@ -57702,18 +57794,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.",
@@ -57883,6 +58003,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,
@@ -58064,6 +58186,41 @@ async function meshViewQueue(ctx, args) {
     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 });
+  }
+}
 async function meshSendTask(ctx, args) {
   const node = await findNodeWithRefresh(ctx, args.node_id);
   if (node.policy?.readOnly) {
@@ -58099,6 +58256,35 @@ async function meshSendTask(ctx, args) {
       }
       return JSON.stringify({ ...result, nodeId: args.node_id });
     }
+    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
@@ -60243,6 +60429,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;