@adhdev/daemon-standalone 0.9.82-rc.136 → 0.9.82-rc.138

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-BmnJCMQ2.js"></script>
+  <script type="module" crossorigin src="/assets/index-CNP9SlXf.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/vendor-DNk1FT1R.js">
   <link rel="stylesheet" crossorigin href="/assets/index-If4eNpuX.css">
 </head>

package/vendor/mcp-server/index.js

@@ -50,6 +50,113 @@ var IPC_COMMAND_TIMEOUTS_MS = {
   fast_forward_mesh_node: 12e4,
   mesh_status: 12e4
 };
+var WS_CONNECTING = 0;
+var WS_OPEN = 1;
+var POOL_IDLE_EVICT_MS = 5 * 6e4;
+var POOL_MAX_AGE_MS = 10 * 6e4;
+var connectionPool = /* @__PURE__ */ new Map();
+function buildRequestId() {
+  return `mcp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function getTimeoutMs(type, nestedCommand) {
+  return Math.max(
+    IPC_COMMAND_TIMEOUTS_MS[type] ?? DEFAULT_IPC_COMMAND_TIMEOUT_MS,
+    IPC_COMMAND_TIMEOUTS_MS[nestedCommand] ?? DEFAULT_IPC_COMMAND_TIMEOUT_MS
+  );
+}
+function getOrCreateConnection(WebSocketCtor, url) {
+  const existing = connectionPool.get(url);
+  if (existing) {
+    const { readyState } = existing.ws;
+    const now2 = Date.now();
+    const isAlive = readyState === WS_CONNECTING || readyState === WS_OPEN;
+    const isIdle = now2 - existing.lastUsedAt > POOL_IDLE_EVICT_MS && existing.pending.size === 0;
+    const isTooOld = now2 - existing.createdAt > POOL_MAX_AGE_MS && existing.pending.size === 0;
+    if (isAlive && !isIdle && !isTooOld) {
+      return existing;
+    }
+    if (isAlive && (isIdle || isTooOld)) {
+      try {
+        existing.ws.close();
+      } catch {
+      }
+      connectionPool.delete(url);
+    }
+    connectionPool.delete(url);
+  }
+  const now = Date.now();
+  const conn = {
+    ws: new WebSocketCtor(url),
+    ready: false,
+    commandQueue: [],
+    pending: /* @__PURE__ */ new Map(),
+    lastUsedAt: now,
+    createdAt: now
+  };
+  connectionPool.set(url, conn);
+  const drainQueue = () => {
+    conn.ready = true;
+    for (const { type, args, requestId } of conn.commandQueue) {
+      conn.ws.send(JSON.stringify({ type: "ext:command", payload: { command: type, args, requestId } }));
+    }
+    conn.commandQueue = [];
+  };
+  let tornDown = false;
+  const teardown = (error) => {
+    if (tornDown) return;
+    tornDown = true;
+    connectionPool.delete(url);
+    conn.ready = false;
+    for (const [, req] of conn.pending) {
+      clearTimeout(req.timer);
+      req.reject(error);
+    }
+    conn.pending.clear();
+    conn.commandQueue = [];
+  };
+  conn.ws.addEventListener("open", () => {
+    conn.ws.send(JSON.stringify({
+      type: "ext:register",
+      payload: {
+        ideType: "mcp-server",
+        ideVersion: "1.0.0",
+        extensionVersion: "1.0.0",
+        instanceId: `mcp-server-${process.pid}`,
+        machineId: "mcp-server",
+        workspaceFolders: []
+      }
+    }));
+  });
+  conn.ws.addEventListener("message", (event) => {
+    try {
+      const raw = typeof event.data === "string" ? event.data : String(event.data);
+      const msg = JSON.parse(raw);
+      if (msg?.type === "daemon:welcome") {
+        drainQueue();
+        return;
+      }
+      if (msg?.type !== "ext:command_result") return;
+      const req = conn.pending.get(msg?.payload?.requestId);
+      if (!req) return;
+      conn.pending.delete(msg.payload.requestId);
+      clearTimeout(req.timer);
+      const payload = msg.payload;
+      if (payload?.success === false) {
+        req.reject(new Error(payload.error || "Daemon IPC command failed"));
+      } else {
+        req.resolve(payload?.result ?? payload);
+      }
+    } catch {
+    }
+  });
+  conn.ws.addEventListener("error", () => {
+    teardown(new Error(`Cannot connect to daemon IPC at ${url}`));
+  });
+  conn.ws.addEventListener("close", () => {
+    teardown(new Error(`Daemon IPC connection closed: ${url}`));
+  });
+  return conn;
+}
 var IpcTransport = class {
   port;
   path;
@@ -78,86 +185,41 @@ var IpcTransport = class {
       args
     });
   }
-  async sendIpcCommand(type, args) {
+  sendIpcCommand(type, args) {
     const WebSocketCtor = globalThis.WebSocket;
     if (!WebSocketCtor) {
-      throw new Error("WebSocket is not available in this Node runtime; Node 20+ is required for daemon IPC mode");
+      return Promise.reject(new Error("WebSocket is not available in this Node runtime; Node 20+ is required for daemon IPC mode"));
     }
+    const requestId = buildRequestId();
+    const nestedCommand = typeof args?.command === "string" ? args.command : "";
+    const timeoutMs = getTimeoutMs(type, nestedCommand);
+    const targetDaemonId = typeof args?.targetDaemonId === "string" ? args.targetDaemonId : "";
+    const diagnosticParts = [
+      `command='${type}'`,
+      ...nestedCommand ? [`relayedCommand='${nestedCommand}'`] : [],
+      ...targetDaemonId ? [`targetDaemonId='${targetDaemonId.slice(0, 12)}'`] : [],
+      ...typeof args?.nodeId === "string" ? [`nodeId='${args.nodeId}'`] : [],
+      ...typeof args?.workspace === "string" ? [`workspace='${args.workspace}'`] : []
+    ];
+    const url = `ws://127.0.0.1:${this.port}${this.path}`;
     return new Promise((resolve, reject) => {
-      const requestId = `mcp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-      const ws = new WebSocketCtor(`ws://127.0.0.1:${this.port}${this.path}`);
-      let settled = false;
-      const finish = (fn) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timeout);
-        try {
-          ws.close();
-        } catch {
-        }
-        fn();
-      };
-      const nestedCommand = typeof args?.command === "string" ? args.command : "";
-      const targetDaemonId = typeof args?.targetDaemonId === "string" ? args.targetDaemonId : "";
-      const effectiveType = type === "mesh_relay_command" && nestedCommand ? nestedCommand : type;
-      const timeoutMs = Math.max(
-        IPC_COMMAND_TIMEOUTS_MS[type] ?? DEFAULT_IPC_COMMAND_TIMEOUT_MS,
-        IPC_COMMAND_TIMEOUTS_MS[effectiveType] ?? DEFAULT_IPC_COMMAND_TIMEOUT_MS
-      );
-      const diagnosticParts = [
-        `command='${type}'`,
-        ...nestedCommand ? [`relayedCommand='${nestedCommand}'`] : [],
-        ...targetDaemonId ? [`targetDaemonId='${targetDaemonId.slice(0, 12)}'`] : [],
-        ...typeof args?.nodeId === "string" ? [`nodeId='${args.nodeId}'`] : [],
-        ...typeof args?.workspace === "string" ? [`workspace='${args.workspace}'`] : []
-      ];
-      const timeout = setTimeout(() => {
-        finish(() => reject(new Error(`Daemon IPC ${diagnosticParts.join(" ")} timed out after ${Math.round(timeoutMs / 1e3)}s (requestId=${requestId})`)));
+      let conn;
+      try {
+        conn = getOrCreateConnection(WebSocketCtor, url);
+      } catch (e) {
+        return reject(new Error(`Failed to create IPC connection: ${e?.message || e}`));
+      }
+      const timer = setTimeout(() => {
+        conn.pending.delete(requestId);
+        reject(new Error(`Daemon IPC ${diagnosticParts.join(" ")} timed out after ${Math.round(timeoutMs / 1e3)}s (requestId=${requestId})`));
       }, timeoutMs);
-      let commandSent = false;
-      const send = () => {
-        if (commandSent) return;
-        commandSent = true;
-        ws.send(JSON.stringify({
-          type: "ext:command",
-          payload: { command: type, args, requestId }
-        }));
-      };
-      ws.addEventListener("open", () => {
-        ws.send(JSON.stringify({
-          type: "ext:register",
-          payload: {
-            ideType: "mcp-server",
-            ideVersion: "1.0.0",
-            extensionVersion: "1.0.0",
-            instanceId: `mcp-server-${process.pid}`,
-            machineId: "mcp-server",
-            workspaceFolders: []
-          }
-        }));
-      });
-      ws.addEventListener("message", (event) => {
-        try {
-          const raw = typeof event.data === "string" ? event.data : String(event.data);
-          const msg = JSON.parse(raw);
-          if (msg?.type === "daemon:welcome") {
-            send();
-            return;
-          }
-          if (msg?.type !== "ext:command_result") return;
-          if (msg?.payload?.requestId !== requestId) return;
-          const payload = msg.payload;
-          if (payload?.success === false) {
-            finish(() => reject(new Error(payload.error || `Daemon IPC command '${type}' failed`)));
-            return;
-          }
-          finish(() => resolve(payload?.result ?? payload));
-        } catch {
-        }
-      });
-      ws.addEventListener("error", () => {
-        finish(() => reject(new Error(`Cannot connect to daemon IPC at ws://127.0.0.1:${this.port}${this.path}`)));
-      });
+      conn.pending.set(requestId, { resolve, reject, timer });
+      conn.lastUsedAt = Date.now();
+      if (conn.ready) {
+        conn.ws.send(JSON.stringify({ type: "ext:command", payload: { command: type, args, requestId } }));
+      } else {
+        conn.commandQueue.push({ type, args, requestId });
+      }
     });
   }
 };
