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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-standalone",
-  "version": "0.9.77-rc.33",
+  "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) {
@@ -41350,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
     });
@@ -53146,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() : "";
@@ -57722,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.",
@@ -57903,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,
@@ -58084,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) {
@@ -60292,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;