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

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-CWWeDAva.js"></script>
+  <script type="module" crossorigin src="/assets/index-Crr3Vqz7.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/vendor-CLec0455.js">
   <link rel="stylesheet" crossorigin href="/assets/index-DftJ2WZr.css">
 </head>

package/vendor/mcp-server/index.js

@@ -26416,12 +26416,14 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
   return "";
 }
 function injectMeshSystemMessage(components, args) {
+  let completedTaskForLedger = null;
   if (args.event === "agent:generating_completed") {
     const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
     const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
     const providerType = readNonEmptyString(args.metadataEvent.providerType);
     if (sessionId) {
-      updateSessionTaskStatus(args.meshId, sessionId, "completed");
+      const completedTask = updateSessionTaskStatus(args.meshId, sessionId, "completed");
+      completedTaskForLedger = completedTask ? { id: completedTask.id } : null;
       if (nodeId && providerType) {
         setTimeout(() => {
           tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
@@ -26434,6 +26436,7 @@ function injectMeshSystemMessage(components, args) {
     const providerType = readNonEmptyString(args.metadataEvent.providerType);
     const completedTask = sessionId ? updateSessionTaskStatus(args.meshId, sessionId, "completed") : null;
     if (completedTask) {
+      completedTaskForLedger = { id: completedTask.id };
       try {
         appendLedgerEntry(args.meshId, {
           kind: "task_completed",
@@ -26445,7 +26448,8 @@ function injectMeshSystemMessage(components, args) {
             nodeLabel: args.nodeLabel,
             taskId: completedTask.id,
             completedViaReady: true,
-            providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0
+            providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0,
+            finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0
           }
         });
       } catch (e) {
@@ -26488,7 +26492,9 @@ function injectMeshSystemMessage(components, args) {
         payload: {
           event: args.event,
           nodeLabel: args.nodeLabel,
-          providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0
+          taskId: completedTaskForLedger?.id || void 0,
+          providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0,
+          finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0
         }
       });
     } catch (e) {
@@ -26603,7 +26609,8 @@ function handleMeshForwardEvent(components, payload) {
     metadataEvent: {
       targetSessionId: readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.instanceId),
       providerType: readNonEmptyString(payload.providerType),
-      providerSessionId: readNonEmptyString(payload.providerSessionId)
+      providerSessionId: readNonEmptyString(payload.providerSessionId),
+      finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary)
     }
   });
 }
@@ -42098,7 +42105,7 @@ ${lastSnapshot}`;
           }
           getFreshParsedStatusCache() {
             const cached2 = this.parsedStatusCache;
-            if (cached2 && cached2.responseBuffer === this.responseBuffer && cached2.currentTurnScope === this.currentTurnScope && cached2.recentOutputBuffer === this.recentOutputBuffer && cached2.accumulatedBuffer === this.accumulatedBuffer && cached2.screenText === this.lastScreenText && cached2.currentStatus === this.currentStatus && cached2.activeModal === this.activeModal && cached2.cliName === this.cliName) {
+            if (cached2 && cached2.responseBuffer === this.responseBuffer && cached2.currentTurnScope === this.currentTurnScope && cached2.recentOutputBuffer === this.recentOutputBuffer && cached2.accumulatedBuffer === this.accumulatedBuffer && cached2.accumulatedRawBuffer === this.accumulatedRawBuffer && cached2.screenText === this.lastScreenText && cached2.currentStatus === this.currentStatus && cached2.activeModal === this.activeModal && cached2.cliName === this.cliName) {
               return cached2.result;
             }
             return null;
@@ -43073,6 +43080,11 @@ ${lastSnapshot}`;
             };
           }
           // ─── Script Execution ──────────────────────────
+          invokeCliScript(script, input) {
+            const hasStateFactory = typeof this.cliScripts?.createState === "function";
+            const expectsStateArgument = hasStateFactory || this.scriptState !== null || script.length >= 2;
+            return expectsStateArgument ? script(this.scriptState, input) : script(input);
+          }
           runParseSession() {
             if (typeof this.cliScripts?.parseSession !== "function") {
               this.parseErrorMessage = `${this.cliType} parseSession unavailable`;
@@ -43093,7 +43105,10 @@ ${lastSnapshot}`;
                 scope: this.currentTurnScope,
                 runtimeSettings: this.runtimeSettings
               });
-              const session = this.cliScripts.parseSession(this.scriptState, { ...input, tail, tailScreen: buildCliScreenSnapshot(tail) });
+              const session = this.invokeCliScript(
+                this.cliScripts.parseSession,
+                { ...input, tail, tailScreen: buildCliScreenSnapshot(tail) }
+              );
               this.parseErrorMessage = null;
               return session && typeof session === "object" ? session : null;
             } catch (e) {
@@ -43107,7 +43122,7 @@ ${lastSnapshot}`;
             if (!this.cliScripts?.detectStatus) return null;
             try {
               const screenText = this.terminalScreen.getText();
-              const status = this.cliScripts.detectStatus(this.scriptState, {
+              const status = this.invokeCliScript(this.cliScripts.detectStatus, {
                 tail: text.slice(-500),
                 screenText,
                 rawBuffer: this.accumulatedRawBuffer,
@@ -43126,7 +43141,7 @@ ${lastSnapshot}`;
             try {
               const screenText = this.terminalScreen.getText();
               const buffer = screenText || this.accumulatedBuffer;
-              return this.cliScripts.parseApproval(this.scriptState, {
+              return this.invokeCliScript(this.cliScripts.parseApproval, {
                 buffer,
                 screenText,
                 rawBuffer: this.accumulatedRawBuffer,
@@ -43182,7 +43197,7 @@ ${lastSnapshot}`;
             const screenText = this.readTerminalScreenText();
             const parseScreenText = this.getParseScreenText(screenText);
             const cached2 = this.parsedStatusCache;
-            if (cached2 && cached2.responseBuffer === this.responseBuffer && cached2.currentTurnScope === this.currentTurnScope && cached2.recentOutputBuffer === this.recentOutputBuffer && cached2.accumulatedBuffer === this.accumulatedBuffer && cached2.screenText === parseScreenText && cached2.currentStatus === this.currentStatus && cached2.activeModal === this.activeModal && cached2.cliName === this.cliName) {
+            if (cached2 && cached2.responseBuffer === this.responseBuffer && cached2.currentTurnScope === this.currentTurnScope && cached2.recentOutputBuffer === this.recentOutputBuffer && cached2.accumulatedBuffer === this.accumulatedBuffer && cached2.accumulatedRawBuffer === this.accumulatedRawBuffer && cached2.screenText === parseScreenText && cached2.currentStatus === this.currentStatus && cached2.activeModal === this.activeModal && cached2.cliName === this.cliName) {
               return cached2.result;
             }
             const parsed = this.runParseSession();
@@ -43210,6 +43225,7 @@ ${lastSnapshot}`;
               currentTurnScope: this.currentTurnScope,
               recentOutputBuffer: this.recentOutputBuffer,
               accumulatedBuffer: this.accumulatedBuffer,
+              accumulatedRawBuffer: this.accumulatedRawBuffer,
               screenText: parseScreenText,
               currentStatus: this.currentStatus,
               activeModal: this.activeModal,
@@ -53375,7 +53391,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
                   appendLedgerEntry2(meshId, {
                     kind: "node_removed",
                     nodeId,
-                    payload: { worktree: !!node?.isLocalWorktree, sessionCleanupMode }
+                    payload: {
+                      worktree: !!node?.isLocalWorktree,
+                      sessionCleanupMode,
+                      workspace: typeof node?.workspace === "string" ? node.workspace : void 0,
+                      daemonId: typeof node?.daemonId === "string" ? node.daemonId : void 0,
+                      worktreeBranch: typeof node?.worktreeBranch === "string" ? node.worktreeBranch : void 0
+                    }
                   });
                 } catch {
                 }
@@ -57531,6 +57553,11 @@ function annotateRapidReadChatAdvisory(payload, options) {
 // src/tools/mesh-tools.ts
 init_dist2();
 var meshSessionProviderMetadata = /* @__PURE__ */ new Map();
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+var DUPLICATE_DISPATCH_WINDOW_MS = 6e4;
+var STALE_ASSIGNED_QUEUE_MS = 30 * 6e4;
 async function refreshMeshFromDaemon(ctx) {
   if (!(ctx.transport instanceof IpcTransport)) return;
   try {
@@ -57551,6 +57578,138 @@ async function findNodeWithRefresh(ctx, nodeId) {
   if (!refreshed) throw new Error(`Node '${nodeId}' is not a member of mesh '${ctx.mesh.name}'`);
   return refreshed;
 }
+async function findOptionalNodeWithRefresh(ctx, nodeId) {
+  const hit = ctx.mesh.nodes.find((n) => n.id === nodeId);
+  if (hit) return hit;
+  await refreshMeshFromDaemon(ctx);
+  return ctx.mesh.nodes.find((n) => n.id === nodeId) ?? null;
+}
+function hasRecentDuplicateDispatch(ctx, args) {
+  const now = Date.now();
+  const normalizedMessage = args.message.trim();
+  for (const task of getQueue(ctx.mesh.id)) {
+    const timestamp2 = new Date(task.updatedAt || task.createdAt).getTime();
+    if (!Number.isFinite(timestamp2) || now - timestamp2 > DUPLICATE_DISPATCH_WINDOW_MS) continue;
+    if (task.targetNodeId && task.targetNodeId !== args.node_id) continue;
+    if (task.assignedNodeId && task.assignedNodeId !== args.node_id) continue;
+    if (args.session_id && task.targetSessionId !== args.session_id && task.assignedSessionId !== args.session_id) continue;
+    if (task.message?.trim() === normalizedMessage) {
+      return { duplicate: true, entry: task, source: "queue" };
+    }
+  }
+  const entries = readLedgerEntries(ctx.mesh.id, { tail: 200 });
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    const entry = entries[i];
+    const timestamp2 = new Date(entry.timestamp).getTime();
+    if (Number.isFinite(timestamp2) && now - timestamp2 > DUPLICATE_DISPATCH_WINDOW_MS) break;
+    if (entry.kind !== "task_dispatched") continue;
+    if (entry.nodeId !== args.node_id) continue;
+    if (args.session_id && entry.sessionId !== args.session_id) continue;
+    if (typeof entry.payload?.message !== "string") continue;
+    if (entry.payload.message.trim() === normalizedMessage) {
+      return { duplicate: true, entry, source: "ledger" };
+    }
+  }
+  return { duplicate: false };
+}
+function buildMissingNodeReadChatRecovery(ctx, args) {
+  const entries = readLedgerEntries(ctx.mesh.id, { tail: 300 });
+  const relatedEntries = entries.filter((entry) => entry.nodeId === args.node_id || entry.sessionId === args.session_id);
+  const completedEntries = relatedEntries.filter((entry) => entry.kind === "task_completed");
+  const lastDispatch = [...relatedEntries].reverse().find((entry) => entry.kind === "task_dispatched");
+  const lastTerminal = [...relatedEntries].reverse().find((entry) => entry.kind === "task_completed" || entry.kind === "task_failed" || entry.kind === "task_stalled");
+  const lastRemoved = [...relatedEntries].reverse().find((entry) => entry.kind === "node_removed");
+  const lastLaunch = [...relatedEntries].reverse().find((entry) => entry.kind === "session_launched");
+  const providerSessionId = args.provider_session_id || readString(lastTerminal?.payload?.providerSessionId) || readString(lastLaunch?.payload?.providerSessionId) || readString(lastDispatch?.payload?.providerSessionId);
+  const finalSummary = readString(lastTerminal?.payload?.finalSummary) || readString(lastTerminal?.payload?.compactSummary) || readString(lastTerminal?.payload?.summary);
+  const ledger = {
+    taskCompletedFound: completedEntries.length > 0,
+    nodeRemovedFound: !!lastRemoved,
+    providerType: lastTerminal?.providerType || lastLaunch?.providerType || lastDispatch?.providerType,
+    providerSessionId,
+    nodeRemovedAt: lastRemoved?.timestamp,
+    sessionCleanupMode: readString(lastRemoved?.payload?.sessionCleanupMode),
+    readDebugLocator: readString(lastTerminal?.payload?.readDebugLocator) || readString(lastTerminal?.payload?.debugBundlePath)
+  };
+  if (finalSummary) {
+    return {
+      success: true,
+      compact: args.compact === true,
+      recoveredFromLedger: true,
+      nodeId: args.node_id,
+      sessionId: args.session_id,
+      summary: finalSummary,
+      ledger,
+      messages: [{ role: "assistant", content: finalSummary, isHistorical: true }]
+    };
+  }
+  return {
+    success: false,
+    recoverable: true,
+    code: "mesh_removed_node_transcript_unavailable",
+    error: `Node '${args.node_id}' is not a current member of mesh '${ctx.mesh.name}'.`,
+    nodeId: args.node_id,
+    sessionId: args.session_id,
+    providerSessionId,
+    reason: "node_not_in_current_mesh_snapshot",
+    ledger,
+    completedSessionSeenInLedger: ledger.taskCompletedFound,
+    lastDispatch: lastDispatch ? {
+      timestamp: lastDispatch.timestamp,
+      sessionId: lastDispatch.sessionId,
+      providerType: lastDispatch.providerType,
+      taskId: typeof lastDispatch.payload?.taskId === "string" ? lastDispatch.payload.taskId : void 0,
+      messagePreview: typeof lastDispatch.payload?.message === "string" ? lastDispatch.payload.message.slice(0, 500) : void 0
+    } : null,
+    lastTerminalEvent: lastTerminal ? {
+      kind: lastTerminal.kind,
+      timestamp: lastTerminal.timestamp,
+      sessionId: lastTerminal.sessionId,
+      providerType: lastTerminal.providerType,
+      taskId: typeof lastTerminal.payload?.taskId === "string" ? lastTerminal.payload.taskId : void 0,
+      payload: lastTerminal.payload
+    } : null,
+    nextSteps: [
+      providerSessionId ? `Retry mesh_read_chat with provider_session_id='${providerSessionId}' on a current live node for the same daemon if one exists.` : "If the node UI shows a provider transcript id, retry mesh_read_chat/mesh_read_debug with provider_session_id.",
+      "Use mesh_read_debug with the provider_session_id or daemon-side debug bundle locator if available.",
+      "Check mesh_task_history for task_completed and node_removed entries before redispatching; do not resend solely because transcript recovery failed.",
+      "If this node was removed with stop_and_delete, the runtime transcript may be gone; rely on the ledger summary/locator or ask the operator for the saved UI output."
+    ],
+    recoveryHints: [
+      "The worktree/node may have been removed or the mesh snapshot may be stale after task completion.",
+      "If you have a provider_session_id, retry mesh_read_chat with that value while targeting a live node for the same daemon if available.",
+      "Use mesh_read_debug with provider_session_id, or inspect the daemon/session-host history locator if the transcript has already been archived.",
+      "Avoid redispatching the same task solely because read_chat could not recover the transcript; check task_history and git status first."
+    ]
+  };
+}
+function annotateQueueStaleness(queue) {
+  const now = Date.now();
+  return queue.map((task) => {
+    const taskStatus = typeof task?.status === "string" ? task.status : void 0;
+    const annotated = {
+      ...task,
+      taskStatus,
+      dispatchedAt: task?.createdAt,
+      ...taskStatus === "assigned" ? { activeTaskId: task.id } : {},
+      ...taskStatus === "completed" || taskStatus === "failed" ? {
+        isHistorical: true,
+        completedAt: task.updatedAt
+      } : {}
+    };
+    if (taskStatus !== "assigned") return annotated;
+    const updatedAt = new Date(task.updatedAt).getTime();
+    const ageMs = Number.isFinite(updatedAt) ? now - updatedAt : null;
+    if (ageMs === null || ageMs < STALE_ASSIGNED_QUEUE_MS) return annotated;
+    return {
+      ...annotated,
+      stale: true,
+      staleAssigned: true,
+      staleReason: "assigned task has not reached a terminal state within 30 minutes",
+      assignedAgeMs: ageMs
+    };
+  });
+}
 function unwrapCommandPayload(value) {
   let current = value;
   const seen = /* @__PURE__ */ new Set();
@@ -58180,8 +58339,16 @@ async function meshEnqueueTask(ctx, args) {
 }
 async function meshViewQueue(ctx, args) {
   try {
-    const queue = getQueue(ctx.mesh.id, { status: args.status });
-    return JSON.stringify({ success: true, queue }, null, 2);
+    const queue = annotateQueueStaleness(getQueue(ctx.mesh.id, { status: args.status }));
+    const staleAssignedTasks = queue.filter((task) => task?.status === "assigned" && task?.staleAssigned);
+    return JSON.stringify({
+      success: true,
+      queue,
+      staleAssignedTasks,
+      staleAssignedCount: staleAssignedTasks.length,
+      // Back-compat alias for callers already reading the first hardening payload.
+      staleAssignments: staleAssignedTasks
+    }, null, 2);
   } catch (e) {
     return JSON.stringify({ success: false, error: e.message });
   }
@@ -58226,6 +58393,24 @@ async function meshSendTask(ctx, args) {
   if (node.policy?.readOnly) {
     return JSON.stringify({ error: `Node '${args.node_id}' is read-only` });
   }
+  const duplicate = hasRecentDuplicateDispatch(ctx, args);
+  if (duplicate.duplicate) {
+    return JSON.stringify({
+      success: true,
+      duplicate: true,
+      dispatched: false,
+      warning: "Duplicate mesh_send_task suppressed: the same node/session/message was dispatched recently.",
+      nodeId: args.node_id,
+      sessionId: args.session_id,
+      source: duplicate.source,
+      previousDispatch: duplicate.entry ? {
+        id: duplicate.entry.id,
+        timestamp: duplicate.entry.timestamp || duplicate.entry.updatedAt || duplicate.entry.createdAt,
+        nodeId: duplicate.entry.nodeId || duplicate.entry.targetNodeId || duplicate.entry.assignedNodeId,
+        sessionId: duplicate.entry.sessionId || duplicate.entry.targetSessionId || duplicate.entry.assignedSessionId
+      } : void 0
+    });
+  }
   try {
     if (!isLocalTransport(ctx.transport) && node.daemonId) {
       const res = await ctx.transport.meshEnqueueTask(node.daemonId, {
@@ -58244,17 +58429,22 @@ async function meshSendTask(ctx, args) {
         providerType: cached2?.providerType
       });
       if (result.success) {
+        const dispatchedSessionId = args.session_id || result.sessionId;
         try {
           appendLedgerEntry(ctx.mesh.id, {
             kind: "task_dispatched",
             nodeId: args.node_id,
-            sessionId: result.sessionId,
-            payload: { message: args.message, via: "p2p_direct" }
+            sessionId: dispatchedSessionId,
+            payload: {
+              message: args.message,
+              via: "p2p_direct",
+              ...dispatchedSessionId ? { targetSessionId: dispatchedSessionId } : {}
+            }
           });
         } catch {
         }
       }
-      return JSON.stringify({ ...result, nodeId: args.node_id });
+      return JSON.stringify({ ...result, nodeId: args.node_id, dispatched: result.success === true });
     }
     if (args.session_id && isLocalTransport(ctx.transport)) {
       const cached2 = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id));
@@ -58299,7 +58489,10 @@ async function meshSendTask(ctx, args) {
   }
 }
 async function meshReadChat(ctx, args) {
-  const node = await findNodeWithRefresh(ctx, args.node_id);
+  const node = await findOptionalNodeWithRefresh(ctx, args.node_id);
+  if (!node) {
+    return JSON.stringify(buildMissingNodeReadChatRecovery(ctx, args), null, 2);
+  }
   if (isLocalTransport(ctx.transport)) {
     const cached2 = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id));
     const providerSessionId = typeof args.provider_session_id === "string" && args.provider_session_id.trim() ? args.provider_session_id.trim() : cached2?.providerSessionId;