adhdev 0.9.76-rc.2 → 0.9.76-rc.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adhdev",
-  "version": "0.9.76-rc.2",
+  "version": "0.9.76-rc.20",
   "description": "ADHDev — Agent Dashboard Hub for Dev. Remote-control AI coding agents from anywhere.",
   "main": "dist/index.js",
   "bin": {
@@ -47,7 +47,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@adhdev/daemon-core": "0.9.76-rc.2",
+    "@adhdev/daemon-core": "0.9.76-rc.20",
     "@adhdev/ghostty-vt-node": "*",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "@xterm/addon-serialize": "^0.14.0",

package/vendor/mcp-server/index.js

@@ -6,6 +6,10 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -22,6 +26,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  parseArgs: () => parseArgs
+});
+module.exports = __toCommonJS(index_exports);
 
 // src/server.ts
 var import_server = require("@modelcontextprotocol/sdk/server/index.js");
@@ -234,6 +246,107 @@ var CloudTransport = class {
   }
 };
 
+// src/transports/ipc.ts
+var DEFAULT_IPC_PORT = 19222;
+var DEFAULT_IPC_PATH = "/ipc";
+var IpcTransport = class {
+  port;
+  path;
+  constructor(opts = {}) {
+    this.port = opts.port ?? DEFAULT_IPC_PORT;
+    this.path = opts.path || DEFAULT_IPC_PATH;
+  }
+  async ping() {
+    try {
+      const res = await fetch(`http://127.0.0.1:${this.port}/health`);
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+  async getStatus() {
+    return this.command("get_status_metadata");
+  }
+  async command(type, args = {}) {
+    return this.sendIpcCommand(type, args);
+  }
+  async meshCommand(targetDaemonId, command, args = {}) {
+    return this.sendIpcCommand("mesh_relay_command", {
+      targetDaemonId,
+      command,
+      args
+    });
+  }
+  async sendIpcCommand(type, args) {
+    const WebSocketCtor = globalThis.WebSocket;
+    if (!WebSocketCtor) {
+      throw new Error("WebSocket is not available in this Node runtime; Node 20+ is required for daemon IPC mode");
+    }
+    return new Promise((resolve, reject) => {
+      const requestId = `mcp_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      const ws = new WebSocketCtor(`ws://127.0.0.1:${this.port}${this.path}`);
+      let settled = false;
+      const finish = (fn) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        try {
+          ws.close();
+        } catch {
+        }
+        fn();
+      };
+      const timeout = setTimeout(() => {
+        finish(() => reject(new Error(`Daemon IPC command '${type}' timed out after 15s`)));
+      }, 15e3);
+      let commandSent = false;
+      const send = () => {
+        if (commandSent) return;
+        commandSent = true;
+        ws.send(JSON.stringify({
+          type: "ext:command",
+          payload: { command: type, args, requestId }
+        }));
+      };
+      ws.addEventListener("open", () => {
+        ws.send(JSON.stringify({
+          type: "ext:register",
+          payload: {
+            ideType: "mcp-server",
+            ideVersion: "1.0.0",
+            extensionVersion: "1.0.0",
+            instanceId: `mcp-server-${process.pid}`,
+            machineId: "mcp-server",
+            workspaceFolders: []
+          }
+        }));
+      });
+      ws.addEventListener("message", (event) => {
+        try {
+          const raw = typeof event.data === "string" ? event.data : String(event.data);
+          const msg = JSON.parse(raw);
+          if (msg?.type === "daemon:welcome") {
+            send();
+            return;
+          }
+          if (msg?.type !== "ext:command_result") return;
+          if (msg?.payload?.requestId !== requestId) return;
+          const payload = msg.payload;
+          if (payload?.success === false) {
+            finish(() => reject(new Error(payload.error || `Daemon IPC command '${type}' failed`)));
+            return;
+          }
+          finish(() => resolve(payload?.result ?? payload));
+        } catch {
+        }
+      });
+      ws.addEventListener("error", () => {
+        finish(() => reject(new Error(`Cannot connect to daemon IPC at ws://127.0.0.1:${this.port}${this.path}`)));
+      });
+    });
+  }
+};
+
 // src/transports/mode.ts
 function isLocalTransport(transport) {
   return typeof transport.command === "function";
@@ -1265,10 +1378,69 @@ ${lines.join("\n\n")}`;
 }
 
 // src/tools/mesh-tools.ts
-function findNode(mesh, nodeId) {
-  const node = mesh.nodes.find((n) => n.id === nodeId);
-  if (!node) throw new Error(`Node '${nodeId}' is not a member of mesh '${mesh.name}'`);
-  return node;
+async function refreshMeshFromDaemon(ctx) {
+  if (!(ctx.transport instanceof IpcTransport)) return;
+  try {
+    const result = await ctx.transport.command("get_mesh", { meshId: ctx.mesh.id });
+    if (!result?.success || !Array.isArray(result.mesh?.nodes)) return;
+    const refreshedNodes = result.mesh.nodes.filter((n) => n?.id).map((n) => n);
+    if (!refreshedNodes.length) return;
+    ctx.mesh.nodes.splice(0, ctx.mesh.nodes.length, ...refreshedNodes);
+    ctx.mesh.updatedAt = result.mesh.updatedAt ?? ctx.mesh.updatedAt;
+  } catch {
+  }
+}
+async function findNodeWithRefresh(ctx, nodeId) {
+  const hit = ctx.mesh.nodes.find((n) => n.id === nodeId);
+  if (hit) return hit;
+  await refreshMeshFromDaemon(ctx);
+  const refreshed = ctx.mesh.nodes.find((n) => n.id === nodeId);
+  if (!refreshed) throw new Error(`Node '${nodeId}' is not a member of mesh '${ctx.mesh.name}'`);
+  return refreshed;
+}
+function unwrapCommandPayload(value) {
+  return value?.result?.result ?? value?.result ?? value;
+}
+function findNestedPayload(value, predicate) {
+  let cursor = value;
+  for (let depth = 0; depth < 8; depth += 1) {
+    if (predicate(cursor)) return cursor;
+    if (!cursor || typeof cursor !== "object" || !("result" in cursor)) break;
+    cursor = cursor.result;
+  }
+  return value;
+}
+function extractCloneNodePayload(value) {
+  return findNestedPayload(value, (payload) => Boolean(payload?.node?.id));
+}
+function extractGitStatus(value) {
+  const payload = unwrapCommandPayload(value);
+  return payload?.status ?? value?.status ?? payload;
+}
+function extractGitDiff(value) {
+  const payload = unwrapCommandPayload(value);
+  return payload?.diffSummary ?? payload?.diff ?? value?.diffSummary ?? value?.diff ?? payload;
+}
+function countUncommittedChanges(status) {
+  if (typeof status?.uncommittedChanges === "number") return status.uncommittedChanges;
+  const keys = ["staged", "modified", "untracked", "deleted", "renamed"];
+  const counted = keys.reduce((sum, key) => sum + (Number.isFinite(Number(status?.[key])) ? Number(status[key]) : 0), 0);
+  const conflicts = Array.isArray(status?.conflictFiles) ? status.conflictFiles.length : status?.hasConflicts ? 1 : 0;
+  return counted + conflicts;
+}
+function isGitStatusDirty(status) {
+  if (typeof status?.isDirty === "boolean") return status.isDirty;
+  if (typeof status?.dirty === "boolean") return status.dirty;
+  return countUncommittedChanges(status) > 0;
+}
+async function commandForNode(ctx, node, command, args = {}) {
+  if (ctx.transport instanceof IpcTransport && node.daemonId) {
+    return ctx.transport.meshCommand(node.daemonId, command, args);
+  }
+  if (isLocalTransport(ctx.transport)) {
+    return ctx.transport.command(command, args);
+  }
+  throw new Error(`Command '${command}' requires daemon IPC/local transport for node '${node.id}'`);
 }
 var MESH_STATUS_TOOL = {
   name: "mesh_status",
@@ -1314,12 +1486,12 @@ var MESH_READ_CHAT_TOOL = {
 };
 var MESH_LAUNCH_SESSION_TOOL = {
   name: "mesh_launch_session",
-  description: "Launch a new agent session on a mesh node. Returns the session ID for subsequent send_task/read_chat calls.",
+  description: "Launch a new agent session on a mesh node. Returns the session ID for subsequent send_task/read_chat calls. If the user names a provider, preserve it exactly: Hermes = hermes-cli, Claude Code/Claude = claude-cli, Codex = codex-cli, Gemini = gemini-cli. Do not default to claude-cli unless the user requested Claude Code or no provider was specified.",
   inputSchema: {
     type: "object",
     properties: {
       node_id: { type: "string", description: "Target node ID." },
-      type: { type: "string", description: 'Provider type (e.g. "claude-cli", "gemini-cli", "cursor").' }
+      type: { type: "string", description: "Provider type to launch. Use hermes-cli for Hermes, claude-cli for Claude Code, codex-cli for Codex, gemini-cli for Gemini." }
     },
     required: ["node_id", "type"]
   }
@@ -1360,6 +1532,30 @@ var MESH_APPROVE_TOOL = {
     required: ["node_id", "session_id", "action"]
   }
 };
+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.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      source_node_id: { type: "string", description: "Node ID to clone from (from mesh_list_nodes)." },
+      branch: { type: "string", description: 'Branch name for the new worktree (e.g. "feat/auth-refactor").' },
+      base_branch: { type: "string", description: "Starting point for the branch (default: current HEAD)." }
+    },
+    required: ["source_node_id", "branch"]
+  }
+};
+var MESH_REMOVE_NODE_TOOL = {
+  name: "mesh_remove_node",
+  description: "Remove a node from the mesh. If the node is a worktree, also cleans up the git worktree and directory.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Node ID to remove." }
+    },
+    required: ["node_id"]
+  }
+};
 var ALL_MESH_TOOLS = [
   MESH_STATUS_TOOL,
   MESH_LIST_NODES_TOOL,
@@ -1368,9 +1564,12 @@ var ALL_MESH_TOOLS = [
   MESH_LAUNCH_SESSION_TOOL,
   MESH_GIT_STATUS_TOOL,
   MESH_CHECKPOINT_TOOL,
-  MESH_APPROVE_TOOL
+  MESH_APPROVE_TOOL,
+  MESH_CLONE_NODE_TOOL,
+  MESH_REMOVE_NODE_TOOL
 ];
 async function meshStatus(ctx) {
+  await refreshMeshFromDaemon(ctx);
   const { mesh, transport } = ctx;
   const results = [];
   for (const node of mesh.nodes) {
@@ -1381,18 +1580,22 @@ async function meshStatus(ctx) {
     try {
       if (!isLocalTransport(transport) && node.daemonId) {
         const result = await transport.gitStatus(node.daemonId, node.workspace, false);
-        const status = result?.status ?? result;
-        entry.health = status?.isGitRepo ? status?.isDirty ? "dirty" : "online" : "degraded";
+        const status = extractGitStatus(result);
+        const uncommittedChanges = countUncommittedChanges(status);
+        const dirty = isGitStatusDirty(status);
+        entry.health = status?.isGitRepo ? dirty ? "dirty" : "online" : "degraded";
         entry.branch = status?.branch;
-        entry.isDirty = status?.isDirty;
-        entry.uncommittedChanges = status?.uncommittedChanges ?? 0;
+        entry.isDirty = dirty;
+        entry.uncommittedChanges = uncommittedChanges;
       } else if (isLocalTransport(transport)) {
-        const statusResult = await transport.command("git_status", { workspace: node.workspace });
-        const status = statusResult?.status ?? statusResult;
-        entry.health = status?.isGitRepo ? status?.isDirty ? "dirty" : "online" : "degraded";
+        const statusResult = await commandForNode(ctx, node, "git_status", { workspace: node.workspace });
+        const status = extractGitStatus(statusResult);
+        const uncommittedChanges = countUncommittedChanges(status);
+        const dirty = isGitStatusDirty(status);
+        entry.health = status?.isGitRepo ? dirty ? "dirty" : "online" : "degraded";
         entry.branch = status?.branch;
-        entry.isDirty = status?.isDirty;
-        entry.uncommittedChanges = status?.uncommittedChanges ?? 0;
+        entry.isDirty = dirty;
+        entry.uncommittedChanges = uncommittedChanges;
       } else {
         entry.health = "unknown";
         entry.note = "No daemonId available for cloud status probe";
@@ -1413,6 +1616,7 @@ async function meshStatus(ctx) {
   }, null, 2);
 }
 async function meshListNodes(ctx) {
+  await refreshMeshFromDaemon(ctx);
   const { mesh } = ctx;
   return JSON.stringify({
     meshId: mesh.id,
@@ -1428,14 +1632,15 @@ async function meshListNodes(ctx) {
   }, null, 2);
 }
 async function meshSendTask(ctx, args) {
-  const node = findNode(ctx.mesh, args.node_id);
+  const node = await findNodeWithRefresh(ctx, args.node_id);
   if (node.policy?.readOnly) {
     return JSON.stringify({ error: `Node '${args.node_id}' is read-only` });
   }
   if (isLocalTransport(ctx.transport)) {
-    await ctx.transport.command("send_chat", {
+    await commandForNode(ctx, node, "send_chat", {
       message: args.message,
-      sessionId: args.session_id
+      sessionId: args.session_id,
+      targetSessionId: args.session_id
     });
     return JSON.stringify({ success: true, nodeId: args.node_id, sessionId: args.session_id });
   } else {
@@ -1443,10 +1648,11 @@ async function meshSendTask(ctx, args) {
   }
 }
 async function meshReadChat(ctx, args) {
-  findNode(ctx.mesh, args.node_id);
+  const node = await findNodeWithRefresh(ctx, args.node_id);
   if (isLocalTransport(ctx.transport)) {
-    const result = await ctx.transport.command("read_chat", {
+    const result = await commandForNode(ctx, node, "read_chat", {
       sessionId: args.session_id,
+      targetSessionId: args.session_id,
       tailLimit: args.tail ?? 10
     });
     return JSON.stringify(result, null, 2);
@@ -1455,9 +1661,9 @@ async function meshReadChat(ctx, args) {
   }
 }
 async function meshLaunchSession(ctx, args) {
-  const node = findNode(ctx.mesh, args.node_id);
+  const node = await findNodeWithRefresh(ctx, args.node_id);
   if (isLocalTransport(ctx.transport)) {
-    const result = await ctx.transport.command("launch_cli", {
+    const result = await commandForNode(ctx, node, "launch_cli", {
       cliType: args.type,
       dir: node.workspace,
       settings: {
@@ -1471,39 +1677,39 @@ async function meshLaunchSession(ctx, args) {
   }
 }
 async function meshGitStatus(ctx, args) {
-  const node = findNode(ctx.mesh, args.node_id);
+  const node = await findNodeWithRefresh(ctx, args.node_id);
   if (!isLocalTransport(ctx.transport) && node.daemonId) {
     const result = await ctx.transport.gitStatus(node.daemonId, node.workspace, true);
     return JSON.stringify({
       nodeId: args.node_id,
       workspace: node.workspace,
-      status: result?.status ?? result,
-      diff: result?.diff ?? null
+      status: extractGitStatus(result),
+      diff: extractGitDiff(result)
     }, null, 2);
   } else if (isLocalTransport(ctx.transport)) {
-    const statusResult = await ctx.transport.command("git_status", {
+    const statusResult = await commandForNode(ctx, node, "git_status", {
       workspace: node.workspace
     });
-    const diffResult = await ctx.transport.command("git_diff_summary", {
+    const diffResult = await commandForNode(ctx, node, "git_diff_summary", {
       workspace: node.workspace
     });
     return JSON.stringify({
       nodeId: args.node_id,
       workspace: node.workspace,
-      status: statusResult?.status ?? statusResult,
-      diff: diffResult?.diffSummary ?? diffResult
+      status: extractGitStatus(statusResult),
+      diff: extractGitDiff(diffResult)
     }, null, 2);
   } else {
     return JSON.stringify({ error: "No daemonId available for cloud git_status probe" });
   }
 }
 async function meshCheckpoint(ctx, args) {
-  const node = findNode(ctx.mesh, args.node_id);
+  const node = await findNodeWithRefresh(ctx, args.node_id);
   if (node.policy?.readOnly) {
     return JSON.stringify({ error: `Node '${args.node_id}' is read-only \u2014 cannot checkpoint` });
   }
   if (isLocalTransport(ctx.transport)) {
-    const result = await ctx.transport.command("git_checkpoint", {
+    const result = await commandForNode(ctx, node, "git_checkpoint", {
       workspace: node.workspace,
       message: args.message
     });
@@ -1513,10 +1719,11 @@ async function meshCheckpoint(ctx, args) {
   }
 }
 async function meshApprove(ctx, args) {
-  findNode(ctx.mesh, args.node_id);
+  const node = await findNodeWithRefresh(ctx, args.node_id);
   if (isLocalTransport(ctx.transport)) {
-    const result = await ctx.transport.command("resolve_action", {
+    const result = await commandForNode(ctx, node, "resolve_action", {
       sessionId: args.session_id,
+      targetSessionId: args.session_id,
       action: args.action === "reject" ? "reject" : "approve"
     });
     return JSON.stringify(result, null, 2);
@@ -1524,13 +1731,63 @@ async function meshApprove(ctx, args) {
     return JSON.stringify({ error: "Cloud mesh approve not yet implemented" });
   }
 }
+async function meshCloneNode(ctx, args) {
+  const sourceNode = await findNodeWithRefresh(ctx, args.source_node_id);
+  if (isLocalTransport(ctx.transport)) {
+    const result = await commandForNode(ctx, sourceNode, "clone_mesh_node", {
+      meshId: ctx.mesh.id,
+      sourceNodeId: args.source_node_id,
+      branch: args.branch,
+      baseBranch: args.base_branch,
+      inlineMesh: ctx.mesh
+    });
+    const clonePayload = extractCloneNodePayload(result);
+    if (clonePayload?.success && clonePayload.node?.id) {
+      const existingIndex = ctx.mesh.nodes.findIndex((n) => n.id === clonePayload.node.id);
+      if (existingIndex >= 0) ctx.mesh.nodes[existingIndex] = clonePayload.node;
+      else ctx.mesh.nodes.push(clonePayload.node);
+      ctx.mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    return JSON.stringify(result, null, 2);
+  } else {
+    return JSON.stringify({ error: "Cloud mesh clone_node not yet implemented" });
+  }
+}
+async function meshRemoveNode(ctx, args) {
+  const node = await findNodeWithRefresh(ctx, args.node_id);
+  if (isLocalTransport(ctx.transport)) {
+    const result = await commandForNode(ctx, node, "remove_mesh_node", {
+      meshId: ctx.mesh.id,
+      nodeId: args.node_id,
+      inlineMesh: ctx.mesh
+    });
+    if (result?.success && result.removed !== false) {
+      const idx = ctx.mesh.nodes.findIndex((n) => n.id === args.node_id);
+      if (idx >= 0) {
+        ctx.mesh.nodes.splice(idx, 1);
+        ctx.mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+    }
+    return JSON.stringify(result, null, 2);
+  } else {
+    return JSON.stringify({ error: "Cloud mesh remove_node not yet implemented" });
+  }
+}
 
 // src/server.ts
+async function buildMeshModeCoordinatorPrompt(mesh) {
+  try {
+    const { buildCoordinatorSystemPrompt } = await import("@adhdev/daemon-core");
+    return buildCoordinatorSystemPrompt({ mesh });
+  } catch (e) {
+    throw new Error(`Failed to build Repo Mesh coordinator prompt: ${e?.message ?? String(e)}`);
+  }
+}
 async function startMcpServer(opts) {
-  const transport = opts.mode === "cloud" ? new CloudTransport({ apiKey: opts.apiKey, baseUrl: opts.baseUrl }) : new LocalTransport({ port: opts.port, password: opts.password });
+  const transport = opts.mode === "cloud" ? new CloudTransport({ apiKey: opts.apiKey, baseUrl: opts.baseUrl }) : opts.mode === "ipc" ? new IpcTransport({ port: opts.port }) : new LocalTransport({ port: opts.port, password: opts.password });
   const alive = await transport.ping();
   if (!alive) {
-    const hint = opts.mode === "local" ? `Make sure the standalone daemon is running (adhdev standalone or npx @adhdev/daemon-standalone).` : `Check your API key and network connectivity.`;
+    const hint = opts.mode === "local" ? `Make sure the standalone daemon is running (adhdev standalone or npx @adhdev/daemon-standalone).` : opts.mode === "ipc" ? `Make sure the cloud daemon is running with local IPC enabled (adhdev daemon).` : `Check your API key and network connectivity.`;
     process.stderr.write(`[adhdev-mcp] Cannot reach ${opts.mode} daemon. ${hint}
 `);
     process.exit(1);
@@ -1613,7 +1870,7 @@ async function startMcpServer(opts) {
 `);
       }
     }
