adhdev 0.9.61 → 0.9.63

package/vendor/mcp-server/index.js

@@ -129,6 +129,18 @@ var CloudTransport = class {
     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`,
@@ -141,6 +153,55 @@ var CloudTransport = class {
     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();
@@ -151,6 +212,11 @@ var CloudTransport = class {
   }
 };
 
+// src/transports/mode.ts
+function isLocalTransport(transport) {
+  return typeof transport.command === "function";
+}
+
 // src/tools/list-sessions.ts
 var FORMAT_PROP = {
   format: {
@@ -176,7 +242,7 @@ var LIST_SESSIONS_TOOL = {
 };
 async function listSessions(transport, args = {}) {
   const asJson = args.format === "json";
-  if ("getStatus" in transport) {
+  if (isLocalTransport(transport)) {
     const status = await transport.getStatus();
     const sessions = status?.sessions ?? [];
     if (asJson) {
@@ -253,6 +319,62 @@ async function listSessionsCloud(transport, daemonId, asJson) {
 ${lines.join("\n")}`;
 }
 
+// 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: {
+      ...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",
@@ -279,7 +401,7 @@ var READ_CHAT_TOOL = {
 };
 async function readChat(transport, args) {
   const limit = args.limit ?? 50;
-  if ("command" in transport) {
+  if (isLocalTransport(transport)) {
     const result2 = await transport.command("read_chat", {
       ...args.session_id ? { targetSessionId: args.session_id } : {},
       limit
@@ -343,7 +465,7 @@ var SEND_CHAT_TOOL = {
 };
 async function sendChat(transport, args) {
   if (!args.message?.trim()) throw new Error("message is required");
-  if ("command" in transport) {
+  if (isLocalTransport(transport)) {
     const result2 = await transport.command("send_chat", {
       message: args.message,
       ...args.session_id ? { targetSessionId: args.session_id } : {}
@@ -386,7 +508,7 @@ var APPROVE_TOOL = {
 };
 async function approve(transport, args) {
   const action = args.action === "reject" ? "reject" : "approve";
-  if ("command" in transport) {
+  if (isLocalTransport(transport)) {
     const result2 = await transport.command("resolve_action", {
       action,
       ...args.session_id ? { targetSessionId: args.session_id } : {}
@@ -418,7 +540,7 @@ var SCREENSHOT_TOOL = {
 };
 async function screenshot(transport, args) {
   let result;
-  if ("command" in transport) {
+  if (isLocalTransport(transport)) {
     result = await transport.command("screenshot", {
       ...args.session_id ? { targetSessionId: args.session_id } : {}
     });
@@ -463,7 +585,7 @@ var GIT_STATUS_TOOL = {
 async function gitStatus(transport, args) {
   let status;
   let diffSummary;
-  if ("command" in transport) {
+  if (isLocalTransport(transport)) {
     const statusResult = await transport.command("git_status", {
       workspace: args.workspace
     });
@@ -551,6 +673,372 @@ async function gitStatus(transport, args) {
   return 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.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      workspace: {
+        type: "string",
+        description: "Absolute path to the workspace/repository directory."
+      },
+      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)."
+      },
+      daemon_id: {
+        type: "string",
+        description: "Daemon ID (cloud mode only, required)."
+      },
+      ...FORMAT_PROP
+    },
+    required: ["workspace"]
+  }
+};
+async function gitLog(transport, args) {
+  const limit = Math.max(1, Math.min(100, args.limit ?? 20));
+  let raw;
+  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 } : {}
+    });
+    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 (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}`;
+  });
+  const header = `Commits (${entries.length}${raw.truncated ? ", truncated" : ""}):`;
+  return `${header}
+${lines.join("\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.",
+  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 (cloud mode only, required)."
+      },
+      ...FORMAT_PROP
+    },
+    required: ["workspace"]
+  }
+};
+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 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}`;
+  }
+  return formatDiffResult(result, 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;
+  }
+  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.";
+  }
+  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);
+}
+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:
+`);
+  }
+  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"}`);
+    }
+  }
+  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: {
+      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: ["workspace", "message"]
+  }
+};
+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;
+  }
+  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}`;
+  }
+  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: {
+      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: ["workspace"]
+  }
+};
+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;
+  }
+  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",
@@ -579,7 +1067,7 @@ var LAUNCH_SESSION_TOOL = {
   }
 };
 async function launchSession(transport, args) {
-  if ("command" in transport) {
+  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 };
@@ -599,6 +1087,57 @@ async function launchSession(transport, args) {
   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: {
+        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,
+      cliType: resolvedType
+    });
+    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.`;
+}
+
 // src/tools/check-pending.ts
 var CHECK_PENDING_TOOL = {
   name: "check_pending",
@@ -616,7 +1155,7 @@ var CHECK_PENDING_TOOL = {
   }
 };
 async function checkPending(transport, args) {
-  if ("getStatus" in transport) {
+  if (isLocalTransport(transport)) {
     return checkPendingLocal(transport, args.format);
   }
   return checkPendingCloud(transport, args.daemon_id, args.format);
@@ -715,17 +1254,23 @@ async function startMcpServer(opts) {
   }
   const isLocal = opts.mode === "local";
   const allTools = [
+    LIST_DAEMONS_TOOL,
     LIST_SESSIONS_TOOL,
     LAUNCH_SESSION_TOOL,
+    STOP_SESSION_TOOL,
     CHECK_PENDING_TOOL,
     READ_CHAT_TOOL,
     SEND_CHAT_TOOL,
     APPROVE_TOOL,
     GIT_STATUS_TOOL,
+    GIT_LOG_TOOL,
+    GIT_DIFF_TOOL,
+    GIT_CHECKPOINT_TOOL,
+    GIT_PUSH_TOOL,
     ...isLocal ? [SCREENSHOT_TOOL] : []
   ];
   const server = new import_server.Server(
-    { name: "adhdev-mcp-server", version: "0.9.61" },
+    { name: "adhdev-mcp-server", version: "0.9.63" },
     { capabilities: { tools: {} } }
   );
   server.setRequestHandler(import_types.ListToolsRequestSchema, async () => ({ tools: allTools }));
@@ -734,6 +1279,10 @@ async function startMcpServer(opts) {
     const a = args ?? {};
     try {
       switch (name) {
+        case "list_daemons": {
+          const text = await listDaemons(transport, { format: a.format });
+          return { content: [{ type: "text", text }] };
+        }
         case "list_sessions": {
           const text = await listSessions(transport, { format: a.format, daemon_id: a.daemon_id });
           return { content: [{ type: "text", text }] };
@@ -764,6 +1313,22 @@ async function startMcpServer(opts) {
           const text = await gitStatus(transport, { workspace: a.workspace, include_diff: a.include_diff, daemon_id: a.daemon_id, format: a.format });
           return { content: [{ type: "text", text }] };
         }
+        case "git_log": {
+          const text = await gitLog(transport, { workspace: a.workspace, limit: a.limit, file: a.file, since: a.since, until: a.until, daemon_id: a.daemon_id, format: a.format });
+          return { content: [{ type: "text", text }] };
+        }
+        case "git_diff": {
+          const text = await gitDiff(transport, { workspace: a.workspace, file: a.file, max_lines: a.max_lines, staged: a.staged, daemon_id: a.daemon_id, format: a.format });
+          return { content: [{ type: "text", text }] };
+        }
+        case "git_checkpoint": {
+          const text = await gitCheckpoint(transport, { workspace: a.workspace, message: a.message, include_untracked: a.include_untracked, daemon_id: a.daemon_id });
+          return { content: [{ type: "text", text }] };
+        }
+        case "git_push": {
+          const text = await gitPush(transport, { workspace: a.workspace, remote: a.remote, branch: a.branch, daemon_id: a.daemon_id });
+          return { content: [{ type: "text", text }] };
+        }
         case "launch_session": {
           const text = await launchSession(transport, {
             type: a.type,
@@ -773,6 +1338,14 @@ async function startMcpServer(opts) {
           });
           return { content: [{ type: "text", text }] };
         }
+        case "stop_session": {
+          const text = await stopSession(transport, {
+            session_id: a.session_id,
+            daemon_id: a.daemon_id,
+            type: a.type
+          });
+          return { content: [{ type: "text", text }] };
+        }
         case "check_pending": {
           const text = await checkPending(transport, { daemon_id: a.daemon_id, format: a.format });
           return { content: [{ type: "text", text }] };
@@ -843,8 +1416,8 @@ Environment variables:
   ADHDEV_API_KEY      API key (cloud mode)
   ADHDEV_PASSWORD     Daemon password (local mode)
 
-Local mode tools:   list_sessions, launch_session, check_pending, read_chat, send_chat, approve, git_status, screenshot
-Cloud mode tools:   list_sessions, launch_session, check_pending, read_chat, send_chat, approve, git_status
+Local mode 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
+Cloud mode 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
 `.trim());
 }
 startMcpServer(parseArgs(process.argv)).catch((err) => {