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

package/package.json

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

package/vendor/mcp-server/index.js

@@ -26312,10 +26312,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) {
@@ -57489,6 +57491,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 +57551,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 +57565,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)}` };
@@ -58099,6 +58119,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