cc-claw 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jacob Ben David
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,246 @@
+# CC-Claw — Coding CLI Claw
+
+<p align="center">
+  <img src="assets/cc_claw.png" alt="CC-Claw Logo" width="300" />
+</p>
+
+Your personal AI assistant on Telegram, powered by the best coding CLIs. CC-Claw uses **Claude Code**, **Gemini CLI**, and **Codex** as its backend intelligence — giving you a full personal and productivity assistant accessible from any device.
+
+Send text, voice messages, photos, documents, or videos. The agent handles coding, research, email, scheduling, content creation, document analysis, and any task you need. Switch backends on the fly with `/claude`, `/gemini`, or `/codex`. Spawn sub-agents across different CLIs to work in parallel.
+
+## Supported Backends
+
+| Backend | CLI | Models |
+|---------|-----|--------|
+| **Claude** | `claude` | Opus 4.6, Sonnet 4.6, Haiku 4.5 |
+| **Gemini** | `gemini` | 3.1 Pro Preview, 3 Flash |
+| **Codex** | `codex` | GPT-5.4, GPT-5.3 Codex, GPT-5.2 Codex |
+
+Each backend supports per-model thinking/reasoning level control, session resumption, and configurable permission modes.
+
+## Prerequisites
+
+- **Node.js 20+**
+- **At least one coding CLI** installed:
+  - Claude Code CLI — `npm install -g @anthropic-ai/claude-code`
+  - Gemini CLI — `npm install -g @google/gemini-cli` (or via Homebrew)
+  - Codex CLI — `npm install -g @openai/codex` (or via Homebrew)
+- **Telegram bot token** from [@BotFather](https://t.me/BotFather)
+
+Backend-specific setup (e.g., Vertex AI for Claude, Google Cloud for Gemini, ChatGPT subscription for Codex) is handled during `cc-claw setup`.
+
+## Install
+
+```bash
+npm install -g cc-claw
+```
+
+## Setup
+
+```bash
+cc-claw setup
+```
+
+The interactive wizard walks you through:
+
+1. Creating a Telegram bot and pasting the token
+2. Getting your Telegram chat ID (for security — only you can use the bot)
+3. Selecting your default backend and configuring its credentials
+4. Optional features: voice (Groq STT + ElevenLabs TTS), web dashboard, video analysis (Gemini)
+5. Installing as a background service
+
+Configuration is saved to `~/.cc-claw/.env`. Data is organized under `~/.cc-claw/`:
+
+```
+~/.cc-claw/
+  .env                        config (Telegram token, backend credentials)
+  data/cc-claw.db             SQLite database
+  logs/cc-claw.log            stdout log
+  logs/cc-claw.error.log      stderr log
+  runners/                    config-driven CLI runner definitions (JSON)
+  workspace/
+    SOUL.md                   agent identity and personality (customizable)
+    USER.md                   your profile and preferences
+    CLAUDE.md / GEMINI.md     native CLI awareness notes (auto-generated)
+    context/                  on-demand context files
+    skills/                   skill repository (available to all backends)
+```
+
+## Run
+
+```bash
+# Foreground (see output in terminal)
+cc-claw start
+
+# Or install as a background service (launchd on macOS, systemd on Linux)
+cc-claw install
+```
+
+## CLI
+
+CC-Claw has a comprehensive CLI with 50+ commands. Every command supports `--json` for AI agents and scripts.
+
+```bash
+cc-claw status                    # System status (backend, model, usage)
+cc-claw doctor                    # Health checks + auto-fix
+cc-claw logs -f                   # Follow daemon logs
+cc-claw chat send "hello"         # Talk to the AI from terminal
+cc-claw tui                       # Interactive terminal chat
+cc-claw backend set gemini        # Switch backend
+cc-claw model list                # List models
+cc-claw cron list                 # List scheduled jobs
+cc-claw agents list               # List active sub-agents
+cc-claw agents spawn --runner claude --task "review code"
+cc-claw db stats                  # Database health
+cc-claw completion --shell zsh    # Shell completions
+cc-claw --ai                      # Generate AI skill file
+```
+
+| Command Group | Description |
+|---------------|-------------|
+| `service` | start, stop, restart, status, install, uninstall |
+| `status` / `doctor` / `logs` | Diagnostics and monitoring |
+| `chat` / `tui` | Talk to the AI from terminal |
+| `backend` / `model` / `thinking` | Backend and model management |
+| `memory` | list, search, add, forget, history |
+| `cron` / `schedule` | Scheduler management (create, cancel, pause, resume, run) |
+| `agents` / `tasks` / `runners` | Agent orchestration |
+| `config` | Runtime and static configuration |
+| `usage` / `cost` | Cost tracking and usage limits |
+| `permissions` / `tools` / `verbose` | Permission and tool management |
+| `skills` / `mcps` | Skills and MCP servers |
+| `db` | Database stats, backup, prune |
+| `completion` | Shell completions (bash/zsh/fish) |
+| `setup` | Interactive configuration wizard |
+
+Read commands work offline (direct DB). Write commands require the daemon running.
+
+### Telegram Commands
+
+Once running, send these to your bot:
+
+| Command | Description |
+|---------|-------------|
+| `/help` | Show available commands |
+| `/backend` | Switch AI backend (Claude / Gemini / Codex) |
+| `/model` | Switch model for active backend (with thinking level picker) |
+| `/summarizer` | Configure session summarization model |
+| `/status` | Backend, model, thinking level, session, context usage |
+| `/cost` | Estimated API cost for this chat (per-model breakdown) |
+| `/cost all` | All-time cost breakdown by model across all chats |
+| `/usage` | Usage per backend with limit warnings |
+| `/limits` | Configure usage limits per backend |
+| `/newchat` | Start a fresh conversation |
+| `/cwd <path>` | Set the working directory |
+| `/memory` | List stored memories |
+| `/forget <keyword>` | Remove a memory |
+| `/voice` | Toggle voice responses |
+| `/cron <desc>` | Schedule a task (or `/schedule`) |
+| `/cron` | List scheduled jobs (or `/jobs`) |
+| `/cron cancel <id>` | Cancel a scheduled job |
+| `/cron pause <id>` | Pause a job |
+| `/cron resume <id>` | Resume a job |
+| `/cron run <id>` | Trigger a job now |
+| `/cron runs [id]` | View run history |
+| `/cron edit <id>` | Edit a job |
+| `/cron health` | Scheduler health |
+| `/skills` | List skills from all backends |
+| `/skill-install <url>` | Install a skill from GitHub |
+| `/setup-profile` | Set up your user profile |
+| `/chats` | List authorized chats and aliases |
+| `/heartbeat` | Proactive awareness (on/off/interval/hours) |
+| `/history` | List recent session summaries |
+| `/stop` | Cancel the current task |
+| `/tools` | Configure which tools the agent can use |
+| `/permissions` | Switch permission mode |
+| `/verbose` | Tool visibility (off / normal / verbose) |
+| `/claude` `/gemini` `/codex` | Quick backend switch |
+| `/agents` | List active sub-agents |
+| `/tasks` | Show task board for current orchestration |
+| `/stopagent <id>` | Cancel a specific sub-agent |
+| `/stopall` | Cancel all sub-agents |
+| `/runners` | List registered CLI runners |
+| `/mcp` | List all MCP servers (central + backends) |
+
+### Permission Modes
+
+- **yolo** — Full autopilot, all tools auto-approved
+- **safe** — Only user-configured tools allowed
+- **readonly** — Read, Glob, Grep only
+- **plan** — Plan only, no execution
+
+## Architecture
+
+```
+Telegram --> TelegramChannel --> router (handleMessage)
+  |-- command --> handleCommand
+  |-- voice --> Groq Whisper STT --> askAgent
+  |-- photo/document/video --> handleMedia --> askAgent
+  '-- text --> askAgent --> sendResponse
+                            '--> [SEND_FILE:/path] --> channel.sendFile
+```
+
+The core `askAgent()` function delegates to the active backend's adapter, which handles CLI arg construction, NDJSON parsing, and env setup. All state is persisted in SQLite with FTS5 full-text search.
+
+### Agent Orchestration
+
+CC-Claw can spawn and manage multiple sub-agents across different coding CLIs simultaneously:
+
+```
+User: "Have Claude review the code while Gemini researches the API docs"
+  → Main agent calls spawn_agent(runner: "claude", task: "Review...", role: "reviewer")
+  → Main agent calls spawn_agent(runner: "gemini", task: "Research...", role: "worker")
+  → Sub-agents communicate via inbox, share data via whiteboard
+  → Results flow back to the main agent for synthesis
+```
+
+Sub-agents support task dependencies, role-based prompts (worker/reviewer/planner), idle detection, timeout enforcement, and per-orchestration cost tracking. See `docs/plans/2026-03-09-agent-orchestration-design.md` for the full design.
+
+### MCP Management
+
+MCP (Model Context Protocol) servers are managed centrally. `/mcp` shows all MCPs across all backends. Each backend's native MCPs are available when running through CC-Claw. The orchestrator MCP server gives agents tools for spawning sub-agents, messaging, and task management.
+
+### Adding a CLI Runner
+
+Users can add any coding CLI as a sub-agent runner without code changes:
+
+1. Tell CC-Claw: *"Onboard cursor CLI as a sub-agent"*
+2. The agent discovers capabilities, tests the CLI, and creates a JSON config at `~/.cc-claw/runners/`
+3. The new runner is immediately available via `/runners`
+
+For developers: create a JSON runner config (see `src/agents/runners/config-types.ts`) or a TypeScript adapter.
+
+### Adding a Channel
+
+1. Create `src/channels/<name>.ts` implementing the `Channel` interface
+2. Register it in `src/index.ts`
+
+The router handles all message logic — the channel only delivers and sends messages.
+
+## Environment Variables
+
+Set in `~/.cc-claw/.env` (created by `cc-claw setup`):
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `TELEGRAM_BOT_TOKEN` | Yes | From @BotFather |
+| `ALLOWED_CHAT_ID` | Yes | Comma-separated chat IDs (your user ID + group IDs) |
+| `CLAUDE_CODE_USE_VERTEX` | For Claude | Set to `1` |
+| `CLOUD_ML_REGION` | For Claude | e.g. `us-east5` |
+| `ANTHROPIC_VERTEX_PROJECT_ID` | For Claude | Your GCP project |
+| `GROQ_API_KEY` | No | Voice transcription |
+| `ELEVENLABS_API_KEY` | No | Voice replies (TTS) |
+| `GEMINI_API_KEY` | No | Video analysis |
+| `DASHBOARD_ENABLED` | No | Set to `1` for web dashboard |
+| `DASHBOARD_TOKEN` | No | Fixed auth token for dashboard API (auto-generated if not set) |
+| `CLAUDE_CODE_EXECUTABLE` | No | Path to claude CLI (auto-detected) |
+| `GEMINI_CLI_EXECUTABLE` | No | Path to gemini CLI (auto-detected) |
+| `CODEX_EXECUTABLE` | No | Path to codex CLI (auto-detected) |
+| `EMBEDDING_PROVIDER` | No | Embedding provider: `ollama` (default), `gemini`, `openai`, `off` |
+| `MEMORY_VECTOR_WEIGHT` | No | Vector vs keyword weight for memory search (default: `0.7`) |
+| `OLLAMA_URL` | No | Ollama server URL (default: `http://localhost:11434`) |
+| `CC_CLAW_HOME` | No | Config dir (default: `~/.cc-claw`) |
+
+## License
+
+MIT

package/dist/agents/mcp-server.js

@@ -0,0 +1,342 @@
+#!/usr/bin/env node
+
+// src/agents/mcp-server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+var BASE_URL = `http://127.0.0.1:${process.env.CC_CLAW_PORT ?? "3141"}`;
+var CHAT_ID = process.env.CC_CLAW_CHAT_ID ?? "";
+var AGENT_ID = process.env.CC_CLAW_AGENT_ID ?? "main";
+var DASHBOARD_TOKEN = process.env.CC_CLAW_DASHBOARD_TOKEN ?? "";
+var IS_SUB_AGENT = AGENT_ID !== "main";
+async function callApi(path, body) {
+  const url = `${BASE_URL}${path}`;
+  const headers = { "Content-Type": "application/json" };
+  if (DASHBOARD_TOKEN) {
+    headers["Authorization"] = `Bearer ${DASHBOARD_TOKEN}`;
+  }
+  const opts = body ? { method: "POST", headers, body: JSON.stringify(body) } : { method: "GET", headers };
+  const res = await fetch(url, opts);
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`API error ${res.status}: ${text}`);
+  }
+  return res.json();
+}
+var server = new McpServer({
+  name: "cc-claw-orchestrator",
+  version: "1.0.0"
+});
+if (!IS_SUB_AGENT) {
+  server.tool(
+    "spawn_agent",
+    `Spawn a sub-agent using a specific CLI runner to execute a task.
+
+CRITICAL \u2014 Path verification:
+Before calling this tool with a cwd, you MUST verify the path exists using your file system tools (Glob, Read, ls, etc.).
+User-provided paths are often approximate (wrong name, missing suffix, typo). Always confirm the exact path yourself.
+A non-existent cwd will cause the agent to fail immediately. Never pass an unverified path.
+
+Typical workflow:
+1. User says "scan the foo-bar folder under dev_projects"
+2. You run: ls /Users/.../dev_projects/ (or Glob) to find the actual folder name
+3. You confirm the exact path exists (e.g., it might be foo-bars, foobar, foo_bar, etc.)
+4. Only then call spawn_agent with the verified cwd`,
+    {
+      runner: z.string().describe("CLI runner ID (e.g., 'claude', 'gemini', 'codex', 'opencode')"),
+      task: z.string().describe("Task description for the sub-agent"),
+      name: z.string().optional().describe("Human-readable agent name (e.g., 'security-reviewer', 'linkedin-writer')"),
+      description: z.string().optional().describe("Short description of what this agent does"),
+      model: z.string().optional().describe("Model override for the sub-agent"),
+      skills: z.array(z.string()).optional().describe("Skills to inject into the sub-agent"),
+      permMode: z.string().optional().describe("Permission mode: yolo, safe, readonly, plan (defaults to chat's mode)"),
+      role: z.string().optional().describe("Agent role. Presets: worker, reviewer, planner, researcher, writer, analyst, debugger, critic, synthesizer. Custom roles accepted as labels."),
+      persona: z.string().optional().describe("Custom system prompt for the agent. Replaces the role's default prompt while preserving orchestrator tools and task."),
+      allowedTools: z.array(z.string()).optional().describe("Restrict agent to specific tools (Claude-only). E.g., ['Read', 'Grep', 'Glob']"),
+      maxRuntimeMs: z.number().optional().describe("Max runtime in ms before timeout (default: 600000 = 10 min)"),
+      summarizeResult: z.boolean().optional().describe("Summarize agent output before posting to inbox"),
+      mcps: z.array(z.string()).optional().describe("MCP servers to inject into the sub-agent"),
+      cwd: z.string().optional().describe("Working directory for the sub-agent. MUST be a verified, existing absolute path \u2014 check it before calling."),
+      template: z.string().optional().describe("Name of an agent template from ~/.cc-claw/agents/ to use as defaults. Call list_templates to discover available templates. Call-time params override template defaults.")
+    },
+    async (params) => {
+      try {
+        const result = await callApi("/api/orchestrator/spawn", { chatId: CHAT_ID, ...params });
+        const status = result.queued ? "queued (at capacity, will start when a slot opens)" : "spawning";
+        return {
+          content: [{ type: "text", text: `Agent ${result.agentId} \u2014 ${status}` }]
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `spawn_agent failed: ${msg}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "list_templates",
+    "List available agent templates from ~/.cc-claw/agents/. Use a template name with spawn_agent's template parameter to spawn a pre-configured agent.",
+    {},
+    async () => {
+      const templates = await callApi("/api/orchestrator/list-templates");
+      if (!templates.length) {
+        return { content: [{ type: "text", text: "No agent templates found. Create .md files in ~/.cc-claw/agents/ with YAML frontmatter." }] };
+      }
+      const lines = templates.map(
+        (t) => `\u2022 **${t.name}**${t.description ? ` \u2014 ${t.description}` : ""}${t.runner ? ` (runner: ${t.runner})` : ""}${t.model ? ` [${t.model}]` : ""}`
+      );
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server.tool(
+    "cancel_agent",
+    "Cancel a specific sub-agent",
+    {
+      agentId: z.string().describe("The agent ID to cancel"),
+      reason: z.string().optional().describe("Reason for cancellation")
+    },
+    async ({ agentId, reason }) => {
+      const result = await callApi("/api/orchestrator/cancel", { agentId, reason });
+      return {
+        content: [{ type: "text", text: result.success ? `Agent ${agentId} cancelled.` : `Agent ${agentId} not found or already completed.` }]
+      };
+    }
+  );
+  server.tool(
+    "create_task",
+    "Add a task to the shared task list",
+    {
+      subject: z.string().describe("Short imperative title for the task"),
+      description: z.string().describe("Detailed task requirements"),
+      assignee: z.string().optional().describe("Agent ID to assign the task to"),
+      blockedBy: z.array(z.number()).optional().describe("Task IDs that must complete before this task can start")
+    },
+    async (params) => {
+      const result = await callApi("/api/orchestrator/create-task", {
+        chatId: CHAT_ID,
+        task: { ...params, createdBy: AGENT_ID }
+      });
+      return {
+        content: [{ type: "text", text: `Task #${result.taskId} created.` }]
+      };
+    }
+  );
+}
+server.tool(
+  "list_agents",
+  "List all active and queued sub-agents",
+  {},
+  async () => {
+    const agents = await callApi("/api/agents");
+    if (!agents.length) {
+      return { content: [{ type: "text", text: "No active agents." }] };
+    }
+    const lines = agents.map((a) => {
+      const label = a.name ?? a.id.slice(0, 8);
+      return `\u2022 ${label} (${a.runnerId}) \u2014 ${a.status}${a.task ? ` \u2192 ${a.task.slice(0, 80)}` : ""}`;
+    });
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  }
+);
+server.tool(
+  "check_agent",
+  "Get detailed status of a specific agent",
+  {
+    agentId: z.string().describe("The agent ID to check")
+  },
+  async ({ agentId }) => {
+    const agent = await callApi("/api/orchestrator/check-agent", { agentId });
+    if (!agent) {
+      return { content: [{ type: "text", text: `Agent ${agentId} not found.` }] };
+    }
+    return {
+      content: [{
+        type: "text",
+        text: [
+          `Agent: ${agent.name ?? agent.id.slice(0, 8)} (${agent.runnerId})`,
+          agent.name ? `ID: ${agent.id.slice(0, 8)}` : null,
+          agent.description ? `Description: ${agent.description}` : null,
+          `Status: ${agent.status}`,
+          `Task: ${agent.task ?? "none"}`,
+          `Role: ${agent.role}`,
+          `Tokens: ${agent.tokenInput} in / ${agent.tokenOutput} out`,
+          agent.resultSummary ? `Result: ${agent.resultSummary.slice(0, 500)}` : null
+        ].filter(Boolean).join("\n")
+      }]
+    };
+  }
+);
+server.tool(
+  "list_tasks",
+  "Get the full task board",
+  {},
+  async () => {
+    const tasks = await callApi("/api/tasks");
+    if (!tasks.length) {
+      return { content: [{ type: "text", text: "No tasks." }] };
+    }
+    const lines = tasks.map(
+      (t) => `#${t.id} [${t.status}] ${t.subject}${t.assignee ? ` (\u2192 ${t.assignee.slice(0, 8)})` : ""}`
+    );
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  }
+);
+server.tool(
+  "update_task",
+  "Update a task's status",
+  {
+    taskId: z.number().describe("The task ID to update"),
+    status: z.enum(["pending", "in_progress", "completed", "failed", "abandoned"]).describe("New status"),
+    result: z.string().optional().describe("Result summary (for completed/failed)")
+  },
+  async ({ taskId, status, result }) => {
+    await callApi("/api/orchestrator/update-task", { taskId, status, result });
+    return { content: [{ type: "text", text: `Task #${taskId} \u2192 ${status}` }] };
+  }
+);
+server.tool(
+  "send_message",
+  "Send a message to another agent's inbox",
+  {
+    toAgentId: z.string().describe("Recipient agent ID (or 'main' for the main agent)"),
+    content: z.string().describe("Message content"),
+    messageType: z.enum(["task_result", "question", "status_update", "direct_message"]).optional().describe("Message type (default: direct_message)")
+  },
+  async ({ toAgentId, content, messageType }) => {
+    await callApi("/api/orchestrator/send-message", {
+      chatId: CHAT_ID,
+      message: {
+        toAgentId,
+        fromAgentId: AGENT_ID,
+        messageType: messageType ?? "direct_message",
+        content
+      }
+    });
+    return { content: [{ type: "text", text: `Message sent to ${toAgentId}.` }] };
+  }
+);
+server.tool(
+  "read_inbox",
+  "Read pending messages from your inbox. Messages remain unread unless markRead is true.",
+  {
+    markRead: z.boolean().optional().describe("Mark messages as read after returning them (default: false)")
+  },
+  async ({ markRead }) => {
+    const messages = await callApi("/api/orchestrator/read-inbox", {
+      chatId: CHAT_ID,
+      agentId: AGENT_ID,
+      markRead: markRead ?? false
+    });
+    if (!messages.length) {
+      return { content: [{ type: "text", text: "No new messages." }] };
+    }
+    const lines = messages.map(
+      (m) => `[${m.messageType}] from ${m.fromAgentId.slice(0, 8)}: ${m.content.slice(0, 500)}`
+    );
+    return { content: [{ type: "text", text: lines.join("\n\n") }] };
+  }
+);
+server.tool(
+  "set_state",
+  "Write a key-value pair to the shared state whiteboard",
+  {
+    key: z.string().describe("State key (1-256 chars)"),
+    value: z.string().describe("State value (JSON-serialized data)")
+  },
+  async ({ key, value }) => {
+    await callApi("/api/orchestrator/set-state", {
+      chatId: CHAT_ID,
+      key,
+      value,
+      setBy: AGENT_ID
+    });
+    return { content: [{ type: "text", text: `State '${key}' set.` }] };
+  }
+);
+server.tool(
+  "get_state",
+  "Read a value from the shared state whiteboard",
+  {
+    key: z.string().describe("State key to read")
+  },
+  async ({ key }) => {
+    const entry = await callApi("/api/orchestrator/get-state", {
+      chatId: CHAT_ID,
+      key
+    });
+    if (!entry) {
+      return { content: [{ type: "text", text: `State '${key}' not set.` }] };
+    }
+    return { content: [{ type: "text", text: `${key} = ${entry.value} (set by ${entry.setBy})` }] };
+  }
+);
+server.tool(
+  "list_state",
+  "List all key-value entries on the shared whiteboard for this orchestration",
+  {},
+  async () => {
+    const entries = await callApi("/api/orchestrator/list-state", {
+      chatId: CHAT_ID
+    });
+    if (!entries.length) {
+      return { content: [{ type: "text", text: "Whiteboard is empty." }] };
+    }
+    const lines = entries.map((e) => `${e.setBy}: ${e.key} = ${e.value}`);
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  }
+);
+server.tool(
+  "broadcast",
+  "Send a message to ALL other agents in the orchestration",
+  {
+    content: z.string().describe("Message content to broadcast"),
+    messageType: z.enum(["status_update", "direct_message"]).optional().describe("Message type (default: direct_message)")
+  },
+  async ({ content, messageType }) => {
+    const result = await callApi("/api/orchestrator/broadcast", {
+      chatId: CHAT_ID,
+      fromAgentId: AGENT_ID,
+      content,
+      messageType: messageType ?? "direct_message"
+    });
+    return { content: [{ type: "text", text: `Broadcast sent to ${result.sent} agent(s).` }] };
+  }
+);
+server.tool(
+  "list_runners",
+  "List all registered CLI runners and their capabilities",
+  {},
+  async () => {
+    const runners = await callApi("/api/orchestrator/list-runners");
+    const lines = runners.map(
+      (r) => `\u2022 ${r.id} (${r.displayName}) \u2014 ${r.capabilities.specialties.join(", ")}`
+    );
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  }
+);
+server.tool(
+  "list_mcps",
+  "List all MCP servers in the global registry",
+  {},
+  async () => {
+    const mcps = await callApi("/api/orchestrator/list-mcps");
+    if (!mcps.length) {
+      return { content: [{ type: "text", text: "No MCP servers registered." }] };
+    }
+    const lines = mcps.map(
+      (m) => `\u2022 ${m.name} (${m.transport})${m.description ? ` \u2014 ${m.description}` : ""}${m.enabledByDefault ? " [auto]" : ""}`
+    );
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  }
+);
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(`[cc-claw-mcp] Server running on stdio (chatId=${CHAT_ID}, agentId=${AGENT_ID})`);
+}
+main().catch((err) => {
+  console.error("[cc-claw-mcp] Fatal error:", err);
+  process.exit(1);
+});