-    if (!mesh && transport instanceof LocalTransport) {
+    if (!mesh && (transport instanceof LocalTransport || transport instanceof IpcTransport)) {
       try {
         const result = await transport.command("get_mesh", { meshId: opts.meshId });
         if (result?.success && result.mesh) {
@@ -1632,13 +1889,7 @@ async function startMcpServer(opts) {
       process.exit(1);
     }
     const meshCtx = { mesh, transport };
-    let coordinatorPrompt = "";
-    try {
-      const { buildCoordinatorSystemPrompt } = await import("@adhdev/daemon-core");
-      coordinatorPrompt = buildCoordinatorSystemPrompt({ mesh });
-    } catch {
-      coordinatorPrompt = `You are a Repo Mesh Coordinator for "${mesh.name}" (${mesh.repoIdentity}). Use mesh_* tools to orchestrate work.`;
-    }
+    const coordinatorPrompt = await buildMeshModeCoordinatorPrompt(mesh);
     const server2 = new import_server.Server(
       { name: "adhdev-mcp-server", version: "0.9.75" },
       { capabilities: { tools: {}, resources: {} } }
@@ -1689,6 +1940,12 @@ async function startMcpServer(opts) {
           case "mesh_approve":
             text = await meshApprove(meshCtx, a);
             break;
+          case "mesh_clone_node":
+            text = await meshCloneNode(meshCtx, a);
+            break;
+          case "mesh_remove_node":
+            text = await meshRemoveNode(meshCtx, a);
+            break;
           default:
             return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
         }
@@ -1817,13 +2074,14 @@ async function startMcpServer(opts) {
 }
 
 // src/index.ts
-function parseArgs(argv) {
+function parseArgs(argv, env = process.env) {
   const args = argv.slice(2);
   let apiKey;
   let baseUrl;
   let port;
   let password;
   let meshId;
+  let explicitMode;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if ((arg === "--api-key" || arg === "-k") && args[i + 1]) {
@@ -1832,6 +2090,12 @@ function parseArgs(argv) {
       apiKey = arg.slice("--api-key=".length);
     } else if (arg === "--base-url" && args[i + 1]) {
       baseUrl = args[++i];
+    } else if (arg === "--mode" && args[i + 1]) {
+      const value = String(args[++i]).trim();
+      if (value === "local" || value === "cloud" || value === "ipc") explicitMode = value;
+    } else if (arg?.startsWith("--mode=")) {
+      const value = arg.slice("--mode=".length).trim();
+      if (value === "local" || value === "cloud" || value === "ipc") explicitMode = value;
     } else if (arg === "--port" && args[i + 1]) {
       port = Number(args[++i]);
     } else if (arg?.startsWith("--port=")) {
@@ -1847,10 +2111,14 @@ function parseArgs(argv) {
       process.exit(0);
     }
   }
-  if (!apiKey && process.env.ADHDEV_API_KEY) apiKey = process.env.ADHDEV_API_KEY;
-  if (!password && process.env.ADHDEV_PASSWORD) password = process.env.ADHDEV_PASSWORD;
-  if (!meshId && process.env.ADHDEV_MESH_ID) meshId = process.env.ADHDEV_MESH_ID;
-  const mode = apiKey ? "cloud" : "local";
+  if (!apiKey && env.ADHDEV_API_KEY) apiKey = env.ADHDEV_API_KEY;
+  if (!password && env.ADHDEV_PASSWORD) password = env.ADHDEV_PASSWORD;
+  if (!meshId && env.ADHDEV_MESH_ID) meshId = env.ADHDEV_MESH_ID;
+  if (!explicitMode && env.ADHDEV_MCP_TRANSPORT) {
+    const value = env.ADHDEV_MCP_TRANSPORT.trim();
+    if (value === "local" || value === "cloud" || value === "ipc") explicitMode = value;
+  }
+  const mode = explicitMode || (apiKey ? "cloud" : meshId && env.ADHDEV_INLINE_MESH ? "ipc" : "local");
   return { mode, port, password, apiKey, baseUrl, meshId };
 }
 function printHelp() {
@@ -1860,10 +2128,12 @@ adhdev-mcp \u2014 ADHDev MCP Server
 Usage:
   adhdev-mcp                                    Local mode (requires standalone daemon)
   adhdev-mcp --api-key <key>                    Cloud mode (ADHDev cloud API)
+  adhdev-mcp --mode ipc --repo-mesh <mesh_id>   Cloud daemon IPC mesh mode
   adhdev-mcp --repo-mesh <mesh_id>              Mesh mode (coordinator-scoped tools)
 
 Options:
-  --port <n>              Standalone daemon port (default: 3847)
+  --mode <mode>           Transport: local, cloud, or ipc
+  --port <n>              Standalone or IPC daemon port (defaults: local 3847, ipc 19222)
   --password <pass>       Standalone daemon password (if set)
   --api-key <key>         ADHDev cloud API key (switches to cloud mode)
   --base-url <url>        Override cloud API base URL
@@ -1874,9 +2144,10 @@ Environment variables:
   ADHDEV_API_KEY      API key (cloud mode)
   ADHDEV_PASSWORD     Daemon password (local mode)
   ADHDEV_MESH_ID      Mesh ID (mesh mode)
+  ADHDEV_MCP_TRANSPORT Transport: local, cloud, or ipc
 
 Standard tools:   list_daemons, list_sessions, launch_session, stop_session, check_pending, read_chat, send_chat, approve, git_status, git_log, git_diff, git_checkpoint, git_push, screenshot
-Mesh tools:       mesh_status, mesh_list_nodes, mesh_send_task, mesh_read_chat, mesh_launch_session, mesh_git_status, mesh_checkpoint, mesh_approve
+Mesh tools:       mesh_status, mesh_list_nodes, mesh_send_task, mesh_read_chat, mesh_launch_session, mesh_git_status, mesh_checkpoint, mesh_approve, mesh_clone_node, mesh_remove_node
 `.trim());
 }
 startMcpServer(parseArgs(process.argv)).catch((err) => {
@@ -1884,4 +2155,8 @@ startMcpServer(parseArgs(process.argv)).catch((err) => {
 `);
   process.exit(1);
 });
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseArgs
+});
 //# sourceMappingURL=index.js.map