adhdev 0.9.82-rc.21 → 0.9.82-rc.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adhdev",
-  "version": "0.9.82-rc.21",
+  "version": "0.9.82-rc.22",
   "description": "ADHDev — Agent Dashboard Hub for Dev. Remote-control AI coding agents from anywhere.",
   "main": "dist/index.js",
   "bin": {
@@ -47,7 +47,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@adhdev/daemon-core": "0.9.82-rc.21",
+    "@adhdev/daemon-core": "0.9.82-rc.22",
     "@adhdev/ghostty-vt-node": "*",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "@xterm/addon-serialize": "^0.14.0",

package/vendor/mcp-server/index.js

@@ -404,6 +404,14 @@ function buildMissingNodeReadChatRecovery(ctx, args) {
 function readSessionRecordId(session) {
   return readString(session?.id) || readString(session?.sessionId) || readString(session?.session_id) || readString(session?.runtimeSessionId) || readString(session?.runtime_session_id) || readString(session?.instanceId) || readString(session?.instance_id);
 }
+function extractStatusMetadataSessions(value) {
+  const payload = unwrapCommandPayload(value);
+  const status = payload?.status && typeof payload.status === "object" ? payload.status : payload;
+  return Array.isArray(status?.sessions) ? status.sessions : [];
+}
+function resolveSessionProviderType(session) {
+  return readString(session?.providerType) || readString(session?.cliType) || readString(session?.agentType) || "";
+}
 function addSessionRecord(target, session) {
   if (!session || typeof session !== "object" || isTerminalSessionRecord(session)) return;
   const sessionId = readSessionRecordId(session);
@@ -616,22 +624,59 @@ function isIdleSessionRecord(session) {
   const chatStatus = typeof session?.activeChat?.status === "string" ? session.activeChat.status.toLowerCase() : "";
   return status === "idle" || chatStatus === "waiting_input";
 }
+function isMeshOwnedDelegateSession(session, meshId, nodeId) {
+  const settings = session?.settings;
+  const sessionMeshId = typeof settings?.meshNodeFor === "string" ? settings.meshNodeFor.trim() : "";
+  const coordinatorDaemonId = typeof settings?.meshCoordinatorDaemonId === "string" ? settings.meshCoordinatorDaemonId.trim() : "";
+  const sessionNodeId = typeof settings?.meshNodeId === "string" ? settings.meshNodeId.trim() : "";
+  if (sessionMeshId !== meshId || !coordinatorDaemonId) return false;
+  return !sessionNodeId || sessionNodeId === nodeId;
+}
 function chooseDispatchableSession(sessions, providerType, meshId, nodeId) {
   const live = sessions.filter((session) => !isTerminalSessionRecord(session));
   const matchingProvider = (session) => !providerType || session?.providerType === providerType || session?.cliType === providerType;
-  const isMeshOwnedDelegateSession = (session) => {
-    const settings = session?.settings;
-    const sessionMeshId = typeof settings?.meshNodeFor === "string" ? settings.meshNodeFor.trim() : "";
-    const coordinatorDaemonId = typeof settings?.meshCoordinatorDaemonId === "string" ? settings.meshCoordinatorDaemonId.trim() : "";
-    const sessionNodeId = typeof settings?.meshNodeId === "string" ? settings.meshNodeId.trim() : "";
-    if (sessionMeshId !== meshId || !coordinatorDaemonId) return false;
-    return !sessionNodeId || sessionNodeId === nodeId;
-  };
   const meshSessions = live.filter(
-    (session) => isMeshOwnedDelegateSession(session)
+    (session) => isMeshOwnedDelegateSession(session, meshId, nodeId)
   );
   return meshSessions.find((session) => isIdleSessionRecord(session) && matchingProvider(session)) || meshSessions.find(matchingProvider) || void 0;
 }
+function buildRelayUnsafeRemoteSessionFailure(ctx, node, sessionId, providerType) {
+  return {
+    success: false,
+    recoverable: true,
+    code: "mesh_delegate_session_missing_relay_metadata",
+    reason: "mesh_delegate_session_missing_relay_metadata",
+    transport: "mesh_transport",
+    retryRecommended: true,
+    meshId: ctx.mesh.id,
+    nodeId: node.id,
+    daemonId: node.daemonId,
+    workspace: node.workspace,
+    sessionId,
+    ...providerType ? { resolvedProviderType: providerType } : {},
+    error: `Remote session '${sessionId}' is not relay-safe for mesh '${ctx.mesh.id}': missing meshNodeFor/meshCoordinatorDaemonId metadata, so completion events would not reach the coordinator ledger.`,
+    nextAction: `Launch a fresh relay-safe session with mesh_launch_session(node_id: '${node.id}'${providerType ? `, type: '${providerType}'` : ""}) or dispatch without session_id so Repo Mesh can choose a valid delegate session.`,
+    noFallbackReason: "Blindly reusing a remote session without mesh relay metadata would silently drop task_completed / generating_completed events."
+  };
+}
+function buildMissingCoordinatorDaemonIdFailure(ctx, node, providerType) {
+  return {
+    success: false,
+    recoverable: true,
+    code: "mesh_coordinator_daemon_unknown",
+    reason: "mesh_coordinator_daemon_unknown",
+    transport: "mesh_transport",
+    retryRecommended: true,
+    meshId: ctx.mesh.id,
+    nodeId: node.id,
+    daemonId: node.daemonId,
+    workspace: node.workspace,
+    ...providerType ? { resolvedProviderType: providerType } : {},
+    error: `Cannot launch a remote mesh delegate for node '${node.id}': coordinator daemon identity is unavailable, so the worker would be unable to relay completion events back to the coordinator.`,
+    nextAction: "Retry after the coordinator daemon identity is available (for example from an attached daemon-backed MCP session) so meshCoordinatorDaemonId can be stamped on the worker session.",
+    noFallbackReason: "Launching without meshCoordinatorDaemonId would create a worker session that can finish work but cannot emit task_completed / generating_completed back to the coordinator."
+  };
+}
 function findNestedPayload(value, predicate) {
   const seen = /* @__PURE__ */ new Set();
   const stack = [{ payload: value, depth: 0 }];
@@ -789,20 +834,63 @@ async function ipcDispatchToRemoteAgent(ctx, node, args) {
   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) {
+  if (!sessionId || args.session_id) {
     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;
+      const sessions = extractStatusMetadataSessions(relayResult);
+      if (sessionId) {
+        const explicitSession = sessions.find((session) => readSessionRecordId(session) === sessionId);
+        if (!explicitSession) {
+          return {
+            success: false,
+            recoverable: true,
+            code: "mesh_target_session_not_found",
+            reason: "mesh_target_session_not_found",
+            transport: "mesh_transport",
+            retryRecommended: true,
+            meshId: ctx.mesh.id,
+            nodeId: node.id,
+            daemonId,
+            workspace: node.workspace,
+            sessionId,
+            ...resolvedProviderType ? { resolvedProviderType } : {},
+            error: `Remote session '${sessionId}' is not present in the live status for node '${node.id}'.`,
+            nextAction: `Launch a fresh session with mesh_launch_session(node_id: '${node.id}'${resolvedProviderType ? `, type: '${resolvedProviderType}'` : ""}) or retry without session_id so Repo Mesh can target a live delegate session.`
+          };
+        }
+        if (!isMeshOwnedDelegateSession(explicitSession, ctx.mesh.id, node.id)) {
+          return buildRelayUnsafeRemoteSessionFailure(
+            ctx,
+            node,
+            sessionId,
+            resolvedProviderType || resolveSessionProviderType(explicitSession) || void 0
+          );
+        }
         if (!resolvedProviderType) {
-          resolvedProviderType = targetSession.providerType || targetSession.cliType || "";
+          resolvedProviderType = resolveSessionProviderType(explicitSession);
+        }
+      } else {
+        const targetSession = chooseDispatchableSession(sessions, resolvedProviderType, ctx.mesh.id, node.id);
+        if (targetSession?.id || targetSession?.sessionId) {
+          sessionId = targetSession.id || targetSession.sessionId;
+          if (!resolvedProviderType) {
+            resolvedProviderType = resolveSessionProviderType(targetSession);
+          }
         }
       }
     } catch (e) {
+      if (sessionId) {
+        return {
+          ...buildCoordinatorP2pRelayFailure(e, {
+            command: "get_status_metadata",
+            targetDaemonId: daemonId,
+            nodeId: node.id,
+            sessionId
+          }),
+          success: false,
+          error: `Cannot verify remote session '${sessionId}' before dispatch: ${e?.message || String(e)}`
+        };
+      }
     }
   }
   if (!resolvedProviderType) {
@@ -1901,9 +1989,52 @@ async function meshSendTask(ctx, args) {
     }
     if (args.session_id && isLocalTransport(ctx.transport)) {
       const cached = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id));
+      let resolvedProviderType = cached?.providerType || "";
+      if (!resolvedProviderType) {
+        const statusResult = await commandForNode(ctx, node, "get_status_metadata", {});
+        const sessions = extractStatusMetadataSessions(statusResult);
+        const explicitSession = sessions.find((session) => readSessionRecordId(session) === args.session_id);
+        if (!explicitSession) {
+          return JSON.stringify({
+            success: false,
+            recoverable: true,
+            code: "mesh_target_session_not_found",
+            reason: "mesh_target_session_not_found",
+            transport: "local_ipc",
+            retryRecommended: true,
+            nodeId: args.node_id,
+            sessionId: args.session_id,
+            error: `Local session '${args.session_id}' is not present in live status for node '${args.node_id}'.`,
+            nextAction: `Launch a fresh session with mesh_launch_session(node_id: '${args.node_id}') or retry without session_id so Repo Mesh can target a live delegate session.`
+          });
+        }
+        resolvedProviderType = resolveSessionProviderType(explicitSession);
+        if (resolvedProviderType) {
+          meshSessionProviderMetadata.set(meshSessionCacheKey(args.node_id, args.session_id), {
+            providerType: resolvedProviderType,
+            providerSessionId: readString(explicitSession?.providerSessionId) || void 0
+          });
+        }
+      }
+      if (!resolvedProviderType) {
+        return JSON.stringify({
+          success: false,
+          recoverable: true,
+          code: "mesh_target_session_provider_unknown",
+          reason: "mesh_target_session_provider_unknown",
+          transport: "local_ipc",
+          retryRecommended: false,
+          nodeId: args.node_id,
+          sessionId: args.session_id,
+          error: `Local session '${args.session_id}' is live but does not expose providerType/cliType, so agent_command cannot be routed safely.`,
+          nextAction: `Relaunch the target session on node '${args.node_id}' or retry without session_id so Repo Mesh can pick a session with provider metadata.`
+        });
+      }
       const dispatchResult = await commandForNode(ctx, node, "agent_command", {
         targetSessionId: args.session_id,
-        ...cached?.providerType ? { agentType: cached.providerType, cliType: cached.providerType, providerType: cached.providerType } : {},
+        agentType: resolvedProviderType,
+        cliType: resolvedProviderType,
+        providerType: resolvedProviderType,
         action: "send_chat",
         message: args.message
       });
@@ -1921,7 +2052,7 @@ async function meshSendTask(ctx, args) {
           kind: "task_dispatched",
           nodeId: args.node_id,
           sessionId: args.session_id,
-          providerType: cached?.providerType,
+          providerType: resolvedProviderType,
           payload: { message: args.message, via: "local_direct" }
         });
       } catch {
@@ -2062,6 +2193,10 @@ async function meshLaunchSession(ctx, args) {
     const coordinatorNode = resolveCoordinatorNode(ctx);
     const coordinatorDaemonId = coordinatorNode?.daemonId || ctx.localDaemonId;
     const spawnedSessionVisibility = readSpawnedSessionVisibility(ctx.mesh.policy);
+    const isLocalNode = isLocalControlPlaneNode(ctx, node);
+    if (node.daemonId && !isLocalNode && !coordinatorDaemonId) {
+      return JSON.stringify(buildMissingCoordinatorDaemonIdFailure(ctx, node, resolvedProviderType), null, 2);
+    }
     let result;
     try {
       result = await commandForNode(ctx, node, "launch_cli", {
@@ -2102,7 +2237,6 @@ async function meshLaunchSession(ctx, args) {
       });
     } catch {
     }
-    const isLocalNode = isLocalControlPlaneNode(ctx, node);
     if (ctx.transport instanceof IpcTransport && node.daemonId && !isLocalNode) {
       ctx.transport.meshCommand(node.daemonId, "trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
       });
@@ -2127,6 +2261,9 @@ async function meshLaunchSession(ctx, args) {
     const coordinatorNode = resolveCoordinatorNode(ctx);
     const coordinatorDaemonId = coordinatorNode?.daemonId || ctx.localDaemonId;
     const spawnedSessionVisibility = readSpawnedSessionVisibility(ctx.mesh.policy);
+    if (!coordinatorDaemonId) {
+      return JSON.stringify(buildMissingCoordinatorDaemonIdFailure(ctx, node, resolvedProviderType), null, 2);
+    }
     try {
       const res = await ctx.transport.launch(node.daemonId, {
         type: resolvedProviderType,