npm - @adhdev/daemon-standalone - Versions diffs - 1.0.28-rc.1 → 1.0.28-rc.11 - Mend

@adhdev/daemon-standalone 1.0.28-rc.1 → 1.0.28-rc.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/index.js +8022 -7127
package/dist/index.js.map +1 -1
package/package.json +2 -2
package/public/assets/{index-B51nIfEq.css → index-8TNNoifN.css} +1 -1
package/public/assets/{index-CX3wQvni.js → index-DJ5eteX0.js} +51 -51
package/public/index.html +2 -2
package/vendor/mcp-server/index.js +201 -9
package/vendor/mcp-server/index.js.map +1 -1

package/public/index.html CHANGED Viewed

@@ -7,9 +7,9 @@
     <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-CX3wQvni.js"></script>
+  <script type="module" crossorigin src="/assets/index-DJ5eteX0.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/vendor-DyCWA2YZ.js">
-  <link rel="stylesheet" crossorigin href="/assets/index-B51nIfEq.css">
+  <link rel="stylesheet" crossorigin href="/assets/index-8TNNoifN.css">
 </head>
 <body>
     <!-- Apply theme immediately to prevent FOIT (Flash of Incorrect Theme) -->

package/vendor/mcp-server/index.js CHANGED Viewed

@@ -393,6 +393,8 @@ var CANONICAL_MESH_TOOL_NAMES = [
   "mesh_approve",
   "mesh_answer_question",
   "mesh_list_pending_approvals",
+  "mesh_create",
+  "mesh_add_node",
   "mesh_clone_node",
   "mesh_remove_node",
   "mesh_refine_node",
@@ -998,12 +1000,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"]
   }
@@ -1116,6 +1125,41 @@ var MESH_LIST_PENDING_APPROVALS_TOOL = {
     properties: {}
   }
 };
+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.",
+  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." },
+      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." }
+    },
+    required: ["name"]
+  }
+};
+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.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      mesh_id: { type: "string", description: "Target mesh id (from mesh_create / mesh_status). Required in standard mode; defaults to the active mesh in mesh mode." },
+      workspace: { type: "string", description: "Absolute path to the repo checkout on the owning daemon (e.g. /Users/me/work/repo). Must be unique within the mesh." },
+      read_only: { type: "boolean", description: "Mark the node read-only (no launches/mutations targeted here). Parity with CLI --read-only." },
+      provider_priority: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Ordered provider types this node prefers when mesh_launch_session omits an explicit type (e.g. ["claude-cli","codex"]). Parity with CLI --provider-priority. A comma-separated string is also accepted.'
+      },
+      is_worktree: { type: "boolean", description: "Mark this workspace as an existing local git worktree (parity with CLI --worktree). This only tags an already-present worktree dir; it does NOT create one \u2014 use mesh_clone_node to create a worktree+branch." }
+    },
+    required: ["workspace"]
+  }
+};
 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.",
