adhdev 0.9.76-rc.7 → 0.9.76-rc.71

package/vendor/mcp-server/index.js

@@ -35,217 +35,6 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/server.ts
-var import_server = require("@modelcontextprotocol/sdk/server/index.js");
-var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
-var import_types = require("@modelcontextprotocol/sdk/types.js");
-
-// src/transports/local.ts
-var DEFAULT_PORT = 3847;
-var LocalTransport = class {
-  baseUrl;
-  authHeader;
-  constructor(opts = {}) {
-    this.baseUrl = `http://localhost:${opts.port ?? DEFAULT_PORT}`;
-    this.authHeader = opts.password ? `Bearer ${opts.password}` : null;
-  }
-  headers() {
-    const h = { "Content-Type": "application/json" };
-    if (this.authHeader) h["Authorization"] = this.authHeader;
-    return h;
-  }
-  async getStatus() {
-    const res = await fetch(`${this.baseUrl}/api/v1/status`, { headers: this.headers() });
-    if (!res.ok) throw new Error(`Status fetch failed: ${res.status}`);
-    return res.json();
-  }
-  async command(type, args = {}) {
-    const res = await fetch(`${this.baseUrl}/api/v1/command`, {
-      method: "POST",
-      headers: this.headers(),
-      body: JSON.stringify({ type, ...args })
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => res.statusText);
-      throw new Error(`Command ${type} failed: ${res.status} ${text}`);
-    }
-    return res.json();
-  }
-  async ping() {
-    try {
-      await this.getStatus();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-};
-
-// src/transports/cloud.ts
-var DEFAULT_BASE_URL = "https://api.adhf.dev";
-var CloudTransport = class {
-  baseUrl;
-  apiKey;
-  constructor(opts) {
-    this.apiKey = opts.apiKey;
-    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL;
-  }
-  headers() {
-    return {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${this.apiKey}`
-    };
-  }
-  async listDaemons() {
-    const res = await fetch(`${this.baseUrl}/api/v1/daemons`, { headers: this.headers() });
-    if (!res.ok) throw new Error(`List daemons failed: ${res.status}`);
-    return res.json();
-  }
-  async getStatus(targetId) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/status`,
-      { headers: this.headers() }
-    );
-    if (!res.ok) throw new Error(`Status failed: ${res.status}`);
-    return res.json();
-  }
-  /** Get all sessions for a daemon (returns CompactSessionEntry[]). */
-  async getDaemonStatus(daemonId) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/daemons/${encodeURIComponent(daemonId)}/status`,
-      { headers: this.headers() }
-    );
-    if (!res.ok) throw new Error(`Daemon status failed: ${res.status}`);
-    return res.json();
-  }
-  async readChat(targetId, opts = {}) {
-    const params = new URLSearchParams();
-    if (opts.limit) params.set("limit", String(opts.limit));
-    if (opts.sessionId) params.set("sessionId", opts.sessionId);
-    const qs = params.toString() ? `?${params}` : "";
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/chat${qs}`,
-      { headers: this.headers() }
-    );
-    if (!res.ok) throw new Error(`Read chat failed: ${res.status}`);
-    return res.json();
-  }
-  async sendChat(targetId, message, opts = {}) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/chat`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify({ message, ...opts })
-      }
-    );
-    if (!res.ok) throw new Error(`Send chat failed: ${res.status}`);
-    return res.json();
-  }
-  async approve(targetId, action, agentType) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/approve`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify({ action, ...agentType ? { agentType } : {} })
-      }
-    );
-    if (!res.ok) throw new Error(`Approve failed: ${res.status}`);
-    return res.json();
-  }
-  async gitStatus(daemonId, workspace, includeDiff = true) {
-    const params = new URLSearchParams({ workspace, includeDiff: String(includeDiff) });
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-status?${params}`,
-      { headers: this.headers() }
-    );
-    if (!res.ok) throw new Error(`Git status failed: ${res.status}`);
-    return res.json();
-  }
-  async stop(daemonId, opts) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/stop`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(opts)
-      }
-    );
-    if (!res.ok) throw new Error(`Stop failed: ${res.status}`);
-    return res.json();
-  }
-  async launch(daemonId, opts) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/launch`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(opts)
-      }
-    );
-    if (!res.ok) throw new Error(`Launch failed: ${res.status}`);
-    return res.json();
-  }
-  async gitLog(daemonId, workspace, opts = {}) {
-    const params = new URLSearchParams({ workspace });
-    if (opts.limit) params.set("limit", String(opts.limit));
-    if (opts.file) params.set("file", opts.file);
-    if (opts.since) params.set("since", opts.since);
-    if (opts.until) params.set("until", opts.until);
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-log?${params}`,
-      { headers: this.headers() }
-    );
-    if (!res.ok) throw new Error(`Git log failed: ${res.status}`);
-    return res.json();
-  }
-  async gitDiff(daemonId, workspace, opts = {}) {
-    const params = new URLSearchParams({ workspace });
-    if (opts.file) params.set("file", opts.file);
-    if (opts.maxLines) params.set("maxLines", String(opts.maxLines));
-    if (opts.staged) params.set("staged", "true");
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-diff?${params}`,
-      { headers: this.headers() }
-    );
-    if (!res.ok) throw new Error(`Git diff failed: ${res.status}`);
-    return res.json();
-  }
-  async gitPush(daemonId, opts) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-push`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(opts)
-      }
-    );
-    if (!res.ok) throw new Error(`Git push failed: ${res.status}`);
-    return res.json();
-  }
-  async gitCheckpoint(daemonId, opts) {
-    const res = await fetch(
-      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-checkpoint`,
-      {
-        method: "POST",
-        headers: this.headers(),
-        body: JSON.stringify(opts)
-      }
-    );
-    if (!res.ok) throw new Error(`Git checkpoint failed: ${res.status}`);
-    return res.json();
-  }
-  async ping() {
-    try {
-      await this.listDaemons();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-};
-
 // src/transports/ipc.ts
 var DEFAULT_IPC_PORT = 19222;
 var DEFAULT_IPC_PATH = "/ipc";
@@ -296,10 +85,14 @@ var IpcTransport = class {
         }
         fn();
       };
+      const timeoutMs = type === "mesh_relay_command" ? 6e4 : 15e3;
       const timeout = setTimeout(() => {
-        finish(() => reject(new Error(`Daemon IPC command '${type}' timed out after 15s`)));
-      }, 15e3);
+        finish(() => reject(new Error(`Daemon IPC command '${type}' timed out after ${Math.round(timeoutMs / 1e3)}s`)));
+      }, timeoutMs);
+      let commandSent = false;
       const send = () => {
+        if (commandSent) return;
+        commandSent = true;
         ws.send(JSON.stringify({
           type: "ext:command",
           payload: { command: type, args, requestId }
@@ -349,775 +142,1504 @@ function isLocalTransport(transport) {
   return typeof transport.command === "function";
 }
 
-// src/tools/list-sessions.ts
-var FORMAT_PROP = {
-  format: {
-    type: "string",
-    enum: ["text", "json"],
-    description: "Output format: 'text' (default, human-readable) or 'json' (structured, for programmatic use)."
+// src/tools/chat-compact.ts
+function messageContent(message) {
+  const content = message?.content;
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => typeof part === "string" ? part : part?.text ?? "").join("");
+  }
+  return "";
+}
+function isCoordinatorVisibleMessage(message) {
+  if (!message || typeof message !== "object") return false;
+  const role = String(message.role ?? "").toLowerCase();
+  if (role === "tool" || role === "system" || role === "debug") return false;
+  const kind = String(message.kind ?? message.type ?? message.messageKind ?? "").toLowerCase();
+  if (["tool", "tool_call", "tool_result", "terminal", "internal", "control", "debug", "status"].includes(kind)) return false;
+  const meta = message.meta ?? message.metadata;
+  if (meta?.internal === true || meta?.debug === true || meta?.control === true || meta?.userVisible === false || meta?.user_visible === false) return false;
+  return role === "user" || role === "assistant" || role === "agent";
+}
+function compactChatPayload(payload, opts = {}) {
+  const rawMessages = Array.isArray(payload?.messages) ? payload.messages : [];
+  const visible = rawMessages.filter(isCoordinatorVisibleMessage);
+  const limit = Math.max(1, Math.min(opts.limit ?? 10, 10));
+  const messages = visible.slice(-limit);
+  const finalAssistant = [...visible].reverse().find((message) => {
+    const role = String(message?.role ?? "").toLowerCase();
+    return (role === "assistant" || role === "agent") && messageContent(message).trim();
+  });
+  const summary = typeof payload?.summary === "string" && payload.summary.trim() ? payload.summary.trim() : messageContent(finalAssistant).trim();
+  return {
+    success: payload?.success !== false,
+    compact: true,
+    ...opts.nodeId ? { nodeId: opts.nodeId } : {},
+    ...opts.sessionId !== void 0 ? { sessionId: opts.sessionId } : {},
+    status: payload?.status ?? null,
+    providerSessionId: payload?.providerSessionId ?? null,
+    totalMessages: rawMessages.length,
+    visibleMessages: visible.length,
+    filteredMessages: visible.length,
+    omittedMessages: Math.max(0, rawMessages.length - visible.length),
+    summary,
+    ...payload?.changedFiles !== void 0 ? { changedFiles: payload.changedFiles } : {},
+    ...payload?.testsRun !== void 0 ? { testsRun: payload.testsRun } : {},
+    messages
+  };
+}
+
+// src/tools/read-chat-polling-advisory.ts
+var RAPID_READ_CHAT_ADVISORY_WINDOW_MS = 5e3;
+var ACTIVE_READ_STATUSES = /* @__PURE__ */ new Set([
+  "generating",
+  "running",
+  "streaming",
+  "starting",
+  "busy"
+]);
+var recentReads = /* @__PURE__ */ new Map();
+function isActiveReadChatStatus(status) {
+  return typeof status === "string" && ACTIVE_READ_STATUSES.has(status.toLowerCase());
+}
+function annotateRapidReadChatAdvisory(payload, options) {
+  const now = options.now ?? Date.now();
+  const status = options.status ?? payload?.status ?? payload?.data?.status ?? payload?.result?.status;
+  const active = isActiveReadChatStatus(status);
+  const previous = recentReads.get(options.key);
+  if (!active) {
+    recentReads.set(options.key, { at: now, status: typeof status === "string" ? status : void 0 });
+    return payload;
+  }
+  recentReads.set(options.key, { at: now, status: typeof status === "string" ? status : void 0 });
+  if (!previous || !isActiveReadChatStatus(previous.status)) return payload;
+  const elapsedMs = now - previous.at;
+  if (elapsedMs < 0 || elapsedMs >= RAPID_READ_CHAT_ADVISORY_WINDOW_MS) return payload;
+  return {
+    ...payload,
+    pollingAdvisory: {
+      type: "rapid_read_chat_polling",
+      toolName: options.toolName,
+      windowMs: RAPID_READ_CHAT_ADVISORY_WINDOW_MS,
+      elapsedMs,
+      nextSuggestedReadAt: previous.at + RAPID_READ_CHAT_ADVISORY_WINDOW_MS,
+      completionCallbackExpected: Boolean(options.completionCallbackExpected),
+      message: `This session is still ${String(status)}. Avoid repeated ${options.toolName} polling for the same generating session; wait for the completion callback/status event or retry after the suggested time if you are debugging a real stall.`
+    }
+  };
+}
+
+// src/tools/mesh-tools.ts
+var meshSessionProviderMetadata = /* @__PURE__ */ new Map();
+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 {
   }
-};
-var LIST_SESSIONS_TOOL = {
-  name: "list_sessions",
-  description: "List all connected agent sessions. In cloud mode, fetches session state from each daemon (data is sourced from daemon WS status reports, up to 30s stale). Pass daemon_id to scope to a single daemon.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only). Omit to list sessions across all daemons."
-      },
-      ...FORMAT_PROP
-    },
-    required: []
+}
+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) {
+  let current = value;
+  const seen = /* @__PURE__ */ new Set();
+  for (let depth = 0; depth < 8; depth += 1) {
+    if (!current || typeof current !== "object" || seen.has(current)) break;
+    seen.add(current);
+    const nested = current.result ?? current.payload;
+    if (!nested || typeof nested !== "object") break;
+    current = nested;
+  }
+  return current;
+}
+function findNestedPayload(value, predicate) {
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [{ payload: value, depth: 0 }];
+  while (stack.length) {
+    const { payload, depth } = stack.pop();
+    if (predicate(payload)) return payload;
+    if (!payload || typeof payload !== "object" || seen.has(payload) || depth >= 8) continue;
+    seen.add(payload);
+    for (const key of ["payload", "result"]) {
+      if (key in payload) stack.push({ payload: payload[key], depth: depth + 1 });
+    }
   }
-};
-async function listSessions(transport, args = {}) {
-  const asJson = args.format === "json";
-  if (isLocalTransport(transport)) {
-    const status = await transport.getStatus();
-    const sessions = status?.sessions ?? [];
-    if (asJson) {
-      return JSON.stringify({
-        sessions: sessions.map((s) => ({
-          id: s.id,
-          type: s.providerType ?? s.type ?? "unknown",
-          label: s.label ?? null,
-          status: s.status ?? s.agentStatus ?? null,
-          workspace: s.workspace ?? null
-        }))
-      }, null, 2);
-    }
-    if (sessions.length === 0) return "No active sessions.";
-    const lines = sessions.map((s) => {
-      const parts = [`id: ${s.id}`, `type: ${s.providerType ?? s.type ?? "unknown"}`];
-      if (s.label) parts.push(`label: ${s.label}`);
-      if (s.status ?? s.agentStatus) parts.push(`status: ${s.status ?? s.agentStatus}`);
-      if (s.workspace) parts.push(`workspace: ${s.workspace}`);
-      return parts.join(", ");
-    });
-    return `Sessions (${sessions.length}):
-${lines.join("\n")}`;
+  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 extractLaunchPayload(value) {
+  return findNestedPayload(value, (payload) => Boolean(payload?.sessionId || payload?.id || payload?.runtimeSessionId));
+}
+function resolveCoordinatorNode(ctx) {
+  const preferredNodeId = typeof ctx.mesh.coordinator?.preferredNodeId === "string" ? ctx.mesh.coordinator.preferredNodeId.trim() : "";
+  if (preferredNodeId) {
+    const preferred = ctx.mesh.nodes.find((n) => n.id === preferredNodeId && typeof n.daemonId === "string" && n.daemonId.trim());
+    if (preferred) return preferred;
   }
-  return listSessionsCloud(transport, args.daemon_id, asJson);
+  if (ctx.localDaemonId) {
+    return ctx.mesh.nodes.find((n) => n.daemonId === ctx.localDaemonId);
+  }
+  return void 0;
 }
-async function listSessionsCloud(transport, daemonId, asJson) {
-  const collected = [];
-  if (daemonId) {
-    const daemonStatus = await transport.getDaemonStatus(daemonId);
-    for (const s of daemonStatus?.sessions ?? []) {
-      collected.push({ daemonId, session: s });
-    }
-  } else {
-    const data = await transport.listDaemons();
-    const daemons = data?.daemons ?? [];
-    for (let i = 0; i < daemons.length; i += 5) {
-      await Promise.allSettled(
-        daemons.slice(i, i + 5).map(async (d) => {
-          try {
-            const daemonStatus = await transport.getDaemonStatus(d.id);
-            for (const s of daemonStatus?.sessions ?? []) {
-              collected.push({ daemonId: d.id, session: s });
-            }
-          } catch {
-          }
-        })
-      );
+function meshSessionCacheKey(nodeId, runtimeSessionId) {
+  return `${nodeId}:${runtimeSessionId}`;
+}
+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;
+}
+function readRelatedRepos(node) {
+  const raw = Array.isArray(node.relatedRepos) ? node.relatedRepos : Array.isArray(node.policy?.relatedRepos) ? node.policy.relatedRepos : [];
+  return raw.map((entry) => ({
+    label: typeof entry?.label === "string" ? entry.label.trim() : "",
+    workspace: typeof entry?.workspace === "string" ? entry.workspace.trim() : ""
+  })).filter((entry) => Boolean(entry.label && entry.workspace));
+}
+function summarizeRelatedRepoStatus(repo, status) {
+  const dirty = isGitStatusDirty(status);
+  return {
+    label: repo.label,
+    workspace: repo.workspace,
+    isGitRepo: status?.isGitRepo === true,
+    branch: status?.branch ?? null,
+    ahead: Number.isFinite(Number(status?.ahead)) ? Number(status.ahead) : 0,
+    behind: Number.isFinite(Number(status?.behind)) ? Number(status.behind) : 0,
+    dirty,
+    uncommittedChanges: countUncommittedChanges(status),
+    head: status?.headCommit ?? null,
+    lastCommitSummary: status?.headMessage ?? null,
+    ...status?.reason ? { reason: status.reason } : {},
+    ...status?.error ? { error: status.error } : {}
+  };
+}
+async function collectRelatedRepoStatuses(ctx, node) {
+  const relatedRepos = readRelatedRepos(node);
+  if (!relatedRepos.length) return [];
+  const results = [];
+  for (const repo of relatedRepos) {
+    try {
+      const statusResult = !isLocalTransport(ctx.transport) && node.daemonId ? await ctx.transport.gitStatus(node.daemonId, repo.workspace, false) : await commandForNode(ctx, node, "git_status", { workspace: repo.workspace });
+      const status = extractGitStatus(statusResult);
+      results.push(summarizeRelatedRepoStatus(repo, status));
+    } catch (e) {
+      results.push({
+        label: repo.label,
+        workspace: repo.workspace,
+        error: e?.message || "related repo status failed"
+      });
     }
   }
-  if (asJson) {
-    return JSON.stringify({
-      sessions: collected.map(({ daemonId: dId, session: s }) => ({
-        daemon_id: dId,
-        id: s.id,
-        type: s.providerType ?? "unknown",
-        status: s.status ?? null,
-        workspace: s.workspace ?? null
-      }))
-    }, null, 2);
+  return results;
+}
+function readProviderPriority(policy) {
+  const raw = policy?.providerPriority;
+  return Array.isArray(raw) ? raw.map((type) => typeof type === "string" ? type.trim() : "").filter(Boolean) : [];
+}
+function readSpawnedSessionVisibility(policy) {
+  return policy?.spawnedSessionVisibility === "hidden" ? "hidden" : "visible";
+}
+function missingProviderPriorityMessage(nodeId) {
+  return `Node '${nodeId}' has no providerPriority policy; pass type explicitly or configure node.policy.providerPriority`;
+}
+function getNodeLaunchReadiness(node) {
+  const providerPriority = readProviderPriority(node.policy);
+  if (providerPriority.length) {
+    return {
+      providerPriority,
+      launchReady: true
+    };
   }
-  if (collected.length === 0) return "No active sessions.";
-  const lines = collected.map(({ daemonId: dId, session: s }) => {
-    const parts = [
-      `daemon: ${dId}`,
-      `session: ${s.id}`,
-      `type: ${s.providerType ?? "unknown"}`
-    ];
-    if (s.status) parts.push(`status: ${s.status}`);
-    if (s.workspace) parts.push(`workspace: ${s.workspace}`);
-    return parts.join(", ");
-  });
-  return `Sessions (${collected.length}):
-${lines.join("\n")}`;
+  return {
+    providerPriority,
+    launchReady: false,
+    launchBlockedReason: "missing_provider_priority",
+    launchBlockedMessage: missingProviderPriorityMessage(node.id)
+  };
 }
-
-// src/tools/list-daemons.ts
-var LIST_DAEMONS_TOOL = {
-  name: "list_daemons",
-  description: "List all connected daemons (machines running the ADHDev agent). Use this to discover daemon IDs before calling launch_session, git_status, or other tools that require daemon_id. In local mode returns the single standalone daemon info.",
+async function commandForNode(ctx, node, command, args = {}) {
+  if (ctx.transport instanceof IpcTransport && node.daemonId && node.daemonId !== ctx.localDaemonId) {
+    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",
+  description: "Get the current status of all nodes in the repo mesh \u2014 health, git state, active sessions. Use this to decide which node to send work to.",
   inputSchema: {
     type: "object",
-    properties: {
-      ...FORMAT_PROP
-    },
-    required: []
+    properties: {}
   }
 };
-async function listDaemons(transport, args = {}) {
-  const asJson = args.format === "json";
-  if (isLocalTransport(transport)) {
-    const status = await transport.getStatus();
-    const daemon = {
-      id: status?.id ?? status?.instanceId ?? "standalone",
-      hostname: status?.hostname ?? status?.machine?.hostname ?? "localhost",
-      platform: status?.platform ?? status?.machine?.platform ?? "unknown",
-      version: status?.version ?? null,
-      sessions: (status?.sessions ?? []).length
-    };
-    if (asJson) return JSON.stringify({ daemons: [daemon] }, null, 2);
-    return `Daemons (1):
-  id: ${daemon.id}, hostname: ${daemon.hostname}, platform: ${daemon.platform}${daemon.version ? `, version: ${daemon.version}` : ""}, sessions: ${daemon.sessions}`;
-  }
-  const data = await transport.listDaemons();
-  const daemons = data?.daemons ?? [];
-  if (asJson) {
-    return JSON.stringify({
-      daemons: daemons.map((d) => ({
-        id: d.id,
-        hostname: d.hostname ?? null,
-        platform: d.platform ?? null,
-        nickname: d.nickname ?? null,
-        version: d.version ?? null,
-        p2p_available: d.p2p?.available ?? null,
-        cdp_connected: d.cdpConnected ?? null
-      }))
-    }, null, 2);
+var MESH_LIST_NODES_TOOL = {
+  name: "mesh_list_nodes",
+  description: "List all nodes in the mesh with their capabilities, platform, and workspace paths.",
+  inputSchema: {
+    type: "object",
+    properties: {}
   }
-  if (daemons.length === 0) return "No connected daemons.";
-  const lines = daemons.map((d) => {
-    const parts = [`id: ${d.id}`];
-    if (d.nickname) parts.push(`nickname: ${d.nickname}`);
-    if (d.hostname) parts.push(`hostname: ${d.hostname}`);
-    if (d.platform) parts.push(`platform: ${d.platform}`);
-    if (d.version) parts.push(`version: ${d.version}`);
-    if (d.p2p?.available != null) parts.push(`p2p: ${d.p2p.available ? "yes" : "no"}`);
-    return parts.join(", ");
-  });
-  return `Daemons (${daemons.length}):
-${lines.join("\n")}`;
-}
-
-// src/tools/read-chat.ts
-var READ_CHAT_TOOL = {
-  name: "read_chat",
-  description: "Read the current chat conversation from an IDE agent session. Returns recent messages.",
+};
+var MESH_SEND_TASK_TOOL = {
+  name: "mesh_send_task",
+  description: "Send a natural-language task to an agent session on a mesh node. The agent will execute the task autonomously.",
   inputSchema: {
     type: "object",
     properties: {
-      session_id: {
-        type: "string",
-        description: "Target session ID (from list_sessions). Pass explicitly in local mode when more than one session exists; omitting requires an active target and may fail."
-      },
-      limit: {
-        type: "number",
-        description: "Max messages to return (default: 50)."
-      },
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only). Omit for local mode."
-      },
-      ...FORMAT_PROP
+      node_id: { type: "string", description: "Target node ID (from mesh_list_nodes)." },
+      session_id: { type: "string", description: "Agent session ID on the target node." },
+      message: { type: "string", description: "Natural-language task to send to the agent." }
     },
-    required: []
+    required: ["node_id", "session_id", "message"]
   }
 };
-async function readChat(transport, args) {
-  const limit = args.limit ?? 50;
-  if (isLocalTransport(transport)) {
-    const result2 = await transport.command("read_chat", {
-      ...args.session_id ? { targetSessionId: args.session_id } : {},
-      tailLimit: limit
-    });
-    return formatChatResult(result2, args.session_id, args.format, limit);
-  }
-  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-  const targetId = args.session_id ? `${args.daemon_id}:session:${args.session_id}` : args.daemon_id;
-  const result = await transport.readChat(targetId, { limit, sessionId: args.session_id });
-  return formatChatResult(result, args.session_id, args.format, limit);
-}
-function formatChatResult(result, sessionId, format, limit = 50) {
-  if (!result?.success && result?.error) {
-    if (format === "json") return JSON.stringify({ error: result.error, messages: [] }, null, 2);
-    return `Error: ${result.error}`;
+var MESH_READ_CHAT_TOOL = {
+  name: "mesh_read_chat",
+  description: "Read recent chat messages from a delegated agent session on a mesh node. Use compact=true for coordinator context-efficient review: it filters tool/internal/debug chatter and returns the final user-visible summary plus recent key messages. If the runtime session has completed, provider_session_id can explicitly target provider transcript history.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Target node ID." },
+      session_id: { type: "string", description: "Agent session ID to read from." },
+      provider_session_id: { type: "string", description: "Optional provider transcript/session ID for completed sessions." },
+      tail: { type: "number", description: "Number of recent messages to return (default: 10)." },
+      compact: { type: "boolean", description: "When true, return a compact coordinator summary instead of the full transcript: tool/internal/control/debug messages are excluded and only recent user-visible key messages plus the final assistant summary are included." }
+    },
+    required: ["node_id", "session_id"]
   }
-  const messages = result?.messages ?? result?.data?.messages ?? [];
-  if (format === "json") {
-    return JSON.stringify({
-      session_id: sessionId ?? null,
-      messages: messages.slice(-limit).map((m) => ({
-        role: m.role,
-        kind: m.kind ?? null,
-        content: typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((p) => typeof p === "string" ? p : p?.text ?? "").join("") : "",
-        timestamp: m.timestamp ?? null
-      }))
-    }, null, 2);
+};
+var MESH_READ_DEBUG_TOOL = {
+  name: "mesh_read_debug",
+  description: "Collect a daemon-side chat/parser debug bundle for a delegated agent session on a mesh node without opening the browser UI. Defaults to daemon_file delivery and returns a saved bundle locator.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Target node ID." },
+      session_id: { type: "string", description: "Agent session ID to debug." },
+      provider_session_id: { type: "string", description: "Optional provider transcript/session ID for completed session history." },
+      tail: { type: "number", description: "Number of recent read_chat messages to embed (default: 40)." },
+      delivery: { type: "string", enum: ["daemon_file", "inline"], description: "daemon_file saves the full sanitized bundle on the daemon; inline returns it directly. Default: daemon_file." }
+    },
+    required: ["node_id", "session_id"]
   }
-  if (messages.length === 0) return "No messages in chat.";
-  const lines = messages.slice(-limit).map((m) => {
-    const role = m.role === "user" ? "User" : m.role === "assistant" ? "Agent" : m.role;
-    const content = typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((p) => typeof p === "string" ? p : p?.text ?? "").join("") : "";
-    const truncated = content.length > 500 ? `${content.slice(0, 500)}\u2026` : content;
-    return `[${role}] ${truncated}`;
-  });
-  return lines.join("\n\n");
-}
-
-// src/tools/send-chat.ts
-var SEND_CHAT_TOOL = {
-  name: "send_chat",
-  description: "Send a message to an IDE agent session.",
+};
+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. If the user names a provider, preserve it exactly: Hermes = hermes-cli, Claude Code/Claude = claude-cli, Codex = codex-cli, Gemini = gemini-cli. If type is omitted, resolve strictly from the node policy providerPriority and provider detection; fail closed when no configured provider is usable. Do not default to claude-cli.",
   inputSchema: {
     type: "object",
     properties: {
-      message: {
-        type: "string",
-        description: "The message to send to the agent."
-      },
-      session_id: {
-        type: "string",
-        description: "Target session ID (from list_sessions). Omit to use the active session."
-      },
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only). Omit for local mode."
-      }
+      node_id: { type: "string", description: "Target node ID." },
+      type: { type: "string", description: "Optional provider type to launch. Use hermes-cli for Hermes, claude-cli for Claude Code, codex-cli for Codex, gemini-cli for Gemini. When omitted, node.policy.providerPriority is probed in order." }
     },
-    required: ["message"]
+    required: ["node_id"]
   }
 };
-async function sendChat(transport, args) {
-  if (!args.message?.trim()) throw new Error("message is required");
-  if (isLocalTransport(transport)) {
-    const result2 = await transport.command("send_chat", {
-      message: args.message,
-      ...args.session_id ? { targetSessionId: args.session_id } : {}
-    });
-    if (result2?.success === false) return `Error: ${result2.error ?? "send_chat failed"}`;
-    return "Message sent.";
+var MESH_GIT_STATUS_TOOL = {
+  name: "mesh_git_status",
+  description: "Get git status for a mesh node workspace \u2014 branch, dirty state, changed files.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Target node ID." }
+    },
+    required: ["node_id"]
   }
-  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-  const targetId = args.session_id ? `${args.daemon_id}:session:${args.session_id}` : args.daemon_id;
-  const result = await transport.sendChat(targetId, args.message, {
-    ...args.session_id ? { sessionId: args.session_id } : {}
-  });
-  if (result?.success === false) return `Error: ${result.error ?? "send_chat failed"}`;
-  return "Message sent.";
-}
-
-// src/tools/approve.ts
-var APPROVE_TOOL = {
-  name: "approve",
-  description: "Approve or reject a pending agent action (e.g. file write, command execution).",
+};
+var MESH_CHECKPOINT_TOOL = {
+  name: "mesh_checkpoint",
+  description: "Create a git checkpoint (commit) on a mesh node workspace.",
   inputSchema: {
     type: "object",
     properties: {
-      action: {
-        type: "string",
-        enum: ["approve", "reject"],
-        description: "Whether to approve or reject the pending action."
-      },
-      session_id: {
-        type: "string",
-        description: "Target session ID. Omit to use the active session."
-      },
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only)."
-      }
+      node_id: { type: "string", description: "Target node ID." },
+      message: { type: "string", description: "Checkpoint commit message." }
     },
-    required: ["action"]
+    required: ["node_id", "message"]
   }
 };
-async function approve(transport, args) {
-  const action = args.action === "reject" ? "reject" : "approve";
-  if (isLocalTransport(transport)) {
-    const result2 = await transport.command("resolve_action", {
-      action,
-      ...args.session_id ? { targetSessionId: args.session_id } : {}
-    });
-    if (result2?.success === false) return `Error: ${result2.error ?? "resolve_action failed"}`;
-    return `Action ${action}d.`;
+var MESH_APPROVE_TOOL = {
+  name: "mesh_approve",
+  description: "Approve or reject a pending action on a delegated agent session.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Target node ID." },
+      session_id: { type: "string", description: "Agent session ID with pending approval." },
+      action: { type: "string", enum: ["approve", "reject"], description: "Action to take." }
+    },
+    required: ["node_id", "session_id", "action"]
   }
-  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-  const targetId = args.session_id ? `${args.daemon_id}:session:${args.session_id}` : args.daemon_id;
-  const result = await transport.approve(targetId, action);
-  if (result?.success === false) return `Error: ${result.error ?? "approve failed"}`;
-  return `Action ${action}d.`;
-}
-
-// src/tools/screenshot.ts
-var SCREENSHOT_TOOL = {
-  name: "screenshot",
-  description: "Capture a screenshot of the current IDE window. Returns the image. Local mode only \u2014 screenshots require direct P2P access to the daemon and are not available in cloud mode.",
+};
+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: {
-      session_id: {
+      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. Session cleanup is controlled by mesh policy sessionCleanupOnNodeRemove unless session_cleanup_mode overrides it for this call.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      node_id: { type: "string", description: "Node ID to remove." },
+      session_cleanup_mode: {
         type: "string",
-        description: "Target session ID. Omit to use the active session."
+        enum: ["preserve", "stop", "delete_stopped", "stop_and_delete"],
+        description: "Optional override for cleanup of delegated sessions attached to this node. preserve keeps history/processes; stop stops live runtimes only; delete_stopped removes completed transcripts only; stop_and_delete stops live runtimes and deletes records."
       }
     },
-    required: []
+    required: ["node_id"]
   }
 };
-async function screenshot(transport, args) {
-  let result;
-  if (isLocalTransport(transport)) {
-    result = await transport.command("screenshot", {
-      ...args.session_id ? { targetSessionId: args.session_id } : {}
-    });
-  } else {
-    return { type: "text", text: "Screenshots are not available in cloud mode. Run adhdev mcp in local mode (requires standalone daemon)." };
-  }
-  if (result?.success === false) {
-    return { type: "text", text: `Error: ${result.error ?? "screenshot failed"}` };
-  }
-  const b64 = result?.base64 ?? result?.screenshot ?? result?.result;
-  if (!b64) {
-    return { type: "text", text: "Screenshot captured but no image data returned." };
-  }
-  const mimeType = result?.format === "png" ? "image/png" : "image/webp";
-  return { type: "image", data: b64, mimeType };
-}
-
-// src/tools/git-status.ts
-var GIT_STATUS_TOOL = {
-  name: "git_status",
-  description: "Get git repository status for a workspace on the daemon machine.",
+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.",
   inputSchema: {
     type: "object",
     properties: {
-      workspace: {
+      node_id: { type: "string", description: "Node ID whose delegated sessions should be considered for cleanup." },
+      mode: {
         type: "string",
-        description: "Absolute path to the workspace/repository directory."
+        enum: ["preserve", "stop", "delete_stopped", "stop_and_delete"],
+        description: "preserve = no-op; stop = release process occupancy by stopping live runtimes; delete_stopped = remove completed/stopped records while leaving live runtimes alone; stop_and_delete = stop live runtimes and delete records."
       },
-      include_diff: {
-        type: "boolean",
-        description: "Include changed file list (default: true)."
-      },
-      daemon_id: {
-        type: "string",
-        description: "Daemon ID (cloud mode only)."
+      session_ids: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional explicit session IDs to limit cleanup to. When omitted, sessions are matched by node/workspace metadata."
       },
-      ...FORMAT_PROP
+      dry_run: { type: "boolean", description: "Preview matched/stopped/deleted/skipped session IDs without mutating session-host state." }
     },
-    required: ["workspace"]
+    required: ["node_id", "mode"]
   }
 };
-async function gitStatus(transport, args) {
-  let status;
-  let diffSummary;
-  if (isLocalTransport(transport)) {
-    const statusResult = await transport.command("git_status", {
-      workspace: args.workspace
+var ALL_MESH_TOOLS = [
+  MESH_STATUS_TOOL,
+  MESH_LIST_NODES_TOOL,
+  MESH_SEND_TASK_TOOL,
+  MESH_READ_CHAT_TOOL,
+  MESH_READ_DEBUG_TOOL,
+  MESH_LAUNCH_SESSION_TOOL,
+  MESH_GIT_STATUS_TOOL,
+  MESH_CHECKPOINT_TOOL,
+  MESH_APPROVE_TOOL,
+  MESH_CLONE_NODE_TOOL,
+  MESH_REMOVE_NODE_TOOL,
+  MESH_CLEANUP_SESSIONS_TOOL
+];
+async function meshStatus(ctx) {
+  await refreshMeshFromDaemon(ctx);
+  const { mesh, transport } = ctx;
+  const results = [];
+  for (const node of mesh.nodes) {
+    const entry = {
+      nodeId: node.id,
+      workspace: node.workspace,
+      ...getNodeLaunchReadiness(node)
+    };
+    try {
+      if (!isLocalTransport(transport) && node.daemonId) {
+        const result = await transport.gitStatus(node.daemonId, node.workspace, false);
+        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 = dirty;
+        entry.uncommittedChanges = uncommittedChanges;
+      } else if (isLocalTransport(transport)) {
+        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 = dirty;
+        entry.uncommittedChanges = uncommittedChanges;
+      } else {
+        entry.health = "unknown";
+        entry.note = "No daemonId available for cloud status probe";
+      }
+    } catch (e) {
+      entry.health = "degraded";
+      entry.error = e.message;
+    }
+    const relatedRepos = await collectRelatedRepoStatuses(ctx, node);
+    if (relatedRepos.length) entry.relatedRepos = relatedRepos;
+    results.push(entry);
+  }
+  return JSON.stringify({
+    meshId: mesh.id,
+    meshName: mesh.name,
+    repoIdentity: mesh.repoIdentity,
+    policy: mesh.policy,
+    refreshedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    nodes: results
+  }, null, 2);
+}
+async function meshListNodes(ctx) {
+  await refreshMeshFromDaemon(ctx);
+  const { mesh } = ctx;
+  return JSON.stringify({
+    meshId: mesh.id,
+    meshName: mesh.name,
+    nodes: mesh.nodes.map((n) => ({
+      nodeId: n.id,
+      workspace: n.workspace,
+      repoRoot: n.repoRoot,
+      isLocalWorktree: n.isLocalWorktree,
+      policy: n.policy,
+      relatedRepos: readRelatedRepos(n),
+      ...getNodeLaunchReadiness(n),
+      userOverrides: n.userOverrides
+    }))
+  }, null, 2);
+}
+async function meshSendTask(ctx, args) {
+  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)) {
+    const result = await commandForNode(ctx, node, "send_chat", {
+      message: args.message,
+      sessionId: args.session_id,
+      targetSessionId: args.session_id
     });
-    status = statusResult?.status ?? statusResult;
-    if (args.include_diff !== false) {
-      const diffResult = await transport.command("git_diff_summary", {
-        workspace: args.workspace
+    const payload = unwrapCommandPayload(result);
+    if (payload?.success === false) {
+      return JSON.stringify({
+        success: false,
+        nodeId: args.node_id,
+        sessionId: args.session_id,
+        error: payload.error || "send_chat failed"
       });
-      diffSummary = diffResult?.diffSummary ?? diffResult;
     }
+    return JSON.stringify({ success: true, nodeId: args.node_id, sessionId: args.session_id });
   } else {
-    if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-    const result = await transport.gitStatus(
-      args.daemon_id,
-      args.workspace,
-      args.include_diff !== false
-    );
-    if (result?.error) {
-      if (args.format === "json") return JSON.stringify({ error: result.error }, null, 2);
-      return `Error: ${result.error}`;
-    }
-    status = result?.status;
-    diffSummary = result?.diff;
+    return JSON.stringify({ error: "Cloud mesh send_task not yet implemented" });
   }
-  if (status?.success === false || status?.reason) {
-    const msg = status?.error ?? status?.reason ?? "unknown";
-    if (args.format === "json") return JSON.stringify({ error: msg }, null, 2);
-    return `Git error: ${msg}`;
+}
+async function meshReadChat(ctx, args) {
+  const node = await findNodeWithRefresh(ctx, args.node_id);
+  if (isLocalTransport(ctx.transport)) {
+    const cached = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id));
+    const providerSessionId = typeof args.provider_session_id === "string" && args.provider_session_id.trim() ? args.provider_session_id.trim() : cached?.providerSessionId;
+    const result = await commandForNode(ctx, node, "read_chat", {
+      sessionId: args.session_id,
+      targetSessionId: args.session_id,
+      workspace: node.workspace,
+      ...cached?.providerType ? { agentType: cached.providerType, providerType: cached.providerType } : {},
+      ...providerSessionId ? { providerSessionId } : {},
+      tailLimit: args.tail ?? 10
+    });
+    const payload = annotateRapidReadChatAdvisory(unwrapCommandPayload(result), {
+      key: `mesh:${args.node_id}:${args.session_id}`,
+      toolName: "mesh_read_chat",
+      completionCallbackExpected: true
+    });
+    if (args.compact) {
+      const compactPayload = compactChatPayload(payload, {
+        nodeId: args.node_id,
+        sessionId: args.session_id,
+        limit: args.tail ?? 10
+      });
+      return JSON.stringify(
+        payload.pollingAdvisory ? { ...compactPayload, pollingAdvisory: payload.pollingAdvisory } : compactPayload,
+        null,
+        2
+      );
+    }
+    return JSON.stringify(payload, null, 2);
+  } else {
+    return JSON.stringify({ error: "Cloud mesh read_chat not yet implemented" });
   }
-  if (!status?.isGitRepo) {
-    if (args.format === "json") return JSON.stringify({ error: `Not a git repository: ${args.workspace}` }, null, 2);
-    return `Not a git repository: ${args.workspace}`;
+}
+async function meshReadDebug(ctx, args) {
+  const node = await findNodeWithRefresh(ctx, args.node_id);
+  if (isLocalTransport(ctx.transport)) {
+    const cached = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id));
+    const providerSessionId = typeof args.provider_session_id === "string" && args.provider_session_id.trim() ? args.provider_session_id.trim() : cached?.providerSessionId;
+    const delivery = args.delivery === "inline" ? void 0 : "daemon_file";
+    const result = await commandForNode(ctx, node, "get_chat_debug_bundle", {
+      sessionId: args.session_id,
+      targetSessionId: args.session_id,
+      workspace: node.workspace,
+      ...cached?.providerType ? { agentType: cached.providerType, providerType: cached.providerType } : {},
+      ...providerSessionId ? { providerSessionId } : {},
+      tailLimit: args.tail ?? 40,
+      ...delivery ? { delivery } : {}
+    });
+    const payload = unwrapCommandPayload(result);
+    return JSON.stringify(payload, null, 2);
   }
-  if (args.format === "json") {
-    const files = diffSummary?.files?.map((f) => ({
-      path: f.path,
-      old_path: f.oldPath ?? null,
-      status: f.status ?? "M",
-      insertions: f.insertions ?? 0,
-      deletions: f.deletions ?? 0
-    })) ?? [];
-    return JSON.stringify({
-      branch: status.branch ?? null,
-      head_commit: status.headCommit ?? null,
-      head_message: status.headMessage ?? null,
-      ahead: status.ahead ?? 0,
-      behind: status.behind ?? 0,
-      staged: status.staged ?? 0,
-      modified: status.modified ?? 0,
-      untracked: status.untracked ?? 0,
-      deleted: status.deleted ?? 0,
-      stash_count: status.stashCount ?? 0,
-      has_conflicts: status.hasConflicts ?? false,
-      dirty: status.dirty ?? false,
-      changed_files: files,
-      total_insertions: diffSummary?.totalInsertions ?? 0,
-      total_deletions: diffSummary?.totalDeletions ?? 0
+  return JSON.stringify({ error: "Cloud mesh read_debug not yet implemented" });
+}
+async function meshLaunchSession(ctx, args) {
+  const node = await findNodeWithRefresh(ctx, args.node_id);
+  if (isLocalTransport(ctx.transport)) {
+    let resolvedProviderType = typeof args.type === "string" && args.type.trim() ? args.type : "";
+    if (!resolvedProviderType) {
+      const providerPriority = readProviderPriority(node.policy);
+      if (!providerPriority.length) {
+        return JSON.stringify({ success: false, error: missingProviderPriorityMessage(args.node_id) });
+      }
+      const failed = [];
+      for (const providerType of providerPriority) {
+        const detectedResult = await commandForNode(ctx, node, "detect_provider", { providerType });
+        const detectedPayload = unwrapCommandPayload(detectedResult);
+        if (detectedPayload?.success && detectedPayload?.detected) {
+          resolvedProviderType = providerType;
+          break;
+        }
+        failed.push(`${providerType}: ${detectedPayload?.error || "not detected"}`);
+      }
+      if (!resolvedProviderType) {
+        return JSON.stringify({ success: false, error: `No usable provider detected for node '${args.node_id}' from providerPriority: ${failed.join("; ")}` });
+      }
+    }
+    const coordinatorNode = resolveCoordinatorNode(ctx);
+    const coordinatorDaemonId = coordinatorNode?.daemonId || ctx.localDaemonId;
+    const spawnedSessionVisibility = readSpawnedSessionVisibility(ctx.mesh.policy);
+    const result = await commandForNode(ctx, node, "launch_cli", {
+      cliType: resolvedProviderType,
+      dir: node.workspace,
+      settings: {
+        meshNodeFor: ctx.mesh.id,
+        meshNodeId: args.node_id,
+        spawnedSessionVisibility,
+        ...coordinatorDaemonId ? { meshCoordinatorDaemonId: coordinatorDaemonId } : {},
+        ...coordinatorNode?.id ? { meshCoordinatorNodeId: coordinatorNode.id } : {},
+        launchedByCoordinator: true
+      }
+    });
+    const launchPayload = extractLaunchPayload(result);
+    const runtimeSessionId = typeof launchPayload?.sessionId === "string" ? launchPayload.sessionId : typeof launchPayload?.id === "string" ? launchPayload.id : typeof launchPayload?.runtimeSessionId === "string" ? launchPayload.runtimeSessionId : "";
+    const providerSessionId = typeof launchPayload?.providerSessionId === "string" && launchPayload.providerSessionId.trim() ? launchPayload.providerSessionId.trim() : void 0;
+    if (runtimeSessionId) {
+      meshSessionProviderMetadata.set(meshSessionCacheKey(args.node_id, runtimeSessionId), {
+        providerType: resolvedProviderType,
+        ...providerSessionId ? { providerSessionId } : {}
+      });
+    }
+    return JSON.stringify({
+      ...launchPayload,
+      resolvedProviderType,
+      ...providerSessionId ? { providerSessionId } : {}
     }, null, 2);
+  } else {
+    return JSON.stringify({ error: "Cloud mesh launch_session not yet implemented" });
   }
-  const lines = [];
-  if (status.branch) lines.push(`Branch: ${status.branch}`);
-  if (status.headCommit) {
-    lines.push(`HEAD: ${status.headCommit.slice(0, 7)}${status.headMessage ? ` \u2014 ${status.headMessage.slice(0, 80)}` : ""}`);
+}
+async function meshGitStatus(ctx, args) {
+  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: extractGitStatus(result),
+      diff: extractGitDiff(result),
+      relatedRepos: await collectRelatedRepoStatuses(ctx, node)
+    }, null, 2);
+  } else if (isLocalTransport(ctx.transport)) {
+    const statusResult = await commandForNode(ctx, node, "git_status", {
+      workspace: node.workspace
+    });
+    const diffResult = await commandForNode(ctx, node, "git_diff_summary", {
+      workspace: node.workspace
+    });
+    return JSON.stringify({
+      nodeId: args.node_id,
+      workspace: node.workspace,
+      status: extractGitStatus(statusResult),
+      diff: extractGitDiff(diffResult),
+      relatedRepos: await collectRelatedRepoStatuses(ctx, node)
+    }, null, 2);
+  } else {
+    return JSON.stringify({ error: "No daemonId available for cloud git_status probe" });
+  }
+}
+async function meshCheckpoint(ctx, args) {
+  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 commandForNode(ctx, node, "git_checkpoint", {
+      workspace: node.workspace,
+      message: args.message,
+      includeUntracked: true
+    });
+    return JSON.stringify(result, null, 2);
+  } else {
+    return JSON.stringify({ error: "Cloud mesh checkpoint not yet implemented" });
+  }
+}
+async function meshApprove(ctx, args) {
+  const node = await findNodeWithRefresh(ctx, args.node_id);
+  if (isLocalTransport(ctx.transport)) {
+    const cached = meshSessionProviderMetadata.get(meshSessionCacheKey(args.node_id, args.session_id));
+    const providerSessionId = cached?.providerSessionId;
+    const result = await commandForNode(ctx, node, "resolve_action", {
+      sessionId: args.session_id,
+      targetSessionId: args.session_id,
+      workspace: node.workspace,
+      ...cached?.providerType ? { agentType: cached.providerType, providerType: cached.providerType } : {},
+      ...providerSessionId ? { providerSessionId } : {},
+      action: args.action === "reject" ? "reject" : "approve"
+    });
+    return JSON.stringify(result, null, 2);
+  } else {
+    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 meshCleanupSessions(ctx, args) {
+  const node = await findNodeWithRefresh(ctx, args.node_id);
+  if (isLocalTransport(ctx.transport)) {
+    const result = await commandForNode(ctx, node, "cleanup_mesh_sessions", {
+      meshId: ctx.mesh.id,
+      nodeId: args.node_id,
+      mode: args.mode,
+      sessionIds: args.session_ids,
+      dryRun: args.dry_run === true,
+      inlineMesh: ctx.mesh
+    });
+    return JSON.stringify(result, null, 2);
+  } else {
+    return JSON.stringify({ error: "Cloud mesh cleanup_sessions 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,
+      ...args.session_cleanup_mode ? { sessionCleanupMode: args.session_cleanup_mode } : {},
+      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/help.ts
+var STANDARD_TOOLS = [
+  "list_daemons",
+  "list_sessions",
+  "launch_session",
+  "stop_session",
+  "check_pending",
+  "read_chat",
+  "read_chat_debug",
+  "send_chat",
+  "approve",
+  "git_status",
+  "git_log",
+  "git_diff",
+  "git_checkpoint",
+  "git_push",
+  "screenshot"
+];
+function buildMcpHelpText() {
+  const meshTools = ALL_MESH_TOOLS.map((tool) => tool.name);
+  return `
+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:
+  --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
+  --repo-mesh <mesh_id>   Enable mesh mode \u2014 exposes only mesh-scoped coordinator tools
+  --help                  Show this help
+
+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:   ${STANDARD_TOOLS.join(", ")}
+Mesh tools:       ${meshTools.join(", ")}
+`.trim();
+}
+
+// src/server.ts
+var import_server = require("@modelcontextprotocol/sdk/server/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+
+// src/transports/local.ts
+var DEFAULT_PORT = 3847;
+var LocalTransport = class {
+  baseUrl;
+  authHeader;
+  constructor(opts = {}) {
+    this.baseUrl = `http://localhost:${opts.port ?? DEFAULT_PORT}`;
+    this.authHeader = opts.password ? `Bearer ${opts.password}` : null;
+  }
+  headers() {
+    const h = { "Content-Type": "application/json" };
+    if (this.authHeader) h["Authorization"] = this.authHeader;
+    return h;
+  }
+  async getStatus() {
+    const res = await fetch(`${this.baseUrl}/api/v1/status`, { headers: this.headers() });
+    if (!res.ok) throw new Error(`Status fetch failed: ${res.status}`);
+    return res.json();
+  }
+  async command(type, args = {}) {
+    const res = await fetch(`${this.baseUrl}/api/v1/command`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({ type, ...args })
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => res.statusText);
+      throw new Error(`Command ${type} failed: ${res.status} ${text}`);
+    }
+    return res.json();
+  }
+  async ping() {
+    try {
+      await this.getStatus();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/transports/cloud.ts
+var DEFAULT_BASE_URL = "https://api.adhf.dev";
+var CloudTransport = class {
+  baseUrl;
+  apiKey;
+  constructor(opts) {
+    this.apiKey = opts.apiKey;
+    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL;
+  }
+  headers() {
+    return {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${this.apiKey}`
+    };
+  }
+  async listDaemons() {
+    const res = await fetch(`${this.baseUrl}/api/v1/daemons`, { headers: this.headers() });
+    if (!res.ok) throw new Error(`List daemons failed: ${res.status}`);
+    return res.json();
+  }
+  async getStatus(targetId) {
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/status`,
+      { headers: this.headers() }
+    );
+    if (!res.ok) throw new Error(`Status failed: ${res.status}`);
+    return res.json();
+  }
+  /** Get all sessions for a daemon (returns CompactSessionEntry[]). */
+  async getDaemonStatus(daemonId) {
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/daemons/${encodeURIComponent(daemonId)}/status`,
+      { headers: this.headers() }
+    );
+    if (!res.ok) throw new Error(`Daemon status failed: ${res.status}`);
+    return res.json();
+  }
+  async readChat(targetId, opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.limit) params.set("limit", String(opts.limit));
+    if (opts.sessionId) params.set("sessionId", opts.sessionId);
+    const qs = params.toString() ? `?${params}` : "";
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/chat${qs}`,
+      { headers: this.headers() }
+    );
+    if (!res.ok) throw new Error(`Read chat failed: ${res.status}`);
+    return res.json();
+  }
+  async getChatDebugBundle(targetId, opts = {}) {
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/chat/debug`,
+      {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify({
+          ...opts.agentType ? { agentType: opts.agentType } : {},
+          ...opts.sessionId ? { sessionId: opts.sessionId } : {},
+          ...opts.tailLimit ? { tailLimit: opts.tailLimit } : {},
+          ...opts.delivery ? { delivery: opts.delivery } : {}
+        })
+      }
+    );
+    if (!res.ok) throw new Error(`Chat debug bundle failed: ${res.status}`);
+    return res.json();
+  }
+  async sendChat(targetId, message, opts = {}) {
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/chat`,
+      {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify({ message, ...opts })
+      }
+    );
+    if (!res.ok) throw new Error(`Send chat failed: ${res.status}`);
+    return res.json();
+  }
+  async approve(targetId, action, agentType) {
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(targetId)}/approve`,
+      {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify({ action, ...agentType ? { agentType } : {} })
+      }
+    );
+    if (!res.ok) throw new Error(`Approve failed: ${res.status}`);
+    return res.json();
+  }
+  async gitStatus(daemonId, workspace, includeDiff = true) {
+    const params = new URLSearchParams({ workspace, includeDiff: String(includeDiff) });
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-status?${params}`,
+      { headers: this.headers() }
+    );
+    if (!res.ok) throw new Error(`Git status failed: ${res.status}`);
+    return res.json();
+  }
+  async stop(daemonId, opts) {
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/stop`,
+      {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify(opts)
+      }
+    );
+    if (!res.ok) throw new Error(`Stop failed: ${res.status}`);
+    return res.json();
+  }
+  async launch(daemonId, opts) {
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/launch`,
+      {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify(opts)
+      }
+    );
+    if (!res.ok) throw new Error(`Launch failed: ${res.status}`);
+    return res.json();
+  }
+  async gitLog(daemonId, workspace, opts = {}) {
+    const params = new URLSearchParams({ workspace });
+    if (opts.limit) params.set("limit", String(opts.limit));
+    if (opts.file) params.set("file", opts.file);
+    if (opts.since) params.set("since", opts.since);
+    if (opts.until) params.set("until", opts.until);
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-log?${params}`,
+      { headers: this.headers() }
+    );
+    if (!res.ok) throw new Error(`Git log failed: ${res.status}`);
+    return res.json();
+  }
+  async gitDiff(daemonId, workspace, opts = {}) {
+    const params = new URLSearchParams({ workspace });
+    if (opts.file) params.set("file", opts.file);
+    if (opts.maxLines) params.set("maxLines", String(opts.maxLines));
+    if (opts.staged) params.set("staged", "true");
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-diff?${params}`,
+      { headers: this.headers() }
+    );
+    if (!res.ok) throw new Error(`Git diff failed: ${res.status}`);
+    return res.json();
+  }
+  async gitPush(daemonId, opts) {
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-push`,
+      {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify(opts)
+      }
+    );
+    if (!res.ok) throw new Error(`Git push failed: ${res.status}`);
+    return res.json();
+  }
+  async gitCheckpoint(daemonId, opts) {
+    const res = await fetch(
+      `${this.baseUrl}/api/v1/shortcuts/${encodeURIComponent(daemonId)}/git-checkpoint`,
+      {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify(opts)
+      }
+    );
+    if (!res.ok) throw new Error(`Git checkpoint failed: ${res.status}`);
+    return res.json();
+  }
+  async ping() {
+    try {
+      await this.listDaemons();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/tools/list-sessions.ts
+var FORMAT_PROP = {
+  format: {
+    type: "string",
+    enum: ["text", "json"],
+    description: "Output format: 'text' (default, human-readable) or 'json' (structured, for programmatic use)."
+  }
+};
+var LIST_SESSIONS_TOOL = {
+  name: "list_sessions",
+  description: "List all connected agent sessions. In cloud mode, fetches session state from each daemon (data is sourced from daemon WS status reports, up to 30s stale). Pass daemon_id to scope to a single daemon.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      daemon_id: {
+        type: "string",
+        description: "Daemon ID (cloud mode only). Omit to list sessions across all daemons."
+      },
+      ...FORMAT_PROP
+    },
+    required: []
+  }
+};
+async function listSessions(transport, args = {}) {
+  const asJson = args.format === "json";
+  if (isLocalTransport(transport)) {
+    const status = await transport.getStatus();
+    const sessions = status?.sessions ?? [];
+    if (asJson) {
+      return JSON.stringify({
+        sessions: sessions.map((s) => ({
+          id: s.id,
+          type: s.providerType ?? s.type ?? "unknown",
+          label: s.label ?? null,
+          status: s.status ?? s.agentStatus ?? null,
+          workspace: s.workspace ?? null
+        }))
+      }, null, 2);
+    }
+    if (sessions.length === 0) return "No active sessions.";
+    const lines = sessions.map((s) => {
+      const parts = [`id: ${s.id}`, `type: ${s.providerType ?? s.type ?? "unknown"}`];
+      if (s.label) parts.push(`label: ${s.label}`);
+      if (s.status ?? s.agentStatus) parts.push(`status: ${s.status ?? s.agentStatus}`);
+      if (s.workspace) parts.push(`workspace: ${s.workspace}`);
+      return parts.join(", ");
+    });
+    return `Sessions (${sessions.length}):
+${lines.join("\n")}`;
   }
-  if (status.ahead > 0) lines.push(`Ahead: ${status.ahead}`);
-  if (status.behind > 0) lines.push(`Behind: ${status.behind}`);
-  if (status.staged > 0) lines.push(`Staged: ${status.staged}`);
-  if (status.modified > 0) lines.push(`Modified: ${status.modified}`);
-  if (status.untracked > 0) lines.push(`Untracked: ${status.untracked}`);
-  if (status.deleted > 0) lines.push(`Deleted: ${status.deleted}`);
-  if (status.stashCount > 0) lines.push(`Stashes: ${status.stashCount}`);
-  if (status.hasConflicts) lines.push("Conflicts: YES");
-  if (!status.dirty) lines.push("Working tree: clean");
-  if (diffSummary?.files?.length > 0) {
-    lines.push("");
-    lines.push(`Changed files (${diffSummary.files.length}):`);
-    for (const f of diffSummary.files.slice(0, 20)) {
-      lines.push(`  ${f.status ?? "M"} ${f.path}${f.oldPath ? ` (was ${f.oldPath})` : ""}${f.insertions || f.deletions ? ` +${f.insertions ?? 0}/-${f.deletions ?? 0}` : ""}`);
+  return listSessionsCloud(transport, args.daemon_id, asJson);
+}
+async function listSessionsCloud(transport, daemonId, asJson) {
+  const collected = [];
+  if (daemonId) {
+    const daemonStatus = await transport.getDaemonStatus(daemonId);
+    for (const s of daemonStatus?.sessions ?? []) {
+      collected.push({ daemonId, session: s });
     }
-    if (diffSummary.files.length > 20) lines.push(`  \u2026 and ${diffSummary.files.length - 20} more`);
-    if (diffSummary.totalInsertions || diffSummary.totalDeletions) {
-      lines.push(`Total: +${diffSummary.totalInsertions ?? 0}/-${diffSummary.totalDeletions ?? 0}`);
+  } else {
+    const data = await transport.listDaemons();
+    const daemons = data?.daemons ?? [];
+    for (let i = 0; i < daemons.length; i += 5) {
+      await Promise.allSettled(
+        daemons.slice(i, i + 5).map(async (d) => {
+          try {
+            const daemonStatus = await transport.getDaemonStatus(d.id);
+            for (const s of daemonStatus?.sessions ?? []) {
+              collected.push({ daemonId: d.id, session: s });
+            }
+          } catch {
+          }
+        })
+      );
     }
   }
-  return lines.join("\n");
+  if (asJson) {
+    return JSON.stringify({
+      sessions: collected.map(({ daemonId: dId, session: s }) => ({
+        daemon_id: dId,
+        id: s.id,
+        type: s.providerType ?? "unknown",
+        status: s.status ?? null,
+        workspace: s.workspace ?? null
+      }))
+    }, null, 2);
+  }
+  if (collected.length === 0) return "No active sessions.";
+  const lines = collected.map(({ daemonId: dId, session: s }) => {
+    const parts = [
+      `daemon: ${dId}`,
+      `session: ${s.id}`,
+      `type: ${s.providerType ?? "unknown"}`
+    ];
+    if (s.status) parts.push(`status: ${s.status}`);
+    if (s.workspace) parts.push(`workspace: ${s.workspace}`);
+    return parts.join(", ");
+  });
+  return `Sessions (${collected.length}):
+${lines.join("\n")}`;
 }
 
-// src/tools/git-log.ts
-var GIT_LOG_TOOL = {
-  name: "git_log",
-  description: "Get commit history for a workspace. Shows hash, message, author, and date for recent commits. Use this to track what changes an agent has made, verify checkpoint commits, or understand project history.",
+// src/tools/list-daemons.ts
+var LIST_DAEMONS_TOOL = {
+  name: "list_daemons",
+  description: "List all connected daemons (machines running the ADHDev agent). Use this to discover daemon IDs before calling launch_session, git_status, or other tools that require daemon_id. In local mode returns the single standalone daemon info.",
   inputSchema: {
     type: "object",
     properties: {
-      workspace: {
+      ...FORMAT_PROP
+    },
+    required: []
+  }
+};
+async function listDaemons(transport, args = {}) {
+  const asJson = args.format === "json";
+  if (isLocalTransport(transport)) {
+    const status = await transport.getStatus();
+    const daemon = {
+      id: status?.id ?? status?.instanceId ?? "standalone",
+      hostname: status?.hostname ?? status?.machine?.hostname ?? "localhost",
+      platform: status?.platform ?? status?.machine?.platform ?? "unknown",
+      version: status?.version ?? null,
+      sessions: (status?.sessions ?? []).length
+    };
+    if (asJson) return JSON.stringify({ daemons: [daemon] }, null, 2);
+    return `Daemons (1):
+  id: ${daemon.id}, hostname: ${daemon.hostname}, platform: ${daemon.platform}${daemon.version ? `, version: ${daemon.version}` : ""}, sessions: ${daemon.sessions}`;
+  }
+  const data = await transport.listDaemons();
+  const daemons = data?.daemons ?? [];
+  if (asJson) {
+    return JSON.stringify({
+      daemons: daemons.map((d) => ({
+        id: d.id,
+        hostname: d.hostname ?? null,
+        platform: d.platform ?? null,
+        nickname: d.nickname ?? null,
+        version: d.version ?? null,
+        p2p_available: d.p2p?.available ?? null,
+        cdp_connected: d.cdpConnected ?? null
+      }))
+    }, null, 2);
+  }
+  if (daemons.length === 0) return "No connected daemons.";
+  const lines = daemons.map((d) => {
+    const parts = [`id: ${d.id}`];
+    if (d.nickname) parts.push(`nickname: ${d.nickname}`);
+    if (d.hostname) parts.push(`hostname: ${d.hostname}`);
+    if (d.platform) parts.push(`platform: ${d.platform}`);
+    if (d.version) parts.push(`version: ${d.version}`);
+    if (d.p2p?.available != null) parts.push(`p2p: ${d.p2p.available ? "yes" : "no"}`);
+    return parts.join(", ");
+  });
+  return `Daemons (${daemons.length}):
+${lines.join("\n")}`;
+}
+
+// src/tools/read-chat.ts
+var READ_CHAT_TOOL = {
+  name: "read_chat",
+  description: "Read the current chat conversation from an IDE agent session. Returns recent messages.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      session_id: {
         type: "string",
-        description: "Absolute path to the workspace/repository directory."
+        description: "Target session ID (from list_sessions). Pass explicitly in local mode when more than one session exists; omitting requires an active target and may fail."
       },
       limit: {
         type: "number",
-        description: "Max commits to return (default: 20, max: 100)."
-      },
-      file: {
-        type: "string",
-        description: "Filter history to commits that touched this repo-relative file path (optional)."
-      },
-      since: {
-        type: "string",
-        description: "Only commits after this date (ISO 8601 or git date string, optional)."
-      },
-      until: {
-        type: "string",
-        description: "Only commits before this date (ISO 8601 or git date string, optional)."
+        description: "Max messages to return (default: 50)."
       },
       daemon_id: {
         type: "string",
-        description: "Daemon ID (cloud mode only, required)."
+        description: "Daemon ID (cloud mode only). Omit for local mode."
+      },
+      compact: {
+        type: "boolean",
+        description: "Opt-in compact mode: filters tool/terminal/system/internal/control/debug/status chatter and returns user-visible messages plus lightweight summary metadata."
       },
       ...FORMAT_PROP
     },
-    required: ["workspace"]
+    required: []
   }
 };
-async function gitLog(transport, args) {
-  const limit = Math.max(1, Math.min(100, args.limit ?? 20));
-  let raw;
+async function readChat(transport, args) {
+  const limit = args.limit ?? 50;
   if (isLocalTransport(transport)) {
-    raw = await transport.command("git_log", {
-      workspace: args.workspace,
-      limit,
-      ...args.file ? { path: args.file } : {},
-      ...args.since ? { since: args.since } : {},
-      ...args.until ? { until: args.until } : {}
+    const result2 = await transport.command("read_chat", {
+      ...args.session_id ? { targetSessionId: args.session_id } : {},
+      tailLimit: limit
     });
-    raw = raw?.log ?? raw;
-  } else {
-    if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-    const result = await transport.gitLog(args.daemon_id, args.workspace, {
-      limit,
-      file: args.file,
-      since: args.since,
-      until: args.until
+    const annotated2 = annotateRapidReadChatAdvisory(result2, {
+      key: `local:${args.session_id ?? "__active__"}`,
+      toolName: "read_chat",
+      completionCallbackExpected: false
     });
-    raw = result?.log ?? result;
-  }
-  if (raw?.success === false || raw?.reason) {
-    const msg = raw?.error ?? raw?.reason ?? "unknown";
-    if (args.format === "json") return JSON.stringify({ error: msg }, null, 2);
-    return `Git log error: ${msg}`;
+    return formatChatResult(annotated2, args.session_id, args.format, limit, args.compact);
   }
-  if (!raw?.isGitRepo) {
-    const msg = `Not a git repository: ${args.workspace}`;
-    if (args.format === "json") return JSON.stringify({ error: msg }, null, 2);
-    return msg;
+  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
+  const targetId = args.session_id ? `${args.daemon_id}:session:${args.session_id}` : args.daemon_id;
+  const result = await transport.readChat(targetId, { limit, sessionId: args.session_id });
+  const annotated = annotateRapidReadChatAdvisory(result, {
+    key: `cloud:${args.daemon_id}:${args.session_id ?? "__active__"}`,
+    toolName: "read_chat",
+    completionCallbackExpected: false
+  });
+  return formatChatResult(annotated, args.session_id, args.format, limit, args.compact);
+}
+function formatChatResult(result, sessionId, format, limit = 50, compact = false) {
+  if (!result?.success && result?.error) {
+    if (format === "json") return JSON.stringify({ error: result.error, messages: [] }, null, 2);
+    return `Error: ${result.error}`;
   }
-  const entries = raw?.entries ?? [];
-  if (args.format === "json") {
+  const messages = result?.messages ?? result?.data?.messages ?? [];
+  const source = { ...result, messages };
+  const compactPayload = compact ? compactChatPayload(source, { sessionId: sessionId ?? null, limit }) : null;
+  const outputMessages = compact ? compactPayload.messages : messages;
+  if (format === "json") {
+    if (compact && compactPayload) {
+      return JSON.stringify({
+        session_id: sessionId ?? null,
+        ...compactPayload,
+        ...result?.pollingAdvisory ? { pollingAdvisory: result.pollingAdvisory } : {},
+        messages: compactPayload.messages.map((m) => ({
+          role: m.role,
+          kind: m.kind ?? null,
+          content: messageContent(m),
+          timestamp: m.timestamp ?? null
+        }))
+      }, null, 2);
+    }
     return JSON.stringify({
-      workspace: raw.workspace,
-      branch: raw.branch ?? null,
-      entries: entries.map((e) => ({
-        commit: e.commit,
-        short: e.commit?.slice(0, 7),
-        message: e.message,
-        author: e.authorName ?? null,
-        author_email: e.authorEmail ?? null,
-        authored_at: e.authoredAt ? new Date(e.authoredAt).toISOString() : null
-      })),
-      total: entries.length,
-      truncated: raw.truncated ?? false
+      session_id: sessionId ?? null,
+      ...result?.pollingAdvisory ? { pollingAdvisory: result.pollingAdvisory } : {},
+      messages: outputMessages.slice(-limit).map((m) => ({
+        role: m.role,
+        kind: m.kind ?? null,
+        content: messageContent(m),
+        timestamp: m.timestamp ?? null
+      }))
     }, null, 2);
   }
-  if (entries.length === 0) return "No commits found.";
-  const lines = entries.map((e) => {
-    const hash = e.commit?.slice(0, 7) ?? "???????";
-    const date = e.authoredAt ? new Date(e.authoredAt).toISOString().slice(0, 10) : "";
-    const author = e.authorName ? ` (${e.authorName})` : "";
-    return `${hash} ${date}${author} ${e.message}`;
+  if (outputMessages.length === 0) {
+    return result?.pollingAdvisory ? `No messages in chat.
+
+Advisory: ${result.pollingAdvisory.message}` : "No messages in chat.";
+  }
+  const lines = outputMessages.slice(-limit).map((m) => {
+    const role = m.role === "user" ? "User" : m.role === "assistant" ? "Agent" : m.role;
+    const content = messageContent(m);
+    const truncated = content.length > 500 ? `${content.slice(0, 500)}\u2026` : content;
+    return `[${role}] ${truncated}`;
   });
-  const header = `Commits (${entries.length}${raw.truncated ? ", truncated" : ""}):`;
-  return `${header}
-${lines.join("\n")}`;
+  if (result?.pollingAdvisory) {
+    lines.push(`Advisory: ${result.pollingAdvisory.message}`);
+  }
+  return lines.join("\n\n");
 }
 
-// src/tools/git-diff.ts
-var GIT_DIFF_TOOL = {
-  name: "git_diff",
-  description: "Get the actual diff content for changed files in a workspace. Without a specific file, returns diffs for up to 5 changed files. Use this to review what an agent actually changed \u2014 file names alone (from git_status) are not enough for code review.",
+// src/tools/read-chat-debug.ts
+var READ_CHAT_DEBUG_TOOL = {
+  name: "read_chat_debug",
+  description: "Collect a daemon-side chat/parser debug bundle for an agent session without opening the browser UI. Prefer this when terminal/chat diverge or long CLI transcripts parse incorrectly. Defaults to daemon_file delivery and returns a saved bundle locator.",
   inputSchema: {
     type: "object",
     properties: {
-      workspace: {
+      session_id: {
+        type: "string",
+        description: "Target session ID (from list_sessions). Required for reliable routing."
+      },
+      daemon_id: {
         type: "string",
-        description: "Absolute path to the workspace/repository directory."
+        description: "Daemon ID (cloud mode only). Omit for local mode."
       },
-      file: {
+      agent_type: {
         type: "string",
-        description: "Specific repo-relative file path to diff (optional \u2014 if omitted, returns top 5 changed files)."
+        description: "Optional provider/agent type hint, e.g. hermes-cli, claude-cli, codex-cli."
       },
-      max_lines: {
+      limit: {
         type: "number",
-        description: "Max diff lines per file before truncating (default: 300)."
-      },
-      staged: {
-        type: "boolean",
-        description: "Show staged changes instead of unstaged (default: false)."
+        description: "Max read_chat tail messages embedded in the bundle (default: 40)."
       },
-      daemon_id: {
+      delivery: {
         type: "string",
-        description: "Daemon ID (cloud mode only, required)."
+        enum: ["daemon_file", "inline"],
+        description: "daemon_file saves the full sanitized bundle on the daemon and returns a locator; inline returns the sanitized bundle in the MCP response. Default: daemon_file."
       },
       ...FORMAT_PROP
     },
-    required: ["workspace"]
+    required: ["session_id"]
   }
 };
-async function gitDiff(transport, args) {
-  const maxLines = Math.max(10, Math.min(2e3, args.max_lines ?? 300));
-  const staged = args.staged ?? false;
+async function readChatDebug(transport, args) {
+  const sessionId = typeof args.session_id === "string" ? args.session_id.trim() : "";
+  if (!sessionId) throw new Error("session_id is required");
+  const tailLimit = args.limit ?? 40;
+  const delivery = args.delivery === "inline" ? "inline" : "daemon_file";
+  const commandArgs = {
+    targetSessionId: sessionId,
+    tailLimit,
+    ...args.agent_type ? { agentType: args.agent_type, providerType: args.agent_type } : {},
+    ...delivery === "daemon_file" ? { delivery: "daemon_file" } : {}
+  };
+  let result;
   if (isLocalTransport(transport)) {
-    return localGitDiff(transport, args.workspace, args.file, maxLines, staged, args.format);
-  }
-  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-  const result = await transport.gitDiff(args.daemon_id, args.workspace, {
-    file: args.file,
-    maxLines,
-    staged
-  });
-  if (result?.error) {
-    if (args.format === "json") return JSON.stringify({ error: result.error }, null, 2);
-    return `Git diff error: ${result.error}`;
+    result = await transport.command("get_chat_debug_bundle", commandArgs);
+  } else {
+    if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
+    const targetId = `${args.daemon_id}:session:${sessionId}`;
+    result = await transport.getChatDebugBundle(targetId, {
+      sessionId,
+      agentType: args.agent_type,
+      tailLimit,
+      delivery
+    });
   }
-  return formatDiffResult(result, args.format);
+  return formatChatDebugResult(result, { sessionId, delivery, format: args.format });
 }
-async function localGitDiff(transport, workspace, file, maxLines, staged, format) {
-  if (file) {
-    const raw = await transport.command("git_diff_file", { workspace, path: file, staged });
-    const d = raw?.diff ?? raw;
-    if (d?.success === false || d?.reason) {
-      const msg = d?.error ?? d?.reason ?? "unknown";
-      if (format === "json") return JSON.stringify({ error: msg }, null, 2);
-      return `Git diff error: ${msg}`;
-    }
-    const lines = (d?.diff ?? "").split("\n");
-    const truncated = lines.length > maxLines;
-    const result = {
-      files: [{
-        path: file,
-        diff: truncated ? lines.slice(0, maxLines).join("\n") + "\n... (truncated)" : d?.diff ?? "",
-        truncated,
-        binary: d?.binary ?? false
-      }],
-      total_files: 1,
-      shown_files: 1,
-      truncated
-    };
-    return formatDiffResult(result, format);
-  }
-  const summaryRaw = await transport.command("git_diff_summary", { workspace, staged });
-  const summary = summaryRaw?.diffSummary ?? summaryRaw;
-  if (summary?.success === false || summary?.reason) {
-    const msg = summary?.error ?? summary?.reason ?? "unknown";
-    if (format === "json") return JSON.stringify({ error: msg }, null, 2);
-    return `Git diff error: ${msg}`;
-  }
-  if (!summary?.isGitRepo) {
-    const msg = `Not a git repository: ${workspace}`;
-    if (format === "json") return JSON.stringify({ error: msg }, null, 2);
-    return msg;
+function formatChatDebugResult(result, options) {
+  if (!result?.success && result?.error) {
+    if (options.format === "json") return JSON.stringify({ success: false, error: result.error }, null, 2);
+    return `Error: ${result.error}`;
   }
-  const files = summary?.files ?? [];
-  if (files.length === 0) {
-    if (format === "json") return JSON.stringify({ files: [], total_files: 0, shown_files: 0, truncated: false }, null, 2);
-    return "No changed files.";
+  if (options.format === "json") {
+    return JSON.stringify(result, null, 2);
   }
-  const topFiles = files.slice(0, 5);
-  const fileDiffs = await Promise.all(
-    topFiles.map(async (f) => {
-      try {
-        const raw = await transport.command("git_diff_file", { workspace, path: f.path, staged });
-        const d = raw?.diff ?? raw;
-        const lines = (d?.diff ?? "").split("\n");
-        const trunc = lines.length > maxLines;
-        return {
-          path: f.path,
-          old_path: f.oldPath ?? null,
-          status: f.status ?? "M",
-          diff: trunc ? lines.slice(0, maxLines).join("\n") + "\n... (truncated)" : d?.diff ?? "",
-          truncated: trunc,
-          binary: d?.binary ?? false
-        };
-      } catch {
-        return { path: f.path, diff: "", truncated: false, binary: false, error: "fetch failed" };
-      }
-    })
-  );
-  return formatDiffResult({
-    files: fileDiffs,
-    total_files: files.length,
-    shown_files: topFiles.length,
-    truncated: files.length > 5
-  }, format);
+  if (result?.delivery === "daemon_file") {
+    const summary = result.summary && typeof result.summary === "object" ? result.summary : {};
+    return [
+      "ADHDev chat debug bundle saved on daemon.",
+      `session_id: ${options.sessionId}`,
+      `bundle_id: ${String(result.bundleId || "")}`,
+      `saved_path: ${String(result.savedPath || "")}`,
+      `size_bytes: ${String(result.sizeBytes || "")}`,
+      `created_at: ${String(result.createdAt || "")}`,
+      `read_chat_status: ${String(summary.readChatStatus || "")}`,
+      `read_chat_total_messages: ${String(summary.readChatTotalMessages ?? "")}`,
+      `cli_status: ${String(summary.cliStatus || "")}`,
+      `cli_message_count: ${String(summary.cliMessageCount ?? "")}`
+    ].join("\n");
+  }
+  if (typeof result?.text === "string") return result.text;
+  if (result?.bundle) return JSON.stringify(result.bundle, null, 2);
+  return JSON.stringify(result, null, 2);
 }
-function formatDiffResult(result, format) {
-  if (format === "json") return JSON.stringify(result, null, 2);
-  const files = result?.files ?? [];
-  if (files.length === 0) return "No changed files.";
-  const parts = [];
-  const totalShown = result?.shown_files ?? files.length;
-  const totalAll = result?.total_files ?? files.length;
-  if (totalAll > totalShown) {
-    parts.push(`Showing ${totalShown} of ${totalAll} changed files:
-`);
+
+// src/tools/send-chat.ts
+var SEND_CHAT_TOOL = {
+  name: "send_chat",
+  description: "Send a message to an IDE agent session.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      message: {
+        type: "string",
+        description: "The message to send to the agent."
+      },
+      session_id: {
+        type: "string",
+        description: "Target session ID (from list_sessions). Omit to use the active session."
+      },
+      daemon_id: {
+        type: "string",
+        description: "Daemon ID (cloud mode only). Omit for local mode."
+      }
+    },
+    required: ["message"]
   }
-  for (const f of files) {
-    const header = `--- ${f.path}${f.old_path ? ` (was ${f.old_path})` : ""} ---`;
-    if (f.error) {
-      parts.push(`${header}
-(error: ${f.error})
-`);
-    } else if (f.binary) {
-      parts.push(`${header}
-(binary file)
-`);
-    } else if (!f.diff) {
-      parts.push(`${header}
-(no diff)
-`);
-    } else {
-      parts.push(`${header}
-${f.diff}${f.truncated ? "" : "\n"}`);
-    }
+};
+async function sendChat(transport, args) {
+  if (!args.message?.trim()) throw new Error("message is required");
+  if (isLocalTransport(transport)) {
+    const result2 = await transport.command("send_chat", {
+      message: args.message,
+      ...args.session_id ? { targetSessionId: args.session_id } : {}
+    });
+    if (result2?.success === false) return `Error: ${result2.error ?? "send_chat failed"}`;
+    return "Message sent.";
   }
-  return parts.join("\n");
+  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
+  const targetId = args.session_id ? `${args.daemon_id}:session:${args.session_id}` : args.daemon_id;
+  const result = await transport.sendChat(targetId, args.message, {
+    ...args.session_id ? { sessionId: args.session_id } : {}
+  });
+  if (result?.success === false) return `Error: ${result.error ?? "send_chat failed"}`;
+  return "Message sent.";
 }
 
-// src/tools/git-checkpoint.ts
-var GIT_CHECKPOINT_TOOL = {
-  name: "git_checkpoint",
-  description: "Create a checkpoint commit in a workspace. Stages all tracked changes (or all files including untracked) and commits with a prefixed message. Use this to save progress before a risky operation, or to create a restore point the orchestrator can reference.",
+// src/tools/approve.ts
+var APPROVE_TOOL = {
+  name: "approve",
+  description: "Approve or reject a pending agent action (e.g. file write, command execution).",
   inputSchema: {
     type: "object",
     properties: {
-      workspace: {
+      action: {
         type: "string",
-        description: "Absolute path to the workspace/repository directory."
+        enum: ["approve", "reject"],
+        description: "Whether to approve or reject the pending action."
       },
-      message: {
+      session_id: {
         type: "string",
-        description: 'Checkpoint message (max 200 chars). Will be prefixed with "adhdev: checkpoint ".'
-      },
-      include_untracked: {
-        type: "boolean",
-        description: "Also stage and commit untracked files (default: false)."
+        description: "Target session ID. Omit to use the active session."
       },
       daemon_id: {
         type: "string",
-        description: "Daemon ID (cloud mode only, required)."
+        description: "Daemon ID (cloud mode only)."
       }
     },
-    required: ["workspace", "message"]
+    required: ["action"]
   }
 };
-async function gitCheckpoint(transport, args) {
-  const message = args.message?.trim();
-  if (!message) return "Error: message is required";
-  if (message.length > 200) return "Error: message must be 200 characters or fewer";
-  let raw;
+async function approve(transport, args) {
+  const action = args.action === "reject" ? "reject" : "approve";
   if (isLocalTransport(transport)) {
-    raw = await transport.command("git_checkpoint", {
-      workspace: args.workspace,
-      message,
-      includeUntracked: args.include_untracked ?? false
+    const result2 = await transport.command("resolve_action", {
+      action,
+      ...args.session_id ? { targetSessionId: args.session_id } : {}
     });
-    raw = raw?.checkpoint ?? raw;
-  } else {
-    if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-    const result = await transport.gitCheckpoint(args.daemon_id, {
-      workspace: args.workspace,
-      message,
-      includeUntracked: args.include_untracked ?? false
+    if (result2?.success === false) return `Error: ${result2.error ?? "resolve_action failed"}`;
+    return `Action ${action}d.`;
+  }
+  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
+  const targetId = args.session_id ? `${args.daemon_id}:session:${args.session_id}` : args.daemon_id;
+  const result = await transport.approve(targetId, action);
+  if (result?.success === false) return `Error: ${result.error ?? "approve failed"}`;
+  return `Action ${action}d.`;
+}
+
+// src/tools/screenshot.ts
+var SCREENSHOT_TOOL = {
+  name: "screenshot",
+  description: "Capture a screenshot of the current IDE window. Returns the image. Local mode only \u2014 screenshots require direct P2P access to the daemon and are not available in cloud mode.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      session_id: {
+        type: "string",
+        description: "Target session ID. Omit to use the active session."
+      }
+    },
+    required: []
+  }
+};
+async function screenshot(transport, args) {
+  let result;
+  if (isLocalTransport(transport)) {
+    result = await transport.command("screenshot", {
+      ...args.session_id ? { targetSessionId: args.session_id } : {}
     });
-    raw = result?.checkpoint ?? result;
+  } else {
+    return { type: "text", text: "Screenshots are not available in cloud mode. Run adhdev mcp in local mode (requires standalone daemon)." };
   }
-  if (raw?.success === false || raw?.reason) {
-    const msg = raw?.error ?? raw?.reason ?? "unknown";
-    if (msg.includes("Nothing to commit") || msg.includes("nothing to commit")) {
-      return "Nothing to commit \u2014 working tree is clean.";
-    }
-    return `Git checkpoint error: ${msg}`;
+  if (result?.success === false) {
+    return { type: "text", text: `Error: ${result.error ?? "screenshot failed"}` };
   }
-  const commit = raw?.commit?.slice(0, 7) ?? "???????";
-  const fullMsg = raw?.message ?? `adhdev: checkpoint ${message}`;
-  return `Checkpoint created: ${commit} \u2014 ${fullMsg}`;
+  const b64 = result?.base64 ?? result?.screenshot ?? result?.result;
+  if (!b64) {
+    return { type: "text", text: "Screenshot captured but no image data returned." };
+  }
+  const mimeType = result?.format === "png" ? "image/png" : "image/webp";
+  return { type: "image", data: b64, mimeType };
 }
 
-// src/tools/git-push.ts
-var GIT_PUSH_TOOL = {
-  name: "git_push",
-  description: "Push a branch to a remote repository on the daemon machine. If the branch has no upstream configured, sets it automatically. Key for parallel multi-machine workflows: after git_checkpoint, push each machine's branch to origin so changes are available for PR/review.",
+// src/tools/git-status.ts
+var GIT_STATUS_TOOL = {
+  name: "git_status",
+  description: "Get git repository status for a workspace on the daemon machine.",
   inputSchema: {
     type: "object",
     properties: {
@@ -1125,529 +1647,688 @@ var GIT_PUSH_TOOL = {
         type: "string",
         description: "Absolute path to the workspace/repository directory."
       },
-      remote: {
-        type: "string",
-        description: 'Remote name (default: "origin").'
-      },
-      branch: {
-        type: "string",
-        description: "Branch to push (default: current branch)."
+      include_diff: {
+        type: "boolean",
+        description: "Include changed file list (default: true)."
       },
       daemon_id: {
         type: "string",
-        description: "Daemon ID (cloud mode only, required)."
-      }
+        description: "Daemon ID (cloud mode only)."
+      },
+      ...FORMAT_PROP
     },
     required: ["workspace"]
   }
 };
-async function gitPush(transport, args) {
-  let raw;
+async function gitStatus(transport, args) {
+  let status;
+  let diffSummary;
   if (isLocalTransport(transport)) {
-    raw = await transport.command("git_push", {
-      workspace: args.workspace,
-      remote: args.remote ?? "origin",
-      ...args.branch ? { branch: args.branch } : {}
+    const statusResult = await transport.command("git_status", {
+      workspace: args.workspace
     });
-    raw = raw?.push ?? raw;
+    status = statusResult?.status ?? statusResult;
+    if (args.include_diff !== false) {
+      const diffResult = await transport.command("git_diff_summary", {
+        workspace: args.workspace
+      });
+      diffSummary = diffResult?.diffSummary ?? diffResult;
+    }
   } else {
     if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-    const result = await transport.gitPush(args.daemon_id, {
-      workspace: args.workspace,
-      remote: args.remote,
-      branch: args.branch
-    });
-    raw = result?.push ?? result;
+    const result = await transport.gitStatus(
+      args.daemon_id,
+      args.workspace,
+      args.include_diff !== false
+    );
+    if (result?.error) {
+      if (args.format === "json") return JSON.stringify({ error: result.error }, null, 2);
+      return `Error: ${result.error}`;
+    }
+    status = result?.status;
+    diffSummary = result?.diff;
   }
-  if (raw?.success === false || raw?.reason) {
-    const msg = raw?.error ?? raw?.reason ?? "unknown";
-    return `Git push error: ${msg}`;
+  if (status?.success === false || status?.reason) {
+    const msg = status?.error ?? status?.reason ?? "unknown";
+    if (args.format === "json") return JSON.stringify({ error: msg }, null, 2);
+    return `Git error: ${msg}`;
   }
-  const branch = raw?.branch ?? args.branch ?? "(current)";
-  const remote = raw?.remote ?? args.remote ?? "origin";
-  const newBranch = raw?.newBranch ? " [new branch]" : "";
-  const output = raw?.output ? `
-${raw.output}` : "";
-  return `Pushed ${branch} \u2192 ${remote}${newBranch}${output}`;
+  if (!status?.isGitRepo) {
+    if (args.format === "json") return JSON.stringify({ error: `Not a git repository: ${args.workspace}` }, null, 2);
+    return `Not a git repository: ${args.workspace}`;
+  }
+  if (args.format === "json") {
+    const files = diffSummary?.files?.map((f) => ({
+      path: f.path,
+      old_path: f.oldPath ?? null,
+      status: f.status ?? "M",
+      insertions: f.insertions ?? 0,
+      deletions: f.deletions ?? 0
+    })) ?? [];
+    return JSON.stringify({
+      branch: status.branch ?? null,
+      head_commit: status.headCommit ?? null,
+      head_message: status.headMessage ?? null,
+      ahead: status.ahead ?? 0,
+      behind: status.behind ?? 0,
+      staged: status.staged ?? 0,
+      modified: status.modified ?? 0,
+      untracked: status.untracked ?? 0,
+      deleted: status.deleted ?? 0,
+      stash_count: status.stashCount ?? 0,
+      has_conflicts: status.hasConflicts ?? false,
+      dirty: status.dirty ?? false,
+      changed_files: files,
+      total_insertions: diffSummary?.totalInsertions ?? 0,
+      total_deletions: diffSummary?.totalDeletions ?? 0
+    }, null, 2);
+  }
+  const lines = [];
+  if (status.branch) lines.push(`Branch: ${status.branch}`);
+  if (status.headCommit) {
+    lines.push(`HEAD: ${status.headCommit.slice(0, 7)}${status.headMessage ? ` \u2014 ${status.headMessage.slice(0, 80)}` : ""}`);
+  }
+  if (status.ahead > 0) lines.push(`Ahead: ${status.ahead}`);
+  if (status.behind > 0) lines.push(`Behind: ${status.behind}`);
+  if (status.staged > 0) lines.push(`Staged: ${status.staged}`);
+  if (status.modified > 0) lines.push(`Modified: ${status.modified}`);
+  if (status.untracked > 0) lines.push(`Untracked: ${status.untracked}`);
+  if (status.deleted > 0) lines.push(`Deleted: ${status.deleted}`);
+  if (status.stashCount > 0) lines.push(`Stashes: ${status.stashCount}`);
+  if (status.hasConflicts) lines.push("Conflicts: YES");
+  if (!status.dirty) lines.push("Working tree: clean");
+  if (diffSummary?.files?.length > 0) {
+    lines.push("");
+    lines.push(`Changed files (${diffSummary.files.length}):`);
+    for (const f of diffSummary.files.slice(0, 20)) {
+      lines.push(`  ${f.status ?? "M"} ${f.path}${f.oldPath ? ` (was ${f.oldPath})` : ""}${f.insertions || f.deletions ? ` +${f.insertions ?? 0}/-${f.deletions ?? 0}` : ""}`);
+    }
+    if (diffSummary.files.length > 20) lines.push(`  \u2026 and ${diffSummary.files.length - 20} more`);
+    if (diffSummary.totalInsertions || diffSummary.totalDeletions) {
+      lines.push(`Total: +${diffSummary.totalInsertions ?? 0}/-${diffSummary.totalDeletions ?? 0}`);
+    }
+  }
+  return lines.join("\n");
 }
 
-// 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).",
+// src/tools/git-log.ts
+var GIT_LOG_TOOL = {
+  name: "git_log",
+  description: "Get commit history for a workspace. Shows hash, message, author, and date for recent commits. Use this to track what changes an agent has made, verify checkpoint commits, or understand project history.",
   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."
-      },
       workspace: {
         type: "string",
-        description: "Working directory for the session. Defaults to the daemon default workspace."
+        description: "Absolute path to the workspace/repository directory."
       },
-      model: {
+      limit: {
+        type: "number",
+        description: "Max commits to return (default: 20, max: 100)."
+      },
+      file: {
         type: "string",
-        description: "Model override for ACP agents (e.g. claude-opus-4-7)."
+        description: "Filter history to commits that touched this repo-relative file path (optional)."
       },
-      daemon_id: {
+      since: {
         type: "string",
-        description: "Daemon ID (cloud mode only). Required in cloud mode."
-      }
-    },
-    required: ["type"]
-  }
-};
-async function launchSession(transport, args) {
-  if (isLocalTransport(transport)) {
-    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 result2 = await transport.command(commandType, payload);
-    if (result2?.success === false) return `Error: ${result2.error ?? "launch failed"}`;
-    const id2 = result2?.id ?? result2?.sessionId;
-    return id2 ? `Session launched. id: ${id2}, type: ${args.type}` : `Launched: ${JSON.stringify(result2)}`;
-  }
-  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-  const result = await transport.launch(args.daemon_id, {
-    type: args.type,
-    dir: args.workspace,
-    model: args.model
-  });
-  if (result?.success === false || result?.error) 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)}`;
-}
-
-// src/tools/stop-session.ts
-var STOP_SESSION_TOOL = {
-  name: "stop_session",
-  description: "Stop a running agent session. For CLI agents (hermes-cli, claude-cli, etc.) this sends a graceful stop signal. Use list_sessions to find the session_id.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      session_id: {
+        description: "Only commits after this date (ISO 8601 or git date string, optional)."
+      },
+      until: {
         type: "string",
-        description: "Session ID to stop (from list_sessions)."
+        description: "Only commits before this date (ISO 8601 or git date string, optional)."
       },
       daemon_id: {
         type: "string",
         description: "Daemon ID (cloud mode only, required)."
       },
