@loicngr/kobo 0.1.1

package/README.md

@@ -0,0 +1,199 @@
+# Kōbō
+
+> **Kōbō** (工房) — Japanese for *workshop*. A multi-workspace agent manager for [Claude Code](https://claude.com/claude-code).
+
+Kōbō lets you delegate multiple coding missions to Claude Code agents in parallel. Each workspace lives in its own isolated git worktree with its own branch, its own Claude session, optionally its own dev server, and a custom MCP tools server the agent uses to track progress. A Vue 3 dashboard shows live agent output, tasks, acceptance criteria, and git state across every workspace.
+
+Think of it as an apprentice's hall: you hand out missions, each apprentice sets up their own workbench, and you watch them work from a single control surface.
+
+## Features
+
+- **Isolated git worktrees** — every workspace runs on its own branch in its own directory, so concurrent Claude sessions never step on each other
+- **Live agent output** — stream `stdout`/`stderr` from Claude Code to the browser via WebSocket, with persisted event replay on reconnect
+- **Task & acceptance criteria tracking** — the agent reports progress through a dedicated MCP server (`kobo-tasks`) that reads and updates tasks directly from the SQLite database
+- **Notion integration** — pull workspace missions straight from Notion pages, extract markdown, and use it as the source of truth for acceptance criteria
+- **Per-workspace dev servers** — start/stop Docker or Node dev servers scoped to each branch, with log streaming
+- **Conventional-commit enforcement** — project-level git conventions are written to `.ai/git-conventions.md` inside every workspace so Claude follows them during commits
+- **Pull request automation** — one-click `push` and `open-pr` endpoints integrate with the GitHub CLI, using a configurable prompt template
+- **Archive instead of delete** — soft-remove workspaces without losing the worktree, branches, or history; unarchive restores the exact pre-archive state
+
+## Tech stack
+
+- **Backend** — Node.js ≥ 20, [Hono](https://hono.dev/), [better-sqlite3](https://github.com/WiseLibs/better-sqlite3), [ws](https://github.com/websockets/ws), [`@modelcontextprotocol/sdk`](https://github.com/modelcontextprotocol/typescript-sdk)
+- **Frontend** — [Vue 3](https://vuejs.org/), [Quasar 2](https://quasar.dev/), [Pinia](https://pinia.vuejs.org/), `vue-router`
+- **Tooling** — TypeScript, [Vitest](https://vitest.dev/), [Biome](https://biomejs.dev/) (lint + format), `tsx` for dev
+- **Storage** — single SQLite file (`~/.config/kobo/kobo.db` by default, overridable via `KOBO_HOME`) with WAL mode
+
+## Quick start
+
+### Prerequisites
+
+- Node.js ≥ 20
+- [Claude Code CLI](https://claude.com/claude-code) installed and authenticated (`claude` on your `PATH`)
+- Git
+- Optional: Docker (if you configure per-workspace dev servers)
+- Optional: `gh` CLI (if you use the PR automation)
+- Optional: a Notion integration token (only if you want to import workspace missions from Notion pages — see [Notion integration](#notion-integration))
+
+### Run via `npx` (recommended)
+
+```bash
+PORT=9999 npx @loicngr/kobo@latest
+```
+
+That's it. npm downloads the package, installs dependencies, starts the Kōbō server on the port you specified, and serves the web UI at `http://localhost:9999`. Data is persisted to `~/.config/kobo/` (overridable via `KOBO_HOME`).
+
+On first launch Kōbō creates `~/.config/kobo/` if it doesn't exist. If the `claude` CLI is missing from your `PATH` you will see a warning in the terminal — install Claude Code before creating your first workspace.
+
+### Run from source (contributors)
+
+```bash
+git clone https://github.com/loicngr/kobo.git
+cd kobo
+npm install
+(cd src/client && npm install)
+```
+
+### Run (development)
+
+```bash
+npm run dev:all
+```
+
+This starts the Hono backend on port `3000` (via `tsx watch`, with `KOBO_HOME=./data` so dev uses the repo-local data directory and never touches your real `~/.config/kobo/`) and the Quasar dev server on port `8080` concurrently. Open <http://localhost:8080> in your browser.
+
+You can run a production-installed Kōbō (`npx @loicngr/kobo`) alongside a dev server without any conflict — they use different data directories by design.
+
+To run them separately:
+
+```bash
+npm run dev         # backend only (KOBO_HOME=./data automatically)
+npm run dev:client  # frontend only
+```
+
+### Build (production)
+
+```bash
+npm run build       # builds client + server
+npm start           # runs the compiled server
+```
+
+### Test & lint
+
+```bash
+npm test            # full vitest suite (366+ tests)
+npm run lint        # biome check (lint + format verification)
+npm run lint:fix    # biome check with safe auto-fixes
+npm run format      # biome format --write
+npx tsc --noEmit    # server type check
+```
+
+## Notion integration
+
+Kōbō can pull the content of a Notion page (title, body, checklists) and turn it into tasks and acceptance criteria when you create a workspace. **This feature is opt-in and requires you to configure your own Notion credentials** — Kōbō does not ship an API key.
+
+Under the hood, Kōbō spawns the official [`@notionhq/notion-mcp-server`](https://github.com/makenotion/notion-mcp-server) as a child process and talks to it over stdio using the Model Context Protocol. The package is fetched via `npx -y @notionhq/notion-mcp-server` the first time you trigger an import, so there is nothing to install manually — only a token to provide.
+
+### Getting a Notion integration token
+
+1. Go to <https://www.notion.so/profile/integrations> and create a new internal integration
+2. Give it a name (e.g. `kobo`) and the capabilities you need (at minimum: *Read content*)
+3. Copy the internal integration secret (format `ntn_...` or `secret_...`)
+4. Open the Notion page you want to import, click **…** → **Connections** → **Add connection** → select your integration. Kōbō can only read pages that are explicitly shared with the integration.
+
+### Giving the token to Kōbō
+
+Kōbō reads the token from the first source available, in this order:
+
+1. `NOTION_API_TOKEN` environment variable
+2. `NOTION_TOKEN` environment variable
+3. `~/.claude.json` — if you already have the Notion MCP configured for Claude Code, Kōbō reads the token from `mcpServers.notion.env.NOTION_TOKEN` (or `NOTION_API_TOKEN`). **This is the recommended setup** — one token configured once, shared by both Claude Code and Kōbō.
+
+Example: configure Notion MCP in Claude Code (one-time setup that also unlocks Kōbō's Notion import):
+
+```bash
+claude mcp add notion -s user -e NOTION_TOKEN=ntn_your_token_here -- npx -y @notionhq/notion-mcp-server
+```
+
+Or launch Kōbō with the token inline:
+
+```bash
+NOTION_API_TOKEN=ntn_your_token_here PORT=9999 npx @loicngr/kobo@latest
+```
+
+### Advanced: overriding the MCP command
+
+If you need to pin a specific version of the Notion MCP server, use a fork, or avoid `npx`, set these env vars before launching Kōbō:
+
+- `NOTION_MCP_COMMAND` — the binary to run (default: `npx`)
+- `NOTION_MCP_ARGS` — space-separated arguments (default: `-y @notionhq/notion-mcp-server`)
+
+Without a valid token configured, the Notion import field in the workspace creation form will return an error when you click **Refresh** or submit a Notion URL — the rest of Kōbō (workspaces, agents, tasks, Git integration) keeps working independently.
+
+## Architecture
+
+```
+src/
+├── server/                         # Hono backend
+│   ├── index.ts                    # app bootstrap + WS upgrade
+│   ├── db/                         # SQLite schema and singleton
+│   ├── services/                   # business logic (workspace, agent, dev-server, ws, notion, settings, pr-template)
+│   ├── routes/                     # Hono handlers
+│   └── utils/                      # git-ops, process-tracker
+├── client/                         # Vue 3 + Quasar SPA
+│   └── src/
+│       ├── stores/                 # Pinia state management
+│       ├── components/             # WorkspaceList, NotionPanel, ChatInput, GitPanel, …
+│       ├── pages/                  # WorkspacePage, CreatePage, SettingsPage
+│       └── router/
+├── mcp-server/                     # Standalone MCP server spawned per workspace
+│   ├── kobo-tasks-server.ts        # entry point, registers list_tasks & mark_task_done
+│   └── kobo-tasks-handlers.ts      # pure handlers over SQLite
+└── __tests__/                      # Vitest suite
+```
+
+See [`AGENTS.md`](./AGENTS.md) for a deeper dive into conventions, data model, WebSocket protocol, and contribution guidelines.
+
+## Data model
+
+| Table | Purpose |
+|---|---|
+| `workspaces` | the unit of work — branch, status, Notion link, model, `archived_at`, … |
+| `tasks` | workspace sub-items — tasks and acceptance criteria |
+| `agent_sessions` | Claude Code CLI invocations — `claude_session_id`, pid, lifecycle |
+| `ws_events` | persisted WebSocket events for replay on reconnect |
+
+## MCP server
+
+Each workspace spawns its own `kobo-tasks` MCP server as a child process of the Claude Code agent. It exposes two tools:
+
+- `list_tasks()` — returns all tasks & acceptance criteria for the current workspace with their IDs and status
+- `mark_task_done(task_id)` — marks a task as done and notifies the backend over HTTP so the UI updates live
+
+The MCP server reads and writes the same SQLite database as the main backend. Isolation between workspaces is enforced via the `KOBO_WORKSPACE_ID` environment variable passed at spawn time and validated on every query.
+
+## Configuration
+
+Kōbō reads settings from `~/.config/kobo/settings.json` (or falls back to defaults). Global settings cascade into per-project overrides:
+
+- `defaultModel` — Claude model to use (e.g. `claude-opus-4-6`)
+- `prPromptTemplate` — template rendered when opening a PR via the `/open-pr` endpoint; supports `{{pr_number}}`, `{{pr_url}}`, `{{branch_name}}`, `{{diff_stats}}`, `{{commits}}`, etc.
+- `gitConventions` — markdown-formatted git conventions written to `.ai/git-conventions.md` in every workspace so the agent follows them when committing
+- `devServer` — per-project `startCommand` / `stopCommand` for launching workspace-scoped dev servers
+
+## Contributing
+
+This is a personal tool, but PRs and issues are welcome. Before submitting:
+
+1. Read [`AGENTS.md`](./AGENTS.md) — it covers the commit rules, branching model, and code conventions
+2. Run `npm run lint`, `npx tsc --noEmit`, and `npm test` locally
+3. Base your branch on `develop` (not `main`); PRs target `develop`
+4. **Do not add `Co-Authored-By` trailers** in commits, even for AI-assisted work
+
+CI runs lint + type check + tests on every PR to `develop`.
+
+## License
+
+GNU General Public License v3.0 or later. See [`LICENSE`](./LICENSE) for the full text.
+
+Kōbō links against [`better-sqlite3`](https://github.com/WiseLibs/better-sqlite3), [`@modelcontextprotocol/sdk`](https://github.com/modelcontextprotocol/typescript-sdk), [Vue](https://vuejs.org/), [Quasar](https://quasar.dev/), and other open-source libraries — see `package.json` for the full list.

package/dist/mcp-server/kobo-tasks-handlers.js

@@ -0,0 +1,27 @@
+function rowToDto(row) {
+    return {
+        id: row.id,
+        title: row.title,
+        status: row.status,
+        is_acceptance_criterion: row.is_acceptance_criterion === 1,
+    };
+}
+export function listTasksHandler(db, workspaceId) {
+    const rows = db
+        .prepare('SELECT id, title, status, is_acceptance_criterion FROM tasks WHERE workspace_id = ? ORDER BY sort_order ASC')
+        .all(workspaceId);
+    return rows.map(rowToDto);
+}
+export function markTaskDoneHandler(db, workspaceId, taskId) {
+    const now = new Date().toISOString();
+    const result = db
+        .prepare('UPDATE tasks SET status = ?, updated_at = ? WHERE id = ? AND workspace_id = ?')
+        .run('done', now, taskId, workspaceId);
+    if (result.changes === 0) {
+        throw new Error(`Task '${taskId}' not found in workspace '${workspaceId}'`);
+    }
+    const row = db
+        .prepare('SELECT id, title, status, is_acceptance_criterion FROM tasks WHERE id = ?')
+        .get(taskId);
+    return { success: true, task: rowToDto(row) };
+}

package/dist/mcp-server/kobo-tasks-server.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import Database from 'better-sqlite3';
+import { listTasksHandler, markTaskDoneHandler } from './kobo-tasks-handlers.js';
+const workspaceId = process.env.KOBO_WORKSPACE_ID;
+const dbPath = process.env.KOBO_DB_PATH;
+const backendUrl = process.env.KOBO_BACKEND_URL ?? 'http://localhost:3000';
+if (!workspaceId) {
+    console.error('[kobo-tasks-server] KOBO_WORKSPACE_ID env var is required');
+    process.exit(1);
+}
+if (!dbPath) {
+    console.error('[kobo-tasks-server] KOBO_DB_PATH env var is required');
+    process.exit(1);
+}
+let db;
+try {
+    db = new Database(dbPath, { readonly: false });
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+}
+catch (err) {
+    console.error('[kobo-tasks-server] Failed to open database:', err);
+    process.exit(1);
+}
+async function notifyBackend(taskId) {
+    try {
+        const url = `${backendUrl}/api/workspaces/${workspaceId}/tasks/${taskId}/notify-done`;
+        const res = await fetch(url, { method: 'POST' });
+        if (!res.ok) {
+            console.error(`[kobo-tasks-server] notify-done HTTP ${res.status}`);
+        }
+    }
+    catch (err) {
+        console.error('[kobo-tasks-server] notify-done failed:', err);
+    }
+}
+const server = new Server({ name: 'kobo-tasks', version: '1.0.0' }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: 'list_tasks',
+            description: 'List all tasks and acceptance criteria for the current workspace with their IDs and current status. Call this first to discover task IDs before calling mark_task_done.',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+                required: [],
+            },
+        },
+        {
+            name: 'mark_task_done',
+            description: 'Mark a task or acceptance criterion as done. Use this when you have completed the work for a criterion and validated it.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    task_id: {
+                        type: 'string',
+                        description: 'The ID of the task to mark as done (obtained from list_tasks)',
+                    },
+                },
+                required: ['task_id'],
+            },
+        },
+    ],
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    if (name === 'list_tasks') {
+        const tasks = listTasksHandler(db, workspaceId);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(tasks, null, 2) }],
+        };
+    }
+    if (name === 'mark_task_done') {
+        const taskId = args?.task_id;
+        if (!taskId) {
+            return {
+                content: [{ type: 'text', text: 'Error: task_id parameter is required' }],
+                isError: true,
+            };
+        }
+        try {
+            const result = markTaskDoneHandler(db, workspaceId, taskId);
+            void notifyBackend(taskId);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: 'text', text: `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    }
+    return {
+        content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+        isError: true,
+    };
+});
+const transport = new StdioServerTransport();
+server.connect(transport).catch((err) => {
+    console.error('[kobo-tasks-server] Fatal:', err);
+    process.exit(1);
+});
+process.on('SIGTERM', () => {
+    db.close();
+    process.exit(0);
+});
+process.on('SIGINT', () => {
+    db.close();
+    process.exit(0);
+});

package/dist/server/db/index.js

@@ -0,0 +1,22 @@
+import Database from 'better-sqlite3';
+import { ensureKoboHome, getDbPath } from '../utils/paths.js';
+let instance = null;
+export function getDb(dbPath) {
+    if (instance)
+        return instance;
+    let resolvedPath = dbPath;
+    if (!resolvedPath) {
+        ensureKoboHome();
+        resolvedPath = getDbPath();
+    }
+    instance = new Database(resolvedPath);
+    instance.pragma('journal_mode=WAL');
+    instance.pragma('foreign_keys=ON');
+    return instance;
+}
+export function closeDb() {
+    if (instance) {
+        instance.close();
+        instance = null;
+    }
+}

package/dist/server/db/migrations.js

@@ -0,0 +1,20 @@
+import { initSchema } from './schema.js';
+export const SCHEMA_VERSION = 1;
+export function runMigrations(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_version (
+      version INTEGER NOT NULL
+    )
+  `);
+    const row = db.prepare('SELECT version FROM schema_version LIMIT 1').get();
+    const currentVersion = row?.version ?? 0;
+    if (currentVersion < 1) {
+        initSchema(db);
+        if (currentVersion === 0) {
+            db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(1);
+        }
+        else {
+            db.prepare('UPDATE schema_version SET version = ?').run(1);
+        }
+    }
+}

package/dist/server/db/schema.js

@@ -0,0 +1,49 @@
+export function initSchema(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS workspaces (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      project_path TEXT NOT NULL,
+      source_branch TEXT NOT NULL,
+      working_branch TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'created',
+      notion_url TEXT,
+      notion_page_id TEXT,
+      model TEXT NOT NULL DEFAULT 'claude-opus-4-6',
+      dev_server_status TEXT NOT NULL DEFAULT 'stopped',
+      archived_at TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+      title TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending',
+      is_acceptance_criterion INTEGER DEFAULT 0,
+      sort_order INTEGER DEFAULT 0,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS agent_sessions (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+      pid INTEGER,
+      claude_session_id TEXT,
+      status TEXT NOT NULL DEFAULT 'running',
+      started_at TEXT NOT NULL,
+      ended_at TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS ws_events (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+      type TEXT NOT NULL,
+      payload TEXT NOT NULL,
+      session_id TEXT,
+      created_at TEXT NOT NULL
+    );
+  `);
+}

package/dist/server/index.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { serve } from '@hono/node-server';
+import { Hono } from 'hono';
+import { WebSocketServer } from 'ws';
+import { getDb } from './db/index.js';
+import { runMigrations } from './db/migrations.js';
+import devServerRouter from './routes/dev-server.js';
+import gitRouter from './routes/git.js';
+import notionRouter from './routes/notion.js';
+import settingsRouter from './routes/settings.js';
+import workspacesRouter from './routes/workspaces.js';
+import { getAvailableSkills, sendMessage, startAgent, stopAgent } from './services/agent-manager.js';
+import { startDevServer, stopDevServer } from './services/dev-server-service.js';
+import { emit, handleConnection, setMessageHandler } from './services/websocket-service.js';
+import { getLatestSession, getWorkspace, updateWorkspaceStatus } from './services/workspace-service.js';
+import { getClientSpaPath, getKoboHome } from './utils/paths.js';
+import { initProcessCleanup } from './utils/process-tracker.js';
+// 0. Runtime prerequisite check — warn if claude CLI is missing. Don't block
+// startup: the user may still want to configure settings or browse workspaces
+// before installing Claude Code.
+{
+    const check = spawnSync('claude', ['--version'], { stdio: 'ignore' });
+    if (check.error && check.error.code === 'ENOENT') {
+        console.warn("[kobo] WARNING: 'claude' CLI not found on PATH. Kōbō will fail to spawn agents until Claude Code is installed. See https://claude.com/claude-code");
+    }
+}
+console.log(`[kobo] Kōbō home: ${getKoboHome()}`);
+// 1. Initialize DB + run migrations
+const db = getDb();
+runMigrations(db);
+// 2. Initialize process cleanup
+initProcessCleanup();
+// 3. Create Hono app
+const app = new Hono();
+// Health check (root / is handled by the SPA catch-all below)
+app.get('/api/health', (c) => c.json({ status: 'ok', version: '0.1.0' }));
+// 4. Mount route sub-routers
+app.route('/api/workspaces', workspacesRouter);
+app.route('/api/notion', notionRouter);
+app.route('/api/git', gitRouter);
+app.route('/api/settings', settingsRouter);
+app.route('/api/dev-server', devServerRouter);
+// Skills endpoint
+app.get('/api/skills', (c) => c.json(getAvailableSkills()));
+const PORT = process.env.PORT ? parseInt(process.env.PORT, 10) : 3000;
+// 9. Serve static files from the built SPA if present (production mode).
+// The path is resolved relative to the package install directory, so this
+// works both in dev (tsx running from src/) and when installed via npm / npx
+// (node running from dist/).
+const clientDistPath = getClientSpaPath();
+if (clientDistPath) {
+    app.get('*', async (c) => {
+        const url = new URL(c.req.url);
+        let filePath = path.join(clientDistPath, url.pathname);
+        // Prevent path traversal
+        if (!path.resolve(filePath).startsWith(clientDistPath)) {
+            return c.notFound();
+        }
+        // Serve index.html for non-asset routes (SPA fallback)
+        if (!fs.existsSync(filePath) || fs.statSync(filePath).isDirectory()) {
+            filePath = path.join(clientDistPath, 'index.html');
+        }
+        if (!fs.existsSync(filePath)) {
+            return c.notFound();
+        }
+        const content = fs.readFileSync(filePath);
+        const ext = path.extname(filePath);
+        const mimeTypes = {
+            '.html': 'text/html',
+            '.js': 'application/javascript',
+            '.css': 'text/css',
+            '.json': 'application/json',
+            '.png': 'image/png',
+            '.jpg': 'image/jpeg',
+            '.svg': 'image/svg+xml',
+            '.ico': 'image/x-icon',
+            '.woff': 'font/woff',
+            '.woff2': 'font/woff2',
+        };
+        const contentType = mimeTypes[ext] ?? 'application/octet-stream';
+        return new Response(content, {
+            headers: { 'Content-Type': contentType },
+        });
+    });
+}
+// 5. Create HTTP server via @hono/node-server
+const server = serve({
+    fetch: app.fetch,
+    port: PORT,
+}, (info) => {
+    console.log(`Server running at http://localhost:${info.port}`);
+});
+// 6. Create WebSocketServer attached to the HTTP server
+const wss = new WebSocketServer({ noServer: true });
+// 7. Wire WebSocket connections to websocket-service.handleConnection()
+wss.on('connection', (ws) => {
+    handleConnection(ws);
+});
+// 8. Wire websocket-service message handler to agent-manager
+setMessageHandler((type, payload) => {
+    const p = payload;
+    if (type === 'chat:message' && p?.workspaceId && p?.content) {
+        // Persist user message so it survives page refresh
+        const latestSession = getLatestSession(p.workspaceId);
+        emit(p.workspaceId, 'user:message', { content: p.content, sender: 'user' }, latestSession?.claudeSessionId ?? undefined);
+        try {
+            sendMessage(p.workspaceId, p.content);
+        }
+        catch {
+            // Agent not running — resume the existing session
+            try {
+                const workspace = getWorkspace(p.workspaceId);
+                if (workspace) {
+                    const worktreePath = `${workspace.projectPath}/.worktrees/${workspace.workingBranch}`;
+                    startAgent(p.workspaceId, worktreePath, p.content, workspace.model, true);
+                    updateWorkspaceStatus(p.workspaceId, 'executing');
+                }
+            }
+            catch (restartErr) {
+                console.error('[ws] Failed to resume agent:', restartErr instanceof Error ? restartErr.message : restartErr);
+            }
+        }
+    }
+    if (type === 'workspace:start' && p?.workspaceId) {
+        try {
+            const workspace = getWorkspace(p.workspaceId);
+            if (!workspace) {
+                console.error(`[ws] workspace:start — workspace '${p.workspaceId}' not found`);
+                return;
+            }
+            const worktreePath = `${workspace.projectPath}/.worktrees/${workspace.workingBranch}`;
+            const prompt = p.prompt ?? 'Continue the previous task where you left off.';
+            startAgent(p.workspaceId, worktreePath, prompt, workspace.model);
+        }
+        catch (err) {
+            console.error('[ws] Failed to start agent:', err);
+        }
+    }
+    if (type === 'workspace:stop' && p?.workspaceId) {
+        try {
+            stopAgent(p.workspaceId);
+        }
+        catch (err) {
+            console.error('[ws] Failed to stop agent:', err);
+        }
+    }
+    if (type === 'devserver:start' && p?.workspaceId) {
+        try {
+            startDevServer(p.workspaceId);
+        }
+        catch (err) {
+            console.error('[ws] Failed to start dev-server:', err);
+        }
+    }
+    if (type === 'devserver:stop' && p?.workspaceId) {
+        try {
+            stopDevServer(p.workspaceId);
+        }
+        catch (err) {
+            console.error('[ws] Failed to stop dev-server:', err);
+        }
+    }
+});
+// Handle WebSocket upgrade requests on /ws path
+server.on('upgrade', (request, socket, head) => {
+    const { pathname } = new URL(request.url ?? '/', `http://localhost:${PORT}`);
+    if (pathname === '/ws') {
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            wss.emit('connection', ws, request);
+        });
+    }
+    else {
+        socket.destroy();
+    }
+});