@adhdev/daemon-standalone 0.9.82-rc.121 → 0.9.82-rc.123

package/public/index.html

@@ -7,7 +7,7 @@
     <meta name="description" content="ADHDev self-hosted dashboard for controlling AI agents" />
     <link rel="icon" href="/otter-logo.png" />
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap" rel="stylesheet" />
-  <script type="module" crossorigin src="/assets/index-BKsjvBcH.js"></script>
+  <script type="module" crossorigin src="/assets/index--3Wc6sJr.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/vendor-CgiI0UIA.js">
   <link rel="stylesheet" crossorigin href="/assets/index-xSlc1ntZ.css">
 </head>

package/vendor/mcp-server/index.js

@@ -275,8 +275,8 @@ function buildActiveWorkPollingGuidance(summary, now = Date.now()) {
     generatingCount: summary.generatingCount,
     doNotPollBefore: new Date(now + ACTIVE_WORK_POLLING_BACKOFF_MS).toISOString(),
     eventSurface: "pendingCoordinatorEvents",
-    nextRecommendedAction: "Wait for pendingCoordinatorEvents/completion events or an explicit user status request. After a terminal signal, call mesh_read_chat once with compact=true, then verify git state if repository changes were expected.",
-    message: "Do not repeatedly poll mesh_status/mesh_view_queue/mesh_read_chat while delegated work is generating; these snapshots rarely change until the worker emits a completion/status event."
+    nextRecommendedAction: "Wait for pendingCoordinatorEvents/completion events or an explicit user status request. If no terminal evidence appears and the user asks for status, make one bounded status check, then wait again.",
+    message: "Do not repeatedly poll mesh_status/mesh_view_queue/mesh_read_chat while delegated work is generating; terminal ledger or completion evidence will be surfaced through pendingCoordinatorEvents when available."
   };
 }
 function readString(value) {
@@ -478,6 +478,17 @@ function isMeshCoordinatorSessionRecord(session) {
     readString(session?.settings?.meshCoordinatorFor) || readString(session?.meta?.meshCoordinatorFor) || readString(session?.metadata?.meshCoordinatorFor) || readString(session?.meshCoordinatorFor)
   );
 }
+function isUnmanagedSessionRecord(session) {
+  const hasMeshNodeFor = Boolean(
+    readString(session?.settings?.meshNodeFor) || readString(session?.meta?.meshNodeFor) || readString(session?.metadata?.meshNodeFor) || readString(session?.meshNodeFor)
+  );
+  if (hasMeshNodeFor) return false;
+  if (isMeshCoordinatorSessionRecord(session)) return false;
+  const launchedByCoordinator = Boolean(
+    session?.settings?.launchedByCoordinator === true || session?.meta?.launchedByCoordinator === true || session?.launchedByCoordinator === true
+  );
+  return !launchedByCoordinator;
+}
 function isWorkerTaskMode(taskMode) {
   return taskMode !== "live_debug_readonly";
 }
@@ -742,8 +753,9 @@ function buildRelayUnsafeRemoteSessionFailure(ctx, node, sessionId, providerType
     daemonId: node.daemonId,
     workspace: node.workspace,
     sessionId,
+    unsafeTranscriptAlias: true,
     ...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.`,
+    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. This session may be the coordinator itself or an unrelated session (unsafe_transcript_alias risk).`,
     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."
   };
@@ -1169,6 +1181,10 @@ function isConfiguredCoordinatorNode(ctx, node) {
   if (!ctx.localMachineId && !ctx.localDaemonId) return false;
   const nodeId = readString(node.id) || readString(node.nodeId) || readString(node.node_id);
   if (!nodeId) return false;
+  const nodeDaemonId = readNodeDaemonId(node);
+  const nodeMachineId = readNodeMachineId(node);
+  if (nodeDaemonId && ctx.localDaemonId && nodeDaemonId !== ctx.localDaemonId) return false;
+  if (nodeMachineId && ctx.localMachineId && nodeMachineId !== ctx.localMachineId) return false;
   const preferredNodeId = readString(ctx.mesh.coordinator?.preferredNodeId) || readString(ctx.mesh.coordinator?.preferred_node_id);
   if (preferredNodeId) return nodeId === preferredNodeId;
   const first = ctx.mesh.nodes?.[0];
@@ -2424,6 +2440,20 @@ async function meshSendTask(ctx, args) {
           nextAction: `Call mesh_launch_session for node '${args.node_id}' and then retry mesh_send_task with that worker session_id, or use mesh_enqueue_task for queue-based worker assignment.`
         });
       }
+      if (explicitTargetSession && isUnmanagedSessionRecord(explicitTargetSession)) {
+        return JSON.stringify({
+          success: false,
+          recoverable: true,
+          code: "mesh_target_session_unmanaged",
+          reason: "mesh_target_session_unmanaged",
+          nodeId: args.node_id,
+          sessionId: args.session_id,
+          taskMode: taskMode || "unspecified",
+          unsafeTranscriptAlias: true,
+          error: `Session '${args.session_id}' on node '${args.node_id}' has no Repo Mesh delegation metadata (missing meshNodeFor/meshCoordinatorFor/launchedByCoordinator). It may be the coordinator's own session or an unrelated session \u2014 dispatching risks self-send and orphaned completion events that never reach the coordinator ledger.`,
+          nextAction: `Call mesh_launch_session for node '${args.node_id}' to start a fresh managed worker session, then retry mesh_send_task with the returned session_id. Alternatively use mesh_enqueue_task for queue-based assignment without specifying session_id.`
+        });
+      }
     } catch {
       explicitTargetSession = void 0;
     }
@@ -2519,6 +2549,34 @@ async function meshSendTask(ctx, args) {
             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.`
           });
         }
+        if (isMeshCoordinatorSessionRecord(explicitSession)) {
+          return JSON.stringify({
+            success: false,
+            recoverable: true,
+            code: "mesh_target_session_is_coordinator",
+            reason: "mesh_target_session_is_coordinator",
+            nodeId: args.node_id,
+            sessionId: args.session_id,
+            taskMode: taskMode || "unspecified",
+            error: `Session '${args.session_id}' is a Repo Mesh coordinator session, not a visible worker session. Launch or use a visible worker session before dispatching this task.`,
+            nextAction: `Call mesh_launch_session for node '${args.node_id}' and then retry mesh_send_task with that worker session_id, or use mesh_enqueue_task for queue-based worker assignment.`
+          });
+        }
+        if (isUnmanagedSessionRecord(explicitSession)) {
+          return JSON.stringify({
+            success: false,
+            recoverable: true,
+            code: "mesh_target_session_unmanaged",
+            reason: "mesh_target_session_unmanaged",
+            nodeId: args.node_id,
+            sessionId: args.session_id,
+            taskMode: taskMode || "unspecified",
+            unsafeTranscriptAlias: true,
+            unsafeDelegateTarget: true,
+            error: `Session '${args.session_id}' on node '${args.node_id}' has no Repo Mesh delegation metadata (missing meshNodeFor/meshCoordinatorFor/launchedByCoordinator). It may be the coordinator's own session or an unrelated session \u2014 dispatching risks self-send and orphaned completion events that never reach the coordinator ledger.`,
+            nextAction: `Call mesh_launch_session for node '${args.node_id}' to start a fresh managed worker session, then retry mesh_send_task with the returned session_id. Alternatively use mesh_enqueue_task for queue-based assignment without specifying session_id.`
+          });
+        }
         resolvedProviderType = resolveSessionProviderType(explicitSession);
         if (resolvedProviderType) {
           meshSessionProviderMetadata.set(meshSessionCacheKey(args.node_id, args.session_id), {