-      type: {
-        type: "string",
-        description: "Provider type (e.g. hermes-cli, claude-cli). Local mode auto-resolves from session_id if omitted; cloud mode forwards the session_id and omits type unless explicitly provided."
-      }
+      ...FORMAT_PROP
     },
-    required: ["session_id"]
+    required: ["workspace"]
   }
 };
-async function stopSession(transport, args) {
+async function gitLog(transport, args) {
+  const limit = Math.max(1, Math.min(100, args.limit ?? 20));
+  let raw;
   if (isLocalTransport(transport)) {
-    const local = transport;
-    let resolvedType = args.type;
-    if (!resolvedType) {
-      const status = await local.getStatus();
-      const session = (status?.sessions ?? []).find((s) => s.id === args.session_id);
-      resolvedType = session?.providerType ?? session?.type;
-    }
-    if (!resolvedType) {
-      return `Error: could not resolve session type for ${args.session_id}. Pass type= explicitly.`;
-    }
-    const result2 = await local.command("stop_cli", {
-      targetSessionId: args.session_id,
-      cliType: resolvedType
+    raw = await transport.command("git_log", {
+      workspace: args.workspace,
+      limit,
+      ...args.file ? { path: args.file } : {},
+      ...args.since ? { since: args.since } : {},
+      ...args.until ? { until: args.until } : {}
     });
-    if (result2?.success === false) return `Error: ${result2.error ?? "stop failed"}`;
-    return `Session ${args.session_id} stopped.`;
+    raw = raw?.log ?? raw;
+  } else {
+    if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
+    const result = await transport.gitLog(args.daemon_id, args.workspace, {
+      limit,
+      file: args.file,
+      since: args.since,
+      until: args.until
+    });
+    raw = result?.log ?? result;
+  }
+  if (raw?.success === false || raw?.reason) {
+    const msg = raw?.error ?? raw?.reason ?? "unknown";
+    if (args.format === "json") return JSON.stringify({ error: msg }, null, 2);
+    return `Git log error: ${msg}`;
+  }
+  if (!raw?.isGitRepo) {
+    const msg = `Not a git repository: ${args.workspace}`;
+    if (args.format === "json") return JSON.stringify({ error: msg }, null, 2);
+    return msg;
+  }
+  const entries = raw?.entries ?? [];
+  if (args.format === "json") {
+    return JSON.stringify({
+      workspace: raw.workspace,
+      branch: raw.branch ?? null,
+      entries: entries.map((e) => ({
+        commit: e.commit,
+        short: e.commit?.slice(0, 7),
+        message: e.message,
+        author: e.authorName ?? null,
+        author_email: e.authorEmail ?? null,
+        authored_at: e.authoredAt ? new Date(e.authoredAt).toISOString() : null
+      })),
+      total: entries.length,
+      truncated: raw.truncated ?? false
+    }, null, 2);
   }
-  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
-  const result = await transport.stop(args.daemon_id, {
-    id: args.session_id,
-    ...args.type ? { type: args.type } : {}
+  if (entries.length === 0) return "No commits found.";
+  const lines = entries.map((e) => {
+    const hash = e.commit?.slice(0, 7) ?? "???????";
+    const date = e.authoredAt ? new Date(e.authoredAt).toISOString().slice(0, 10) : "";
+    const author = e.authorName ? ` (${e.authorName})` : "";
+    return `${hash} ${date}${author} ${e.message}`;
   });
-  if (result?.success === false || result?.error) return `Error: ${result.error ?? "stop failed"}`;
-  return `Session ${args.session_id} stopped.`;
+  const header = `Commits (${entries.length}${raw.truncated ? ", truncated" : ""}):`;
+  return `${header}
+${lines.join("\n")}`;
 }
 
-// src/tools/check-pending.ts
-var CHECK_PENDING_TOOL = {
-  name: "check_pending",
-  description: "List all agent sessions currently waiting for user approval (tool-use confirmation). Returns session ID, daemon ID, workspace, and the approval prompt message when available. Use approve() with the session_id to approve or reject.",
+// src/tools/git-diff.ts
+var GIT_DIFF_TOOL = {
+  name: "git_diff",
+  description: "Get the actual diff content for changed files in a workspace. Without a specific file, returns diffs for up to 5 changed files. Use this to review what an agent actually changed \u2014 file names alone (from git_status) are not enough for code review.",
   inputSchema: {
     type: "object",
     properties: {
+      workspace: {
+        type: "string",
+        description: "Absolute path to the workspace/repository directory."
+      },
+      file: {
+        type: "string",
+        description: "Specific repo-relative file path to diff (optional \u2014 if omitted, returns top 5 changed files)."
+      },
+      max_lines: {
+        type: "number",
+        description: "Max diff lines per file before truncating (default: 300)."
+      },
+      staged: {
+        type: "boolean",
+        description: "Show staged changes instead of unstaged (default: false)."
+      },
       daemon_id: {
         type: "string",
-        description: "Daemon ID to check (cloud mode). Omit to check all daemons."
+        description: "Daemon ID (cloud mode only, required)."
       },
       ...FORMAT_PROP
     },
-    required: []
+    required: ["workspace"]
   }
 };
-async function checkPending(transport, args) {
+async function gitDiff(transport, args) {
+  const maxLines = Math.max(10, Math.min(2e3, args.max_lines ?? 300));
+  const staged = args.staged ?? false;
   if (isLocalTransport(transport)) {
-    return checkPendingLocal(transport, args.format);
-  }
-  return checkPendingCloud(transport, args.daemon_id, args.format);
-}
-async function checkPendingLocal(transport, format) {
-  const status = await transport.getStatus();
-  const sessions = status?.sessions ?? [];
-  const pending = sessions.filter(
-    (s) => s.status === "waiting_approval" || s.agentStatus === "waiting_approval"
-  );
-  if (format === "json") {
-    return JSON.stringify({
-      pending: pending.map((s) => ({
-        session_id: s.id,
-        workspace: s.workspace ?? null,
-        type: s.providerType ?? null,
-        modal_message: s.activeChat?.activeModal?.message ?? null,
-        buttons: s.activeChat?.activeModal?.buttons ?? []
-      }))
-    }, null, 2);
+    return localGitDiff(transport, args.workspace, args.file, maxLines, staged, args.format);
   }
-  if (pending.length === 0) return "No sessions waiting for approval.";
-  const lines = pending.map((s) => {
-    const modal = s.activeChat?.activeModal;
-    const parts = [`session_id: ${s.id}`];
-    if (s.workspace) parts.push(`workspace: ${s.workspace}`);
-    if (s.providerType) parts.push(`type: ${s.providerType}`);
-    if (modal?.message) parts.push(`prompt: ${modal.message}`);
-    if (modal?.buttons?.length) parts.push(`buttons: ${modal.buttons.join(", ")}`);
-    return parts.join("\n  ");
+  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
+  const result = await transport.gitDiff(args.daemon_id, args.workspace, {
+    file: args.file,
+    maxLines,
+    staged
   });
-  return `Pending approvals (${pending.length}):
-
-${lines.join("\n\n")}`;
+  if (result?.error) {
+    if (args.format === "json") return JSON.stringify({ error: result.error }, null, 2);
+    return `Git diff error: ${result.error}`;
+  }
+  return formatDiffResult(result, args.format);
 }
-async function checkPendingCloud(transport, daemonId, format) {
-  const pending = [];
-  if (daemonId) {
-    const daemonStatus = await transport.getDaemonStatus(daemonId);
-    const sessions = daemonStatus?.sessions ?? [];
-    for (const s of sessions) {
-      if (s.status === "waiting_approval") pending.push({ daemonId, session: s });
-    }
-  } else {
-    const data = await transport.listDaemons();
-    const daemons = data?.daemons ?? [];
-    for (let i = 0; i < daemons.length; i += 5) {
-      await Promise.allSettled(
-        daemons.slice(i, i + 5).map(async (d) => {
-          try {
-            const daemonStatus = await transport.getDaemonStatus(d.id);
-            const sessions = daemonStatus?.sessions ?? [];
-            for (const s of sessions) {
-              if (s.status === "waiting_approval") pending.push({ daemonId: d.id, session: s });
-            }
-          } catch {
-          }
-        })
-      );
+async function localGitDiff(transport, workspace, file, maxLines, staged, format) {
+  if (file) {
+    const raw = await transport.command("git_diff_file", { workspace, path: file, staged });
+    const d = raw?.diff ?? raw;
+    if (d?.success === false || d?.reason) {
+      const msg = d?.error ?? d?.reason ?? "unknown";
+      if (format === "json") return JSON.stringify({ error: msg }, null, 2);
+      return `Git diff error: ${msg}`;
     }
+    const lines = (d?.diff ?? "").split("\n");
+    const truncated = lines.length > maxLines;
+    const result = {
+      files: [{
+        path: file,
+        diff: truncated ? lines.slice(0, maxLines).join("\n") + "\n... (truncated)" : d?.diff ?? "",
+        truncated,
+        binary: d?.binary ?? false
+      }],
+      total_files: 1,
+      shown_files: 1,
+      truncated
+    };
+    return formatDiffResult(result, format);
   }
-  if (format === "json") {
-    return JSON.stringify({
-      pending: pending.map(({ daemonId: dId, session: s }) => ({
-        daemon_id: dId,
-        session_id: s.id,
-        workspace: s.workspace ?? null,
-        type: s.providerType ?? null,
-        modal_message: null,
-        buttons: []
-      }))
-    }, null, 2);
+  const summaryRaw = await transport.command("git_diff_summary", { workspace, staged });
+  const summary = summaryRaw?.diffSummary ?? summaryRaw;
+  if (summary?.success === false || summary?.reason) {
+    const msg = summary?.error ?? summary?.reason ?? "unknown";
+    if (format === "json") return JSON.stringify({ error: msg }, null, 2);
+    return `Git diff error: ${msg}`;
   }
-  if (pending.length === 0) return "No sessions waiting for approval.";
-  const lines = pending.map(({ daemonId: dId, session: s }) => {
-    const parts = [`daemon_id: ${dId}`, `session_id: ${s.id}`];
-    if (s.workspace) parts.push(`workspace: ${s.workspace}`);
-    if (s.providerType) parts.push(`type: ${s.providerType}`);
-    parts.push("(use read_chat to see the approval prompt)");
-    return parts.join("\n  ");
-  });
-  return `Pending approvals (${pending.length}):
-
-${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 commandForNode(ctx, node, command, args = {}) {
-  if (ctx.transport instanceof IpcTransport && node.daemonId) {
-    return ctx.transport.meshCommand(node.daemonId, command, args);
+  if (!summary?.isGitRepo) {
+    const msg = `Not a git repository: ${workspace}`;
+    if (format === "json") return JSON.stringify({ error: msg }, null, 2);
+    return msg;
   }
-  if (isLocalTransport(ctx.transport)) {
-    return ctx.transport.command(command, args);
+  const files = summary?.files ?? [];
+  if (files.length === 0) {
+    if (format === "json") return JSON.stringify({ files: [], total_files: 0, shown_files: 0, truncated: false }, null, 2);
+    return "No changed files.";
   }
-  throw new Error(`Command '${command}' requires daemon IPC/local transport for node '${node.id}'`);
+  const topFiles = files.slice(0, 5);
+  const fileDiffs = await Promise.all(
+    topFiles.map(async (f) => {
+      try {
+        const raw = await transport.command("git_diff_file", { workspace, path: f.path, staged });
+        const d = raw?.diff ?? raw;
+        const lines = (d?.diff ?? "").split("\n");
+        const trunc = lines.length > maxLines;
+        return {
+          path: f.path,
+          old_path: f.oldPath ?? null,
+          status: f.status ?? "M",
+          diff: trunc ? lines.slice(0, maxLines).join("\n") + "\n... (truncated)" : d?.diff ?? "",
+          truncated: trunc,
+          binary: d?.binary ?? false
+        };
+      } catch {
+        return { path: f.path, diff: "", truncated: false, binary: false, error: "fetch failed" };
+      }
+    })
+  );
+  return formatDiffResult({
+    files: fileDiffs,
+    total_files: files.length,
+    shown_files: topFiles.length,
+    truncated: files.length > 5
+  }, format);
 }
-var MESH_STATUS_TOOL = {
-  name: "mesh_status",
-  description: "Get the current status of all nodes in the repo mesh \u2014 health, git state, active sessions. Use this to decide which node to send work to.",
-  inputSchema: {
-    type: "object",
-    properties: {}
+function formatDiffResult(result, format) {
+  if (format === "json") return JSON.stringify(result, null, 2);
+  const files = result?.files ?? [];
+  if (files.length === 0) return "No changed files.";
+  const parts = [];
+  const totalShown = result?.shown_files ?? files.length;
+  const totalAll = result?.total_files ?? files.length;
+  if (totalAll > totalShown) {
+    parts.push(`Showing ${totalShown} of ${totalAll} changed files:
+`);
   }
-};
-var MESH_LIST_NODES_TOOL = {
-  name: "mesh_list_nodes",
-  description: "List all nodes in the mesh with their capabilities, platform, and workspace paths.",
-  inputSchema: {
-    type: "object",
-    properties: {}
+  for (const f of files) {
+    const header = `--- ${f.path}${f.old_path ? ` (was ${f.old_path})` : ""} ---`;
+    if (f.error) {
+      parts.push(`${header}
+(error: ${f.error})
+`);
+    } else if (f.binary) {
+      parts.push(`${header}
+(binary file)
+`);
+    } else if (!f.diff) {
+      parts.push(`${header}
+(no diff)
+`);
+    } else {
+      parts.push(`${header}
+${f.diff}${f.truncated ? "" : "\n"}`);
+    }
   }
-};
-var MESH_SEND_TASK_TOOL = {
-  name: "mesh_send_task",
-  description: "Send a natural-language task to an agent session on a mesh node. The agent will execute the task autonomously.",
+  return parts.join("\n");
+}
+
+// src/tools/git-checkpoint.ts
+var GIT_CHECKPOINT_TOOL = {
+  name: "git_checkpoint",
+  description: "Create a checkpoint commit in a workspace. Stages all tracked changes (or all files including untracked) and commits with a prefixed message. Use this to save progress before a risky operation, or to create a restore point the orchestrator can reference.",
   inputSchema: {
     type: "object",
     properties: {
-      node_id: { type: "string", description: "Target node ID (from mesh_list_nodes)." },
-      session_id: { type: "string", description: "Agent session ID on the target node." },
-      message: { type: "string", description: "Natural-language task to send to the agent." }
+      workspace: {
+        type: "string",
+        description: "Absolute path to the workspace/repository directory."
+      },
+      message: {
+        type: "string",
+        description: 'Checkpoint message (max 200 chars). Will be prefixed with "adhdev: checkpoint ".'
+      },
+      include_untracked: {
+        type: "boolean",
+        description: "Also stage and commit untracked files (default: false)."
+      },
+      daemon_id: {
+        type: "string",
+        description: "Daemon ID (cloud mode only, required)."
+      }
     },
-    required: ["node_id", "session_id", "message"]
+    required: ["workspace", "message"]
   }
 };
-var MESH_READ_CHAT_TOOL = {
-  name: "mesh_read_chat",
-  description: "Read recent chat messages from a delegated agent session on a mesh node. Use this to check progress.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      node_id: { type: "string", description: "Target node ID." },
-      session_id: { type: "string", description: "Agent session ID to read from." },
-      tail: { type: "number", description: "Number of recent messages to return (default: 10)." }
-    },
-    required: ["node_id", "session_id"]
+async function gitCheckpoint(transport, args) {
+  const message = args.message?.trim();
+  if (!message) return "Error: message is required";
+  if (message.length > 200) return "Error: message must be 200 characters or fewer";
+  let raw;
+  if (isLocalTransport(transport)) {
+    raw = await transport.command("git_checkpoint", {
+      workspace: args.workspace,
+      message,
+      includeUntracked: args.include_untracked ?? false
+    });
+    raw = raw?.checkpoint ?? raw;
+  } else {
+    if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
+    const result = await transport.gitCheckpoint(args.daemon_id, {
+      workspace: args.workspace,
+      message,
+      includeUntracked: args.include_untracked ?? false
+    });
+    raw = result?.checkpoint ?? result;
   }
-};
-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.",
-  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").' }
-    },
-    required: ["node_id", "type"]
+  if (raw?.success === false || raw?.reason) {
+    const msg = raw?.error ?? raw?.reason ?? "unknown";
+    if (msg.includes("Nothing to commit") || msg.includes("nothing to commit")) {
+      return "Nothing to commit \u2014 working tree is clean.";
+    }
+    return `Git checkpoint error: ${msg}`;
   }
-};
-var MESH_GIT_STATUS_TOOL = {
-  name: "mesh_git_status",
-  description: "Get git status for a mesh node workspace \u2014 branch, dirty state, changed files.",
+  const commit = raw?.commit?.slice(0, 7) ?? "???????";
+  const fullMsg = raw?.message ?? `adhdev: checkpoint ${message}`;
+  return `Checkpoint created: ${commit} \u2014 ${fullMsg}`;
+}
+
+// src/tools/git-push.ts
+var GIT_PUSH_TOOL = {
+  name: "git_push",
+  description: "Push a branch to a remote repository on the daemon machine. If the branch has no upstream configured, sets it automatically. Key for parallel multi-machine workflows: after git_checkpoint, push each machine's branch to origin so changes are available for PR/review.",
   inputSchema: {
     type: "object",
     properties: {
-      node_id: { type: "string", description: "Target node ID." }
+      workspace: {
+        type: "string",
+        description: "Absolute path to the workspace/repository directory."
+      },
+      remote: {
+        type: "string",
+        description: 'Remote name (default: "origin").'
+      },
+      branch: {
+        type: "string",
+        description: "Branch to push (default: current branch)."
+      },
+      daemon_id: {
+        type: "string",
+        description: "Daemon ID (cloud mode only, required)."
+      }
     },
-    required: ["node_id"]
+    required: ["workspace"]
   }
 };
-var MESH_CHECKPOINT_TOOL = {
-  name: "mesh_checkpoint",
-  description: "Create a git checkpoint (commit) on a mesh node workspace.",
-  inputSchema: {
-    type: "object",
-    properties: {
-      node_id: { type: "string", description: "Target node ID." },
-      message: { type: "string", description: "Checkpoint commit message." }
-    },
-    required: ["node_id", "message"]
+async function gitPush(transport, args) {
+  let raw;
+  if (isLocalTransport(transport)) {
+    raw = await transport.command("git_push", {
+      workspace: args.workspace,
+      remote: args.remote ?? "origin",
+      ...args.branch ? { branch: args.branch } : {}
+    });
+    raw = raw?.push ?? raw;
+  } else {
+    if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
+    const result = await transport.gitPush(args.daemon_id, {
+      workspace: args.workspace,
+      remote: args.remote,
+      branch: args.branch
+    });
+    raw = result?.push ?? result;
   }
-};
-var MESH_APPROVE_TOOL = {
-  name: "mesh_approve",
-  description: "Approve or reject a pending action on a delegated agent session.",
+  if (raw?.success === false || raw?.reason) {
+    const msg = raw?.error ?? raw?.reason ?? "unknown";
+    return `Git push error: ${msg}`;
+  }
+  const branch = raw?.branch ?? args.branch ?? "(current)";
+  const remote = raw?.remote ?? args.remote ?? "origin";
+  const newBranch = raw?.newBranch ? " [new branch]" : "";
+  const output = raw?.output ? `
+${raw.output}` : "";
+  return `Pushed ${branch} \u2192 ${remote}${newBranch}${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).",
   inputSchema: {
     type: "object",
     properties: {
-      node_id: { type: "string", description: "Target node ID." },
-      session_id: { type: "string", description: "Agent session ID with pending approval." },
-      action: { type: "string", enum: ["approve", "reject"], description: "Action to take." }
-    },
-    required: ["node_id", "session_id", "action"]
-  }
-};
-var ALL_MESH_TOOLS = [
-  MESH_STATUS_TOOL,
-  MESH_LIST_NODES_TOOL,
-  MESH_SEND_TASK_TOOL,
-  MESH_READ_CHAT_TOOL,
-  MESH_LAUNCH_SESSION_TOOL,
-  MESH_GIT_STATUS_TOOL,
-  MESH_CHECKPOINT_TOOL,
-  MESH_APPROVE_TOOL
-];
-async function meshStatus(ctx) {
-  const { mesh, transport } = ctx;
-  const results = [];
-  for (const node of mesh.nodes) {
-    const entry = {
-      nodeId: node.id,
-      workspace: node.workspace
-    };
-    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";
-        entry.branch = status?.branch;
-        entry.isDirty = status?.isDirty;
-        entry.uncommittedChanges = status?.uncommittedChanges ?? 0;
-      } else if (isLocalTransport(transport)) {
-        const statusResult = await commandForNode(ctx, node, "git_status", { workspace: node.workspace });
-        const status = statusResult?.status ?? statusResult;
-        entry.health = status?.isGitRepo ? status?.isDirty ? "dirty" : "online" : "degraded";
-        entry.branch = status?.branch;
-        entry.isDirty = status?.isDirty;
-        entry.uncommittedChanges = status?.uncommittedChanges ?? 0;
-      } else {
-        entry.health = "unknown";
-        entry.note = "No daemonId available for cloud status probe";
+      type: {
+        type: "string",
+        description: "Provider type to launch. CLI examples: hermes-cli, claude-cli, gemini-cli. ACP examples: claude-acp. IDE examples: cursor, vscode."
+      },
+      workspace: {
+        type: "string",
+        description: "Working directory for the session. Defaults to the daemon default workspace."
+      },
+      model: {
+        type: "string",
+        description: "Model override for ACP agents (e.g. claude-opus-4-7)."
+      },
+      daemon_id: {
+        type: "string",
+        description: "Daemon ID (cloud mode only). Required in cloud mode."
       }
-    } catch (e) {
-      entry.health = "degraded";
-      entry.error = e.message;
-    }
-    results.push(entry);
-  }
-  return JSON.stringify({
-    meshId: mesh.id,
-    meshName: mesh.name,
-    repoIdentity: mesh.repoIdentity,
-    policy: mesh.policy,
-    refreshedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    nodes: results
-  }, null, 2);
-}
-async function meshListNodes(ctx) {
-  const { mesh } = ctx;
-  return JSON.stringify({
-    meshId: mesh.id,
-    meshName: mesh.name,
-    nodes: mesh.nodes.map((n) => ({
-      nodeId: n.id,
-      workspace: n.workspace,
-      repoRoot: n.repoRoot,
-      isLocalWorktree: n.isLocalWorktree,
-      policy: n.policy,
-      userOverrides: n.userOverrides
-    }))
-  }, null, 2);
-}
-async function meshSendTask(ctx, args) {
-  const node = findNode(ctx.mesh, args.node_id);
-  if (node.policy?.readOnly) {
-    return JSON.stringify({ error: `Node '${args.node_id}' is read-only` });
-  }
-  if (isLocalTransport(ctx.transport)) {
-    await commandForNode(ctx, node, "send_chat", {
-      message: args.message,
-      sessionId: args.session_id,
-      targetSessionId: args.session_id
-    });
-    return JSON.stringify({ success: true, nodeId: args.node_id, sessionId: args.session_id });
-  } else {
-    return JSON.stringify({ error: "Cloud mesh send_task not yet implemented" });
+    },
+    required: ["type"]
   }
+};
+async function launchSession(transport, args) {
+  if (isLocalTransport(transport)) {
+    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 result2 = await transport.command(commandType, payload);
+    if (result2?.success === false) return `Error: ${result2.error ?? "launch failed"}`;
+    const id2 = result2?.id ?? result2?.sessionId;
+    return id2 ? `Session launched. id: ${id2}, type: ${args.type}` : `Launched: ${JSON.stringify(result2)}`;
+  }
+  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
+  const result = await transport.launch(args.daemon_id, {
+    type: args.type,
+    dir: args.workspace,
+    model: args.model
+  });
+  if (result?.success === false || result?.error) 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)}`;
 }
-async function meshReadChat(ctx, args) {
-  const node = findNode(ctx.mesh, args.node_id);
-  if (isLocalTransport(ctx.transport)) {
-    const result = await commandForNode(ctx, node, "read_chat", {
-      sessionId: args.session_id,
+
+// src/tools/stop-session.ts
+var STOP_SESSION_TOOL = {
+  name: "stop_session",
+  description: "Stop a running agent session. For CLI agents (hermes-cli, claude-cli, etc.) this sends a graceful stop signal. Use list_sessions to find the session_id.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      session_id: {
+        type: "string",
+        description: "Session ID to stop (from list_sessions)."
+      },
+      daemon_id: {
+        type: "string",
+        description: "Daemon ID (cloud mode only, required)."
+      },
+      type: {
+        type: "string",
+        description: "Provider type (e.g. hermes-cli, claude-cli). Local mode auto-resolves from session_id if omitted; cloud mode forwards the session_id and omits type unless explicitly provided."
+      }
+    },
+    required: ["session_id"]
+  }
+};
+async function stopSession(transport, args) {
+  if (isLocalTransport(transport)) {
+    const local = transport;
+    let resolvedType = args.type;
+    if (!resolvedType) {
+      const status = await local.getStatus();
+      const session = (status?.sessions ?? []).find((s) => s.id === args.session_id);
+      resolvedType = session?.providerType ?? session?.type;
+    }
+    if (!resolvedType) {
+      return `Error: could not resolve session type for ${args.session_id}. Pass type= explicitly.`;
+    }
+    const result2 = await local.command("stop_cli", {
       targetSessionId: args.session_id,
-      tailLimit: args.tail ?? 10
+      cliType: resolvedType
     });
-    return JSON.stringify(result, null, 2);
-  } else {
-    return JSON.stringify({ error: "Cloud mesh read_chat not yet implemented" });
+    if (result2?.success === false) return `Error: ${result2.error ?? "stop failed"}`;
+    return `Session ${args.session_id} stopped.`;
   }
+  if (!args.daemon_id) throw new Error("daemon_id is required in cloud mode");
+  const result = await transport.stop(args.daemon_id, {
+    id: args.session_id,
+    ...args.type ? { type: args.type } : {}
+  });
+  if (result?.success === false || result?.error) return `Error: ${result.error ?? "stop failed"}`;
+  return `Session ${args.session_id} stopped.`;
 }
-async function meshLaunchSession(ctx, args) {
-  const node = findNode(ctx.mesh, args.node_id);
-  if (isLocalTransport(ctx.transport)) {
-    const result = await commandForNode(ctx, node, "launch_cli", {
-      cliType: args.type,
-      dir: node.workspace,
-      settings: {
-        meshNodeFor: ctx.mesh.id,
-        launchedByCoordinator: true
-      }
-    });
-    return JSON.stringify(result, null, 2);
-  } else {
-    return JSON.stringify({ error: "Cloud mesh launch_session not yet implemented" });
+
+// src/tools/check-pending.ts
+var CHECK_PENDING_TOOL = {
+  name: "check_pending",
+  description: "List all agent sessions currently waiting for user approval (tool-use confirmation). Returns session ID, daemon ID, workspace, and the approval prompt message when available. Use approve() with the session_id to approve or reject.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      daemon_id: {
+        type: "string",
+        description: "Daemon ID to check (cloud mode). Omit to check all daemons."
+      },
+      ...FORMAT_PROP
+    },
+    required: []
+  }
+};
+async function checkPending(transport, args) {
+  if (isLocalTransport(transport)) {
+    return checkPendingLocal(transport, args.format);
   }
+  return checkPendingCloud(transport, args.daemon_id, args.format);
 }
-async function meshGitStatus(ctx, args) {
-  const node = findNode(ctx.mesh, 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
-    }, null, 2);
-  } else if (isLocalTransport(ctx.transport)) {
-    const statusResult = await commandForNode(ctx, node, "git_status", {
-      workspace: node.workspace
-    });
-    const diffResult = await commandForNode(ctx, node, "git_diff_summary", {
-      workspace: node.workspace
-    });
+async function checkPendingLocal(transport, format) {
+  const status = await transport.getStatus();
+  const sessions = status?.sessions ?? [];
+  const pending = sessions.filter(
+    (s) => s.status === "waiting_approval" || s.agentStatus === "waiting_approval"
+  );
+  if (format === "json") {
     return JSON.stringify({
-      nodeId: args.node_id,
-      workspace: node.workspace,
-      status: statusResult?.status ?? statusResult,
-      diff: diffResult?.diffSummary ?? diffResult
+      pending: pending.map((s) => ({
+        session_id: s.id,
+        workspace: s.workspace ?? null,
+        type: s.providerType ?? null,
+        modal_message: s.activeChat?.activeModal?.message ?? null,
+        buttons: s.activeChat?.activeModal?.buttons ?? []
+      }))
     }, null, 2);
-  } else {
-    return JSON.stringify({ error: "No daemonId available for cloud git_status probe" });
   }
+  if (pending.length === 0) return "No sessions waiting for approval.";
+  const lines = pending.map((s) => {
+    const modal = s.activeChat?.activeModal;
+    const parts = [`session_id: ${s.id}`];
+    if (s.workspace) parts.push(`workspace: ${s.workspace}`);
+    if (s.providerType) parts.push(`type: ${s.providerType}`);
+    if (modal?.message) parts.push(`prompt: ${modal.message}`);
+    if (modal?.buttons?.length) parts.push(`buttons: ${modal.buttons.join(", ")}`);
+    return parts.join("\n  ");
+  });
+  return `Pending approvals (${pending.length}):
+
+${lines.join("\n\n")}`;
 }
-async function meshCheckpoint(ctx, args) {
-  const node = findNode(ctx.mesh, 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 commandForNode(ctx, node, "git_checkpoint", {
-      workspace: node.workspace,
-      message: args.message
-    });
-    return JSON.stringify(result, null, 2);
+async function checkPendingCloud(transport, daemonId, format) {
+  const pending = [];
+  if (daemonId) {
+    const daemonStatus = await transport.getDaemonStatus(daemonId);
+    const sessions = daemonStatus?.sessions ?? [];
+    for (const s of sessions) {
+      if (s.status === "waiting_approval") pending.push({ daemonId, session: s });
+    }
   } else {
-    return JSON.stringify({ error: "Cloud mesh checkpoint not yet implemented" });
+    const data = await transport.listDaemons();
+    const daemons = data?.daemons ?? [];
+    for (let i = 0; i < daemons.length; i += 5) {
+      await Promise.allSettled(
+        daemons.slice(i, i + 5).map(async (d) => {
+          try {
+            const daemonStatus = await transport.getDaemonStatus(d.id);
+            const sessions = daemonStatus?.sessions ?? [];
+            for (const s of sessions) {
+              if (s.status === "waiting_approval") pending.push({ daemonId: d.id, session: s });
+            }
+          } catch {
+          }
+        })
+      );
+    }
   }
-}
-async function meshApprove(ctx, args) {
-  const node = findNode(ctx.mesh, args.node_id);
-  if (isLocalTransport(ctx.transport)) {
-    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);
-  } else {
-    return JSON.stringify({ error: "Cloud mesh approve not yet implemented" });
+  if (format === "json") {
+    return JSON.stringify({
+      pending: pending.map(({ daemonId: dId, session: s }) => ({
+        daemon_id: dId,
+        session_id: s.id,
+        workspace: s.workspace ?? null,
+        type: s.providerType ?? null,
+        modal_message: null,
+        buttons: []
+      }))
+    }, null, 2);
   }
+  if (pending.length === 0) return "No sessions waiting for approval.";
+  const lines = pending.map(({ daemonId: dId, session: s }) => {
+    const parts = [`daemon_id: ${dId}`, `session_id: ${s.id}`];
+    if (s.workspace) parts.push(`workspace: ${s.workspace}`);
+    if (s.providerType) parts.push(`type: ${s.providerType}`);
+    parts.push("(use read_chat to see the approval prompt)");
+    return parts.join("\n  ");
+  });
+  return `Pending approvals (${pending.length}):
+
+${lines.join("\n\n")}`;
 }
 
 // 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 }) : opts.mode === "ipc" ? new IpcTransport({ port: opts.port }) : new LocalTransport({ port: opts.port, password: opts.password });
   const alive = await transport.ping();
@@ -1703,6 +2384,7 @@ async function startMcpServer(opts) {
               requireApprovalForDestructiveGit: true,
               dirtyWorkspaceBehavior: "warn",
               maxParallelTasks: 2,
+              spawnedSessionVisibility: "visible",
               ...policy
             },
             coordinator,
@@ -1753,14 +2435,17 @@ 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.`;
+    let localDaemonId;
+    if (transport instanceof IpcTransport) {
+      try {
+        const statusResult = await transport.getStatus();
+        const instanceId = typeof statusResult?.status?.instanceId === "string" ? statusResult.status.instanceId.trim() : "";
+        if (instanceId) localDaemonId = instanceId;
+      } catch {
+      }
     }
+    const meshCtx = { mesh, transport, ...localDaemonId ? { localDaemonId } : {} };
+    const coordinatorPrompt = await buildMeshModeCoordinatorPrompt(mesh);
     const server2 = new import_server.Server(
       { name: "adhdev-mcp-server", version: "0.9.75" },
       { capabilities: { tools: {}, resources: {} } }
@@ -1799,6 +2484,9 @@ async function startMcpServer(opts) {
           case "mesh_read_chat":
             text = await meshReadChat(meshCtx, a);
             break;
+          case "mesh_read_debug":
+            text = await meshReadDebug(meshCtx, a);
+            break;
           case "mesh_launch_session":
             text = await meshLaunchSession(meshCtx, a);
             break;
@@ -1811,6 +2499,15 @@ 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;
+          case "mesh_cleanup_sessions":
+            text = await meshCleanupSessions(meshCtx, a);
+            break;
           default:
             return { content: [{ type: "text", text: `Unknown tool: ${name}` }], isError: true };
         }
@@ -1832,6 +2529,7 @@ async function startMcpServer(opts) {
     STOP_SESSION_TOOL,
     CHECK_PENDING_TOOL,
     READ_CHAT_TOOL,
+    READ_CHAT_DEBUG_TOOL,
     SEND_CHAT_TOOL,
     APPROVE_TOOL,
     GIT_STATUS_TOOL,
@@ -1863,6 +2561,10 @@ async function startMcpServer(opts) {
           const text = await readChat(transport, a);
           return { content: [{ type: "text", text }] };
         }
+        case "read_chat_debug": {
+          const text = await readChatDebug(transport, a);
+          return { content: [{ type: "text", text }] };
+        }
         case "send_chat": {
           const text = await sendChat(transport, { message: a.message, session_id: a.session_id, daemon_id: a.daemon_id });
           return { content: [{ type: "text", text }] };
@@ -1987,33 +2689,7 @@ function parseArgs(argv, env = process.env) {
   return { mode, port, password, apiKey, baseUrl, meshId };
 }
 function printHelp() {
-  console.error(`
-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:
-  --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
-  --repo-mesh <mesh_id>   Enable mesh mode \u2014 exposes only mesh-scoped coordinator tools
-  --help                  Show this help
-
-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
-`.trim());
+  console.error(buildMcpHelpText());
 }
 startMcpServer(parseArgs(process.argv)).catch((err) => {
   process.stderr.write(`[adhdev-mcp] Fatal: ${err?.message ?? err}