@@ -266,7 +328,17 @@ function annotateRapidReadChatAdvisory(payload, options) {
 
 // src/tools/mesh-tools.ts
 var import_daemon_core = require("@adhdev/daemon-core");
+var SESSION_PROVIDER_METADATA_TTL_MS = 30 * 6e4;
 var meshSessionProviderMetadata = /* @__PURE__ */ new Map();
+function getSessionMetadata(key) {
+  const entry = meshSessionProviderMetadata.get(key);
+  if (!entry) return void 0;
+  if (entry.expiresAt <= Date.now()) {
+    meshSessionProviderMetadata.delete(key);
+    return void 0;
+  }
+  return entry;
+}
 var ACTIVE_WORK_POLLING_BACKOFF_MS = 6e4;
 function buildActiveWorkPollingGuidance(summary, now = Date.now()) {
   if (!summary || summary.generatingCount <= 0) return void 0;
@@ -313,7 +385,7 @@ var OLD_HISTORICAL_QUEUE_RECORD_MS = 7 * 24 * 60 * 6e4;
 var ACTIVE_QUEUE_STATUSES = /* @__PURE__ */ new Set(["pending", "assigned"]);
 var HISTORICAL_QUEUE_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
 async function refreshMeshFromDaemon(ctx) {
-  if (!(ctx.transport instanceof IpcTransport)) return;
+  if (!isLocalTransport(ctx.transport)) return;
   try {
     const result = await ctx.transport.command("get_mesh", { meshId: ctx.mesh.id });
     if (!result?.success || !Array.isArray(result.mesh?.nodes)) return;
@@ -728,9 +800,8 @@ function isIdleSessionRecord(session) {
 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;
+  if (sessionMeshId !== meshId) return false;
   return !sessionNodeId || sessionNodeId === nodeId;
 }
 function chooseDispatchableSession(sessions, providerType, meshId, nodeId) {
@@ -1220,10 +1291,11 @@ function rememberMeshSessionProviderMetadata(nodeId, runtimeSessionId, metadata)
   const providerType = readString(metadata.providerType);
   const providerSessionId = readString(metadata.providerSessionId);
   if (!providerType && !providerSessionId) return;
-  const existing = meshSessionProviderMetadata.get(meshSessionCacheKey(keyNodeId, keySessionId)) || { providerType: "" };
+  const existing = getSessionMetadata(meshSessionCacheKey(keyNodeId, keySessionId)) || { providerType: "" };
   meshSessionProviderMetadata.set(meshSessionCacheKey(keyNodeId, keySessionId), {
     providerType: providerType || existing.providerType,
-    providerSessionId: providerSessionId || existing.providerSessionId
+    providerSessionId: providerSessionId || existing.providerSessionId,
+    expiresAt: Date.now() + SESSION_PROVIDER_METADATA_TTL_MS
   });
 }
 function rememberMeshSessionProviderMetadataFromEvent(event) {
@@ -1236,7 +1308,7 @@ function rememberMeshSessionProviderMetadataFromEvent(event) {
   });
 }
 function resolveMeshSessionProviderMetadataFromLedger(ctx, nodeId, runtimeSessionId) {
-  const entries = (0, import_daemon_core.readLedgerEntries)(ctx.mesh.id, { tail: 500 });
+  const entries = (0, import_daemon_core.readLedgerEntries)(ctx.mesh.id, { tail: 50 });
   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 : {};
@@ -1255,7 +1327,7 @@ function resolveMeshSessionProviderMetadataFromLedger(ctx, nodeId, runtimeSessio
   return void 0;
 }
 function resolveMeshSessionProviderMetadata(ctx, nodeId, runtimeSessionId) {
-  const cached = meshSessionProviderMetadata.get(meshSessionCacheKey(nodeId, runtimeSessionId));
+  const cached = getSessionMetadata(meshSessionCacheKey(nodeId, runtimeSessionId));
   if (cached?.providerType || cached?.providerSessionId) return cached;
   const fromLedger = resolveMeshSessionProviderMetadataFromLedger(ctx, nodeId, runtimeSessionId);
   if (fromLedger) rememberMeshSessionProviderMetadata(nodeId, runtimeSessionId, fromLedger);
@@ -1273,6 +1345,20 @@ function isGitStatusDirty(status) {
   if (typeof status?.dirty === "boolean") return status.dirty;
   return countUncommittedChanges(status) > 0;
 }
+function slimLedgerPayload(payload) {
+  const slim = {};
+  for (const [k, v] of Object.entries(payload)) {
+    if (k === "message" || k === "taskSummary") {
+      slim[k] = typeof v === "string" && v.length > 200 ? v.slice(0, 200) + "\u2026" : v;
+    } else if (k === "evidence" || k === "workerResult" || k === "gitStatus" || k === "validationResults") {
+    } else if (k === "finalSummary") {
+      slim[k] = typeof v === "string" && v.length > 300 ? v.slice(0, 300) + "\u2026" : v;
+    } else {
+      slim[k] = v;
+    }
+  }
+  return slim;
+}
 function readRelatedRepos(node) {
   const raw = Array.isArray(node.relatedRepos) ? node.relatedRepos : Array.isArray(node.policy?.relatedRepos) ? node.policy.relatedRepos : [];
   return raw.map((entry) => ({
@@ -1592,7 +1678,7 @@ async function drainCoordinatorPendingEvents(ctx, opts) {
     return surfacedEvents;
   }
   if (isLocalTransport(ctx.transport)) {
-    const events = (0, import_daemon_core.drainPendingMeshCoordinatorEvents)(ctx.mesh.id).filter(matchesCurrentMesh);
+    const events = (0, import_daemon_core.drainPendingMeshCoordinatorEvents)(ctx.mesh.id, ctx.localDaemonId).filter(matchesCurrentMesh);
     events.forEach(rememberMeshSessionProviderMetadataFromEvent);
     return events;
   }
@@ -1951,9 +2037,8 @@ var ALL_MESH_TOOLS = [
 async function meshStatus(ctx, args = {}) {
   await refreshMeshFromDaemon(ctx);
   const { mesh, transport } = ctx;
-  const results = [];
   const ledgerSummary = (0, import_daemon_core.getLedgerSummary)(mesh.id);
-  for (const node of mesh.nodes) {
+  const results = await Promise.all(mesh.nodes.map(async (node) => {
     const entry = {
       nodeId: node.id,
       workspace: node.workspace,
@@ -2027,7 +2112,7 @@ async function meshStatus(ctx, args = {}) {
     if (recoveryContext.consecutiveNodeFailures > 0) {
       entry.recoveryHints = {
         consecutiveFailures: recoveryContext.consecutiveNodeFailures,
-        lastTaskMessage: recoveryContext.lastTaskMessage,
+        lastTaskMessage: typeof recoveryContext.lastTaskMessage === "string" ? recoveryContext.lastTaskMessage.slice(0, 100) + (recoveryContext.lastTaskMessage.length > 100 ? "\u2026" : "") : recoveryContext.lastTaskMessage,
         advice: recoveryContext.advice,
         retryRecommended: recoveryContext.retryRecommended
       };
@@ -2069,11 +2154,16 @@ async function meshStatus(ctx, args = {}) {
     if (relatedRepos.length) entry.relatedRepos = relatedRepos;
     const liveSessions = await collectLiveStatusSessions(ctx, node);
     if (liveSessions.length > 0) {
-      entry.sessions = liveSessions;
+      entry.sessions = liveSessions.map((s) => ({
+        id: s.instanceId ?? s.id ?? s.sessionId,
+        status: s.status ?? s.lifecycle ?? s.state,
+        providerType: s.providerType ?? s.cliType ?? s.type,
+        ...s.activeChat?.status ? { chatStatus: s.activeChat.status } : {}
+      })).filter((s) => s.id);
     }
-    results.push(entry);
-  }
-  const ledgerEntries = (0, import_daemon_core.readLedgerEntries)(mesh.id, { tail: 500 });
+    return entry;
+  }));
+  const ledgerEntries = (0, import_daemon_core.readLedgerEntries)(mesh.id, { tail: 200 });
   const activeWorkEvidence = (0, import_daemon_core.buildMeshActiveWork)({
     meshId: mesh.id,
     queue: (0, import_daemon_core.getQueue)(mesh.id),
@@ -2101,7 +2191,8 @@ async function meshStatus(ctx, args = {}) {
     activeWork: activeWorkEvidence.activeWork,
     staleDirectWorkSummary,
     ...args.includeStaleDirectWorkDetails === true ? { staleDirectWork: activeWorkEvidence.staleDirectWork } : {},
-    terminalDirectWork: activeWorkEvidence.terminalDirectWork,
+    // terminalDirectWork is historical (completed/failed direct dispatches) — opt-in only.
+    ...args.includeTerminalDirectWork === true ? { terminalDirectWork: activeWorkEvidence.terminalDirectWork } : {},
     activeWorkSummary: activeWorkEvidence.summary,
     ...pollingGuidance ? { pollingGuidance } : {},
     branchConvergenceSummary: summarizeBranchConvergence(results)
@@ -2132,7 +2223,11 @@ async function meshTaskHistory(ctx, args) {
   const pendingEvents = await drainCoordinatorPendingEvents(ctx);
   const tail = typeof args.tail === "number" && args.tail > 0 ? args.tail : 20;
   const kind = typeof args.kind === "string" && args.kind.trim() ? [args.kind.trim()] : void 0;
-  const entries = (0, import_daemon_core.readLedgerEntries)(mesh.id, { tail, kind });
+  const rawEntries = (0, import_daemon_core.readLedgerEntries)(mesh.id, { tail, kind });
+  const entries = rawEntries.map((e) => ({
+    ...e,
+    payload: e.payload ? slimLedgerPayload(e.payload) : e.payload
+  }));
   const summary = (0, import_daemon_core.getLedgerSummary)(mesh.id);
   return JSON.stringify({
     meshId: mesh.id,
@@ -2282,7 +2377,21 @@ async function meshEnqueueTask(ctx, args) {
               } catch {
               }
             }
-          }).catch(() => {
+          }).catch((err) => {
+            try {
+              (0, import_daemon_core.appendLedgerEntry)(ctx.mesh.id, {
+                kind: "p2p_dispatch_failed",
+                nodeId: node.id,
+                payload: {
+                  source: "queue",
+                  via: "p2p_direct",
+                  taskId: task.id,
+                  error: err?.message || String(err),
+                  dispatchFailedAt: (/* @__PURE__ */ new Date()).toISOString()
+                }
+              });
+            } catch {
+            }
           })
         );
       }
@@ -2310,12 +2419,25 @@ async function meshViewQueue(ctx, args) {
     const visibleSummary = buildQueueStatusSummary(queue);
     const maintenance = buildQueueMaintenanceReport(fullQueue);
     const liveNodes = await collectMeshViewQueueNodesWithLiveSessions(ctx);
+    (0, import_daemon_core.markStaleDirectDispatches)(ctx.mesh.id);
+    const ledgerEntries = (0, import_daemon_core.readLedgerEntries)(ctx.mesh.id, { tail: 200 });
+    const directDispatches = (0, import_daemon_core.getActiveDirectDispatches)(ctx.mesh.id);
     const activeWorkEvidence = (0, import_daemon_core.buildMeshActiveWork)({
       meshId: ctx.mesh.id,
       queue: fullQueue,
-      ledgerEntries: (0, import_daemon_core.readLedgerEntries)(ctx.mesh.id, { tail: 500 }),
+      ledgerEntries,
+      // Always pass BeadsDB records (may be empty). buildMeshActiveWork uses them for local
+      // dispatches and falls through to ledger scan for remote P2P dispatches not in BeadsDB.
+      directDispatches,
       nodes: liveNodes
     });
+    const recentDispatchFailures = ledgerEntries.filter((e) => e.kind === "p2p_dispatch_failed").slice(-20).map((e) => ({
+      nodeId: e.nodeId,
+      taskId: e.payload?.taskId,
+      error: e.payload?.error,
+      via: e.payload?.via,
+      failedAt: e.payload?.dispatchFailedAt || e.timestamp
+    }));
     const staleAssignedTasks = maintenance.staleAssignedTasks || [];
     const requestedHistoricalRows = queue.some((task) => HISTORICAL_QUEUE_STATUSES.has(String(task?.status || "")));
     const pollingGuidance = buildActiveWorkPollingGuidance(activeWorkEvidence.summary);
@@ -2333,25 +2455,20 @@ async function meshViewQueue(ctx, args) {
         filtered: Boolean(statusFilter?.length) || view !== "all"
       },
       queue,
-      visibleQueue: queue,
       activeWork: activeWorkEvidence.activeWork,
       staleDirectWork: activeWorkEvidence.staleDirectWork,
       activeWorkSummary: activeWorkEvidence.summary,
       ...pollingGuidance ? { pollingGuidance } : {},
-      visibleSummary,
       summary,
-      activeCounts: summary.activeCounts,
-      historicalCounts: summary.historicalCounts,
-      activeCount: summary.activeCount,
-      historicalCount: summary.historicalCount,
-      visibleActiveCounts: visibleSummary.activeCounts,
-      visibleHistoricalCounts: visibleSummary.historicalCounts,
-      visibleActiveCount: visibleSummary.activeCount,
-      visibleHistoricalCount: visibleSummary.historicalCount,
       staleAssignedTasks,
       staleAssignedCount: maintenance.staleAssignedCount,
       queueMaintenance: maintenance,
       cleanupDryRun: maintenance,
+      ...recentDispatchFailures.length > 0 ? {
+        recentDispatchFailures,
+        dispatchFailureCount: recentDispatchFailures.length,
+        dispatchFailureNote: "Remote P2P dispatch attempts that failed. Affected tasks remain pending and may require mesh_queue_requeue if no idle session picks them up."
+      } : {},
       ...view === "active" || statusFilter?.some((status) => ACTIVE_QUEUE_STATUSES.has(status)) ? {
         activeQueue: queue.filter((task) => ACTIVE_QUEUE_STATUSES.has(String(task?.status || "")))
       } : {},
@@ -2489,7 +2606,7 @@ async function meshSendTask(ctx, args) {
     }
     const isLocalNode = isLocalControlPlaneNode(ctx, node);
     if (ctx.transport instanceof IpcTransport && node.daemonId && !isLocalNode) {
-      const cached = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id || ""));
+      const cached = getSessionMetadata(meshSessionCacheKey(args.node_id, args.session_id || ""));
       const taskId = (0, import_node_crypto.randomUUID)();
       const result2 = await ipcDispatchToRemoteAgent(ctx, node, {
         session_id: args.session_id,
@@ -2527,7 +2644,7 @@ async function meshSendTask(ctx, args) {
       });
     }
     if (args.session_id && isLocalTransport(ctx.transport)) {
-      const cached = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id));
+      const cached = getSessionMetadata(meshSessionCacheKey(args.node_id, args.session_id));
       let resolvedProviderType = cached?.providerType || "";
       if (!resolvedProviderType) {
         let explicitSession = explicitTargetSession;
@@ -2582,7 +2699,8 @@ async function meshSendTask(ctx, args) {
         if (resolvedProviderType) {
           meshSessionProviderMetadata.set(meshSessionCacheKey(args.node_id, args.session_id), {
             providerType: resolvedProviderType,
-            providerSessionId: readString(explicitSession?.providerSessionId) || void 0
+            providerSessionId: readString(explicitSession?.providerSessionId) || void 0,
+            expiresAt: Date.now() + SESSION_PROVIDER_METADATA_TTL_MS
           });
         }
       }
@@ -2621,6 +2739,7 @@ async function meshSendTask(ctx, args) {
         });
       }
       const taskId = (0, import_node_crypto.randomUUID)();
+      const dispatchedAt = (/* @__PURE__ */ new Date()).toISOString();
       try {
         (0, import_daemon_core.appendLedgerEntry)(ctx.mesh.id, {
           kind: "task_dispatched",
@@ -2637,6 +2756,17 @@ async function meshSendTask(ctx, args) {
         });
       } catch {
       }
+      (0, import_daemon_core.insertDirectDispatch)(ctx.mesh.id, {
+        taskId,
+        nodeId: args.node_id,
+        sessionId: args.session_id,
+        providerType: resolvedProviderType || void 0,
+        message: args.message,
+        taskMode: taskMode || void 0,
+        via: "local_direct",
+        dispatchedToIdleSession: sessionWasIdle,
+        dispatchedAt
+      });
       return JSON.stringify({
         success: true,
         dispatched: true,
@@ -2662,7 +2792,7 @@ async function meshSendTask(ctx, args) {
       ctx.transport.command("trigger_mesh_queue", { meshId: ctx.mesh.id }).catch(() => {
       });
     }
-    const pendingEvents = isLocalTransport(ctx.transport) ? (0, import_daemon_core.drainPendingMeshCoordinatorEvents)(ctx.mesh.id) : [];
+    const pendingEvents = isLocalTransport(ctx.transport) ? (0, import_daemon_core.drainPendingMeshCoordinatorEvents)(ctx.mesh.id, ctx.localDaemonId) : [];
     const result = { success: true, source: "queue", nodeId: args.node_id, taskId: task.id, status: task.status, taskMode: task.taskMode };
     if (pendingEvents.length > 0) {
       result.pendingCoordinatorEvents = pendingEvents;
@@ -2695,18 +2825,19 @@ async function meshReadChat(ctx, args) {
       workspace: node.workspace,
       ...cached?.providerType ? { agentType: cached.providerType, providerType: cached.providerType } : {},
       ...providerSessionId ? { providerSessionId } : {},
-      tailLimit: args.tail ?? 10
+      tailLimit: args.tail ?? 3
     });
     const payload = annotateRapidReadChatAdvisory(unwrapCommandPayload(result), {
       key: `mesh:${args.node_id}:${args.session_id}`,
       toolName: "mesh_read_chat",
       completionCallbackExpected: true
     });
-    if (args.compact) {
+    const useCompact = args.compact !== false;
+    if (useCompact) {
       const compactPayload = compactChatPayload(payload, {
         nodeId: args.node_id,
         sessionId: args.session_id,
-        limit: args.tail ?? 10
+        limit: args.tail ?? 3
       });
       return JSON.stringify(
         payload.pollingAdvisory ? { ...compactPayload, pollingAdvisory: payload.pollingAdvisory } : compactPayload,
@@ -2719,7 +2850,7 @@ async function meshReadChat(ctx, args) {
     try {
       const targetId = `${node.daemonId}:session:${args.session_id}`;
       const res = await ctx.transport.readChat(targetId, {
-        limit: args.tail ?? 10,
+        limit: args.tail ?? 3,
         sessionId: args.session_id
       });
       return JSON.stringify(res, null, 2);
@@ -2821,7 +2952,8 @@ async function meshLaunchSession(ctx, args) {
     if (runtimeSessionId) {
       meshSessionProviderMetadata.set(meshSessionCacheKey(args.node_id, runtimeSessionId), {
         providerType: resolvedProviderType,
-        ...providerSessionId ? { providerSessionId } : {}
+        ...providerSessionId ? { providerSessionId } : {},
+        expiresAt: Date.now() + SESSION_PROVIDER_METADATA_TTL_MS
       });
     }
     try {
@@ -3044,7 +3176,7 @@ async function meshCheckpoint(ctx, args) {
 async function meshApprove(ctx, args) {
   const node = await findNodeWithRefresh(ctx, args.node_id);
   if (isLocalTransport(ctx.transport)) {
-    const cached = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id));
+    const cached = getSessionMetadata(meshSessionCacheKey(args.node_id, args.session_id));
     const providerSessionId = cached?.providerSessionId;
     const result = await commandForNode(ctx, node, "resolve_action", {
       sessionId: args.session_id,