@@ -1406,7 +1450,6 @@ var MESH_MAGI_REVIEW_TOOL = {
       n: { type: "number", description: "Global replica override per slot (clamped by the total-replica guard cap, default 12)." },
       task_kind: { type: "string", enum: ["claim_audit", "rca", "design", "freeform"], description: "REQUIRED. Selects (1) the SINGLE output schema injected into each replica prompt and the strict parser used at collection (no schema-on-schema conflict), AND (2) the user-configured kind-panel binding that supplies the fan-out slots (mesh settings \u2192 magiKindPanels; errors magi_kind_not_configured if that kind has no configured slots \u2014 no named-panel/inline/preset fallback). claim_audit: {claims[],top_findings[],open_questions[]}. rca: {rootCause,failsAt,mechanism,evidence[],fixDirection,confidence}. design: {recommendation,rationale,alternatives[],tradeoffs[],risks[],evidence[],confidence}. freeform: no schema \u2014 natural-language answer, parsing/evidence checks waived, cross-verification is weak. Every kind except freeform requires non-empty evidence[]; an empty-evidence or schema-invalid answer triggers ONE delta re-request before being dropped as unparseable. Do NOT also embed an output-format schema in the question \u2014 it collides with this contract (a warning is surfaced if detected)." },
       mode: { type: "string", enum: ["rca", "investigation", "claim_audit", "design_review", "code_audit"], description: "Synthesis emphasis hint \u2014 affects labels only, never the agent count or schema. Distinct from task_kind (which selects the output schema)." },
-      use_judge: { type: "boolean", description: "Default false (clustering synthesis). STUB: judge synthesis is not yet implemented \u2014 passing true currently falls back to clustering with a warning. Reserved interface only." },
       require_independent_evidence: { type: "boolean", description: "Default true \u2014 high-impact claims with no file:line/source evidence are routed to needs_verification." },
       include_stale: { type: "boolean", description: "Default false. By default, panel slots whose node HEAD commit differs from the coordinator reference commit are EXCLUDED (they would investigate different code). Set true to fan out to them anyway \u2014 results will be git-skewed and a warning is surfaced. If exclusion drops the panel below 2 independent targets the call errors rather than degrading to N=1; include_stale=true is one way to recover." },
       wait: { type: "boolean", description: "Default true \u2014 collect replica outputs and return the synthesis. Set false to dispatch async and return a consensusGroupId handle; collect later with mesh_magi_collect." },
@@ -1543,6 +1586,8 @@ var ALL_MESH_TOOLS = [
   MESH_APPROVE_TOOL,
   MESH_ANSWER_QUESTION_TOOL,
   MESH_LIST_PENDING_APPROVALS_TOOL,
+  MESH_CREATE_TOOL,
+  MESH_ADD_NODE_TOOL,
   MESH_CLONE_NODE_TOOL,
   MESH_REMOVE_NODE_TOOL,
   MESH_REFINE_NODE_TOOL,
@@ -2044,7 +2089,19 @@ function buildDirectTaskPayload(message, via, opts) {
     ...opts.targetSessionId ? { targetSessionId: opts.targetSessionId } : {},
     ...opts.dispatchedToIdleSession !== void 0 ? { dispatchedToIdleSession: opts.dispatchedToIdleSession } : {},
     ...opts.coordinatorSessionId ? { coordinatorSessionId: opts.coordinatorSessionId } : {},
-    ...opts.coordinatorDaemonId ? { coordinatorDaemonId: opts.coordinatorDaemonId } : {}
+    ...opts.coordinatorDaemonId ? { coordinatorDaemonId: opts.coordinatorDaemonId } : {},
+    // Uniform routing rationale (mirrors the queue-claim task_dispatched shape) so both
+    // paths render identically in mesh_task_history / the dashboard. The legacy top-level
+    // `source`/`via`/`providerType` fields above are preserved verbatim for existing
+    // consumers (mesh-active-work / mesh-events-stale key on payload.source === 'direct').
+    routingDecision: {
+      source: "direct",
+      via,
+      ...opts.selectedNodeId ? { selectedNodeId: opts.selectedNodeId } : {},
+      ...opts.providerType ? { resolvedProviderType: opts.providerType } : {},
+      ...opts.resolvedModel ? { resolvedModel: opts.resolvedModel } : {},
+      ...opts.resolvedThinkingLevel ? { resolvedThinkingLevel: opts.resolvedThinkingLevel } : {}
+    }
   };
 }
 function findNode(mesh, nodeId) {
@@ -2809,11 +2866,27 @@ function isGitStatusDirty(status) {
   if (Array.isArray(status?.submodules) && status.submodules.some((submodule) => submodule?.dirty || submodule?.outOfSync || submodule?.error)) return true;
   return countUncommittedChanges(status) > 0;
 }
+var ROUTING_SKIPPED_COMPACT_MAX = 5;
+function compactRoutingDecision(routing) {
+  const out = {};
+  for (const [k, v] of Object.entries(routing)) {
+    if (k === "skippedCandidates" && Array.isArray(v)) {
+      const kept = v.slice(0, ROUTING_SKIPPED_COMPACT_MAX);
+      out[k] = kept;
+      if (v.length > kept.length) out.skippedCandidatesDropped = v.length - kept.length;
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
 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 === "routingDecision" && v && typeof v === "object" && !Array.isArray(v)) {
+      slim[k] = compactRoutingDecision(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;
@@ -5532,8 +5605,6 @@ async function meshMagiReview(ctx, args) {
     }, null, 2);
   }
   const questionSchemaWarning = detectQuestionOutputSchemaConflict(question);
-  const useJudge = (args.use_judge ?? args.useJudge) === true;
-  const judgeWarning = useJudge ? "use_judge=true requested, but judge synthesis is not yet implemented \u2014 falling back to clustering synthesis." : null;
   await refreshMeshFromDaemon(ctx);
   const referenceCommit = resolveMagiReferenceCommit(ctx);
   const referenceSubmoduleKey = resolveMagiReferenceSubmoduleKey(ctx);
@@ -5639,7 +5710,6 @@ Target: ${args.target}` : ""}`,
     panel: panelName,
     taskKind,
     ...questionSchemaWarning ? { questionSchemaWarning } : {},
-    ...judgeWarning ? { judgeWarning } : {},
     question,
     replicaCount: replicaRecords.length,
     replicas: replicaRecords.map((r) => ({ taskId: r.taskId, provider: r.provider, targetNodeId: r.targetNodeId })),
@@ -6488,6 +6558,7 @@ async function meshSendTask(ctx, args) {
               taskMode,
               providerType,
               targetSessionId: dispatchedSessionId,
+              ...args.node_id ? { selectedNodeId: args.node_id } : {},
               ...ctx.coordinatorSessionId ? { coordinatorSessionId: ctx.coordinatorSessionId } : {},
               // COORD-EVENT-MISROUTE: persist the dispatching coordinator daemon anchor
               // (same value stamped into meshContext above) so a transcript-reconcile
@@ -6650,6 +6721,7 @@ async function meshSendTask(ctx, args) {
             providerType: resolvedProviderType,
             targetSessionId: args.session_id,
             dispatchedToIdleSession: sessionWasIdle,
+            ...args.node_id ? { selectedNodeId: args.node_id } : {},
             ...ctx.coordinatorSessionId ? { coordinatorSessionId: ctx.coordinatorSessionId } : {},
             // COORD-EVENT-MISROUTE: persist the dispatching coordinator daemon anchor so a
             // transcript-reconcile synth recovers it from the ledger rather than stamping
@@ -7300,7 +7372,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) {
@@ -7391,6 +7470,100 @@ async function meshRemoveNode(ctx, args) {
   return JSON.stringify({ ...result || {}, ...transportFallback ? { transportFallback } : {} }, null, 2);
 }
+// src/tools/mesh-tools-crud.ts
+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() : "";
+  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 createResult = await transport.command("create_mesh", {
+    name,
+    ...repoRemoteUrl ? { repoRemoteUrl } : {},
+    ...repoIdentity ? { repoIdentity } : {},
+    ...defaultBranch ? { defaultBranch } : {}
+  });
+  const createPayload = unwrapCommandPayload(createResult);
+  const mesh = createPayload?.mesh;
+  if (!createPayload?.success || !mesh?.id) {
+    return JSON.stringify({
+      success: false,
+      error: createPayload?.error || "create_mesh failed",
+      raw: createPayload ?? createResult
+    }, null, 2);
+  }
+  const out = {
+    success: true,
+    mesh_id: mesh.id,
+    name: mesh.name,
+    repo_identity: mesh.repoIdentity,
+    default_branch: mesh.defaultBranch,
+    node_count: Array.isArray(mesh.nodes) ? mesh.nodes.length : 0,
+    next_step: `Add the base node with mesh_add_node (mesh_id: "${mesh.id}", workspace: <repo path>), then start mesh mode with: adhdev mcp --repo-mesh ${mesh.id}`
+  };
+  if (args?.add_current === true) {
+    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 } : {},
+      inlineMesh: mesh
+    });
+    const addPayload = unwrapCommandPayload(addResult);
+    if (addPayload?.success && addPayload?.node?.id) {
+      out.node_id = addPayload.node.id;
+      out.node_workspace = addPayload.node.workspace;
+    } else {
+      out.add_current_error = addPayload?.error || "add_mesh_node failed (mesh was still created)";
+    }
+  }
+  return JSON.stringify(out, null, 2);
+}
+async function meshAddNode(transport, args, defaultMeshId) {
+  const meshId = typeof args?.mesh_id === "string" && args.mesh_id.trim() ? args.mesh_id.trim() : typeof defaultMeshId === "string" ? defaultMeshId.trim() : "";
+  const workspace = typeof args?.workspace === "string" ? args.workspace.trim() : "";
+  if (!meshId) {
+    return JSON.stringify({ success: false, error: "mesh_id required (create one first with mesh_create)." }, null, 2);
+  }
+  if (!workspace) {
+    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", {
+    meshId,
+    workspace,
+    ...args?.read_only === true ? { readOnly: true } : {},
+    ...providerPriority.length ? { providerPriority } : {},
+    ...args?.is_worktree === true ? { isLocalWorktree: true } : {},
+    ...args?.inline_mesh ? { inlineMesh: args.inline_mesh } : {}
+  });
+  const addPayload = unwrapCommandPayload(addResult);
+  if (!addPayload?.success || !addPayload?.node?.id) {
+    return JSON.stringify({
+      success: false,
+      error: addPayload?.error || "add_mesh_node failed",
+      code: addPayload?.code,
+      raw: addPayload ?? addResult
+    }, null, 2);
+  }
+  return JSON.stringify({
+    success: true,
+    mesh_id: meshId,
+    node_id: addPayload.node.id,
+    workspace: addPayload.node.workspace,
+    read_only: addPayload.node.policy?.readOnly === true,
+    provider_priority: addPayload.node.policy?.providerPriority,
+    next_step: `Node registered. Launch an agent on it with mesh_launch_session (node_id: "${addPayload.node.id}") or delegate work with mesh_send_task / mesh_enqueue_task.`
+  }, null, 2);
+}
 // src/tools/mesh-tools-refine.ts
 async function meshRefineConfigSchema(ctx) {
   const node = resolveRefineConfigNode(ctx);
@@ -8770,6 +8943,12 @@ async function startMcpServer(opts) {
           case "mesh_list_pending_approvals":
             text = await meshListPendingApprovals(meshCtx, a);
             break;
+          case "mesh_create":
+            text = await meshCreate(meshCtx.transport, a);
+            break;
+          case "mesh_add_node":
+            text = await meshAddNode(meshCtx.transport, a, meshCtx.mesh.id);
+            break;
           case "mesh_clone_node":
             text = await meshCloneNode(meshCtx, a);
             break;
@@ -8907,6 +9086,11 @@ async function startMcpServer(opts) {
     GIT_DIFF_TOOL,
     GIT_CHECKPOINT_TOOL,
     GIT_PUSH_TOOL,
+    // 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_CREATE_TOOL,
+    MESH_ADD_NODE_TOOL,
     ...isLocal ? [SCREENSHOT_TOOL] : []
   ];
   const server = new import_server.Server(
@@ -8996,6 +9180,14 @@ async function startMcpServer(opts) {
           const text = await checkPending(transport, { format: a.format });
           return { content: [{ type: "text", text }] };
         }
+        case "mesh_create": {
+          const text = await meshCreate(transport, a);
+          return { content: [{ type: "text", text }] };
+        }
+        case "mesh_add_node": {
+          const text = await meshAddNode(transport, a);
+          return { content: [{ type: "text", text }] };
+        }
         default:
           return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
       }