@adhdev/daemon-standalone 1.0.28-rc.9 → 1.0.29-rc.1

package/vendor/mcp-server/index.js

@@ -51,6 +51,9 @@ var IPC_COMMAND_TIMEOUTS_MS = {
   // 120s leaves headroom and matches the relay-wrapped remote path.
   clone_mesh_node: 12e4,
   remove_mesh_node: 6e4,
+  // Retention plan/execute runs the same git probes as a remove dry-run plus
+  // queue/session/ledger reads; 60s matches the remove budget.
+  cleanup_worktree_nodes: 6e4,
   // A5: plan_mesh_refine_node is the SYNCHRONOUS refine dry-run — it runs several git
   // probes (status/merge-tree/submodule) inline before replying, which can approach the
   // 15s default on a slow (Windows) host. 45s defensively, matching git_status/diff.
@@ -304,6 +307,33 @@ function dedupeSummaryFromTail(messages, summary) {
     return { ...rest, content: "", _sameAsSummary: true };
   });
 }
+var TURN_IDENTITY_FIELDS = [
+  "authority",
+  "status",
+  "stage",
+  "terminalOutcome",
+  "terminalReason",
+  "meshId",
+  "taskId",
+  "attemptId",
+  "attemptSeq",
+  "sessionId",
+  "nodeId",
+  "providerType",
+  "acceptedAt",
+  "deliveredAt",
+  "consumedAt",
+  "terminalAt",
+  "updatedAt"
+];
+function slimTurnPresentation(turn) {
+  if (!turn || typeof turn !== "object" || Array.isArray(turn)) return null;
+  const slim = {};
+  for (const key of TURN_IDENTITY_FIELDS) {
+    if (turn[key] !== void 0) slim[key] = turn[key];
+  }
+  return Object.keys(slim).length > 0 ? slim : null;
+}
 function compactChatPayload(payload, opts = {}) {
   const rawMessages = Array.isArray(payload?.messages) ? payload.messages : [];
   const visible = rawMessages.filter(isCoordinatorVisibleMessage);
@@ -320,6 +350,7 @@ function compactChatPayload(payload, opts = {}) {
   const toolSummaries = rawMessages.filter((m) => !isCoordinatorVisibleMessage(m)).map(summarizeToolMessage).filter((s) => s !== null);
   const omittedMessages = Math.max(0, rawMessages.length - messages.length);
   const filteredMessages = Math.max(0, rawMessages.length - visible.length);
+  const slimTurn = opts.preserveTurn ? slimTurnPresentation(payload?.turn) : null;
   return {
     success: payload?.success !== false,
     compact: true,
@@ -327,6 +358,9 @@ function compactChatPayload(payload, opts = {}) {
     ...opts.sessionId !== void 0 ? { sessionId: opts.sessionId } : {},
     status: payload?.status ?? null,
     providerSessionId: payload?.providerSessionId ?? null,
+    ...slimTurn ? { turn: slimTurn } : {},
+    ...slimTurn?.attemptId !== void 0 ? { attemptId: slimTurn.attemptId } : {},
+    ...slimTurn?.stage !== void 0 ? { turnStage: slimTurn.stage } : {},
     totalMessages: rawMessages.length,
     visibleMessages: visible.length,
     filteredMessages,
@@ -393,10 +427,12 @@ var CANONICAL_MESH_TOOL_NAMES = [
   "mesh_approve",
   "mesh_answer_question",
   "mesh_list_pending_approvals",
+  "mesh_plan_onboarding",
   "mesh_create",
   "mesh_add_node",
   "mesh_clone_node",
   "mesh_remove_node",
+  "mesh_cleanup_worktree_nodes",
   "mesh_refine_node",
   "mesh_refine_batch",
   "mesh_refine_config",
@@ -1000,12 +1036,19 @@ var MESH_FAST_FORWARD_NODE_TOOL = {
 };
 var MESH_RESTART_DAEMON_TOOL = {
   name: "mesh_restart_daemon",
-  description: `Update a mesh node's daemon to the latest published version on its release channel and restart it \u2014 the same path as the dashboard "preview update" button, exposed as a mesh command so a coordinator can roll a worker daemon onto a freshly deployed version without a manual restart round-trip. No agent session is launched. Idle-gated: a node whose daemon has an active session (generating / waiting_approval / starting) is refused with code "blocking_sessions" so an in-flight turn is never interrupted. If the node is already on the latest version it is a no-op (no restart), matching the dashboard button (returns alreadyLatest:true). Targets a single node \u2014 call other (idle) nodes first; restarting the coordinator's OWN daemon is naturally refused while its calling turn is active. Passing channel switches the daemon's release channel (and server URL) before restarting; omit it to keep the daemon on its configured channel.`,
+  description: `Restart a mesh node's daemon, optionally updating it first \u2014 the same path as the dashboard "preview update" button, exposed as a mesh command so a coordinator can roll a worker daemon without a manual restart round-trip. No agent session is launched. mode="upgrade" (default): update to the latest published version on the release channel, then restart; already-latest is a no-op (no restart, returns alreadyLatest:true). mode="restart": pure re-spawn with no reinstall \u2014 restarts even when already latest, with much shorter downtime; use it to reset wedged daemon state (memory leaks, zombie sessions). Idle-gated: a node whose daemon has an active session (generating / waiting_approval / starting) is refused with code "blocking_sessions" so an in-flight turn is never interrupted. self_only=true waives ONLY this mesh's own coordinator session (the structural self-deadlock case \u2014 the coordinator is always generating while it calls). Other sessions still refuse. force=true bypasses the gate entirely: in-flight turns die and the unpersisted pendingOutboundQueue is lost. when_idle=true schedules the restart to run automatically once the daemon goes idle (the safest path \u2014 no queue loss); cancel_when_idle=true cancels it and every response reports the schedule under deferredRestart. kill_session_host=true additionally stops the session-host process, destroying ALL hosted CLI sessions (hard refresh; this is what Windows already does on every upgrade). Default off. Note: on Windows any daemon restart/upgrade terminates all hosted sessions regardless of options; on POSIX hosted sessions survive a plain restart and rebind on next boot. Passing channel switches the daemon's release channel (and server URL) before restarting; omit it to keep the daemon on its configured channel.`,
   inputSchema: {
     type: "object",
     properties: {
-      node_id: { type: "string", description: "Target node ID \u2014 the daemon that owns this node is updated and restarted." },
-      channel: { type: "string", enum: ["stable", "preview"], description: "Optional release channel to update from. Defaults to the daemon's configured updateChannel. Setting it also repoints the daemon's server URL to that channel." }
+      node_id: { type: "string", description: "Target node ID \u2014 the daemon that owns this node is restarted (and updated, in upgrade mode)." },
+      channel: { type: "string", enum: ["stable", "preview"], description: "Optional release channel to update from (upgrade mode only). Defaults to the daemon's configured updateChannel. Setting it also repoints the daemon's server URL to that channel." },
+      mode: { type: "string", enum: ["upgrade", "restart"], description: "upgrade (default): update to latest on channel, then restart (already-latest is a no-op). restart: pure re-spawn, no reinstall \u2014 restarts even when already latest." },
+      force: { type: "boolean", description: "Bypass the idle-gate entirely. Destructive: in-flight turns are killed and the in-memory pendingOutboundQueue is permanently lost. Default false." },
+      self_only: { type: "boolean", description: "Waive only this mesh's own coordinator session when it blocks the restart (the coordinator self-deadlock). Other nodes' active sessions still refuse. Default false." },
+      when_idle: { type: "boolean", description: "If blocked, schedule the restart to execute automatically once the daemon goes idle (safest \u2014 no pendingOutboundQueue loss). The schedule expires after timeout_ms (default 30 min). Default false." },
+      cancel_when_idle: { type: "boolean", description: "Cancel a previously scheduled when_idle restart on the owning daemon." },
+      timeout_ms: { type: "number", description: "Expiry for a when_idle schedule in milliseconds (default 1800000 = 30 min, max 6 h)." },
+      kill_session_host: { type: "boolean", description: "Hard refresh: also stop the session-host process, destroying ALL hosted CLI sessions on the machine. Default false." }
     },
     required: ["node_id"]
   }
@@ -1120,23 +1163,41 @@ var MESH_LIST_PENDING_APPROVALS_TOOL = {
 };
 var MESH_CREATE_TOOL = {
   name: "mesh_create",
-  description: "Bootstrap a brand-new mesh for a Git repository \u2014 the first step for an MCP-only agent that has no mesh yet. Mirrors `adhdev mesh create <name>`. A mesh groups one repo's workspaces/nodes so the coordinator can delegate work across them. You MUST supply the repo identity: pass repo_remote_url (the git remote URL, e.g. git@github.com:user/repo.git or https://github.com/user/repo.git \u2014 the identity is derived from it) OR repo_identity (an explicit normalized identity like github.com/user/repo). At least one is required; there is no auto-detection here (the CLI auto-detects from the current dir, but the MCP server may run elsewhere). Set add_current:true to also register a node in the same call (uses workspace if given, else the daemon's current working directory) \u2014 handy when the daemon runs in the repo you want as the base node. BOOT-GATE / WHEN CALLABLE: this tool is reachable in STANDARD mode (adhdev mcp, no --repo-mesh) \u2014 the bootstrap context where no mesh exists \u2014 and also in mesh mode (where it creates a SEPARATE additional mesh). It is NOT reachable before any mesh exists via mesh mode, because `adhdev mcp --repo-mesh <id>` refuses to start without an existing meshId. So the intended flow is: run standard-mode MCP \u2192 mesh_create \u2192 mesh_add_node \u2192 then relaunch as `adhdev mcp --repo-mesh <returned mesh_id>`. Returns mesh_id (and node_id when add_current is used); use mesh_id for the follow-up mesh_add_node call and to launch mesh mode.",
+  description: "Bootstrap a brand-new mesh for a Git repository \u2014 the first step for an MCP-only agent that has no mesh yet. Mirrors `adhdev mesh create <name>`. A mesh groups one repo's workspaces/nodes so the coordinator can delegate work across them. Pass workspace to auto-detect Git identity/branch/worktree metadata through the read-only planner, or explicitly pass repo_remote_url / repo_identity for backward compatibility. This is a persistent write: call mesh_plan_onboarding first and obtain explicit user approval before invoking it. Set add_current:true to also register a node in the same call (uses workspace if given, else the daemon's current working directory). BOOT-GATE / WHEN CALLABLE: this tool is reachable in STANDARD mode (adhdev mcp, no --repo-mesh) \u2014 the bootstrap context where no mesh exists \u2014 and also in mesh mode (where it creates a SEPARATE additional mesh). It is NOT reachable before any mesh exists via mesh mode, because `adhdev mcp --repo-mesh <id>` refuses to start without an existing meshId. So the intended flow is: run standard-mode MCP \u2192 mesh_create \u2192 mesh_add_node \u2192 then relaunch as `adhdev mcp --repo-mesh <returned mesh_id>`. Returns mesh_id (and node_id when add_current is used); use mesh_id for the follow-up mesh_add_node call and to launch mesh mode.",
   inputSchema: {
     type: "object",
     properties: {
       name: { type: "string", description: 'Human-readable mesh name (e.g. "adhdev-main"). Trimmed, max 100 chars.' },
-      repo_remote_url: { type: "string", description: "Git remote URL of the repo (e.g. git@github.com:user/repo.git). The repo identity is normalized from this. Provide this OR repo_identity." },
-      repo_identity: { type: "string", description: "Explicit normalized repo identity (e.g. github.com/user/repo). Provide this OR repo_remote_url. Wins over repo_remote_url when both are given." },
+      repo_remote_url: { type: "string", description: "Optional explicit Git remote URL. When omitted with repo_identity, identity is read-only auto-detected from workspace." },
+      repo_identity: { type: "string", description: "Optional explicit normalized repo identity. Wins over repo_remote_url; when both are omitted, workspace is auto-detected." },
       default_branch: { type: "string", description: 'Default branch for the repo (e.g. "main"). Optional; used as the merge/convergence target.' },
       add_current: { type: "boolean", description: "Also register a node in this same call (parity with CLI --add-current). Uses `workspace` if provided, otherwise the daemon's current working directory." },
-      workspace: { type: "string", description: "Absolute workspace path to register when add_current:true. Ignored unless add_current is true. Defaults to the daemon's cwd." }
+      workspace: { type: "string", description: "Absolute workspace path used for Git auto-detection and, when add_current:true, node registration. Defaults to the daemon cwd." }
     },
     required: ["name"]
   }
 };
+var MESH_PLAN_ONBOARDING_TOOL = {
+  name: "mesh_plan_onboarding",
+  description: "Read-only Git-aware Repo Mesh discovery and dry-run planning for a workspace path. Detects the Git root, normalized remotes/repo identity, current/default branch, main checkout vs linked worktree/common-dir metadata, dirty/conflict state, and existing mesh/node membership. Returns a typed create+onboarding, add-existing-workspace, or clone-new-worktree plan with suggested .adhdev configs. It never fetches, writes config, creates a mesh/node/branch/worktree, or otherwise mutates state. Use this before mesh_create, mesh_add_node, or mesh_clone_node; execute write steps only after explicit user approval.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      workspace: { type: "string", description: "Absolute path on the daemon that owns the Git checkout." },
+      mesh_id: { type: "string", description: "Optional existing mesh to validate against. In mesh mode defaults to the active mesh." },
+      operation: {
+        type: "string",
+        enum: ["auto", "add_existing", "clone_worktree", "create_mesh"],
+        description: "Planning intent. auto chooses create+onboard when no compatible mesh exists, otherwise add existing. clone_worktree requires branch and a clean source."
+      },
+      branch: { type: "string", description: "New branch name when operation=clone_worktree." }
+    },
+    required: ["workspace"]
+  }
+};
 var MESH_ADD_NODE_TOOL = {
   name: "mesh_add_node",
-  description: "Register a workspace as a node in an EXISTING mesh \u2014 the second bootstrap step after mesh_create (or to add more nodes later). Mirrors `adhdev mesh add-node <mesh_id>` with --workspace / --read-only / --provider-priority. A node is a repo checkout on a daemon that the coordinator can launch agents on and delegate tasks to. mesh_id is REQUIRED in standard mode (pass the id returned by mesh_create); in mesh mode it defaults to the active mesh. workspace is the absolute path to the repo checkout ON THE DAEMON that owns it \u2014 the local base node is added by the daemon that created the mesh. NOTE: this registers an EXISTING directory as a node (including marking one as a worktree via is_worktree). To CREATE a fresh git worktree + branch for isolated parallel work, use mesh_clone_node instead \u2014 that runs the actual `git worktree add`. Returns node_id + workspace so you can immediately target the node with mesh_launch_session / mesh_send_task / mesh_enqueue_task.",
+  description: "Register a workspace as a node in an EXISTING mesh \u2014 the second bootstrap step after mesh_create (or to add more nodes later). Mirrors `adhdev mesh add-node <mesh_id>` with --workspace / --read-only / --provider-priority. A node is a repo checkout on a daemon that the coordinator can launch agents on and delegate tasks to. mesh_id is REQUIRED in standard mode (pass the id returned by mesh_create); in mesh mode it defaults to the active mesh. workspace is the absolute path to the repo checkout ON THE DAEMON that owns it \u2014 the local base node is added by the daemon that created the mesh. This is a persistent mesh write: call mesh_plan_onboarding first and obtain explicit user approval. The implementation re-runs that preflight before writing. NOTE: this registers an EXISTING directory as a node (including auto-detected linked worktrees). To CREATE a fresh git worktree + branch for isolated parallel work, use mesh_clone_node instead \u2014 that runs the actual `git worktree add`. Returns node_id + workspace so you can immediately target the node with mesh_launch_session / mesh_send_task / mesh_enqueue_task.",
   inputSchema: {
     type: "object",
     properties: {
@@ -1155,7 +1216,7 @@ var MESH_ADD_NODE_TOOL = {
 };
 var MESH_CLONE_NODE_TOOL = {
   name: "mesh_clone_node",
-  description: "Create a new worktree-based node from an existing node for isolated parallel work. Creates a git worktree on a new branch so multiple tasks can run on separate branches simultaneously.",
+  description: "Create a new worktree-based node from an existing node for isolated parallel work. Creates a git worktree on a new branch so multiple tasks can run on separate branches simultaneously. This writes a branch, worktree and mesh node: call mesh_plan_onboarding with operation=clone_worktree and obtain explicit user approval first; the implementation re-runs the clean/source preflight.",
   inputSchema: {
     type: "object",
     properties: {
@@ -1183,6 +1244,18 @@ var MESH_REMOVE_NODE_TOOL = {
     required: ["node_id"]
   }
 };
+var MESH_CLEANUP_WORKTREE_NODES_TOOL = {
+  name: "mesh_cleanup_worktree_nodes",
+  description: "Plan (dry-run, default) or execute safe removal of CONVERGED local worktree nodes (lifecycle retention). A node is eligible only when its feature branch is proven merged/pushed/converged AND every safety exclusion passes: no dirty/conflicted/stashed/submodule-drift state, no live session, no queue/direct-dispatch reference, no in-flight or blocked_review Refinery job, not the coordinator/base/cwd/evidence node. The automatic reconcile pass additionally requires two consecutive eligible ticks spanning a grace window (default 48h). Per-node reason codes are always returned; removal never uses force and branch refs are deleted only when proven fully merged.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Optional: restrict the plan/execute to a single node. When omitted, every node in the mesh is evaluated." },
+      dry_run: { type: "boolean", description: "Default true. true = read-only reason-coded plan (identical shape to the automatic pass); false = execute removal for every currently-eligible node (never forces; the non-destructive precheck re-runs immediately before each removal)." }
+    },
+    required: []
+  }
+};
 var MESH_CLEANUP_SESSIONS_TOOL = {
   name: "mesh_cleanup_sessions",
   description: "Manually clean up delegated session records for a mesh node without removing the node. Defaults should preserve reviewable history unless the caller chooses a mode explicitly.",
@@ -1579,10 +1652,12 @@ var ALL_MESH_TOOLS = [
   MESH_APPROVE_TOOL,
   MESH_ANSWER_QUESTION_TOOL,
   MESH_LIST_PENDING_APPROVALS_TOOL,
+  MESH_PLAN_ONBOARDING_TOOL,
   MESH_CREATE_TOOL,
   MESH_ADD_NODE_TOOL,
   MESH_CLONE_NODE_TOOL,
   MESH_REMOVE_NODE_TOOL,
+  MESH_CLEANUP_WORKTREE_NODES_TOOL,
   MESH_REFINE_NODE_TOOL,
   MESH_REFINE_BATCH_TOOL,
   MESH_REFINE_CONFIG_TOOL,
@@ -2359,6 +2434,7 @@ async function reconcileDirectDispatchesFromTranscriptEvidence(ctx, liveNodes, d
       });
       const payload = unwrapCommandPayload(readResult);
       if (payload?.success === false) continue;
+      if ((0, import_daemon_core3.hasTrailingToolActivityAfterFinalAssistant)(Array.isArray(payload?.messages) ? payload.messages : [])) continue;
       const evidence = readFinalAssistantTranscriptEvidence(payload);
       if (!evidence.finalSummary) continue;
       const result = (0, import_daemon_core3.reconcileDirectDispatchCompletionFromTranscript)({
@@ -3231,6 +3307,12 @@ function buildMeshForwardPayloadFromPendingEvent(event) {
     interactionId: readString(metadataEvent.interactionId),
     status: readString(metadataEvent.status),
     targetDaemonId: readString(metadataEvent.targetDaemonId),
+    // RC32: carry the coordinator DAEMON anchor across the remote-pull relay (the
+    // pending event stores it top-level, not inside metadataEvent). The receive-side
+    // whitelist (daemon-core buildRelayMetadataEvent) reads it back so a sessionless
+    // refine terminal event re-queues targeted at THIS coordinator instead of
+    // self-fallback-stamping the relaying worker daemon.
+    targetCoordinatorDaemonId: readString(event?.targetCoordinatorDaemonId),
     startedAt: readString(metadataEvent.startedAt),
     completedAt: readString(metadataEvent.completedAt),
     retryOfJobId: readString(metadataEvent.retryOfJobId),
@@ -3577,6 +3659,11 @@ async function meshStatus(ctx, args = {}) {
           status: s.status ?? s.lifecycle ?? s.state,
           providerType: s.providerType ?? s.cliType ?? s.type,
           ...s.activeChat?.status ? { chatStatus: s.activeChat.status } : {},
+          // Stage 6: attempt identity + causal stage from the unified turn
+          // projection (present on mesh-owned sessions only), so mesh_status
+          // reports the SAME attemptId/stage as read_chat and the dashboard.
+          ...s.turn?.attemptId ? { attemptId: s.turn.attemptId } : {},
+          ...s.turn?.stage ? { turnStage: s.turn.stage } : {},
           ...isSelfCoordinator ? { isSelfCoordinator: true, role: "coordinator" } : {},
           // [T2] Carry the worker-computed last-message preview through the slim so
           // the coordinator's inbox can show the worker's latest ASSISTANT reply
@@ -6671,30 +6758,29 @@ async function meshSendTask(ctx, args) {
       }
       if (explicitTargetSession && !isIdleSessionRecord(explicitTargetSession) && !isTerminalSessionRecord(explicitTargetSession)) {
         const sessionStatus = typeof explicitTargetSession?.status === "string" ? explicitTargetSession.status : "unknown";
-        const { createSessionDelivery: createDelivery, resolveDeliveryDecision } = await import("@adhdev/daemon-core");
+        const { resolveDeliveryDecision } = await import("@adhdev/daemon-core");
         const policyResult = resolveDeliveryDecision(sessionStatus, { kind: "task" });
         if (policyResult.decision === "queued") {
-          const delivery = createDelivery({
-            meshId: ctx.mesh.id,
-            nodeId: args.node_id,
-            sessionId: args.session_id,
-            providerType: resolvedProviderType,
-            kind: "task",
-            message,
-            status: "queued"
+          const queuedTask = (0, import_daemon_core4.enqueueTask)(ctx.mesh.id, message, {
+            targetNodeId: args.node_id,
+            targetSessionId: args.session_id,
+            taskMode,
+            ...readonly ? { readonly: true } : {},
+            ...missionId ? { missionId } : {},
+            ...ctx.coordinatorSessionId ? { sourceCoordinatorSessionId: ctx.coordinatorSessionId } : {}
           });
           return JSON.stringify({
             success: true,
             dispatched: false,
             decision: "queued_delivery",
-            deliveryId: delivery.id,
+            taskId: queuedTask.id,
             reason: policyResult.reason,
             nodeId: args.node_id,
             sessionId: args.session_id,
             sessionStatus,
             taskMode: taskMode || void 0,
             message: policyResult.message,
-            nextAction: `Use mesh_status to watch for session idle transition, or use mesh_enqueue_task for queue-based assignment. Check deliveryId '${delivery.id}' to track queued delivery.`
+            nextAction: `Task '${queuedTask.id}' is queued and pinned to session '${args.session_id}' \u2014 it auto-delivers the moment the session goes idle. Use mesh_status or mesh_task_history to track it; no manual resend needed.`
           });
         }
       }
@@ -6886,7 +6972,11 @@ async function meshReadChat(ctx, args) {
     const compactPayload = compactChatPayload(payload, {
       nodeId: args.node_id,
       sessionId: args.session_id,
-      limit: args.tail ?? 10
+      limit: args.tail ?? 10,
+      // Carry the daemon's Stage 6 turn projection (attemptId/turnStage/
+      // authority/terminal outcome) so the slim response stays at parity
+      // with daemon read_chat and mesh_status. Non-content scalars only.
+      preserveTurn: true
     });
     return JSON.stringify(
       payload.pollingAdvisory ? { ...compactPayload, pollingAdvisory: payload.pollingAdvisory } : compactPayload,
@@ -7365,7 +7455,14 @@ async function meshRestartDaemon(ctx, args) {
       meshId: ctx.mesh.id,
       nodeId: node.id,
       inlineMesh: ctx.mesh,
-      ...args.channel ? { channel: args.channel } : {}
+      ...args.channel ? { channel: args.channel } : {},
+      ...args.mode ? { mode: args.mode } : {},
+      ...args.force === true ? { force: true } : {},
+      ...args.self_only === true ? { selfOnly: true } : {},
+      ...args.when_idle === true ? { whenIdle: true } : {},
+      ...args.cancel_when_idle === true ? { cancelWhenIdle: true } : {},
+      ...typeof args.timeout_ms === "number" ? { timeoutMs: args.timeout_ms } : {},
+      ...args.kill_session_host === true ? { killSessionHost: true } : {}
     });
     return JSON.stringify(unwrapCommandPayload(result), null, 2);
   } catch (e) {
@@ -7405,6 +7502,23 @@ async function meshCheckpoint(ctx, args) {
 }
 async function meshCloneNode(ctx, args) {
   const sourceNode = await findNodeWithRefresh(ctx, args.source_node_id);
+  const planned = unwrapCommandPayload(await commandForNode(ctx, sourceNode, "plan_mesh_onboarding", {
+    workspace: sourceNode.workspace,
+    meshId: ctx.mesh.id,
+    inlineMesh: ctx.mesh,
+    operation: "clone_worktree",
+    branch: args.branch
+  }));
+  if (!planned?.success) {
+    return JSON.stringify({
+      success: false,
+      dry_run: true,
+      code: planned?.code || "onboarding_blocked",
+      error: planned?.error || "Worktree clone preflight failed",
+      action: planned?.action,
+      raw: planned
+    }, null, 2);
+  }
   const result = await commandForNode(ctx, sourceNode, "clone_mesh_node", {
     meshId: ctx.mesh.id,
     sourceNodeId: args.source_node_id,
@@ -7455,21 +7569,105 @@ async function meshRemoveNode(ctx, args) {
   }
   return JSON.stringify({ ...result || {}, ...transportFallback ? { transportFallback } : {} }, null, 2);
 }
+async function meshCleanupWorktreeNodes(ctx, args) {
+  const dryRun = args?.dry_run !== false;
+  const wireArgs = {
+    meshId: ctx.mesh.id,
+    dryRun,
+    ...args?.node_id ? { nodeId: args.node_id } : {}
+  };
+  let result;
+  try {
+    if (args?.node_id) {
+      const node = await findNodeWithRefresh(ctx, args.node_id);
+      result = await commandForNode(ctx, node, "cleanup_worktree_nodes", wireArgs);
+    } else {
+      result = await ctx.transport.command("cleanup_worktree_nodes", wireArgs);
+    }
+  } catch (e) {
+    return JSON.stringify({
+      success: false,
+      code: isP2pTransportUnavailableError(e) ? "p2p_unavailable" : "mesh_cleanup_worktree_nodes_failed",
+      error: e?.message || String(e),
+      recoveryHint: "Inspect mesh_status and retry after resolving the reported failure; per-node reasons are never hidden in a successful plan."
+    }, null, 2);
+  }
+  if (!dryRun && result?.success && Array.isArray(result.entries)) {
+    let changed = false;
+    for (const entry of result.entries) {
+      if (entry?.execution?.success && entry.execution.removed) {
+        const idx = ctx.mesh.nodes.findIndex((n) => n.id === entry.nodeId);
+        if (idx >= 0) {
+          ctx.mesh.nodes.splice(idx, 1);
+          changed = true;
+        }
+      }
+    }
+    if (changed) ctx.mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  return JSON.stringify(result ?? { success: false, error: "no response from daemon" }, null, 2);
+}
 
 // src/tools/mesh-tools-crud.ts
+async function meshPlanOnboarding(transport, args, defaultMeshId) {
+  const workspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";
+  if (!workspace) {
+    return JSON.stringify({
+      success: false,
+      dryRun: true,
+      code: "workspace_required",
+      error: "workspace required",
+      action: "Pass an absolute path on the daemon that owns the checkout."
+    }, null, 2);
+  }
+  const meshId = typeof args?.mesh_id === "string" && args.mesh_id.trim() ? args.mesh_id.trim() : typeof defaultMeshId === "string" ? defaultMeshId.trim() : "";
+  const result = await transport.command("plan_mesh_onboarding", {
+    workspace,
+    ...meshId ? { meshId } : {},
+    ...args?.operation ? { operation: args.operation } : {},
+    ...typeof args?.branch === "string" && args.branch.trim() ? { branch: args.branch.trim() } : {}
+  });
+  return JSON.stringify(unwrapCommandPayload(result), null, 2);
+}
 async function meshCreate(transport, args) {
   const name = typeof args?.name === "string" ? args.name.trim() : "";
   if (!name) {
     return JSON.stringify({ success: false, error: "name required" }, null, 2);
   }
-  const repoRemoteUrl = typeof args?.repo_remote_url === "string" ? args.repo_remote_url.trim() : "";
-  const repoIdentity = typeof args?.repo_identity === "string" ? args.repo_identity.trim() : "";
-  const defaultBranch = typeof args?.default_branch === "string" ? args.default_branch.trim() : "";
+  let repoRemoteUrl = typeof args?.repo_remote_url === "string" ? args.repo_remote_url.trim() : "";
+  let repoIdentity = typeof args?.repo_identity === "string" ? args.repo_identity.trim() : "";
+  let defaultBranch = typeof args?.default_branch === "string" ? args.default_branch.trim() : "";
+  let discovery;
   if (!repoRemoteUrl && !repoIdentity) {
-    return JSON.stringify({
-      success: false,
-      error: "Either repo_remote_url or repo_identity is required. Pass the repo's git remote URL (e.g. git@github.com:user/repo.git) or an explicit identity (e.g. github.com/user/repo)."
-    }, null, 2);
+    const workspace = typeof args?.workspace === "string" && args.workspace.trim() ? args.workspace.trim() : void 0;
+    const planned = unwrapCommandPayload(await transport.command("plan_mesh_onboarding", {
+      ...workspace ? { workspace } : {},
+      operation: "auto"
+    }));
+    if (!planned?.success) {
+      return JSON.stringify({
+        success: false,
+        dry_run: true,
+        code: planned?.code || "onboarding_blocked",
+        error: planned?.error || "Could not infer repository identity from the workspace.",
+        action: planned?.action,
+        raw: planned
+      }, null, 2);
+    }
+    if (planned?.plan?.kind !== "create_mesh_and_onboard") {
+      return JSON.stringify({
+        success: false,
+        dry_run: true,
+        code: "compatible_mesh_exists",
+        error: planned?.plan?.summary || "A compatible mesh already exists.",
+        action: "Use mesh_add_node with the compatible mesh instead of creating a duplicate mesh.",
+        raw: planned
+      }, null, 2);
+    }
+    discovery = planned.discovery;
+    repoRemoteUrl = discovery?.origin?.urls?.[0] || discovery?.upstream?.urls?.[0] || "";
+    repoIdentity = discovery?.repoIdentity || "";
+    defaultBranch ||= discovery?.defaultBranch || "";
   }
   const createResult = await transport.command("create_mesh", {
     name,
@@ -7499,7 +7697,9 @@ async function meshCreate(transport, args) {
     const workspace = typeof args?.workspace === "string" && args.workspace.trim() ? args.workspace.trim() : "";
     const addResult = await transport.command("add_mesh_node", {
       meshId: mesh.id,
-      ...workspace ? { workspace } : {},
+      ...workspace || discovery?.repoRoot ? { workspace: discovery?.repoRoot || workspace } : {},
+      ...discovery?.repoRoot ? { repoRoot: discovery.repoRoot } : {},
+      ...discovery?.isLinkedWorktree === true ? { isLocalWorktree: true } : {},
       inlineMesh: mesh
     });
     const addPayload = unwrapCommandPayload(addResult);
@@ -7522,12 +7722,31 @@ async function meshAddNode(transport, args, defaultMeshId) {
     return JSON.stringify({ success: false, error: "workspace required (absolute path to the repo checkout on the target daemon)." }, null, 2);
   }
   const providerPriority = Array.isArray(args?.provider_priority) ? args.provider_priority.map((v) => typeof v === "string" ? v.trim() : "").filter(Boolean) : typeof args?.provider_priority === "string" ? args.provider_priority.split(",").map((v) => v.trim()).filter(Boolean) : [];
-  const addResult = await transport.command("add_mesh_node", {
+  const planResult = await transport.command("plan_mesh_onboarding", {
     meshId,
     workspace,
+    operation: "add_existing",
+    ...args?.inline_mesh ? { inlineMesh: args.inline_mesh } : {}
+  });
+  const planPayload = unwrapCommandPayload(planResult);
+  if (!planPayload?.success) {
+    return JSON.stringify({
+      success: false,
+      dry_run: true,
+      code: planPayload?.code || "onboarding_blocked",
+      error: planPayload?.error || "Repo Mesh onboarding preflight failed",
+      action: planPayload?.action,
+      raw: planPayload ?? planResult
+    }, null, 2);
+  }
+  const discoveredWorkspace = typeof planPayload?.discovery?.repoRoot === "string" ? planPayload.discovery.repoRoot : workspace;
+  const addResult = await transport.command("add_mesh_node", {
+    meshId,
+    workspace: discoveredWorkspace,
+    repoRoot: discoveredWorkspace,
     ...args?.read_only === true ? { readOnly: true } : {},
     ...providerPriority.length ? { providerPriority } : {},
-    ...args?.is_worktree === true ? { isLocalWorktree: true } : {},
+    ...args?.is_worktree === true || planPayload?.discovery?.isLinkedWorktree === true ? { isLocalWorktree: true } : {},
     ...args?.inline_mesh ? { inlineMesh: args.inline_mesh } : {}
   });
   const addPayload = unwrapCommandPayload(addResult);
@@ -7668,11 +7887,13 @@ async function meshRefinePlan(ctx, args) {
 }
 async function meshRefineNode(ctx, args) {
   const node = await findNodeWithRefresh(ctx, args.node_id);
+  const coordinatorDaemonId = resolveCoordinatorDaemonId(ctx);
   const result = await commandForNode(ctx, node, "refine_mesh_node", {
     meshId: ctx.mesh.id,
     nodeId: args.node_id,
     ...args.execute !== void 0 ? { execute: args.execute } : {},
     ...args.dry_run !== void 0 ? { dryRun: args.dry_run } : {},
+    ...coordinatorDaemonId ? { coordinatorDaemonId } : {},
     inlineMesh: ctx.mesh
   });
   if (result?.success && result.async !== true && result.removeResult?.removed !== false) {
@@ -7687,11 +7908,13 @@ async function meshRefineNode(ctx, args) {
 async function meshRefineBatch(ctx, args = {}) {
   await refreshMeshFromDaemon(ctx);
   const nodeIds = Array.isArray(args.node_ids) ? args.node_ids.filter((v) => typeof v === "string" && v.trim().length > 0).map((v) => v.trim()) : void 0;
+  const coordinatorDaemonId = resolveCoordinatorDaemonId(ctx);
   const result = await ctx.transport.command("batch_refine_mesh_nodes", {
     meshId: ctx.mesh.id,
     ...nodeIds ? { nodeIds } : {},
     ...args.execute !== void 0 ? { execute: args.execute } : {},
     ...args.dry_run !== void 0 ? { dryRun: args.dry_run } : {},
+    ...coordinatorDaemonId ? { coordinatorDaemonId } : {},
     inlineMesh: ctx.mesh
   });
   const payload = unwrapCommandPayload(result) ?? result;
@@ -7916,7 +8139,7 @@ function formatChatResult(result, sessionId, format, limit = 50, compact = false
   }
   const messages = result?.messages ?? result?.data?.messages ?? [];
   const source = { ...result, messages };
-  const compactPayload = compact ? compactChatPayload(source, { sessionId: sessionId ?? null, limit }) : null;
+  const compactPayload = compact ? compactChatPayload(source, { sessionId: sessionId ?? null, limit, preserveTurn: true }) : null;
   const outputMessages = compact ? compactPayload.messages : messages;
   if (format === "json") {
     if (compact && compactPayload) {
@@ -8649,13 +8872,13 @@ ${raw.output}` : "";
 // src/tools/launch-session.ts
 var LAUNCH_SESSION_TOOL = {
   name: "launch_session",
-  description: "Launch a new agent session on the daemon. Supports CLI agents (e.g. hermes-cli, claude-cli, gemini-cli), ACP agents (e.g. claude-acp), and IDEs (e.g. cursor, vscode).",
+  description: "Launch a new agent session on the daemon. Supports CLI agents (e.g. kimi, hermes-cli, claude-cli, gemini-cli), ACP agents (e.g. claude-acp), and IDEs (e.g. cursor, vscode).",
   inputSchema: {
     type: "object",
     properties: {
       type: {
         type: "string",
-        description: "Provider type to launch. CLI examples: hermes-cli, claude-cli, gemini-cli. ACP examples: claude-acp. IDE examples: cursor, vscode."
+        description: "Provider type to launch. CLI examples: kimi, hermes-cli, claude-cli, gemini-cli. ACP examples: claude-acp. IDE examples: cursor, vscode. Manifest aliases (e.g. codex \u2192 codex-cli) resolve to the canonical provider type."
       },
       workspace: {
         type: "string",
@@ -8669,14 +8892,48 @@ var LAUNCH_SESSION_TOOL = {
     required: ["type"]
   }
 };
+function legacyHeuristicRoute(type) {
+  const isCliOrAcp = type.includes("-cli") || type.includes("-acp") || type === "codex";
+  return { route: isCliOrAcp ? "cli" : "ide", canonicalType: type };
+}
+async function resolveProviderRoute(transport, requestedType) {
+  const type = requestedType.trim();
+  if (!type) return { error: "type is required" };
+  let catalog;
+  try {
+    catalog = await transport.command("list_provider_availability", {});
+  } catch {
+    catalog = null;
+  }
+  const providers = Array.isArray(catalog?.providers) ? catalog.providers : null;
+  if (!catalog || catalog.success === false || !providers) {
+    return legacyHeuristicRoute(type);
+  }
+  const query = type.toLowerCase();
+  const hit = providers.find((p) => {
+    if (!p || typeof p.type !== "string") return false;
+    if (p.type.toLowerCase() === query) return true;
+    const aliases = Array.isArray(p.aliases) ? p.aliases : [];
+    return aliases.some((alias) => typeof alias === "string" && alias.toLowerCase() === query);
+  });
+  if (!hit) {
+    const known = providers.map((p) => p && typeof p.type === "string" ? p.type : null).filter(Boolean).sort();
+    return {
+      error: `Unknown provider type '${type}'. Known provider types: ${known.join(", ")}`
+    };
+  }
+  const route = hit.category === "cli" || hit.category === "acp" ? "cli" : "ide";
+  return { route, canonicalType: hit.type };
+}
 async function launchSession(transport, args) {
-  const isCliOrAcp = args.type.includes("-cli") || args.type.includes("-acp") || args.type === "codex";
-  const commandType = isCliOrAcp ? "launch_cli" : "launch_ide";
-  const payload = isCliOrAcp ? { cliType: args.type, dir: args.workspace ?? "~", ...args.model ? { model: args.model } : {} } : { ideType: args.type, enableCdp: true };
+  const resolved = await resolveProviderRoute(transport, args.type);
+  if ("error" in resolved) return `Error: ${resolved.error}`;
+  const commandType = resolved.route === "cli" ? "launch_cli" : "launch_ide";
+  const payload = resolved.route === "cli" ? { cliType: resolved.canonicalType, dir: args.workspace ?? "~", ...args.model ? { model: args.model } : {} } : { ideType: resolved.canonicalType, enableCdp: true };
   const result = await transport.command(commandType, payload);
   if (result?.success === false) return `Error: ${result.error ?? "launch failed"}`;
   const id = result?.id ?? result?.sessionId;
-  return id ? `Session launched. id: ${id}, type: ${args.type}` : `Launched: ${JSON.stringify(result)}`;
+  return id ? `Session launched. id: ${id}, type: ${resolved.canonicalType}` : `Launched: ${JSON.stringify(result)}`;
 }
 
 // src/tools/stop-session.ts
@@ -8844,7 +9101,7 @@ async function startMcpServer(opts) {
     const meshCtx = { mesh, transport, ...localDaemonId ? { localDaemonId } : {}, ...localMachineId ? { localMachineId } : {}, ...coordinatorHostname ? { coordinatorHostname } : {}, ...coordinatorSessionId ? { coordinatorSessionId } : {} };
     const coordinatorPrompt = await buildMeshModeCoordinatorPrompt(mesh);
     const server2 = new import_server.Server(
-      { name: "adhdev-mcp-server", version: "1.0.27" },
+      { name: "adhdev-mcp-server", version: "1.0.28" },
       { capabilities: { tools: {}, resources: {} } }
     );
     const { ListResourcesRequestSchema, ReadResourceRequestSchema } = await import("@modelcontextprotocol/sdk/types.js");
@@ -8929,11 +9186,14 @@ async function startMcpServer(opts) {
           case "mesh_list_pending_approvals":
             text = await meshListPendingApprovals(meshCtx, a);
             break;
+          case "mesh_plan_onboarding":
+            text = await meshPlanOnboarding(meshCtx.transport, a, meshCtx.mesh.id);
+            break;
           case "mesh_create":
             text = await meshCreate(meshCtx.transport, a);
             break;
           case "mesh_add_node":
-            text = await meshAddNode(meshCtx.transport, a, meshCtx.mesh.id);
+            text = await meshAddNode(meshCtx.transport, { ...a, inline_mesh: meshCtx.mesh }, meshCtx.mesh.id);
             break;
           case "mesh_clone_node":
             text = await meshCloneNode(meshCtx, a);
@@ -8941,6 +9201,9 @@ async function startMcpServer(opts) {
           case "mesh_remove_node":
             text = await meshRemoveNode(meshCtx, a);
             break;
+          case "mesh_cleanup_worktree_nodes":
+            text = await meshCleanupWorktreeNodes(meshCtx, a);
+            break;
           case "mesh_refine_node":
             text = await meshRefineNode(meshCtx, a);
             break;
@@ -9075,6 +9338,7 @@ async function startMcpServer(opts) {
     // Mesh bootstrap: create a mesh + register its first node from an MCP-only agent.
     // Exposed in standard mode precisely because this is the no-mesh-yet context —
     // mesh mode refuses to boot without an existing meshId (see the mesh-mode block above).
+    MESH_PLAN_ONBOARDING_TOOL,
     MESH_CREATE_TOOL,
     MESH_ADD_NODE_TOOL,
     ...isLocal ? [SCREENSHOT_TOOL] : []
@@ -9170,6 +9434,10 @@ async function startMcpServer(opts) {
           const text = await meshCreate(transport, a);
           return { content: [{ type: "text", text }] };
         }
+        case "mesh_plan_onboarding": {
+          const text = await meshPlanOnboarding(transport, a);
+          return { content: [{ type: "text", text }] };
+        }
         case "mesh_add_node": {
           const text = await meshAddNode(transport, a);
           return { content: [{ type: "text", text }] };