@adhdev/daemon-standalone 1.0.28-rc.26 → 1.0.28-rc.28

package/public/index.html

@@ -7,7 +7,7 @@
     <meta name="description" content="ADHDev self-hosted dashboard for controlling AI agents" />
     <link rel="icon" href="/otter-logo.png" />
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap" rel="stylesheet" />
-  <script type="module" crossorigin src="/assets/index-C3DSJEo9.js"></script>
+  <script type="module" crossorigin src="/assets/index-CCwmPawg.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/vendor-cL4V2vaO.js">
   <link rel="stylesheet" crossorigin href="/assets/index-8TNNoifN.css">
 </head>

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.
@@ -424,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",
@@ -1158,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: {
@@ -1193,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: {
@@ -1221,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.",
@@ -1617,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,
@@ -7459,6 +7496,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,
@@ -7509,21 +7563,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,
@@ -7553,7 +7691,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);
@@ -7576,12 +7716,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);
@@ -9017,11 +9176,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);
@@ -9029,6 +9191,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;
@@ -9163,6 +9328,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] : []
@@ -9258,6 +9424,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 }] };