@adhdev/daemon-standalone 0.9.82-rc.261 → 0.9.82-rc.263

package/package.json

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

package/vendor/mcp-server/index.js

@@ -1119,6 +1119,28 @@ function buildCompactGitSnapshot(status) {
   }
   return slim;
 }
+function summarizeNodeSessions(sessions) {
+  const list = Array.isArray(sessions) ? sessions : [];
+  const byStatus = {};
+  const providerCounts = {};
+  const selfCoordinatorSessionIds = [];
+  for (const s of list) {
+    const status = typeof s?.status === "string" && s.status ? s.status : "unknown";
+    byStatus[status] = (byStatus[status] ?? 0) + 1;
+    const provider = typeof s?.providerType === "string" && s.providerType ? s.providerType : "unknown";
+    providerCounts[provider] = (providerCounts[provider] ?? 0) + 1;
+    if (s?.isSelfCoordinator === true && s.id) selfCoordinatorSessionIds.push(String(s.id));
+  }
+  const summary = {
+    total: list.length,
+    byStatus,
+    providerCounts
+  };
+  if (selfCoordinatorSessionIds.length > 0) {
+    summary.selfCoordinatorSessionIds = selfCoordinatorSessionIds;
+  }
+  return summary;
+}
 function extractLaunchPayload(value) {
   return findNestedPayload(value, (payload) => Boolean(payload?.sessionId || payload?.id || payload?.runtimeSessionId));
 }
@@ -1705,6 +1727,30 @@ async function collectLiveStatusSessions(ctx, node) {
     return [];
   }
 }
