@famonfa/mono 0.0.0-stage → 0.1.0

package/node_modules/ws/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "ws",
+  "version": "8.22.0",
+  "description": "Simple to use, blazing fast and thoroughly tested websocket client and server for Node.js",
+  "keywords": [
+    "HyBi",
+    "Push",
+    "RFC-6455",
+    "WebSocket",
+    "WebSockets",
+    "real-time"
+  ],
+  "homepage": "https://github.com/websockets/ws",
+  "bugs": "https://github.com/websockets/ws/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/websockets/ws.git"
+  },
+  "author": "Einar Otto Stangvik <einaros@gmail.com> (http://2x.io)",
+  "license": "MIT",
+  "main": "index.js",
+  "exports": {
+    ".": {
+      "browser": "./browser.js",
+      "import": "./wrapper.mjs",
+      "require": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "browser": "browser.js",
+  "engines": {
+    "node": ">=10.0.0"
+  },
+  "files": [
+    "browser.js",
+    "index.js",
+    "lib/*.js",
+    "wrapper.mjs"
+  ],
+  "scripts": {
+    "test": "nyc --reporter=lcov --reporter=text mocha --throw-deprecation test/*.test.js",
+    "integration": "mocha --throw-deprecation test/*.integration.js",
+    "lint": "eslint . && prettier --check --ignore-path .gitignore \"**/*.{json,md,yaml,yml}\""
+  },
+  "peerDependencies": {
+    "bufferutil": "^4.0.1",
+    "utf-8-validate": ">=5.0.2"
+  },
+  "peerDependenciesMeta": {
+    "bufferutil": {
+      "optional": true
+    },
+    "utf-8-validate": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "benchmark": "^2.1.4",
+    "bufferutil": "^4.0.1",
+    "eslint": "^10.0.1",
+    "eslint-config-prettier": "^10.0.1",
+    "eslint-plugin-prettier": "^5.0.0",
+    "globals": "^17.0.0",
+    "mocha": "^8.4.0",
+    "nyc": "^15.0.0",
+    "prettier": "^3.0.0",
+    "utf-8-validate": "^6.0.0"
+  },
+  "allowScripts": {
+    "bufferutil": true,
+    "utf-8-validate": true
+  }
+}

package/node_modules/ws/wrapper.mjs

@@ -0,0 +1,21 @@
+import createWebSocketStream from './lib/stream.js';
+import extension from './lib/extension.js';
+import PerMessageDeflate from './lib/permessage-deflate.js';
+import Receiver from './lib/receiver.js';
+import Sender from './lib/sender.js';
+import subprotocol from './lib/subprotocol.js';
+import WebSocket from './lib/websocket.js';
+import WebSocketServer from './lib/websocket-server.js';
+
+export {
+  createWebSocketStream,
+  extension,
+  PerMessageDeflate,
+  Receiver,
+  Sender,
+  subprotocol,
+  WebSocket,
+  WebSocketServer
+};
+
+export default WebSocket;

package/package.json

@@ -1,6 +1,129 @@
 {
   "name": "@famonfa/mono",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Mono: watch and drive your Claude Code agents from your Mac, the web or your phone",
+  "type": "module",
+  "bin": {
+    "mono": "bin/mono.mjs",
+    "ws": "bin/mono.mjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "skills",
+    "web"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.308",
+    "ws": "^8.22.0"
+  },
+  "bundleDependencies": [
+    "@anthropic-ai/claude-agent-sdk",
+    "@anthropic-ai/sdk",
+    "@babel/runtime",
+    "@hono/node-server",
+    "@modelcontextprotocol/sdk",
+    "@opentelemetry/api",
+    "@stablelib/base64",
+    "accepts",
+    "ajv",
+    "ajv-formats",
+    "body-parser",
+    "bytes",
+    "call-bind-apply-helpers",
+    "call-bound",
+    "content-disposition",
+    "content-type",
+    "cookie",
+    "cookie-signature",
+    "cors",
+    "cross-spawn",
+    "debug",
+    "depd",
+    "dunder-proto",
+    "ee-first",
+    "encodeurl",
+    "es-define-property",
+    "es-errors",
+    "es-object-atoms",
+    "escape-html",
+    "etag",
+    "eventsource",
+    "eventsource-parser",
+    "express",
+    "express-rate-limit",
+    "fast-deep-equal",
+    "fast-sha256",
+    "fast-uri",
+    "finalhandler",
+    "forwarded",
+    "fresh",
+    "function-bind",
+    "get-intrinsic",
+    "get-proto",
+    "gopd",
+    "has-symbols",
+    "hasown",
+    "hono",
+    "http-errors",
+    "iconv-lite",
+    "inherits",
+    "ip-address",
+    "ipaddr.js",
+    "is-promise",
+    "isexe",
+    "jose",
+    "json-schema-to-ts",
+    "json-schema-traverse",
+    "json-schema-typed",
+    "math-intrinsics",
+    "media-typer",
+    "merge-descriptors",
+    "mime-db",
+    "mime-types",
+    "ms",
+    "negotiator",
+    "object-assign",
+    "object-inspect",
+    "on-finished",
+    "once",
+    "parseurl",
+    "path-key",
+    "path-to-regexp",
+    "pkce-challenge",
+    "proxy-addr",
+    "qs",
+    "range-parser",
+    "raw-body",
+    "require-from-string",
+    "router",
+    "safer-buffer",
+    "send",
+    "serve-static",
+    "setprototypeof",
+    "shebang-command",
+    "shebang-regex",
+    "side-channel",
+    "side-channel-list",
+    "side-channel-map",
+    "side-channel-weakmap",
+    "standardwebhooks",
+    "statuses",
+    "toidentifier",
+    "ts-algebra",
+    "type-is",
+    "unpipe",
+    "vary",
+    "which",
+    "wrappy",
+    "ws",
+    "zod",
+    "zod-to-json-schema"
+  ]
 }

package/skills/workspace/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: workspace
+description: Document a task visually in Mono (http://localhost:4600) — TL;DR, story map, before/after flow, test flows and technical map as editable canvases, plus short docs. Use when the user runs /workspace [TICKET], asks to "document this in my workspace", "documentalo en mi workspace", "armame el canvas / story map / flujos", or wants a visual summary of work done. Never commit or publish its output.
+---
+
+# Workspace
+
+Turn a task into a visual, editable workspace entry. The user reviews work by **looking at flows**, not by reading the conversation. Optimize for: understood in 30 seconds, then explore by clicking.
+
+Mono runs locally on this machine. Data: `ws path <TASK>` prints the task folder. The UI refreshes live when you write.
+
+CLI: `mono` or its alias `ws` (on PATH) — run `ws` with no args for usage. Don't store it in a shell variable: zsh won't word-split `$WS`.
+
+## Arguments
+
+`/workspace [TICKET | slug] [board...]`
+
+- No argument: infer the ticket from the current worktree path (`.worktrees/<TICKET>/`) or branch name.
+- Extra args limit which boards to (re)generate, e.g. `/workspace ABC-123 testeo`.
+
+## 1. Make sure the app is running
+
+```bash
+curl -s -o /dev/null localhost:4600/api/health || mono serve > /tmp/mono.log 2>&1 &
+```
+
+## 2. Gather facts (cheaply)
+
+Read only what you need; never paste big outputs into context.
+
+- **Existing entry:** `ws show <TASK>` — if it exists you are *updating*: keep node ids stable so the user's layout survives.
+- **Conversation:** the work you just did is the best source. Use it.
+- **Other agents:** `ws sessions <TASK>` prints what every linked Claude Code session and subagent did recently (sessions link by PR, branch, worktree or a mention of the task id). Use it as evidence for test results and new findings — e.g. QA agents running in another session.
+- **Ticket:** if the project has a tracker CLI or API documented in its CLAUDE.md (Linear, Jira, GitHub issues), fetch only title, url, state and the first ~2000 chars of the description.
+- **Code:** per repo worktree in `.worktrees/<TASK>/<repo>`: `git log --oneline origin/<base>..HEAD` and `git diff --stat origin/<base>...HEAD | tail -30`. Read specific diffs only to understand behavior.
+- **PRs:** `gh pr view --json number,url,title,state` inside each worktree.
+- **UI changes?** Check the diff for UI files (`.tsx`, `.css`, `.css.ts`, screens/components). If there are none, do not create the `ui` board. If there are and no screenshots exist yet, screenshot the running app (Playwright or the project's own capture tooling), then build the `ui` board from them.
+- **Screenshots:** if QA or capture tools produced images (simulator screenshots, Playwright captures), copy them in with `ws asset <TASK> <files...>` and reference them as `assets/<name>.png`.
+
+## 3. Write the entry
+
+Write JSON/MD to `/tmp/ws-<TASK>/` and load each with the CLI. Write everything in the user's language.
+
+### task.json → `ws task <TASK> /tmp/ws-<TASK>/task.json`
+
+```json
+{
+  "title": "Refund + cancel en órdenes pagas",
+  "status": "en-curso",
+  "risk": "medio",
+  "tldr": { "problema": "…", "solucion": "…", "impacto": "…" },
+  "summary": "markdown corto: origen, estado, pendientes fuera de scope",
+  "repos": [{ "name": "api", "branch": "ABC-123-refunds", "pr": "https://github.com/…/pull/1637" }],
+  "linear": "https://linear.app/…/issue/ABC-123",
+  "tags": ["refunds"],
+  "relatedPrs": [1476, 1479]
+}
+```
+
+`status`: `planificado | en-curso | en-review | hecho | bloqueado`. `relatedPrs`: superseded or companion PR numbers, so agent sessions that worked on them link to this task. `projects`: optional list of project ids (the directories Mono shows: `curl -s localhost:4600/api/projects | jq -r '.[].id'`); if omitted, repos are matched to projects by name. `risk`: `bajo | medio | alto`. Each TL;DR field ≤ 2 sentences.
+
+### Boards → `ws board <TASK> <board-id> /tmp/ws-<TASK>/<board>.json`
+
+Default set (skip a board when it adds nothing, e.g. no tech map for a one-file fix):
+
+| board-id | kind | layout | What it shows |
+| --- | --- | --- | --- |
+| `story-map` | storymap | storymap | Actors → activities (columns, in order) → steps under each activity. Mark what changed. |
+| `flujo` | flow | lanes | Lanes `Antes` / `Después` with the same steps side by side, or one lane per variant. |
+| `testeo` | tests | lanes | One lane per test path; last node carries the result (`test`) and screenshot (`image`). |
+| `mapa-tecnico` | tech | lanes | One lane per repo; nodes = modules/files touched; edges = data flow between them. |
+| `ui` | ui | lanes | **Only if the change touched UI.** One lane per screen/state; `image` nodes with real screenshots (`status` new/changed). Skip entirely for backend-only work. |
+
+Board file shape (flat nodes — the CLI normalizes them):
+
+```json
+{
+  "title": "Flujos de testeo", "kind": "tests", "layout": "lanes", "direction": "LR", "order": 3,
+  "description": "Una línea que explica cómo leer el board.",
+  "nodes": [
+    { "id": "t1a", "lane": "1 · Reembolso parcial", "label": "Orden paga con loyalty" },
+    { "id": "t1b", "lane": "1 · Reembolso parcial", "label": "Puntos revocados", "test": "pass", "image": "assets/refund-partial.png" }
+  ],
+  "edges": [{ "from": "t1a", "to": "t1b", "label": "opcional", "dashed": false, "animated": false }]
+}
+```
+
+Never create `lane`-type nodes or set `parentId`/`position` — the app owns layout; put the lane name in each node's `lane`. If a write goes wrong, `ws undo <task> <board>` restores the previous version.
+
+Node fields: `id` (stable, short), `type` (`card` default | `actor` | `activity` | `note` | `image`), `label`, `detail`, `status` (`new | changed | same | removed | risk`), `test` (`pass | fail | todo | skip`), `repo`, `files` (array), `image` (`assets/…`), `lane` (lanes layout), `activity` (storymap: id of the activity column), `color` (hex, notes), `link`.
+
+Storymap specifics: `actor` nodes go in a left column; `activity` nodes become columns in array order (prefix labels with `1.`, `2.`…); steps reference their column with `activity`. Use a `note` (color `#fee2e2`) for pending items or risks outside scope.
+
+### Docs → `ws doc <TASK> <name>.md /tmp/ws-<TASK>/<name>.md`
+
+Only when they add value; usually just `decisiones.md` (table: decisión | por qué, plus rollout risks). No essays.
+
+## Content rules
+
+- **Labels ≤ 6 words.** `detail` ≤ 2 short lines. If it needs more, it belongs in a doc.
+- **Every step gets a `status`** in story map, flow and tech map, so colors tell the story: green new, orange changed, gray unchanged, purple risk/bug (use `risk` for the "before" problems).
+- **Test results must be real.** `pass`/`fail` only for paths that were actually exercised (tests run, manual QA, simulator); everything else is `todo`. Never invent results.
+- **Facts only from evidence** (diff, ticket, PR, conversation). If unsure, put it in a `note` as a question.
+- **Updating:** reuse the same ids. The CLI keeps positions the user arranged, keeps nodes the user edited (`edited`) or created (`manual`), and places new nodes next to their predecessor. Use `--relayout` only if the user asks to reorganize everything.
+
+## 4. Finish
+
+Run `ws open <TASK>` and reply with **one or two lines**: what boards were created/updated and anything that needs the user's attention (failed tests, open questions). Don't repeat the content in chat — it lives in the workspace.

package/src/api.mjs

@@ -0,0 +1,279 @@
+import fs from "node:fs";
+import path from "node:path";
+import * as store from "./store.mjs";
+import * as sessions from "./sessions.mjs";
+import * as chats from "./chats.mjs";
+import * as groups from "./groups.mjs";
+import * as projects from "./projects.mjs";
+import { listCommands } from "./commands.mjs";
+import { refreshStatus, startRefresh } from "./refresh.mjs";
+
+const MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".webmanifest": "application/manifest+json",
+  ".md": "text/markdown; charset=utf-8",
+  ".json": "application/json",
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript",
+  ".css": "text/css",
+  ".woff2": "font/woff2",
+};
+
+const ALLOWED_HOSTS = /^(localhost|127\.0\.0\.1)(:\d+)?$/;
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let raw = "";
+    req.on("data", (chunk) => (raw += chunk));
+    req.on("end", () => resolve(raw));
+    req.on("error", reject);
+  });
+}
+
+function send(res, status, body) {
+  res.statusCode = status;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(body ?? null));
+}
+
+export function serveStatic(res, root, rel) {
+  const file = path.resolve(root, rel);
+  if (!file.startsWith(root + path.sep) || !fs.existsSync(file) || !fs.statSync(file).isFile()) return false;
+  res.setHeader("Content-Type", MIME[path.extname(file).toLowerCase()] ?? "application/octet-stream");
+  fs.createReadStream(file).pipe(res);
+  return true;
+}
+
+/**
+ * The API can launch agents, so it only answers same-machine requests: the Host header must be
+ * localhost (blocks DNS rebinding) and mutating requests must come from the app's own origin
+ * with a JSON body (blocks other websites from posting to localhost).
+ */
+function isTrusted(req) {
+  if (!ALLOWED_HOSTS.test(req.headers.host ?? "")) return false;
+  if (req.method === "GET") return true;
+  const origin = req.headers.origin;
+  if (origin) {
+    try {
+      if (!ALLOWED_HOSTS.test(new URL(origin).host)) return false;
+    } catch {
+      return false;
+    }
+  }
+  return (req.headers["content-type"] ?? "").includes("application/json") || req.method === "DELETE";
+}
+
+function sessionList(days) {
+  const list = sessions.listSessions({ days });
+  const live = new Set(chats.liveChatIds());
+  const focus = chats.readSessionFocus();
+  for (const task of store.listTasks()) {
+    for (const s of sessions.sessionsForTask(task, list)) (s.taskIds ??= []).push(task.id);
+  }
+  for (const s of list) {
+    s.ownedByWorkspace = live.has(s.id);
+    s.focusCwd = focus[s.id] ?? null;
+    s.projectId = projects.projectForPath(focus[s.id] ?? s.firstCwd ?? s.cwd);
+  }
+  return list;
+}
+
+const withProjects = (task) => ({ ...task, projectIds: projects.projectsForTask(task) });
+
+function workingElsewhere(sessionId) {
+  const live = new Set(chats.liveChatIds());
+  return sessions
+    .listSessions({ days: 1 })
+    .filter((s) => s.status === "working" && !live.has(s.id))
+    .map((s) => s.id)
+    .filter((id) => id === sessionId);
+}
+
+async function handleChats(res, method, parts, body) {
+  const [, sessionId, action, actionId] = parts;
+  if (!sessionId && method === "POST") {
+    const prompt = String(body.prompt ?? "").trim();
+    if (!prompt) throw new Error("Escribí un mensaje");
+    return send(res, 200, await chats.startChat({ taskId: body.taskId, cwd: body.cwd, prompt, model: body.model, effort: body.effort, permissionMode: body.permissionMode, attachments: body.attachments ?? [] }));
+  }
+  if (sessionId && !action && method === "GET") return send(res, 200, chats.chatState(sessionId));
+  if (action === "messages" && method === "POST") {
+    const text = String(body.text ?? "").trim();
+    if (!text) throw new Error("Escribí un mensaje");
+    return send(res, 200, await chats.sendMessage(sessionId, text, { workingSessions: workingElsewhere(sessionId), model: body.model, effort: body.effort, permissionMode: body.permissionMode, attachments: body.attachments ?? [] }));
+  }
+  if (action === "interrupt" && method === "POST") return send(res, 200, await chats.interrupt(sessionId));
+  if (action === "config" && method === "POST") return send(res, 200, await chats.configure(sessionId, body));
+  if (action === "permissions" && actionId && method === "POST") return send(res, 200, chats.answerPermission(sessionId, actionId, body));
+  return send(res, 404, { error: "not found" });
+}
+
+function handleGroups(res, method, parts, body) {
+  const [, id, sub, sessionId] = parts;
+  if (!id && method === "GET") return send(res, 200, groups.listGroups());
+  if (!id && method === "POST") return send(res, 200, groups.createGroup(body));
+  if (id && !sub && method === "PUT") return send(res, 200, groups.updateGroup(id, body));
+  if (id && !sub && method === "DELETE") {
+    groups.deleteGroup(id);
+    return send(res, 200, { ok: true });
+  }
+  if (sub === "sessions" && !sessionId && method === "POST") return send(res, 200, groups.addSession(id, body.sessionId, body.title));
+  if (sub === "sessions" && sessionId && method === "DELETE") return send(res, 200, groups.removeSession(id, sessionId));
+  return send(res, 404, { error: "not found" });
+}
+
+/** Creates the request handler plus file watchers that broadcast `ws:data`, `ws:sessions`, `ws:groups` and `ws:chat` events. */
+export function createApi(broadcast) {
+  fs.mkdirSync(store.TASKS_DIR, { recursive: true });
+
+  let timer;
+  const pending = new Set();
+  fs.watch(store.TASKS_DIR, { recursive: true }, (_event, filename) => {
+    if (!filename || filename.endsWith(".tmp")) return;
+    pending.add(filename.split(path.sep)[0]);
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      broadcast("ws:data", { tasks: [...pending] });
+      pending.clear();
+    }, 150);
+  });
+
+  let sessionTimer;
+  const changedSessions = new Set();
+  if (fs.existsSync(sessions.PROJECTS_DIR)) {
+    fs.watch(sessions.PROJECTS_DIR, { recursive: true }, (_event, filename) => {
+      if (!filename?.endsWith(".jsonl")) return;
+      const id = sessions.sessionIdFromPath(filename);
+      if (!id) return;
+      changedSessions.add(id);
+      clearTimeout(sessionTimer);
+      sessionTimer = setTimeout(() => {
+        broadcast("ws:sessions", { ids: [...changedSessions] });
+        changedSessions.clear();
+      }, 300);
+    });
+  }
+
+  let groupsTimer;
+  fs.watch(store.DATA_DIR, (_event, filename) => {
+    if (filename !== path.basename(groups.GROUPS_FILE)) return;
+    clearTimeout(groupsTimer);
+    groupsTimer = setTimeout(() => broadcast("ws:groups", {}), 100);
+  });
+
+  chats.onChatChange((sessionId) => broadcast("ws:chat", { sessionId, state: chats.chatState(sessionId) }));
+
+  return async function handle(req, res, next) {
+    if (!isTrusted(req)) return send(res, 403, { error: "forbidden" });
+    if (req.url.startsWith("/files/")) {
+      const rel = decodeURIComponent(req.url.replace(/^\/files\//, "").split("?")[0]);
+      return serveStatic(res, store.TASKS_DIR, rel) || next();
+    }
+    if (!req.url.startsWith("/api/")) return next();
+
+    const url = new URL(req.url, "http://localhost");
+    const parts = url.pathname.split("/").filter(Boolean).slice(1).map(decodeURIComponent);
+    const method = req.method;
+    try {
+      const body = ["PUT", "POST"].includes(method) ? JSON.parse((await readBody(req)) || "{}") : undefined;
+      const [resource, id, sub, subId] = parts;
+
+      if (resource === "health") return send(res, 200, { app: "mono", ok: true });
+      if (resource === "chats") return await handleChats(res, method, parts, body);
+      if (resource === "groups") return handleGroups(res, method, parts, body);
+      if (resource === "models" && method === "GET") return send(res, 200, chats.listModels());
+      if (resource === "commands" && method === "GET") return send(res, 200, listCommands(url.searchParams.get("cwd") ? chats.expandHome(url.searchParams.get("cwd")) : null));
+      if (resource === "uploads" && method === "POST") return send(res, 200, chats.saveUpload(body));
+      if (resource === "uploads" && method === "GET" && id === "file") {
+        const file = path.resolve(url.searchParams.get("path") ?? "");
+        return file.startsWith(chats.UPLOADS_DIR + path.sep) && serveStatic(res, path.dirname(file), path.basename(file)) ? undefined : send(res, 404, { error: "not found" });
+      }
+      if (resource === "projects") {
+        if (!id && method === "GET") return send(res, 200, projects.listProjects({ fresh: url.searchParams.has("fresh") }).map(({ favicon, ...p }) => ({ ...p, hasIcon: Boolean(favicon) })));
+        if (id && sub === "icon" && method === "GET") {
+          const icon = projects.projectIcon(id);
+          return icon && serveStatic(res, path.dirname(icon), path.basename(icon)) ? undefined : send(res, 404, { error: "not found" });
+        }
+        if (id && !sub && method === "PUT") return send(res, 200, projects.saveOverride(id, { title: body.title || undefined, color: body.color || undefined }));
+        if (id && sub === "worktrees" && method === "GET") {
+          return projects.listProjects().some((p) => p.id === id) ? send(res, 200, chats.worktreesForProject(id)) : send(res, 404, { error: "not found" });
+        }
+        return send(res, 404, { error: "not found" });
+      }
+      if (resource === "sessions") {
+        if (!id) return send(res, 200, sessionList(Number(url.searchParams.get("days") ?? 3)));
+        const since = url.searchParams.get("since");
+        const detail = sessions.readSessionEvents(id, { since: since === null ? undefined : Number(since), agent: url.searchParams.get("agent") ?? undefined });
+        return detail ? send(res, 200, detail) : send(res, 404, { error: "not found" });
+      }
+      if (resource !== "tasks") return send(res, 404, { error: "not found" });
+
+      if (id && sub === "worktrees" && method === "GET") {
+        const task = store.getTask(id);
+        const roots = projects.listProjects().filter((p) => projects.projectsForTask(task ?? {}).includes(p.id)).map((p) => p.root);
+        return send(res, 200, chats.worktreesForTask(task, roots));
+      }
+      if (id && sub === "refresh") {
+        if (method === "POST") return send(res, 200, startRefresh(id));
+        if (method === "GET") return send(res, 200, refreshStatus(id));
+      }
+
+      if (!id) {
+        if (method === "GET") return send(res, 200, store.listTasks().map(withProjects));
+        if (method === "POST") {
+          store.assertSafe(body.id);
+          return send(res, 200, store.saveTask(body.id, body));
+        }
+      }
+
+      if (id && !sub) {
+        if (method === "GET") {
+          const task = store.getTask(id);
+          return task ? send(res, 200, withProjects(task)) : send(res, 404, { error: "not found" });
+        }
+        if (method === "PUT") return send(res, 200, withProjects(store.saveTask(id, body)));
+        if (method === "DELETE") {
+          store.trashTask(id);
+          return send(res, 200, { ok: true });
+        }
+      }
+
+      if (sub === "boards" && subId && parts[4] === "undo" && method === "POST") {
+        const restored = store.restoreBoard(id, subId);
+        return send(res, 200, { restored, remaining: store.boardHistory(id, subId).length });
+      }
+      if (sub === "boards" && subId && parts[4] === "history" && method === "GET") return send(res, 200, store.boardHistory(id, subId));
+      if (sub === "boards" && subId) {
+        if (method === "GET") {
+          const board = store.getBoard(id, subId);
+          return board ? send(res, 200, board) : send(res, 404, { error: "not found" });
+        }
+        if (method === "PUT") return send(res, 200, store.saveBoard(id, subId, body));
+        if (method === "DELETE") {
+          store.deleteBoard(id, subId);
+          return send(res, 200, { ok: true });
+        }
+      }
+
+      if (sub === "docs" && subId) {
+        if (method === "GET") {
+          const doc = store.getDoc(id, subId);
+          return doc === null ? send(res, 404, { error: "not found" }) : send(res, 200, { name: subId, content: doc });
+        }
+        if (method === "PUT") {
+          store.saveDoc(id, subId, body.content ?? "");
+          return send(res, 200, { ok: true });
+        }
+      }
+
+      return send(res, 404, { error: "not found" });
+    } catch (error) {
+      return send(res, 400, { error: String(error.message ?? error) });
+    }
+  };
+}