musecode 0.1.0

package/.env.example

@@ -0,0 +1,31 @@
+# Required: generate independent random values, for example with
+# node -e "console.log(require('node:crypto').randomBytes(32).toString('base64url'))"
+BRIDGE_TOKEN=replace-with-a-random-32-byte-base64url-token
+BRIDGE_APPROVAL_SECRET=replace-with-a-different-random-32-byte-base64url-secret
+
+# Required when BRIDGE_REQUIRE_APPROVAL=true. Treat the topic name as a secret.
+BRIDGE_NTFY_TOPIC=replace-with-a-private-ntfy-topic
+
+# Core settings
+BRIDGE_PORT=8787
+BRIDGE_WORKDIR=workspace
+BRIDGE_DATA=data
+BRIDGE_REQUIRE_APPROVAL=true
+BRIDGE_APPROVAL_TIMEOUT_MINUTES=30
+BRIDGE_TASK_TIMEOUT_MINUTES=30
+BRIDGE_PERMISSION_MODE=bypassPermissions
+BRIDGE_ALLOWED_TOOLS=
+BRIDGE_MODEL=
+
+# Agent executables. Commands on PATH or absolute paths are accepted.
+BRIDGE_CLAUDE_PATH=claude
+BRIDGE_CODEX_PATH=codex
+
+# Network and notification settings
+BRIDGE_NTFY_SERVER=https://ntfy.sh
+BRIDGE_PUBLIC_URL=
+BRIDGE_ALLOWED_IPS=
+BRIDGE_IP_HEADER=cf-connecting-ip
+
+# Optional path to a JSON config file. Environment variables override JSON values.
+BRIDGE_CONFIG_PATH=config.json

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Claude Desktop Bridge contributors
+
+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,175 @@
+# Claude Desktop Bridge
+
+Claude Desktop Bridge is a small, dependency-free Node.js service that lets a remote client hand work to Claude Code or Codex on a Windows PC. It exposes the same capabilities as an HTTP API and an MCP server, keeps task state on disk, and can require a human approval before an agent runs.
+
+The bridge listens only on `127.0.0.1`. Remote access is expected to arrive through a tunnel or private network that you configure separately.
+
+## Architecture
+
+```text
+Remote client
+   |
+   | Bearer-authenticated HTTP
+   v
+server.mjs ── /mcp (MCP over HTTP)
+   |       └─ /api/* + /openapi.json (REST/OpenAPI)
+   |
+   +─ task store + audit log ─────────────── data/
+   +─ inbox queues (to-desktop / to-muse) ─ data/*.jsonl
+   +─ Claude Code / Claude Desktop sessions
+   +─ Codex Desktop tasks (via the official app-server thread API)
+   +─ side threads ───────────────────────── data/threads/
+
+Claude Desktop or Codex
+   |
+   └─ desktop-mcp.mjs / codex-mcp.mjs (local stdio MCP)
+```
+
+- **HTTP API:** `server.mjs` serves MCP JSON-RPC at `POST /mcp` and equivalent REST operations under `/api/*`. `/openapi.json` describes the REST surface.
+- **Claude and Codex agents:** `ask_claude` can start or resume Claude sessions, including delivery into an open Claude Desktop session. `list_codex_sessions` and `read_codex_session` expose real Codex Desktop tasks; `ask_codex` with a session ID continues one through Codex app-server.
+- **Approvals:** when enabled, a task remains pending until the user opens a signed approval link delivered through ntfy. The approval code is derived from a separate HMAC secret.
+- **Side channels:** a per-session side thread lets a remote client coordinate with a read-only Claude fork without adding messages to the user's main conversation.
+- **Inbox:** append-only JSONL queues carry asynchronous messages between the remote client and local desktop agents. The two stdio MCP entry points expose tools to read and write those queues.
+- **Persistence:** tasks, queue cursors, side threads, results, and audit logs live under `data/`. This directory can contain sensitive conversation content and is ignored by Git.
+
+## Requirements
+
+- Windows with PowerShell
+- Node.js 20 or newer
+- Claude Code and/or Codex CLI installed and authenticated
+- Optional: [cloudflared](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/) for the bundled quick-tunnel launcher
+- Optional: an ntfy server/app for approval notifications
+
+The bridge has no npm runtime dependencies.
+
+## Install
+
+1. Clone or copy this directory.
+2. Create a private environment file:
+
+   ```powershell
+   Copy-Item .env.example .env
+   ```
+
+3. Generate two independent secrets and put them in `BRIDGE_TOKEN` and `BRIDGE_APPROVAL_SECRET`:
+
+   ```powershell
+   node -e "console.log(require('node:crypto').randomBytes(32).toString('base64url'))"
+   ```
+
+   Run the command twice. If approvals are enabled, also choose a long, unguessable `BRIDGE_NTFY_TOPIC`; the topic name acts as a credential.
+
+4. Set `BRIDGE_CLAUDE_PATH` and `BRIDGE_CODEX_PATH` if the commands are not available on `PATH`.
+5. Start the local server:
+
+   ```powershell
+   npm start
+   ```
+
+   Or run `./start.ps1` to create a temporary Cloudflare quick tunnel and start the server. `run-server.ps1` is a restart loop suitable for a Windows scheduled task.
+
+On first launch, any omitted credentials are generated into the ignored `config.json`. Supplying all credentials through `.env` is recommended because it makes configuration explicit.
+
+## Configuration
+
+Configuration precedence is environment variables (including `.env`), then `config.json`, then built-in defaults. Copy `config.example.json` to `config.json` if you prefer JSON. Never commit `.env` or `config.json`.
+
+| Variable | Default | Purpose |
+| --- | --- | --- |
+| `BRIDGE_TOKEN` | generated | Bearer token protecting MCP and REST calls |
+| `BRIDGE_APPROVAL_SECRET` | generated | HMAC secret for per-task approval links |
+| `BRIDGE_NTFY_TOPIC` | generated | Private ntfy topic for approval notifications |
+| `BRIDGE_PORT` | `8787` | Local HTTP port |
+| `BRIDGE_WORKDIR` | `workspace` | Working directory for new agent tasks |
+| `BRIDGE_DATA` | `data` | Runtime state directory |
+| `BRIDGE_FILE_DROP` | `%LOCALAPPDATA%\\ClaudeDesktopBridge\\shared-files` | Shared-file storage directory; must be outside the source tree |
+| `BRIDGE_REQUIRE_APPROVAL` | `true` | Require approval before running tasks |
+| `BRIDGE_PERMISSION_MODE` | `bypassPermissions` | Claude Code permission mode |
+| `BRIDGE_ALLOWED_TOOLS` | empty | Comma-separated Claude tool allowlist |
+| `BRIDGE_CLAUDE_PATH` | auto-detected/`claude` | Claude executable or command |
+| `BRIDGE_CODEX_PATH` | `codex.exe` | Codex executable or command |
+| `BRIDGE_PUBLIC_URL` | empty | Fixed public URL used in approval links and Host validation |
+| `BRIDGE_ALLOWED_IPS` | empty | Comma-separated caller IPs or CIDRs |
+| `BRIDGE_IP_HEADER` | `cf-connecting-ip` | Trusted proxy header carrying the caller IP; set empty when unavailable |
+| `BRIDGE_NTFY_SERVER` | `https://ntfy.sh` | ntfy base URL |
+| `BRIDGE_APPROVAL_TIMEOUT_MINUTES` | `30` | Approval expiry |
+| `BRIDGE_TASK_TIMEOUT_MINUTES` | `30` | Agent task timeout |
+| `BRIDGE_MODEL` | empty | Optional Claude model override |
+| `BRIDGE_CONFIG_PATH` | `config.json` | Optional JSON config path |
+
+`bypassPermissions` gives Claude broad local access. Keep approval enabled, protect the bearer token and ntfy topic, and use a restricted permission mode plus `BRIDGE_ALLOWED_TOOLS` when full access is unnecessary.
+
+## Connect the local MCP inbox
+
+Claude Desktop/Claude Code can launch `desktop-mcp.mjs` as a stdio MCP server. Codex can use `codex-mcp.mjs`. Point the command at your clone and make sure the process sees the same `BRIDGE_DATA` directory as the HTTP server.
+
+Example Claude MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "muse-inbox": {
+      "command": "node",
+      "args": ["C:\\path\\to\\claude-desktop-bridge\\desktop-mcp.mjs"],
+      "env": {
+        "BRIDGE_DATA": "C:\\path\\to\\claude-desktop-bridge\\data"
+      }
+    }
+  }
+}
+```
+
+Use `codex-mcp.mjs` in the same way for a Codex MCP configuration.
+
+## Send a task
+
+With the server running, send a task to Codex over REST:
+
+```powershell
+$headers = @{ Authorization = "Bearer <your-BRIDGE_TOKEN>" }
+$body = @{ prompt = "List the top-level files in the workspace."; wait_seconds = 0 } | ConvertTo-Json
+$task = Invoke-RestMethod -Method Post -Uri http://127.0.0.1:8787/api/ask_codex -Headers $headers -ContentType application/json -Body $body
+$task
+```
+
+If approval is enabled, approve the notification, then poll the returned task ID:
+
+```powershell
+$body = @{ task_id = $task.task_id; wait_seconds = 30 } | ConvertTo-Json
+Invoke-RestMethod -Method Post -Uri http://127.0.0.1:8787/api/get_task -Headers $headers -ContentType application/json -Body $body
+```
+
+Replace `ask_codex` with `ask_claude` to route the task to Claude. A client can also initialize MCP at `POST /mcp` and call the same tools through JSON-RPC.
+
+For immediate agent-to-agent delivery, send a `send_to_desktop` message beginning with `FOR CODEX`. The bridge writes an acknowledgment back to Muse immediately, selects the most recent Codex Desktop task, and starts the message there. This works while that task is idle because the bridge runs independently as a Windows scheduled task.
+
+## Shared file drop
+
+The bearer-authenticated REST API can exchange files up to 25 MB. Files are stored under `BRIDGE_FILE_DROP`, which defaults outside the repository so uploaded content cannot be committed accidentally.
+
+- `POST /api/upload_file` accepts JSON with `name`, base64-encoded `content_base64`, and optional `content_type`; it returns a `file_id` plus metadata.
+- `GET /api/download_file?file_id=...` downloads the original bytes with an attachment filename.
+- `GET /api/list_files` returns file IDs, names, sizes, content types, and creation timestamps.
+- `DELETE /api/delete_file?file_id=...` removes the stored file and its metadata.
+
+```bash
+TOKEN="your-BRIDGE_TOKEN"
+BASE64=$(base64 < ./example.txt | tr -d '\n')
+curl -X POST http://127.0.0.1:8787/api/upload_file \
+  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
+  --data "{\"name\":\"example.txt\",\"content_base64\":\"$BASE64\",\"content_type\":\"text/plain\"}"
+curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:8787/api/list_files
+curl -H "Authorization: Bearer $TOKEN" -OJ "http://127.0.0.1:8787/api/download_file?file_id=FILE_ID"
+curl -X DELETE -H "Authorization: Bearer $TOKEN" "http://127.0.0.1:8787/api/delete_file?file_id=FILE_ID"
+```
+
+## Security notes
+
+- The service binds to localhost; do not change that unless you also provide equivalent network controls.
+- A tunnel makes the service internet-reachable. Use TLS, keep the bearer token private, pin `BRIDGE_PUBLIC_URL`, and consider an IP allowlist when your proxy provides a trustworthy client-IP header.
+- Approval links contain a task-specific secret. Keep approval enabled for agents with broad filesystem permissions.
+- `data/`, `workspace/`, `.env`, and `config.json` may contain credentials or private conversation content and must remain untracked.
+
+## License
+
+[MIT](LICENSE)

package/codex-mcp.mjs

@@ -0,0 +1,64 @@
+// Local stdio MCP server for Codex: read what Muse sent, reply to Muse,
+// participate in side threads, and inspect tasks Muse has run on this PC.
+import readline from "node:readline";
+import { createMcpHandler, postMessage, readMessages, loadTasks, TO_DESKTOP, TO_MUSE } from "./lib.mjs";
+import { appendMessage, readThread, listThreads } from "./threads.mjs";
+
+const handle = createMcpHandler({
+  name: "muse-inbox",
+  version: "1.1.0",
+  instructions: "Messages and tasks exchanged between Codex and Meta Muse on the user's phone.",
+  tools: [
+    {
+      name: "read_muse_messages",
+      description: "Read messages Meta Muse has left for desktop agents. Returns unread ones and marks them read.",
+      inputSchema: { type: "object", properties: { include_read: { type: "boolean", description: "Return the last 50 instead of only unread." } } },
+      run: async ({ include_read }) => {
+        const messages = readMessages(TO_DESKTOP, { unreadOnly: !include_read });
+        return messages.length ? { messages } : { messages: [], note: "No new messages from Muse." };
+      },
+    },
+    {
+      name: "send_to_muse",
+      description: "Send a message from Codex to Meta Muse. Muse sees it next time it checks desktop messages.",
+      inputSchema: { type: "object", properties: { text: { type: "string" } }, required: ["text"] },
+      run: async ({ text }) => {
+        if (!text?.trim()) throw new Error("text is required");
+        return { sent: postMessage(TO_MUSE, text, "codex-desktop") };
+      },
+    },
+    {
+      name: "read_side_thread",
+      description:
+        "Read the side thread between Meta Muse and one of the user's sessions. Messages are labeled muse, " +
+        "side-claude, desktop-claude, desktop-codex, or user. Omit session_id to list threads.",
+      inputSchema: { type: "object", properties: { session_id: { type: "string" } } },
+      run: async ({ session_id }) => (session_id ? { messages: readThread(session_id).slice(-100) } : { threads: listThreads() }),
+    },
+    {
+      name: "post_to_side_thread",
+      description: "Post into a session's side thread as desktop-codex. Muse sees it with side_thread_read.",
+      inputSchema: { type: "object", properties: { session_id: { type: "string" }, text: { type: "string" } }, required: ["session_id", "text"] },
+      run: async ({ session_id, text }) => {
+        if (!text?.trim()) throw new Error("text is required");
+        return { posted: appendMessage(session_id, "desktop-codex", text) };
+      },
+    },
+    {
+      name: "list_muse_tasks",
+      description: "List recent tasks Meta Muse sent to agents on this PC, with prompts and results.",
+      inputSchema: { type: "object", properties: {} },
+      run: async () =>
+        Object.values(loadTasks()).sort((a, b) => b.startedAt.localeCompare(a.startedAt)).slice(0, 20),
+    },
+  ],
+});
+
+const rl = readline.createInterface({ input: process.stdin });
+rl.on("line", async (line) => {
+  if (!line.trim()) return;
+  let msg;
+  try { msg = JSON.parse(line); } catch { return; }
+  const reply = await handle(msg);
+  if (reply) process.stdout.write(JSON.stringify(reply) + "\n");
+});

package/codex-sessions.mjs

@@ -0,0 +1,153 @@
+// Codex app-server client used to discover, inspect, and continue real Codex threads.
+// The protocol is JSONL over stdio. Keeping this client short-lived avoids owning a
+// second long-running Codex service while still using the same persisted thread store
+// as Codex Desktop.
+import readline from "node:readline";
+import { spawn } from "node:child_process";
+
+const FINAL_TURN_STATUSES = new Set(["completed", "failed", "interrupted"]);
+
+class CodexAppServer {
+  constructor(codexPath, { cwd, timeoutMs = 120_000, onNotification } = {}) {
+    this.child = spawn(codexPath, ["app-server", "--stdio"], {
+      cwd, windowsHide: true, env: process.env, stdio: ["pipe", "pipe", "pipe"],
+    });
+    this.pending = new Map();
+    this.nextId = 1;
+    this.stderr = "";
+    this.timeoutMs = timeoutMs;
+    this.onNotification = onNotification;
+    this.ready = new Promise((resolve, reject) => {
+      this.child.once("spawn", resolve);
+      this.child.once("error", reject);
+    });
+    this.child.stderr.on("data", (chunk) => { this.stderr = (this.stderr + chunk).slice(-8_000); });
+    readline.createInterface({ input: this.child.stdout }).on("line", (line) => this.handleLine(line));
+    this.child.on("close", (code) => {
+      const error = new Error(this.stderr.trim() || `Codex app-server exited with code ${code}`);
+      for (const { reject, timer } of this.pending.values()) { clearTimeout(timer); reject(error); }
+      this.pending.clear();
+    });
+  }
+
+  handleLine(line) {
+    let msg;
+    try { msg = JSON.parse(line); } catch { return; }
+    if (msg.id !== undefined && this.pending.has(msg.id)) {
+      const pending = this.pending.get(msg.id);
+      this.pending.delete(msg.id);
+      clearTimeout(pending.timer);
+      if (msg.error) pending.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+      else pending.resolve(msg.result);
+      return;
+    }
+    this.onNotification?.(msg);
+  }
+
+  async request(method, params = {}) {
+    await this.ready;
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`Timed out waiting for ${method}`));
+      }, this.timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      this.child.stdin.write(JSON.stringify({ method, id, params }) + "\n");
+    });
+  }
+
+  notify(method, params = {}) {
+    this.child.stdin.write(JSON.stringify({ method, params }) + "\n");
+  }
+
+  close() {
+    this.child.stdin.end();
+    setTimeout(() => this.child.kill(), 1_000).unref();
+  }
+}
+
+async function withServer(codexPath, options, fn) {
+  const server = new CodexAppServer(codexPath, options);
+  try {
+    await server.request("initialize", {
+      clientInfo: { name: "claude-muse-bridge", title: "Claude Muse Bridge", version: "1.2.0" },
+      capabilities: { experimentalApi: true },
+    });
+    server.notify("initialized", {});
+    return await fn(server);
+  } finally {
+    server.close();
+  }
+}
+
+export async function listCodexSessions(codexPath, { cwd, limit = 30 } = {}) {
+  return withServer(codexPath, { cwd }, async (server) => {
+    const result = await server.request("thread/list", {
+      limit, sortKey: "recency_at", sortDirection: "desc", sourceKinds: [],
+    });
+    return result?.data || result?.threads || [];
+  });
+}
+
+export async function readCodexSession(codexPath, threadId, { cwd } = {}) {
+  return withServer(codexPath, { cwd }, async (server) => {
+    const result = await server.request("thread/read", { threadId, includeTurns: true });
+    return result?.thread || result;
+  });
+}
+
+function agentText(item) {
+  if (!item || item.type !== "agentMessage") return "";
+  if (typeof item.text === "string") return item.text;
+  if (typeof item.content === "string") return item.content;
+  if (Array.isArray(item.content)) return item.content.map((part) => part?.text || "").join("");
+  return "";
+}
+
+export async function runCodexSessionTurn(codexPath, threadId, prompt, {
+  cwd, timeoutMs = 30 * 60_000, onUpdate,
+} = {}) {
+  let turnId = null;
+  let text = "";
+  let finish;
+  const completed = new Promise((resolve, reject) => { finish = { resolve, reject }; });
+
+  const onNotification = (msg) => {
+    const method = msg.method || "";
+    const params = msg.params || {};
+    const notificationTurnId = params.turn?.id || params.turnId;
+    if (turnId && notificationTurnId && notificationTurnId !== turnId) return;
+    if (method === "item/agentMessage/delta" && typeof params.delta === "string") {
+      text += params.delta;
+      onUpdate?.(text);
+    } else if (method === "item/completed") {
+      const completeText = agentText(params.item);
+      if (completeText) { text = completeText; onUpdate?.(text); }
+    } else if (method === "turn/completed" && (!turnId || notificationTurnId === turnId)) {
+      const status = params.turn?.status || "completed";
+      if (status === "completed") finish.resolve({ text, turn: params.turn });
+      else finish.reject(new Error(params.turn?.error?.message || `Codex turn ${status}`));
+    }
+  };
+
+  return withServer(codexPath, { cwd, timeoutMs, onNotification }, async (server) => {
+    await server.request("thread/resume", {
+      threadId, cwd: cwd || null, approvalPolicy: "never", sandbox: "danger-full-access", excludeTurns: true,
+    });
+    const started = await server.request("turn/start", {
+      threadId,
+      input: [{ type: "text", text: prompt }],
+      cwd: cwd || null,
+      approvalPolicy: "never",
+      sandboxPolicy: { type: "dangerFullAccess" },
+      turnTrigger: "muse-bridge",
+    });
+    turnId = started?.turn?.id || started?.id || null;
+    const result = await completed;
+    if (result.turn?.status && !FINAL_TURN_STATUSES.has(result.turn.status)) {
+      throw new Error(`Unexpected Codex turn status: ${result.turn.status}`);
+    }
+    return { ...result, threadId, turnId };
+  });
+}

package/config.example.json

@@ -0,0 +1,19 @@
+{
+  "port": 8787,
+  "workdir": "workspace",
+  "permissionMode": "bypassPermissions",
+  "allowedTools": [],
+  "requireApproval": true,
+  "approvalTimeoutMinutes": 30,
+  "ntfyServer": "https://ntfy.sh",
+  "publicUrl": null,
+  "allowedIps": [],
+  "ipHeader": "cf-connecting-ip",
+  "model": null,
+  "taskTimeoutMinutes": 30,
+  "claudePath": "claude",
+  "codexPath": "codex",
+  "token": null,
+  "approvalSecret": null,
+  "ntfyTopic": null
+}

package/desktop-mcp.mjs

@@ -0,0 +1,64 @@
+// Local stdio MCP server for Claude Desktop / Claude Code: read what Muse sent, reply to Muse,
+// and see tasks Muse has run. Never exposed to the network.
+import readline from "node:readline";
+import { createMcpHandler, postMessage, readMessages, loadTasks, TO_DESKTOP, TO_MUSE } from "./lib.mjs";
+import { appendMessage, readThread, listThreads } from "./threads.mjs";
+
+const handle = createMcpHandler({
+  name: "muse-inbox",
+  version: "1.0.0",
+  instructions: "Messages and tasks exchanged with Meta Muse on the user's phone.",
+  tools: [
+    {
+      name: "read_muse_messages",
+      description: "Read messages Meta Muse (on the user's phone) has left for Claude Desktop. Returns unread ones and marks them read.",
+      inputSchema: { type: "object", properties: { include_read: { type: "boolean", description: "Return the last 50 instead of only unread." } } },
+      run: async ({ include_read }) => {
+        const messages = readMessages(TO_DESKTOP, { unreadOnly: !include_read });
+        return messages.length ? { messages } : { messages: [], note: "No new messages from Muse." };
+      },
+    },
+    {
+      name: "send_to_muse",
+      description: "Send a message to Meta Muse on the user's phone. Muse sees it next time it checks read_desktop_messages.",
+      inputSchema: { type: "object", properties: { text: { type: "string" } }, required: ["text"] },
+      run: async ({ text }) => {
+        if (!text?.trim()) throw new Error("text is required");
+        return { sent: postMessage(TO_MUSE, text, "claude-desktop") };
+      },
+    },
+    {
+      name: "read_side_thread",
+      description:
+        "Read the side thread between Meta Muse and one of the user's sessions (an agent-to-agent channel kept out of the " +
+        "user's conversation). Messages are labeled muse / side-claude / desktop-claude / user. Omit session_id to list threads.",
+      inputSchema: { type: "object", properties: { session_id: { type: "string" } } },
+      run: async ({ session_id }) => (session_id ? { messages: readThread(session_id).slice(-100) } : { threads: listThreads() }),
+    },
+    {
+      name: "post_to_side_thread",
+      description: "Post into a session's side thread with Meta Muse, labeled as desktop-claude. Muse sees it with side_thread_read.",
+      inputSchema: { type: "object", properties: { session_id: { type: "string" }, text: { type: "string" } }, required: ["session_id", "text"] },
+      run: async ({ session_id, text }) => {
+        if (!text?.trim()) throw new Error("text is required");
+        return { posted: appendMessage(session_id, "desktop-claude", text) };
+      },
+    },
+    {
+      name: "list_muse_tasks",
+      description: "List recent tasks Meta Muse sent to Claude on this PC, with prompts and results.",
+      inputSchema: { type: "object", properties: {} },
+      run: async () =>
+        Object.values(loadTasks()).sort((a, b) => b.startedAt.localeCompare(a.startedAt)).slice(0, 20),
+    },
+  ],
+});
+
+const rl = readline.createInterface({ input: process.stdin });
+rl.on("line", async (line) => {
+  if (!line.trim()) return;
+  let msg;
+  try { msg = JSON.parse(line); } catch { return; }
+  const reply = await handle(msg);
+  if (reply) process.stdout.write(JSON.stringify(reply) + "\n");
+});