+async function collectLiveStatusProbe(ctx, node) {
+  try {
+    const statusResult = await commandForNode(ctx, node, "get_status_metadata", {});
+    return {
+      sessions: extractStatusMetadataSessions(statusResult),
+      daemonBuild: extractDaemonBuildInfo(statusResult)
+    };
+  } catch {
+    return { sessions: [] };
+  }
+}
+function extractDaemonBuildInfo(value) {
+  const payload = unwrapCommandPayload(value);
+  const build = payload?.daemonBuild && typeof payload.daemonBuild === "object" ? payload.daemonBuild : value?.daemonBuild && typeof value.daemonBuild === "object" ? value.daemonBuild : void 0;
+  if (!build) return void 0;
+  const commit = readString(build.commit);
+  if (!commit) return void 0;
+  return {
+    commit,
+    commitShort: readString(build.commitShort) || commit.slice(0, 7),
+    version: readString(build.version) || "unknown",
+    ...readString(build.builtAt) ? { builtAt: readString(build.builtAt) } : {}
+  };
+}
 async function collectMeshViewQueueNodesWithLiveSessions(ctx) {
   const nodes = await Promise.all(ctx.mesh.nodes.map(async (node) => {
     const liveSessions = await collectLiveStatusSessions(ctx, node);
@@ -1957,13 +2003,14 @@ function buildRemoveNodeArgs(ctx, nodeId, sessionCleanupMode) {
 }
 var MESH_STATUS_TOOL = {
   name: "mesh_status",
-  description: "Get the current status of all nodes in the repo mesh \u2014 health, git state, active sessions, recovery hints, and recommended next steps. Use this to decide which node to send work to or how to recover from failures. Do not repeatedly call this to wait for generating delegated work; wait for pendingCoordinatorEvents/completion events or an explicit user status request.",
+  description: "Get the current status of all nodes in the repo mesh \u2014 health, git state, active sessions, recovery hints, and recommended next steps. Use this to decide which node to send work to or how to recover from failures. Also reports the running daemon build per daemonId under top-level daemonBuilds ({commit, commitShort, version}); when a live daemon was built from a commit BEHIND its workspace HEAD it adds staleDaemonBuilds[] + staleDaemonBuildWarning \u2014 meaning a just-merged refinery/mesh-tool fix is NOT yet live on that daemon (awaiting deploy/restart; a local dist rebuild does not update a cloud daemon). Do not repeatedly call this to wait for generating delegated work; wait for pendingCoordinatorEvents/completion events or an explicit user status request.",
   inputSchema: {
     type: "object",
     properties: {
       _gemini_compat: { type: "string", description: "Dummy property for Gemini compatibility. Ignore this." },
       includeStaleDirectWorkDetails: { type: "boolean", description: "Opt in to the full staleDirectWork array. Defaults false; normal status returns compact staleDirectWorkSummary only." },
-      compact: { type: "boolean", description: "Slim payload for LLM callers. Default true. Set false (or verbose=true) for the full dashboard-grade payload." },
+      includeSessions: { type: "boolean", description: "Opt in to per-node live session arrays. Default false: compact mode returns a per-node sessionSummary (counts) and de-duplicated full session lists under top-level daemonSessions keyed by daemonId (sessions are not repeated for every node that shares a daemon). Set true to also include the full session array on each node." },
+      compact: { type: "boolean", description: "Slim payload for LLM callers. Default true. Folds per-node session arrays to sessionSummary and de-duplicates daemon-shared sessions into daemonSessions. Set false (or verbose=true) for the full dashboard-grade payload." },
       verbose: { type: "boolean", description: "Force the full payload; overrides compact." }
     }
   }
@@ -2119,15 +2166,17 @@ var MESH_GIT_STATUS_TOOL = {
 };
 var MESH_FAST_FORWARD_NODE_TOOL = {
   name: "mesh_fast_forward_node",
-  description: "Safely dry-run or execute an obvious direct fast-forward for a mesh node without launching an agent session. Defaults to dry-run; execution requires execute=true. Never pushes, rebases, resets, cleans, or checks out arbitrary revisions.",
+  description: 'Safely dry-run or execute an obvious direct fast-forward for a mesh node without launching an agent session. mode="merge" (default) absorbs upstream commits into the local branch via git merge --ff-only (ahead=0, behind>0). mode="push" publishes local commits to origin via a strict ff-only push (HEAD must be a descendant of origin/<branch>). Defaults to dry-run; execution requires execute=true. Never force-pushes, rebases, resets, cleans, or checks out arbitrary revisions. When the merge path finds the branch ahead with nothing to merge, it returns code "ahead_needs_push" pointing at mode="push".',
   inputSchema: {
     type: "object",
     properties: {
       node_id: { type: "string", description: "Target node ID." },
+      mode: { type: "string", enum: ["merge", "push"], description: "merge (default): git merge --ff-only to absorb upstream. push: strict ff-only push of local commits to origin/<branch>; refuses any non-fast-forward." },
       branch: { type: "string", description: "Optional guard: require the node's current branch to match this branch before planning/executing." },
-      execute: { type: "boolean", description: "When true, apply the fast-forward if all safety gates pass. Defaults false/dry-run." },
+      execute: { type: "boolean", description: "When true, apply the fast-forward/push if all safety gates pass. Defaults false/dry-run." },
       dry_run: { type: "boolean", description: "Preview only. Defaults true unless execute=true; dry_run=true overrides execute." },
-      update_submodules: { type: "boolean", description: "When true, if the root fast-forward changes gitlinks, run only git submodule update --init --recursive and verify submodules clean." }
+      update_submodules: { type: "boolean", description: 'mode="merge" only: when true, if the root fast-forward changes gitlinks, run only git submodule update --init --recursive and verify submodules clean.' },
+      push_submodules: { type: "boolean", description: 'mode="push" only: also ff-only push submodule HEADs to their origin main. Gated by mesh policy allowAutoPublishSubmoduleMainCommits \u2014 skipped unless that policy is enabled. Defaults false (root push only).' }
     },
     required: ["node_id"]
   }
@@ -2228,8 +2277,10 @@ var MESH_TASK_HISTORY_TOOL = {
   inputSchema: {
     type: "object",
     properties: {
-      tail: { type: "number", description: "Number of recent entries to return (default: 20)." },
-      kind: { type: "string", description: "Filter by entry kind: task_dispatched, task_completed, task_failed, task_stalled, session_launched, checkpoint_created, node_cloned, node_removed, direct_fast_forward." }
+      tail: { type: "number", description: "Number of recent entries to return (default: 20; clamped to 40 in compact mode, 200 in verbose)." },
+      kind: { type: "string", description: "Filter by entry kind: task_dispatched, task_completed, task_failed, task_stalled, session_launched, checkpoint_created, node_cloned, node_removed, direct_fast_forward." },
+      compact: { type: "boolean", description: "Slim payload for LLM callers. Default true. Truncates long payload strings (message/taskSummary \u2264200, finalSummary \u2264300) and drops large nested evidence blobs (accessible via mesh_reconcile_ledger). Set false (or verbose=true) for full untruncated payloads." },
+      verbose: { type: "boolean", description: "Force the full untruncated payload; overrides compact." }
     }
   }
 };
@@ -2247,6 +2298,18 @@ var MESH_RECONCILE_LEDGER_TOOL = {
     }
   }
 };
+var MESH_PRUNE_STALE_DIRECT_TOOL = {
+  name: "mesh_prune_stale_direct",
+  description: "Prune orphaned staleDirect dispatch records \u2014 direct task dispatches whose original node/session is no longer present in the live mesh. dry_run (default) reports exactly which records would be pruned without mutating anything; pass execute=true to delete them. Active/pending/assigned/generating work and fresh unacknowledged dispatch failures (node/session still live) are always preserved. The append-only mesh ledger audit history is left intact.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      execute: { type: "boolean", description: "When true, actually delete the orphaned records. Defaults false (dry run). Ignored when dry_run=true." },
+      dry_run: { type: "boolean", description: "Force a preview without mutation even if execute=true. Defaults to dry-run behavior when execute is not set." },
+      include_terminal: { type: "boolean", description: "Also prune terminal (completed/failed) direct dispatch store rows in addition to orphans. Defaults false." }
+    }
+  }
+};
 var MESH_REFINE_NODE_TOOL = {
   name: "mesh_refine_node",
   description: "The Refinery: Accept an async validation/merge/cleanup job for a completed worktree node. The immediate response includes async:true, status:'accepted', jobId, interactionId, target node, and startedAt; completion/failure evidence is delivered through pending mesh events and the mesh task ledger.",
@@ -2260,7 +2323,7 @@ var MESH_REFINE_NODE_TOOL = {
 };
 var MESH_REFINE_BATCH_TOOL = {
   name: "mesh_refine_batch",
-  description: "Batch Refinery: converge multiple sibling worktree nodes onto the base branch in one conflict-aware sequential pipeline. Orders nodes by change-area (non-submodule nodes first, submodule-touching nodes serialized last) so each merged sibling advances the base and the next node auto-rebases + re-checks patch-equivalence before its own merge. Each node runs the same validation/patch-equivalence/submodule-reachability/merge/cleanup gates as mesh_refine_node. Conflicting or blocked nodes are isolated as blocked_review while the rest of the batch proceeds. Defaults to dry-run (plan only); set execute=true to converge. Never force-pushes or resets.",
+  description: "Batch Refinery: converge multiple sibling worktree nodes onto the base branch in one conflict-aware sequential pipeline. Orders nodes by change-area (non-submodule nodes first, submodule-touching nodes serialized last) so each merged sibling advances the base and the next node auto-rebases + re-checks patch-equivalence before its own merge. Each node runs the same validation/patch-equivalence/submodule-reachability/merge/cleanup gates as mesh_refine_node. Conflicting or blocked nodes are isolated as blocked_review while the rest of the batch proceeds. Defaults to dry-run (plan only); set execute=true to converge. Never force-pushes or resets. execute=true is async: the immediate response is async:true / status:'accepted' with the batch jobId and ordered target node list; per-node convergence runs in the background and the aggregate completion/failure (with per-node merged / blocked_review / not_mergeable results) is delivered as a terminal refine event via pending mesh events and the ledger \u2014 do not re-invoke while a batch is in flight. dry_run returns the plan synchronously.",
   inputSchema: {
     type: "object",
     properties: {
@@ -2347,6 +2410,7 @@ var ALL_MESH_TOOLS = [
   MESH_SUGGEST_REFINE_CONFIG_TOOL,
   MESH_REFINE_PLAN_TOOL,
   MESH_CLEANUP_SESSIONS_TOOL,
+  MESH_PRUNE_STALE_DIRECT_TOOL,
   MESH_TASK_HISTORY_TOOL,
   MESH_RECONCILE_LEDGER_TOOL,
   MESH_MISSION_UPSERT_TOOL,
@@ -2384,6 +2448,9 @@ async function meshStatus(ctx, args = {}) {
       entry.isDirty = dirty;
       entry.uncommittedChanges = uncommittedChanges;
       entry.branchConvergence = buildBranchConvergence(mesh, node, status, dirty, uncommittedChanges);
+      if (status?.daemonBuildBehind && typeof status.daemonBuildBehind === "object") {
+        entry.staleDaemonBuild = status.daemonBuildBehind;
+      }
       const submodules = extractSubmodules(statusResult, node.policy?.submoduleIgnorePaths || []);
       if (submodules && submodules.some((s) => s?.outOfSync)) {
         entry.submoduleWarning = "One or more submodules are out of sync with the parent repo. Run `git submodule update` or check deployment readiness.";
@@ -2451,7 +2518,9 @@ async function meshStatus(ctx, args = {}) {
     }
     const relatedRepos = await collectRelatedRepoStatuses(ctx, node);
     if (relatedRepos.length) entry.relatedRepos = relatedRepos;
-    const liveSessions = await collectLiveStatusSessions(ctx, node);
+    const statusProbe = await collectLiveStatusProbe(ctx, node);
+    const liveSessions = statusProbe.sessions;
+    if (statusProbe.daemonBuild) entry.daemonBuild = statusProbe.daemonBuild;
     if (liveSessions.length > 0) {
       entry.sessions = liveSessions.map((s) => {
         const coordinatorMeshId = typeof s.coordinator?.meshId === "string" ? s.coordinator.meshId : void 0;
@@ -2501,10 +2570,58 @@ async function meshStatus(ctx, args = {}) {
       }
     }
   }
+  const includeSessions = args.includeSessions === true;
+  const daemonSessions = {};
+  if (compact) {
+    const seenDaemons = /* @__PURE__ */ new Set();
+    for (const entry of results) {
+      const daemonId = typeof entry?.daemonId === "string" && entry.daemonId ? entry.daemonId : "";
+      const sessions = Array.isArray(entry?.sessions) ? entry.sessions : [];
+      if (daemonId && sessions.length > 0 && !seenDaemons.has(daemonId)) {
+        seenDaemons.add(daemonId);
+        daemonSessions[daemonId] = includeSessions ? sessions : summarizeNodeSessions(sessions);
+      }
+    }
+  }
+  const daemonBuilds = {};
+  for (const entry of results) {
+    const daemonId = typeof entry?.daemonId === "string" && entry.daemonId ? entry.daemonId : "";
+    if (daemonId && entry?.daemonBuild && !(daemonId in daemonBuilds)) {
+      daemonBuilds[daemonId] = entry.daemonBuild;
+    }
+  }
+  const staleDaemonBuilds = [];
+  const seenStale = /* @__PURE__ */ new Set();
+  for (const entry of results) {
+    const behind = entry?.staleDaemonBuild;
+    if (!behind || typeof behind !== "object") continue;
+    const daemonId = typeof entry?.daemonId === "string" ? entry.daemonId : "";
+    const key = `${daemonId}::${behind.scope ?? ""}::${behind.buildCommit ?? ""}::${behind.head ?? ""}`;
+    if (seenStale.has(key)) continue;
+    seenStale.add(key);
+    staleDaemonBuilds.push({
+      daemonId,
+      nodeId: entry.nodeId,
+      scope: behind.scope,
+      liveBuildCommit: behind.buildCommit,
+      liveBuildCommitShort: behind.buildCommitShort,
+      head: behind.head,
+      warning: behind.warning
+    });
+  }
   const nodesForResponse = compact ? results.map((entry) => {
-    if (!entry || typeof entry !== "object" || entry.git === void 0) return entry;
-    const slimGit = buildCompactGitSnapshot(entry.git);
-    return slimGit ? { ...entry, git: slimGit } : entry;
+    if (!entry || typeof entry !== "object") return entry;
+    const next = { ...entry };
+    if (next.git !== void 0) {
+      const slimGit = buildCompactGitSnapshot(next.git);
+      if (slimGit) next.git = slimGit;
+    }
+    if (Array.isArray(next.sessions)) {
+      next.sessionSummary = summarizeNodeSessions(next.sessions);
+      if (!includeSessions) delete next.sessions;
+    }
+    if (next.daemonBuild !== void 0) delete next.daemonBuild;
+    return next;
   }) : results;
   const response = {
     meshId: mesh.id,
@@ -2520,6 +2637,12 @@ async function meshStatus(ctx, args = {}) {
       historicalEvidenceOnly: ["recoveryHints", "ledgerSummary"]
     },
     nodes: nodesForResponse,
+    ...compact && Object.keys(daemonSessions).length > 0 ? { daemonSessions } : {},
+    ...Object.keys(daemonBuilds).length > 0 ? { daemonBuilds } : {},
+    ...staleDaemonBuilds.length > 0 ? {
+      staleDaemonBuilds,
+      staleDaemonBuildWarning: "One or more live daemons were built from a commit behind the workspace HEAD. Merged refinery/mesh-tool fixes are NOT live on those daemons until they are rebuilt/redeployed and restarted \u2014 a local daemon-core dist rebuild does not update a cloud daemon. Do not assume a just-merged fix is active."
+    } : {},
     activeWork: activeWorkEvidence.activeWork,
     staleDirectWorkSummary,
     ...args.includeStaleDirectWorkDetails === true ? { staleDirectWork: activeWorkEvidence.staleDirectWork } : {},
@@ -2584,14 +2707,16 @@ async function meshStatus(ctx, args = {}) {
 }
 async function meshTaskHistory(ctx, args) {
   const { mesh } = ctx;
+  const compact = args.verbose === true ? false : args.compact ?? true;
   const pendingEvents = await drainCoordinatorPendingEvents(ctx);
-  const tail = typeof args.tail === "number" && args.tail > 0 ? args.tail : 20;
+  const requestedTail = typeof args.tail === "number" && args.tail > 0 ? Math.floor(args.tail) : 20;
+  const tail = compact ? Math.min(requestedTail, 40) : Math.min(requestedTail, 200);
   const kind = typeof args.kind === "string" && args.kind.trim() ? [args.kind.trim()] : void 0;
   const rawEntries = (0, import_daemon_core.readLedgerEntries)(mesh.id, { tail, kind });
-  const entries = rawEntries.map((e) => ({
+  const entries = compact ? rawEntries.map((e) => ({
     ...e,
     payload: e.payload ? slimLedgerPayload(e.payload) : e.payload
-  }));
+  })) : rawEntries;
   const summary = (0, import_daemon_core.getLedgerSummary)(mesh.id);
   let taskStats;
   try {
@@ -2604,6 +2729,7 @@ async function meshTaskHistory(ctx, args) {
   }
   return JSON.stringify({
     meshId: mesh.id,
+    payloadMode: compact ? "compact" : "full",
     entries,
     summary,
     ...taskStats ? { taskStats } : {},
@@ -2688,6 +2814,89 @@ async function meshReconcileLedger(ctx, args) {
   });
   return JSON.stringify({ success: true, evidence }, null, 2);
 }
+async function meshPruneStaleDirect(ctx, args = {}) {
+  await refreshMeshFromDaemon(ctx);
+  const execute = args.execute === true && args.dry_run !== true;
+  const includeTerminal = args.include_terminal === true;
+  const liveNodes = await collectMeshViewQueueNodesWithLiveSessions(ctx);
+  const ledgerEntries = (0, import_daemon_core.readLedgerEntries)(ctx.mesh.id, { tail: 500 });
+  const directDispatches = (0, import_daemon_core.getActiveDirectDispatches)(ctx.mesh.id);
+  const activeWorkEvidence = (0, import_daemon_core.buildMeshActiveWork)({
+    meshId: ctx.mesh.id,
+    queue: (0, import_daemon_core.getQueue)(ctx.mesh.id),
+    ledgerEntries,
+    directDispatches,
+    nodes: liveNodes,
+    includeTerminalDirect: includeTerminal
+  });
+  const candidates = [
+    ...activeWorkEvidence.staleDirectWork,
+    ...includeTerminal ? activeWorkEvidence.terminalDirectWork : []
+  ];
+  const storeTaskIds = new Set(directDispatches.map((d) => d.taskId));
+  const prunable = [];
+  const preservedUnacknowledged = [];
+  const preservedLedgerOnly = [];
+  const preservedNotOrphan = [];
+  for (const record of candidates) {
+    const classification = (0, import_daemon_core.classifyStaleDirectForPrune)(record, { includeTerminal });
+    if (classification === "preserve_unacknowledged") {
+      preservedUnacknowledged.push(record);
+      continue;
+    }
+    if (classification === "preserve_active") {
+      preservedNotOrphan.push(record);
+      continue;
+    }
+    if (!storeTaskIds.has(record.taskId)) {
+      preservedLedgerOnly.push(record);
+      continue;
+    }
+    prunable.push(record);
+  }
+  const summarize = (records) => records.map((r) => ({
+    taskId: r.taskId,
+    nodeId: r.nodeId,
+    sessionId: r.sessionId,
+    status: r.status,
+    terminal: r.terminal === true,
+    staleReason: r.staleReason,
+    taskTitle: r.taskTitle,
+    createdAt: r.createdAt
+  }));
+  let prunedCount = 0;
+  if (execute && prunable.length) {
+    prunedCount = (0, import_daemon_core.deleteDirectDispatchesByTaskId)(ctx.mesh.id, prunable.map((r) => r.taskId));
+    (0, import_daemon_core.appendLedgerEntry)(ctx.mesh.id, {
+      kind: "direct_dispatch_pruned",
+      payload: {
+        source: "mesh_prune_stale_direct",
+        prunedCount,
+        taskIds: prunable.map((r) => r.taskId),
+        reasons: Array.from(new Set(prunable.map((r) => r.staleReason || (r.terminal ? "terminal" : "unknown"))))
+      }
+    });
+  }
+  return JSON.stringify({
+    success: true,
+    mode: execute ? "execute" : "dry_run",
+    meshId: ctx.mesh.id,
+    includeTerminal,
+    candidateCount: candidates.length,
+    prunableCount: prunable.length,
+    prunedCount,
+    prunable: summarize(prunable),
+    preserved: {
+      unacknowledgedCount: preservedUnacknowledged.length,
+      ledgerOnlyCount: preservedLedgerOnly.length,
+      notOrphanCount: preservedNotOrphan.length,
+      unacknowledged: summarize(preservedUnacknowledged),
+      ledgerOnly: summarize(preservedLedgerOnly),
+      notOrphan: summarize(preservedNotOrphan)
+    },
+    note: execute ? `Pruned ${prunedCount} orphaned direct dispatch record(s) from the active staleDirect surface. The append-only mesh ledger audit history is preserved; a direct_dispatch_pruned entry records this prune.` : "Dry run \u2014 nothing was deleted. Re-run with execute=true to prune the listed orphaned records. Fresh unacknowledged dispatch failures (node/session still live) and ledger-only audit entries are always preserved."
+  }, null, 2);
+}
 async function meshListNodes(ctx) {
   await refreshMeshFromDaemon(ctx);
   const { mesh } = ctx;
@@ -3554,10 +3763,12 @@ async function meshFastForwardNode(ctx, args) {
       meshId: ctx.mesh.id,
       nodeId: node.id,
       workspace: node.workspace,
+      mode: args.mode === "push" ? "push" : "merge",
       branch: typeof args.branch === "string" ? args.branch : void 0,
       execute: args.execute === true && args.dry_run !== true,
       dryRun,
       updateSubmodules: args.update_submodules === true,
+      pushSubmodules: args.push_submodules === true,
       submoduleIgnorePaths: submoduleIgnorePaths.length > 0 ? submoduleIgnorePaths : void 0
     });
     return JSON.stringify(unwrapCommandPayload(result), null, 2);
@@ -3745,7 +3956,7 @@ async function meshRefineBatch(ctx, args = {}) {
     inlineMesh: ctx.mesh
   });
   const payload = unwrapCommandPayload(result) ?? result;
-  if (payload?.batch && payload?.dryRun === false && Array.isArray(payload?.results)) {
+  if (payload?.batch && payload?.dryRun === false && payload?.async !== true && Array.isArray(payload?.results)) {
     for (const outcome of payload.results) {
       if (outcome?.convergence === "merged_to_main" || outcome?.convergence === "skipped_patch_equivalent") {
         const idx = ctx.mesh.nodes.findIndex((n) => n.id === outcome.nodeId);
@@ -4963,6 +5174,9 @@ async function startMcpServer(opts) {
           case "mesh_cleanup_sessions":
             text = await meshCleanupSessions(meshCtx, a);
             break;
+          case "mesh_prune_stale_direct":
+            text = await meshPruneStaleDirect(meshCtx, a);
+            break;
           case "mesh_task_history":
             text = await meshTaskHistory(meshCtx, a);
             break;