@adhdev/daemon-standalone 0.9.82-rc.350 → 0.9.82-rc.352

package/package.json

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

package/vendor/mcp-server/index.js

@@ -4071,6 +4071,81 @@ async function meshSendTask(ctx, args) {
     return JSON.stringify(failure);
   }
 }
+function classifyReadChatTransportCause(error) {
+  const message = (error instanceof Error ? error.message : String(error ?? "")).toLowerCase();
+  if (/not acknowledged|delivery failure|channel never opened|connect timed out|not connected|datachannel|disconnected|\bclosed\b|offline|no route|failed to initiate p2p|p2p mesh is not available|connect queue full/.test(message)) {
+    return "not_connected";
+  }
+  return "saturated";
+}
+function resolveCachedMeshSessionPreviewFromLedger(ctx, nodeId, sessionId) {
+  const entries = (0, import_daemon_core.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    const entry = entries[i];
+    const payload = entry.payload && typeof entry.payload === "object" && !Array.isArray(entry.payload) ? entry.payload : {};
+    const entryNodeId = readString(entry.nodeId) || readString(payload.nodeId) || readString(payload.meshNodeId);
+    if (entryNodeId && entryNodeId !== nodeId) continue;
+    const entrySessionId = readString(entry.sessionId) || readString(payload.targetSessionId) || readString(payload.sessionId) || readString(payload.instanceId);
+    if (entrySessionId !== sessionId) continue;
+    const metadataEvent = payload.metadataEvent && typeof payload.metadataEvent === "object" && !Array.isArray(payload.metadataEvent) ? payload.metadataEvent : payload;
+    const preview = (0, import_daemon_core.resolveMeshSurfacedSessionPreview)(metadataEvent);
+    if (preview) {
+      return { ...preview, ledgerKind: entry.kind, timestamp: entry.timestamp };
+    }
+  }
+  return void 0;
+}
+function buildMeshReadChatCacheFallback(ctx, args, node, error) {
+  const classification = (0, import_daemon_core.classifyP2pRelayFailure)(error, { command: "read_chat", targetDaemonId: node.daemonId });
+  const cause = classifyReadChatTransportCause(error);
+  const errorMessage = error instanceof Error ? error.message : String(error ?? "");
+  const causeNote = cause === "not_connected" ? "the worker daemon is not currently connected over P2P (no live channel)" : "the worker daemon is connected but saturated \u2014 it acknowledged the request but did not return the transcript within the deadline";
+  const cached = resolveCachedMeshSessionPreviewFromLedger(ctx, args.node_id, args.session_id);
+  if (cached) {
+    return JSON.stringify({
+      success: true,
+      source: "coordinator_cache_fallback",
+      fallback: true,
+      nodeId: args.node_id,
+      sessionId: args.session_id,
+      transport: "p2p",
+      transportFailure: {
+        code: classification.code,
+        reason: classification.reason,
+        cause,
+        error: errorMessage
+      },
+      advisory: `Live transcript unavailable (${causeNote}). Showing the cached coordinator-side summary surfaced from the worker's last completion/status event \u2014 a stale point-in-time summary, NOT the live transcript. The full transcript requires a live P2P read_chat once the peer is reachable.`,
+      fullTranscriptRequiresP2p: true,
+      summary: cached.preview,
+      messages: [{
+        role: cached.role,
+        content: cached.preview,
+        cached: true,
+        ...cached.receivedAt ? { receivedAt: cached.receivedAt } : {}
+      }],
+      cachedPreview: {
+        role: cached.role,
+        ledgerKind: cached.ledgerKind,
+        ledgerTimestamp: cached.timestamp,
+        ...cached.receivedAt ? { receivedAt: cached.receivedAt } : {}
+      }
+    }, null, 2);
+  }
+  const failure = buildCoordinatorP2pRelayFailure(error, {
+    command: "read_chat",
+    targetDaemonId: node.daemonId,
+    nodeId: args.node_id,
+    sessionId: args.session_id
+  });
+  return JSON.stringify({
+    ...failure,
+    cause,
+    cachedSummaryAvailable: false,
+    fullTranscriptRequiresP2p: true,
+    advisory: `Live transcript unavailable (${causeNote}) and no cached coordinator-side summary exists for this session yet (no completion/status event has been surfaced). The full transcript requires a live P2P read_chat once the peer is reachable.`
+  }, null, 2);
+}
 async function meshReadChat(ctx, args) {
   const node = await findOptionalNodeWithRefresh(ctx, args.node_id);
   if (!node) {
@@ -4079,14 +4154,21 @@ async function meshReadChat(ctx, args) {
   await drainCoordinatorPendingEvents(ctx, { nodeIds: [args.node_id] });
   const cached = resolveMeshSessionProviderMetadata(ctx, args.node_id, args.session_id);
   const providerSessionId = typeof args.provider_session_id === "string" && args.provider_session_id.trim() ? args.provider_session_id.trim() : cached?.providerSessionId;
-  const result = await commandForNode(ctx, node, "read_chat", {
-    sessionId: args.session_id,
-    targetSessionId: args.session_id,
-    workspace: node.workspace,
-    ...cached?.providerType ? { agentType: cached.providerType, providerType: cached.providerType } : {},
-    ...providerSessionId ? { providerSessionId } : {},
-    tailLimit: args.tail ?? 10
-  });
+  const isLocalNode = isLocalControlPlaneNode(ctx, node);
+  let result;
+  try {
+    result = await commandForNode(ctx, node, "read_chat", {
+      sessionId: args.session_id,
+      targetSessionId: args.session_id,
+      workspace: node.workspace,
+      ...cached?.providerType ? { agentType: cached.providerType, providerType: cached.providerType } : {},
+      ...providerSessionId ? { providerSessionId } : {},
+      tailLimit: args.tail ?? 10
+    });
+  } catch (e) {
+    if (isLocalNode || !(0, import_daemon_core.isP2pRelayTransportFailure)(e)) throw e;
+    return buildMeshReadChatCacheFallback(ctx, args, node, e);
+  }
   const payload = annotateRapidReadChatAdvisory(unwrapCommandPayload(result), {
     key: `mesh:${args.node_id}:${args.session_id}`,
     toolName: "mesh_read_chat",