conductor-remote 1.117.0 → 1.118.0

package/dist-node/src/mcp-tools.js

@@ -1,1319 +0,0 @@
-/**
- * The MCP tools, and the JSON-RPC dispatcher that serves them.
- *
- * Shared by both transports, which is the only reason they can't drift: `src/mcp.ts`
- * runs this over stdio as a separate process, and `src/server.ts` mounts the same
- * dispatcher at `POST /mcp` for clients that can only reach a URL.
- *
- * The tool set tracks `/api`, minus the routes that only exist to back a button on the
- * phone. An agent needs no `merge` (it holds `gh`, and `send_prompt` can ask the agent
- * that owns the branch), no push subscription, and no settings editor. What it does need
- * is everything it cannot reach any other way: the model/effort/plan/fast controls, which
- * live in Conductor's UI and nowhere else, the prompts the relay is holding on its behalf,
- * the sleep window that keeps this Mac reachable at all, and the relay's own log.
- *
- * Every tool is an HTTP call to the relay, injected as `call`, and that is the
- * load-bearing decision rather than a convenience. Conductor has one shared window,
- * so the only thing that makes writes safe is `writes.ts` ▸ `uiTurn`, backed by the
- * coordinator's relay-shared mutex. A tool that drove AppleScript itself would sit
- * outside it, and two agents focusing different workspaces would land each other's
- * prompts — the exact failure every fail-closed assertion cannot catch. Routed through
- * the relay, the phone, delivery queues and every agent share the same gate.
- *
- * The in-relay transport calls the relay's own API over loopback rather than reaching
- * into `reads`/`writes` directly. That is a sub-millisecond hop against a 1000-line
- * router it would otherwise have to be carved out of, and it keeps *one* code path:
- * a tool cannot behave differently over HTTP than it does over stdio.
- */
-import { chatCursor, parseChatCursor } from "./chat-cursor.js";
-import { routes } from "./routes.js";
-import { HIT_CLOSE, HIT_OPEN, isToolResult, timestampMs, workspaceTitle } from "./shared.js";
-/** Versions we know how to speak. The client's choice wins when we know it. */
-export const PROTOCOL_VERSIONS = ['2025-06-18', '2025-03-26', '2024-11-05'];
-export const SERVER_INFO = { name: 'conductor-remote', version: '1' };
-export const INSTRUCTIONS = 'Drives local Conductor agents through the conductor-remote relay. search_chats and read_chat reach archived workspaces, which is where most finished work lives. list_voice_calls, search_voice_calls and read_voice_call read saved fleet-call transcripts without driving the UI. Use delegate_task for lightweight codebase agents in tracked sibling subtabs: list_roles shows the configured roles and their current models, then an ordinary chat supplies session_id, role, and a focused prompt. Choose a configured role whose instructions fit the task, usually exploration for independent code searches, investigation, and verification, including helper work requested by skills such as gstack. Use the configured role settings even when a skill names a model. Each task returns its result to its parent; several independent explorers can run concurrently without starting a planning/exploration/implementation Workflow. Continue useful local work while they run; use return_mode=steer if their result is needed during the current turn, since the default queue delivers behind it. Inside an active Workflow, only its root may delegate, using the workflow_id and current phase_capability from its private envelope. Never bypass that path through ordinary delegation or untracked splits. MCP cannot start a Workflow, edit its frozen roles, or perform recovery actions. delegate_task returns immediately; the relay later drives the real Mac UI to open, configure, and send the child. create_workspace opens its workspace link without direct UI control; requested agent settings and the first prompt are applied later through Conductor’s UI. plan_usage, dev_server status, dismiss_prompt, keep_awake and relay_logs touch no UI. Use dev_server instead of launching a long-lived development server from a shell: its start/stop actions use Conductor’s configured Run task, drive the real Mac UI and steal focus for a few seconds. send_prompt, split_chat, stop_turn, close_chat, set_agent_options, set_default_model, a live list_models call, set_workspace_status and archive_workspace also drive the real Mac UI and steal focus for a few seconds — confirm with the user before using them on a chat or workspace they did not name. archive_workspace also deletes the worktree and stops whatever is running there.';
-/** Reads are quick; a UI write is measured in tens of seconds (writes.ts ▸ SEND_ATTEMPT_MS). */
-export const READ_TIMEOUT_MS = 10_000;
-export const WRITE_TIMEOUT_MS = 75_000;
-// ── formatting ──────────────────────────────────────────────────────────────────
-// Tool results are text an agent reads, so they are formatted rather than dumped as
-// JSON: half the tokens, and every id an agent needs to chain the next call stays
-// visible instead of buried in a nested object.
-function unmark(text) {
-    return text.replaceAll(HIT_OPEN, '«').replaceAll(HIT_CLOSE, '»').replace(/\s+/g, ' ').trim();
-}
-function clip(text, max) {
-    return text.length > max ? `${text.slice(0, max)}… [${text.length - max} more chars]` : text;
-}
-/** A true output bound: unlike `clip`, the truncation marker is inside `max`. */
-function clipExact(text, max) {
-    if (text.length <= max)
-        return text;
-    const suffix = '… [truncated]';
-    if (max <= suffix.length)
-        return text.slice(0, max);
-    return `${text.slice(0, max - suffix.length)}${suffix}`;
-}
-/**
- * Fit a transcript inside one MCP result without dropping either side of a nearby
- * read. Short entries keep their full text; the longest entries share what remains.
- */
-function boundedTranscript(header, entries, maxChars) {
-    const prefix = header.length ? `${header.join('\n')}\n\n` : '';
-    if (!entries.length)
-        return clipExact(prefix.trim(), maxChars);
-    const separators = Math.max(0, entries.length - 1) * 2;
-    const available = Math.max(1, maxChars - prefix.length - separators);
-    const fullLength = entries.reduce((sum, entry) => sum + entry.length, 0);
-    if (fullLength <= available)
-        return `${prefix}${entries.join('\n\n')}`;
-    // Find the largest per-entry ceiling whose clipped rows fit. Entries shorter than
-    // it return their unused share to the longer ones, unlike a fixed equal split.
-    let low = 1;
-    let high = Math.max(...entries.map(entry => entry.length));
-    while (low < high) {
-        const mid = Math.ceil((low + high) / 2);
-        const used = entries.reduce((sum, entry) => sum + Math.min(entry.length, mid), 0);
-        if (used <= available)
-            low = mid;
-        else
-            high = mid - 1;
-    }
-    return clipExact(`${prefix}${entries.map(entry => clipExact(entry, low)).join('\n\n')}`, maxChars);
-}
-function plural(n, one, many = `${one}s`) {
-    return `${n} ${n === 1 ? one : many}`;
-}
-/** Wall-clock stamp for a log line. Null on continuation lines the file parser couldn't date. */
-function stamp(t) {
-    if (t === null)
-        return '        ';
-    const d = new Date(t);
-    const p = (n) => String(n).padStart(2, '0');
-    return `${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
-}
-/** "in 42m" / "38m ago" — an absolute epoch is unreadable, and an agent's clock may differ. */
-function relative(at) {
-    const mins = Math.round((at - Date.now()) / 60_000);
-    if (mins > 0)
-        return `in ${mins}m`;
-    return mins < 0 ? `${-mins}m ago` : 'now';
-}
-/** Human-readable state that retains every exact Run-config ID and preview URL. */
-function formatDevServer(state, headline = state.running ? 'running' : 'stopped') {
-    const summary = [headline];
-    if (state.task)
-        summary.push(`task ${state.task}`);
-    if (state.port !== null)
-        summary.push(`port ${state.port}`);
-    if (state.forwarded)
-        summary.push(state.url ? `forwarded ${state.url}` : 'forwarded');
-    else if (state.running)
-        summary.push('not forwarded');
-    const lines = [summary.join(' · ')];
-    if (state.error)
-        lines.push(`! ${state.error}`);
-    if (state.runConfigs.length) {
-        lines.push(`run configs: ${state.runConfigs.map(config => `${config.id} (${config.name})`).join(', ')}`);
-    }
-    if (state.forwards.length) {
-        lines.push('previews:');
-        for (const forward of state.forwards) {
-            const details = [
-                `${forward.name}: port ${forward.port}`,
-                forward.running ? 'running' : 'stopped',
-                forward.forwarded ? (forward.url ? `forwarded ${forward.url}` : 'forwarded') : 'not forwarded'
-            ];
-            lines.push(`- ${details.join(' · ')}`);
-        }
-    }
-    return lines.join('\n');
-}
-const str = (v) => (typeof v === 'string' && v.trim() ? v.trim() : undefined);
-const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
-function need(args, key) {
-    const v = str(args[key]);
-    if (!v)
-        throw new Error(`${key} is required`);
-    return v;
-}
-function rejectUnknown(args, allowed) {
-    const accepted = new Set(allowed);
-    const unknown = Object.keys(args).filter(key => !accepted.has(key));
-    if (unknown.length)
-        throw new Error(`unknown ${unknown.length === 1 ? 'field' : 'fields'}: ${unknown.join(', ')}`);
-}
-function voiceCallHeader(call) {
-    return [
-        `call_id: ${call.callId}`,
-        `${new Date(call.startedAt).toISOString()} · ${call.status} · ${call.transport} · ${call.entryCount} entries`,
-        ...(call.hasGaps ? ['! This transcript may have gaps from an interrupted connection.'] : []),
-        ...(call.captureError ? [`! ${call.captureError}`] : [])
-    ];
-}
-function voiceEntryFlags(entry) {
-    const flags = [
-        ...(entry.transcriptionFailed ? ['audio could not be transcribed'] : entry.partial ? ['partial transcript'] : []),
-        ...(entry.interrupted ? ['reply interrupted; generated text may include words not played'] : [])
-    ];
-    return flags.length ? ` (${flags.join('; ')})` : '';
-}
-/** Build the tool set against a given relay transport. */
-export function createTools(call) {
-    return [
-        {
-            name: 'search_chats',
-            description: 'Full-text search every Conductor chat on this Mac, archived workspaces included, and get back the workspaces that discussed it with the matching excerpts. Use this to answer "which workspace did I do X in" or "what did we decide about X". Searches the prompts the user typed, the agent replies and the agent\'s reasoning, not tool output. Each excerpt is tagged [user], [assistant] or [thinking] — a [thinking] hit is reasoning the agent never said out loud, so do not quote it back as its answer. Every excerpt carries its own session_id and cursor for a bounded nearby read_chat.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    query: {
-                        type: 'string',
-                        description: 'Plain words, ranked by relevance; wrap a "phrase in quotes" to require it word for word. Other punctuation and operators are ignored, not parsed.'
-                    },
-                    limit: { type: 'number', description: 'Max workspaces to return (default 12, max 50).' },
-                    repo: {
-                        type: 'string',
-                        description: 'Only workspaces in this repo, by the exact name list_repos prints. Ranking happens inside the repo, so a rare mention there is not buried by busier repos.'
-                    }
-                },
-                required: ['query']
-            },
-            run: async (args) => {
-                const query = need(args, 'query');
-                const limit = num(args.limit);
-                const repo = typeof args.repo === 'string' && args.repo.trim() ? args.repo.trim() : null;
-                const params = new URLSearchParams({ q: query });
-                if (limit)
-                    params.set('limit', String(limit));
-                if (repo)
-                    params.set('repo', repo);
-                const data = await call(`${routes.search.path()}?${params}`);
-                const lines = [];
-                if (data.index.error)
-                    lines.push(`! chat index unavailable (${data.index.error}) — names matched only`);
-                else if (!data.index.ready)
-                    lines.push(`! still indexing (${Math.round(data.index.progress * 100)}%) — older chats not searchable yet`);
-                const scope = repo ? ` in ${repo}` : '';
-                if (!data.results.length)
-                    return [...lines, `no workspace or chat matches ${JSON.stringify(query)}${scope}`].join('\n');
-                for (const r of data.results) {
-                    const w = r.workspace;
-                    const tags = [w.repo_name, w.branch, w.archived ? 'ARCHIVED' : w.state].filter(Boolean).join(' · ');
-                    lines.push('');
-                    lines.push(`## ${workspaceTitle(w)}`);
-                    lines.push(`${tags}${r.byName ? ' · name match' : ''}`);
-                    lines.push(`workspace_id: ${w.id}${r.sessionId ? `  session_id: ${r.sessionId}` : ''}`);
-                    if (r.hits)
-                        lines.push(`${r.hits} matching message${r.hits === 1 ? '' : 's'}:`);
-                    for (const s of r.snippets) {
-                        lines.push(`  [${s.role}] ${clip(unmark(s.text), 400)}`);
-                        lines.push(`    session_id: ${s.sessionId}  cursor: ${s.cursor}`);
-                    }
-                }
-                return lines.join('\n').trim();
-            }
-        },
-        {
-            name: 'read_chat',
-            description: 'Read a bounded Conductor chat transcript by session_id, newest messages last. Pass a cursor from search_chats or a prior read_chat as near; before and after expand either direction or both together. For a [thinking] search hit, set include_thinking true to include the matching block. Without near, returns the trailing entries. Works for archived workspaces. Tool calls and failed tool output are summarised to one line each; prose is verbatim unless the output budget truncates it.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    session_id: { type: 'string', description: 'From search_chats or list_chats.' },
-                    near: { type: 'string', description: 'A cursor from search_chats or a prior read_chat.' },
-                    before: { type: 'number', description: 'Entries before near to return (default 6, max 100).' },
-                    after: { type: 'number', description: 'Entries after near to return (default 6, max 100).' },
-                    limit: {
-                        type: 'number',
-                        description: 'Trailing entries when near is omitted (default 12, max 400).'
-                    },
-                    max_chars: {
-                        type: 'number',
-                        description: 'Hard result-size budget (default 12000, min 1000, max 40000).'
-                    },
-                    include_thinking: { type: 'boolean', description: 'Include the agent’s reasoning (default false).' },
-                    include_tools: {
-                        type: 'boolean',
-                        description: 'Include tool calls and failed tool output (default false).'
-                    }
-                },
-                required: ['session_id']
-            },
-            run: async (args) => {
-                const sessionId = need(args, 'session_id');
-                const near = str(args.near);
-                const anchor = near ? parseChatCursor(near) : null;
-                if (near && anchor === null)
-                    throw new Error('near must be a cursor returned by search_chats');
-                const count = (value, fallback) => Math.min(100, Math.max(0, Math.floor(num(value) ?? fallback)));
-                const before = count(args.before, 6);
-                const after = count(args.after, 6);
-                const limit = Math.min(400, Math.max(1, Math.floor(num(args.limit) ?? 12)));
-                const maxChars = Math.min(40_000, Math.max(1_000, Math.floor(num(args.max_chars) ?? 12_000)));
-                // One flag each, because they answer different questions: tools are what the agent
-                // *did*, thinking is why it did it. Reading both off `include_tools` meant the only
-                // way to see the reasoning was to take the tool churn along with it.
-                const includeTools = args.include_tools === true;
-                const includeThinking = args.include_thinking === true;
-                const data = await call(`${routes.messages.path(sessionId)}?after=0`, {
-                    timeoutMs: 30_000
-                });
-                if (anchor !== null && !data.entries.some(entry => entry.rowid === anchor)) {
-                    throw new Error('near cursor is not in that session');
-                }
-                const wanted = data.entries.filter(e => {
-                    if (e.role === 'thinking')
-                        return includeThinking;
-                    // A successful result carries the call's output, which is the churn `include_tools`
-                    // exists to keep out of a context window — the call above it already says what ran.
-                    // A failed one stays: one line, and it is why the turn changed course.
-                    if (isToolResult(e) && !e.error)
-                        return false;
-                    if (e.role === 'tool')
-                        return includeTools;
-                    return true;
-                });
-                if (!wanted.length)
-                    return `no messages in session ${sessionId}`;
-                let selected;
-                const head = [];
-                if (anchor === null) {
-                    selected = wanted.slice(-limit);
-                    if (selected.length < wanted.length) {
-                        head.push(`(last ${selected.length} of ${wanted.length} entries · older_cursor: ${chatCursor(selected[0].rowid)})`);
-                    }
-                }
-                else {
-                    const older = wanted.filter(entry => entry.rowid < anchor);
-                    const at = wanted.filter(entry => entry.rowid === anchor);
-                    const newer = wanted.filter(entry => entry.rowid > anchor);
-                    selected = [...(before ? older.slice(-before) : []), ...at, ...newer.slice(0, after)];
-                    const parts = [
-                        `near ${near}`,
-                        `${Math.min(before, older.length)} before`,
-                        `${at.length} at`,
-                        `${Math.min(after, newer.length)} after`
-                    ];
-                    if (older.length > before && selected[0])
-                        parts.push(`older_cursor: ${chatCursor(selected[0].rowid)}`);
-                    if (newer.length > after && selected.at(-1)) {
-                        parts.push(`newer_cursor: ${chatCursor(selected.at(-1).rowid)}`);
-                    }
-                    head.push(`(${parts.join(' · ')})`);
-                }
-                if (!selected.length) {
-                    return boundedTranscript(head, ['(the matching entry is excluded by the current role filters)'], maxChars);
-                }
-                const rendered = selected.map(entry => {
-                    if (entry.role === 'tool')
-                        return `[tool ${entry.tool ?? ''}] ${clip(entry.text, 200)}${entry.detail ? ` — ${entry.detail}` : ''}`;
-                    return `[${entry.role}] ${entry.text}`;
-                });
-                return boundedTranscript(head, rendered, maxChars);
-            }
-        },
-        {
-            name: 'list_voice_calls',
-            description: 'List saved fleet voice calls on this Mac, newest first, with dates, previews and call_id values for read_voice_call. These transcripts are separate from Conductor chat history. Read-only; no live call or UI interaction.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    limit: { type: 'integer', description: 'Calls per page (default 20, max 50).' },
-                    offset: {
-                        type: 'integer',
-                        description: 'Skip this many calls; use next_offset from the previous page (default 0).'
-                    }
-                },
-                additionalProperties: false
-            },
-            run: async (args) => {
-                rejectUnknown(args, ['limit', 'offset']);
-                const limit = Math.min(50, Math.max(1, Math.floor(num(args.limit) ?? 20)));
-                const offset = Math.min(1_000_000, Math.max(0, Math.floor(num(args.offset) ?? 0)));
-                const params = new URLSearchParams({ limit: String(limit), offset: String(offset) });
-                const data = await call(`${routes.voiceHistory.path()}?${params}`);
-                if (!data.calls.length)
-                    return 'No saved voice calls on this page. Only calls captured after transcript saving was enabled are available.';
-                return [
-                    ...data.calls.map(item => [...voiceCallHeader(item), clip(item.preview.replace(/\s+/g, ' '), 200)].join('\n')),
-                    ...(data.hasMore ? [`next_offset: ${offset + data.calls.length}`] : [])
-                ].join('\n\n');
-            }
-        },
-        {
-            name: 'search_voice_calls',
-            description: 'Search caller and assistant text across saved fleet calls. Results include matching excerpts, call_id and item_id; pass those to read_voice_call as call_id and near to read surrounding decisions. Partial and interrupted text is labeled. Read-only; no UI interaction.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    query: {
-                        type: 'string',
-                        maxLength: 500,
-                        description: 'Words ranked by relevance; quote an exact phrase. Uses the same query grammar as search_chats.'
-                    },
-                    call_id: { type: 'string', description: 'Optional: search only this saved call.' },
-                    limit: { type: 'integer', description: 'Matching utterances per page (default 12, max 50).' },
-                    offset: {
-                        type: 'integer',
-                        description: 'Skip this many hits; use next_offset from the previous page (default 0).'
-                    }
-                },
-                required: ['query'],
-                additionalProperties: false
-            },
-            run: async (args) => {
-                rejectUnknown(args, ['query', 'call_id', 'limit', 'offset']);
-                const query = need(args, 'query');
-                if (query.length > 500)
-                    throw new Error('query must be at most 500 characters');
-                const limit = Math.min(50, Math.max(1, Math.floor(num(args.limit) ?? 12)));
-                const offset = Math.min(1_000_000, Math.max(0, Math.floor(num(args.offset) ?? 0)));
-                const params = new URLSearchParams({ q: query, limit: String(limit), offset: String(offset) });
-                if (str(args.call_id))
-                    params.set('callId', str(args.call_id));
-                const data = await call(`${routes.voiceSearch.path()}?${params}`);
-                if (!data.hits.length)
-                    return `No saved voice transcript matches ${JSON.stringify(query)} on this page.`;
-                return [
-                    ...data.hits.map(hit => [
-                        ...voiceCallHeader(hit.call),
-                        `item_id: ${hit.itemId} · ${new Date(hit.at).toISOString()}`,
-                        `[${hit.role}]${voiceEntryFlags(hit)} ${clip(unmark(hit.snippet), 500)}`
-                    ].join('\n')),
-                    ...(data.hasMore ? [`next_offset: ${offset + data.hits.length}`] : [])
-                ].join('\n\n');
-            }
-        },
-        {
-            name: 'read_voice_call',
-            description: 'Read a saved fleet-call transcript by call_id, with caller, orchestrator and tool activity in conversation order. Pass an item_id from search_voice_calls as near for surrounding context, or use older_item/newer_item from a previous read. Without near, reads the latest entries. Text can be clipped to max_chars; narrow the window or raise that budget to read more. Interrupted replies can include generated words the caller never heard. Read-only; no UI interaction.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    call_id: { type: 'string', description: 'From list_voice_calls or search_voice_calls.' },
-                    near: { type: 'string', description: 'A transcript item_id from a search hit or previous read.' },
-                    before: { type: 'integer', description: 'Entries before near (default 6, max 100).' },
-                    after: { type: 'integer', description: 'Entries after near (default 6, max 100).' },
-                    limit: { type: 'integer', description: 'Latest entries when near is omitted (default 20, max 200).' },
-                    max_chars: { type: 'integer', description: 'Hard output budget (default 12000, min 1000, max 40000).' }
-                },
-                required: ['call_id'],
-                additionalProperties: false
-            },
-            run: async (args) => {
-                rejectUnknown(args, ['call_id', 'near', 'before', 'after', 'limit', 'max_chars']);
-                const callId = need(args, 'call_id');
-                const data = await call(routes.voiceTranscript.path(callId));
-                const entries = data.entries.filter(entry => entry.role !== 'relay');
-                const near = str(args.near);
-                const anchor = near ? entries.findIndex(entry => entry.id === near) : -1;
-                if (near && anchor === -1)
-                    throw new Error('near item is not in that saved call');
-                const count = (value, fallback, max) => Math.min(max, Math.max(0, Math.floor(num(value) ?? fallback)));
-                const limit = Math.max(1, count(args.limit, 20, 200));
-                let start = near ? Math.max(0, anchor - count(args.before, 6, 100)) : Math.max(0, entries.length - limit);
-                let end = near ? Math.min(entries.length, anchor + count(args.after, 6, 100) + 1) : entries.length;
-                const maxChars = Math.max(1_000, count(args.max_chars, 12_000, 40_000));
-                const heading = (entry) => `[${entry.role}] item_id: ${entry.id} · ${new Date(entry.at).toISOString()}${voiceEntryFlags(entry)}\n`;
-                // Keep identities and caveats readable even for a tiny budget. Shrink the
-                // window around its anchor, then advertise the omitted sides for paging.
-                while (end - start > 1) {
-                    const minRow = Math.max(...entries.slice(start, end).map(entry => heading(entry).length)) + 80;
-                    if (voiceCallHeader(data).join('\n').length + 240 + (end - start) * (minRow + 2) <= maxChars)
-                        break;
-                    if (!near || anchor - start > end - anchor - 1)
-                        start += 1;
-                    else
-                        end -= 1;
-                }
-                const selected = entries.slice(start, end);
-                const head = [
-                    ...voiceCallHeader(data),
-                    `Showing ${selected.length} of ${entries.length} entries.`,
-                    ...(start > 0 && selected[0] ? [`older_item: ${selected[0].id} (use as near with before > 0)`] : []),
-                    ...(end < entries.length && selected.at(-1)
-                        ? [`newer_item: ${selected.at(-1).id} (use as near with after > 0)`]
-                        : [])
-                ];
-                const rendered = selected.map(entry => `${heading(entry)}${entry.text}`);
-                return boundedTranscript(head, rendered, maxChars);
-            }
-        },
-        {
-            name: 'list_workspaces',
-            description: 'List the live (non-archived) Conductor workspaces with what each one is doing right now: agent status, model, branch, PR state, and any prompt the relay is still holding for it. Use this to see what is running before starting or steering anything.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    status: {
-                        type: 'string',
-                        description: 'Filter by live agent status: working | idle | error. Omit for all.'
-                    }
-                }
-            },
-            run: async (args) => {
-                const status = str(args.status);
-                const data = await call(routes.state.path());
-                const shown = status ? data.workspaces.filter(w => w.session_status === status) : data.workspaces;
-                if (!shown.length)
-                    return status ? `no workspace is ${status}` : 'no live workspaces';
-                return shown
-                    .map(w => {
-                    const assigned = w.active_session_id ? w.session_roles?.[w.active_session_id] : undefined;
-                    const lines = [
-                        `${w.session_status === 'working' ? '▶' : '·'} ${workspaceTitle(w)}`,
-                        `    ${[w.repo_name, w.branch, w.model, assigned ? `role ${assigned.role}` : null, w.pr_number ? `PR #${w.pr_number} ${w.pr_status ?? ''}`.trim() : null].filter(Boolean).join(' · ')}`,
-                        `    workspace_id: ${w.id}${w.active_session_id ? `  session_id: ${w.active_session_id}` : ''}`
-                    ];
-                    // An undelivered prompt is invisible from the DB — it lives in the relay's own
-                    // queues — so an agent reading only status would call a stalled workspace idle
-                    // and send a second copy of the prompt already waiting on it (dismiss_prompt).
-                    if (w.pending_prompt) {
-                        const p = w.pending_prompt;
-                        lines.push(`    ! first prompt ${p.status}: ${clip(unmark(p.text), 120)}${p.error ? ` — ${p.error}` : ''}`);
-                    }
-                    for (const p of w.parked_prompts ?? []) {
-                        lines.push(`    ! prompt ${p.status} for session ${p.sessionId} (${p.reason}): ${clip(unmark(p.text), 120)}`);
-                    }
-                    for (const job of w.delegations ?? []) {
-                        lines.push(`    ${job.status === 'failed' ? '!' : '→'} delegation ${job.role}: ${job.status} (${job.id})${job.failure ? ` — ${job.failure.message}` : ''}`);
-                    }
-                    if (w.delegation_warning)
-                        lines.push(`    ! delegation state: ${w.delegation_warning}`);
-                    return lines.join('\n');
-                })
-                    .join('\n');
-            }
-        },
-        {
-            name: 'list_chats',
-            description: 'List the chat tabs in a workspace with each one’s status, model and how full its context window is. A workspace can hold several conversations, each with its own context; send_prompt and read_chat address one of them.',
-            inputSchema: {
-                type: 'object',
-                properties: { workspace_id: { type: 'string' } },
-                required: ['workspace_id']
-            },
-            run: async (args) => {
-                const id = need(args, 'workspace_id');
-                const data = await call(routes.sessions.path(id));
-                if (!data.sessions.length)
-                    return `no chats in workspace ${id}`;
-                // Context is per chat and only per chat — the same workspace can hold a tab at 85%
-                // beside one at 28% — so it is printed on every row rather than summarised above.
-                return data.sessions
-                    .map(s => {
-                    const ctx = typeof s.context_used_percent === 'number' && s.context_used_percent > 0
-                        ? ` · ${Math.round(s.context_used_percent)}% context`
-                        : '';
-                    // A chat waiting on a background task reads `idle` in `status` and will resume
-                    // itself; an agent that reads only the status would call it done and send a
-                    // second prompt into the wait.
-                    const waiting = (s.background_tasks ?? []).map(t => `\n    waiting for task: ${t.description} (${Math.max(0, Math.round((Date.now() - timestampMs(t.since)) / 60_000))}m so far)`);
-                    const glyph = s.status === 'working' ? '▶' : waiting.length ? '⧗' : '·';
-                    const role = data.session_roles?.[s.id];
-                    return `${glyph} ${s.title ?? '(untitled)'} — ${s.status ?? '?'} · ${s.model ?? '?'}${role ? ` · role ${role.role}` : ''}${ctx}\n    session_id: ${s.id}${waiting.join('')}`;
-                })
-                    .join('\n');
-            }
-        },
-        {
-            name: 'list_roles',
-            description: 'List configured models, effort, Fast mode, instructions, and validation issues before lightweight delegation. Choose a role whose current configuration fits the task. Invalid roles cannot start a child or new Workflow. Active Workflows use the frozen roles from their root envelope.',
-            inputSchema: { type: 'object', properties: {} },
-            run: async () => {
-                const data = await call(routes.roles.path());
-                const issueByRole = new Map(data.issues.map(issue => [issue.role, issue.error]));
-                const lines = Object.entries(data.roles).map(([name, role]) => {
-                    const settings = [
-                        role.model,
-                        role.effort,
-                        role.fast === undefined ? null : role.fast ? 'fast on' : 'fast off'
-                    ]
-                        .filter(Boolean)
-                        .join(' · ');
-                    const issue = issueByRole.get(name);
-                    const instructions = role.preamble?.trim();
-                    return `${issue ? '!' : '·'} ${name}: ${settings}${issue ? ` — ${issue.code}: ${issue.message}` : ''}${instructions ? `\n    Instructions: ${instructions.replaceAll('\n', '\n    ')}` : ''}`;
-                });
-                if (data.warning)
-                    lines.unshift(`! ${data.warning}`);
-                return lines.join('\n') || 'no delegated roles are configured';
-            }
-        },
-        {
-            name: 'delegate_task',
-            description: 'Spawn one lightweight tracked sibling chat in a subtab. From an ordinary chat, pass session_id, a valid role from list_roles, and a focused prompt. Choose a configured role whose instructions fit the task; repeat for independent questions so children can run concurrently. This does not start a Workflow or turn the parent into a planner. The role must use a different provider than the parent. The child follows the configured preamble and assignment, receives a transcript attachment, and returns its result. Queue mode delivers behind the current turn by default; use steer if the result is needed during this turn. Keep working and integrate the result. For an active Workflow, only its root may call with workflow_id and current phase_capability from the private envelope; its frozen settings, role restrictions, transcript boundary, and Baton routing apply. Returns immediately with a delegation id; list_delegations observes progress. The relay later opens/configures/sends the child through the Mac UI. This tool cannot start or recover a Workflow.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    workflow_id: { type: 'string', description: 'Active Workflow only: id from the private root envelope.' },
-                    phase_capability: {
-                        type: 'string',
-                        description: 'Opaque current-phase capability from that same envelope; never copy it elsewhere.'
-                    },
-                    session_id: { type: 'string', description: 'Parent chat id; an active Workflow requires its root session.' },
-                    role: { type: 'string', description: 'Configured role name. Workflows allow exploration or implementation.' },
-                    prompt: {
-                        type: 'string',
-                        description: 'The independent question or implementation brief, including file ownership for edits.'
-                    },
-                    return_mode: {
-                        type: 'string',
-                        enum: ['queue', 'steer'],
-                        description: 'Ordinary chats only. Queue the Baton behind this turn (default), or steer it into a running turn.'
-                    },
-                    through: {
-                        type: 'string',
-                        description: 'Ordinary chats only. Optional read_chat cursor bounding the transcript handoff.'
-                    },
-                    include_thinking: {
-                        type: 'boolean',
-                        description: 'Ordinary chats only. Include parent reasoning in the handoff (default false).'
-                    }
-                },
-                required: ['session_id', 'role', 'prompt'],
-                additionalProperties: false
-            },
-            run: async (args) => {
-                if (!Object.hasOwn(args, 'workflow_id') && !Object.hasOwn(args, 'phase_capability')) {
-                    rejectUnknown(args, ['session_id', 'role', 'prompt', 'return_mode', 'through', 'include_thinking']);
-                    const sessionId = need(args, 'session_id');
-                    if (args.return_mode !== undefined && args.return_mode !== 'queue' && args.return_mode !== 'steer') {
-                        throw new Error('return_mode must be queue or steer');
-                    }
-                    if (args.include_thinking !== undefined && typeof args.include_thinking !== 'boolean') {
-                        throw new Error('include_thinking must be a boolean');
-                    }
-                    const through = args.through === undefined ? undefined : parseChatCursor(need(args, 'through'));
-                    if (through === null)
-                        throw new Error('through must be a read_chat cursor');
-                    const body = {
-                        role: need(args, 'role'),
-                        prompt: need(args, 'prompt'),
-                        ...(args.return_mode === undefined ? {} : { returnMode: args.return_mode }),
-                        ...(through === undefined ? {} : { throughRowid: through }),
-                        ...(args.include_thinking === undefined ? {} : { includeThinking: args.include_thinking })
-                    };
-                    const result = await call(routes.delegateTask.path(sessionId), {
-                        method: routes.delegateTask.method,
-                        body
-                    });
-                    if (!result.ok)
-                        throw new Error(`${result.error.code}: ${result.error.message}`);
-                    return `delegation ${result.delegationId} queued · ${result.role} · ${result.model}`;
-                }
-                rejectUnknown(args, ['workflow_id', 'phase_capability', 'session_id', 'role', 'prompt']);
-                const workflowId = need(args, 'workflow_id');
-                const sessionId = need(args, 'session_id');
-                const role = need(args, 'role');
-                if (role !== 'exploration' && role !== 'implementation')
-                    throw new Error('role is invalid');
-                const body = {
-                    workflow_id: workflowId,
-                    phase_capability: need(args, 'phase_capability'),
-                    session_id: sessionId,
-                    role,
-                    prompt: need(args, 'prompt')
-                };
-                const result = await call(routes.workflowDelegation.path(workflowId), {
-                    method: routes.workflowDelegation.method,
-                    body
-                });
-                if (!result.ok)
-                    throw new Error(`${result.error.code}: ${result.error.message}`);
-                return `delegation ${result.delegationId} queued · ${result.role} · ${result.model}`;
-            }
-        },
-        {
-            name: 'list_delegations',
-            description: 'List active and failed delegated jobs. Successful jobs leave their chats and role chips, not a second history log.',
-            inputSchema: {
-                type: 'object',
-                properties: { workspace_id: { type: 'string', description: 'Optional workspace filter.' } }
-            },
-            run: async (args) => {
-                const workspaceId = str(args.workspace_id);
-                const suffix = workspaceId ? `?workspaceId=${encodeURIComponent(workspaceId)}` : '';
-                const data = await call(`${routes.delegations.path()}${suffix}`);
-                if (!data.delegations.length)
-                    return 'no active or failed delegations';
-                return data.delegations
-                    .map(job => {
-                    const child = job.childSessionId ? ` · child ${job.childSessionId}` : '';
-                    const failure = job.failure ? ` · ${job.failure.code}: ${job.failure.message}` : '';
-                    return `${job.status} · ${job.role} · ${job.resolvedRole.model} · ${job.id}${child}${failure}`;
-                })
-                    .join('\n');
-            }
-        },
-        {
-            name: 'workspace_diff',
-            description: 'The git diff of a live workspace against its target branch, untracked files included.',
-            inputSchema: {
-                type: 'object',
-                properties: { workspace_id: { type: 'string' } },
-                required: ['workspace_id']
-            },
-            run: async (args) => {
-                const id = need(args, 'workspace_id');
-                const data = await call(routes.diff.path(id), {
-                    timeoutMs: 30_000
-                });
-                if (!data.files.length)
-                    return 'no changes against the target branch';
-                return data.files.map(f => `${f.path}  +${f.added} -${f.removed}`).join('\n');
-            }
-        },
-        {
-            name: 'list_repos',
-            description: 'The repos Conductor can create a workspace in. Use before create_workspace to get an exact repo name.',
-            inputSchema: { type: 'object', properties: {} },
-            run: async () => {
-                const data = await call(routes.repos.path());
-                return data.repos.map(r => `${r.name}  (${r.default_branch ?? '?'})  ${r.root_path ?? ''}`).join('\n');
-            }
-        },
-        {
-            name: 'plan_usage',
-            description: 'Read rolling Claude Code and Codex subscription allowances from their local CLIs: percentage used and reset time. Sends no model prompt and touches no Conductor UI. Cursor Agent and OpenCode explain why no comparable plan quota is available.',
-            inputSchema: { type: 'object', properties: {} },
-            run: async () => {
-                const data = await call(routes.planUsage.path(), { timeoutMs: 15_000 });
-                const sections = data.providers.map(provider => {
-                    const head = `## ${provider.label}${provider.plan ? ` · ${provider.plan}` : ''}`;
-                    if (provider.status !== 'available')
-                        return `${head}\n${provider.message ?? 'unavailable'}`;
-                    const lines = provider.buckets.flatMap(bucket => bucket.windows.map(window => {
-                        const bucketName = provider.buckets.length > 1 ? `${bucket.label} — ` : '';
-                        const reset = window.resetsAt === null ? 'reset unavailable' : `resets ${new Date(window.resetsAt).toISOString()}`;
-                        return `- ${bucketName}${window.label}: ${Math.round(window.usedPercent)}% used · ${reset}`;
-                    }));
-                    return `${head}\n${lines.join('\n')}`;
-                });
-                return `${sections.join('\n\n')}\n\nupdated ${new Date(data.fetchedAt).toISOString()}`;
-            }
-        },
-        {
-            name: 'create_workspace',
-            description: 'Start an ordinary new Conductor workspace in a repo, optionally with a first prompt and agent settings. The workspace starts from a Conductor deep link, so creation itself needs no Accessibility. The relay applies requested model, effort, plan, and fast settings through Conductor’s UI after it creates the first chat and before it delivers the prompt. This utility cannot start or join a Workflow. Returns as soon as the workspace row exists (~2s), before the worktree is built.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    repo: { type: 'string', description: 'Exact name from list_repos.' },
-                    prompt: { type: 'string', description: 'First prompt for the new agent. Omit to open an empty workspace.' },
-                    model: {
-                        type: 'string',
-                        description: 'Picker label from list_models with no session_id. The relay applies it before the first prompt, or configures an empty workspace once its chat exists.'
-                    },
-                    effort: {
-                        type: 'string',
-                        enum: ['none', 'low', 'medium', 'high', 'xhigh', 'max', 'ultracode'],
-                        description: 'Reasoning effort applied before the first prompt.'
-                    },
-                    plan: { type: 'boolean', description: 'Start the first chat in Conductor’s Plan mode.' },
-                    fast: { type: 'boolean', description: 'Set Fast mode before the first prompt.' },
-                    wait_for_send: {
-                        type: 'boolean',
-                        description: 'Block until the first prompt is actually delivered (tens of seconds, and longer behind other queued sends). Default false.'
-                    },
-                    send_immediately: {
-                        type: 'boolean',
-                        description: "Send the first prompt without waiting for the worktree to finish building, which is how Conductor's own New workspace box behaves. Default true. Pass false only when the agent's first move needs what the repo's setup script installs."
-                    }
-                },
-                required: ['repo'],
-                additionalProperties: false
-            },
-            run: async (args) => {
-                rejectUnknown(args, ['repo', 'prompt', 'model', 'effort', 'plan', 'fast', 'wait_for_send', 'send_immediately']);
-                const repo = need(args, 'repo');
-                const prompt = str(args.prompt);
-                const model = str(args.model);
-                const effort = str(args.effort);
-                const plan = typeof args.plan === 'boolean' ? args.plan : undefined;
-                const fast = typeof args.fast === 'boolean' ? args.fast : undefined;
-                const explicitAgent = model !== undefined || effort !== undefined || plan !== undefined || fast !== undefined;
-                const configured = explicitAgent;
-                const send = args.wait_for_send === true;
-                // Default on, matching the relay: an omitted flag must never mean "wait".
-                const sendImmediately = args.send_immediately !== false;
-                const data = await call(routes.createWorkspace.path(), {
-                    method: routes.createWorkspace.method,
-                    body: { repo, prompt, model, effort, plan, fast, send, sendImmediately },
-                    timeoutMs: send ? WRITE_TIMEOUT_MS : 30_000
-                });
-                const lines = [
-                    `created ${data.workspace ? workspaceTitle(data.workspace) : data.workspaceId}`,
-                    `workspace_id: ${data.workspaceId}`
-                ];
-                if (data.warning)
-                    lines.push(`! ${data.warning}`);
-                else if (data.pendingPrompt && !data.sent)
-                    lines.push('the first prompt is queued — the relay delivers it, so do not send it again');
-                else if (data.sent)
-                    lines.push('the first prompt was delivered');
-                if (configured)
-                    lines.push(data.configured ? 'agent settings applied' : 'agent settings queued');
-                return lines.join('\n');
-            }
-        },
-        {
-            name: 'send_prompt',
-            description: 'Send a prompt into an existing Conductor chat, exactly as typing it on the Mac would. This DRIVES THE REAL UI: it focuses the workspace, selects the chat tab and presses Enter, so it steals focus for a few seconds. If that chat is already working, the message STEERS the running agent rather than starting a new turn — do not use it to poll or test. Ask the user before sending into a chat they did not name.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    session_id: { type: 'string', description: 'The chat to send to (list_chats / search_chats).' },
-                    workspace_id: {
-                        type: 'string',
-                        description: 'Its workspace. Strongly recommended: it is what the relay asserts against before typing.'
-                    },
-                    text: { type: 'string' }
-                },
-                required: ['session_id', 'text'],
-                additionalProperties: false
-            },
-            run: async (args) => {
-                rejectUnknown(args, ['session_id', 'workspace_id', 'text']);
-                const sessionId = need(args, 'session_id');
-                const text = need(args, 'text');
-                const data = await call(routes.sendPrompt.path(sessionId), {
-                    method: routes.sendPrompt.method,
-                    body: { text, workspaceId: str(args.workspace_id) },
-                    timeoutMs: WRITE_TIMEOUT_MS
-                });
-                if (data.parked)
-                    return 'the Mac is locked — the prompt is parked and will be sent on unlock';
-                if (!data.ok)
-                    throw new Error(data.error ?? 'the send did not land');
-                return data.warning ? `sent (${data.warning})` : 'sent';
-            }
-        },
-        {
-            name: 'split_chat',
-            description: 'Move a tangent out of a chat: copy that chat as a Conductor attachment and ask the new agent your question there. By default it opens a fresh tab beside the source (same files); new_workspace creates a separate Conductor workspace and carries the source worktree’s current tracked and untracked-not-ignored files into it. The transcript copy carries prose and reasoning, not tool calls, and runs to the end unless through names an earlier message. A tab fork DRIVES THE REAL UI twice (new tab, then send); a workspace fork creates through a deep link, then drives the UI for the send. Both steal focus. To split the chat you are in, find its session_id with list_chats on your own workspace.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    session_id: { type: 'string', description: 'The chat to copy (list_chats / search_chats).' },
-                    prompt: { type: 'string', description: 'What to ask in the new destination.' },
-                    workspace_id: { type: 'string', description: 'Its workspace. Resolved from the chat when omitted.' },
-                    include_thinking: {
-                        type: 'boolean',
-                        description: 'Carry the agent’s reasoning across (default true — it is usually the useful half).'
-                    },
-                    include_tools: {
-                        type: 'boolean',
-                        description: 'Carry tool calls across as one line each (default false — mostly noise, and most of the bytes).'
-                    },
-                    new_workspace: {
-                        type: 'boolean',
-                        description: 'Create a separate workspace carrying the source’s current code (default false: a new tab with the same files).'
-                    },
-                    through: {
-                        type: 'string',
-                        description: 'Stop the copy at this message, it included — a cursor from read_chat or search_chats. Default: the whole chat.'
-                    }
-                },
-                required: ['session_id', 'prompt']
-            },
-            run: async (args) => {
-                const sessionId = need(args, 'session_id');
-                const prompt = need(args, 'prompt');
-                const through = str(args.through);
-                const destination = args.new_workspace === true ? 'workspace' : 'chat';
-                const throughRowid = through ? parseChatCursor(through) : null;
-                if (through && throughRowid === null) {
-                    throw new Error('through must be a cursor returned by read_chat or search_chats');
-                }
-                const split = await call(routes.splitChat.path(sessionId), {
-                    method: routes.splitChat.method,
-                    body: {
-                        prompt,
-                        workspaceId: str(args.workspace_id),
-                        includeThinking: args.include_thinking !== false,
-                        includeTools: args.include_tools === true,
-                        throughRowid: throughRowid ?? undefined,
-                        destination
-                    },
-                    timeoutMs: WRITE_TIMEOUT_MS
-                });
-                if (!split.ok)
-                    throw new Error(split.error ?? 'the split did not open its destination');
-                const { attachment: file } = split;
-                // Name the cut. A transcript that quietly dropped half the chat reads exactly
-                // like a complete one to whoever gets it next.
-                const cut = [
-                    file.elided.tools ? plural(file.elided.tools, 'tool call') : '',
-                    file.elided.thinking ? plural(file.elided.thinking, 'thinking block') : '',
-                    file.elided.earlier ? plural(file.elided.earlier, 'entry before the cut', 'entries before the cut') : '',
-                    file.elided.later ? plural(file.elided.later, 'entry after the cut', 'entries after the cut') : ''
-                ].filter(Boolean);
-                const lines = [
-                    `copied ${plural(file.kept, 'entry', 'entries')} (${Math.round(file.bytes / 1024)}kB) to ${file.path}${cut.length ? `, without ${cut.join(' or ')}` : ''}`,
-                    ...(destination === 'workspace' ? [`workspace_id: ${split.workspaceId} (current code carried across)`] : [])
-                ];
-                // The destination exists either way, so every path below leaves the caller somewhere to
-                // go rather than reporting a bare failure over work that half-happened.
-                if (!split.sessionId) {
-                    lines.push(`the new ${destination} is open, but the relay could not read its chat id back`);
-                    lines.push('find it with list_chats, then send_prompt the question yourself');
-                    return lines.join('\n');
-                }
-                lines.push(`session_id: ${split.sessionId}`);
-                const sent = await call(routes.sendPrompt.path(split.sessionId), {
-                    method: routes.sendPrompt.method,
-                    body: { text: split.text, workspaceId: split.workspaceId },
-                    timeoutMs: WRITE_TIMEOUT_MS
-                });
-                if (sent.parked)
-                    lines.push('the Mac is locked — the prompt is parked and lands on unlock');
-                else if (!sent.ok)
-                    lines.push(`! the ${destination} and transcript are ready, but the prompt did not land (${sent.error ?? 'unknown'}) — retry it with send_prompt`);
-                else
-                    lines.push(sent.warning ? `sent (${sent.warning})` : 'sent');
-                return lines.join('\n');
-            }
-        },
-        {
-            name: 'stop_turn',
-            description: 'Cancel the answer a chat is currently streaming — Conductor’s own "Cancel agent". Drives the real UI. A chat that already finished answers alreadyIdle, which is a success. This destroys the in-flight work of another agent, so ask the user first.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    session_id: { type: 'string' },
-                    workspace_id: {
-                        type: 'string',
-                        description: 'Required in practice — the relay asserts the pane against it before pressing.'
-                    }
-                },
-                required: ['session_id']
-            },
-            run: async (args) => {
-                const sessionId = need(args, 'session_id');
-                const data = await call(routes.stop.path(sessionId), {
-                    method: routes.stop.method,
-                    body: { workspaceId: str(args.workspace_id) },
-                    timeoutMs: WRITE_TIMEOUT_MS
-                });
-                if (data.alreadyIdle)
-                    return 'that chat had already finished — nothing to stop';
-                if (!data.ok)
-                    throw new Error(data.error ?? 'the stop did not land');
-                return 'stopped';
-            }
-        },
-        {
-            name: 'close_chat',
-            description: 'Close one visible Conductor chat tab. This hides the tab but keeps its transcript; it can be reopened in Conductor with ⌘⇧T. DRIVES THE REAL UI and steals focus for a few seconds. A running chat is refused unless close_running is true, matching Conductor’s own “Close anyway” confirmation — only set it after the user confirms.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    session_id: { type: 'string', description: 'The visible chat tab to close.' },
-                    workspace_id: {
-                        type: 'string',
-                        description: 'Workspace holding the chat. The relay verifies it when provided.'
-                    },
-                    close_running: {
-                        type: 'boolean',
-                        description: 'Close even though its agent is still working. Requires explicit user confirmation.'
-                    }
-                },
-                required: ['session_id']
-            },
-            run: async (args) => {
-                const sessionId = need(args, 'session_id');
-                const data = await call(routes.closeChat.path(sessionId), {
-                    method: routes.closeChat.method,
-                    body: {
-                        workspaceId: str(args.workspace_id),
-                        closeRunning: args.close_running === true
-                    },
-                    timeoutMs: WRITE_TIMEOUT_MS
-                });
-                if (!data.ok)
-                    throw new Error(data.error ?? 'the chat tab did not close');
-                if (data.alreadyClosed)
-                    return 'already closed';
-                return data.activeSessionId ? `closed; active session_id: ${data.activeSessionId}` : 'closed; no tabs remain';
-            }
-        },
-        {
-            name: 'list_models',
-            description: 'The model labels the relay knows. With no session_id this returns its stored picker labels, grouped by harness; use it before create_workspace. With a session_id it reads that chat’s live Conductor picker and refreshes the stored labels. A live read DRIVES THE REAL UI — it focuses the workspace and opens the menu — so it costs a few seconds of stolen focus.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    session_id: {
-                        type: 'string',
-                        description: 'The chat whose live picker to read. Omit to use the relay cache.'
-                    },
-                    workspace_id: {
-                        type: 'string',
-                        description: 'Workspace holding session_id. Required when session_id is set.'
-                    }
-                }
-            },
-            run: async (args) => {
-                const sessionId = str(args.session_id);
-                if (!sessionId) {
-                    const data = await call(routes.modelCatalog.path());
-                    if (!data.groups.length)
-                        return 'no models are cached yet — read a chat’s live picker with session_id and workspace_id';
-                    return data.groups
-                        .map(group => `## ${group.agentType}\n${group.models.map(model => `- ${model}${model === data.defaultModel ? ' ★ default' : ''}`).join('\n')}`)
-                        .join('\n\n');
-                }
-                const workspaceId = need(args, 'workspace_id');
-                const data = await call(`${routes.models.path(sessionId)}?workspaceId=${encodeURIComponent(workspaceId)}`, { timeoutMs: WRITE_TIMEOUT_MS });
-                if (!data.ok)
-                    throw new Error(data.error ?? 'could not read the model menu');
-                return data.models?.length
-                    ? data.models.map(model => `${model}${model === data.defaultModel ? ' ★ default' : ''}`).join('\n')
-                    : 'the menu listed no models';
-            }
-        },
-        {
-            name: 'set_default_model',
-            description: 'Star a model as Conductor’s user-wide default. This mirrors the desktop picker’s combined “set as default and select” action, so it also switches the target chat to that model for its next turn. DRIVES THE REAL UI and changes a global preference — ask the user first.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    session_id: { type: 'string', description: 'Chat whose live model picker should be used.' },
-                    workspace_id: {
-                        type: 'string',
-                        description: 'Required in practice — the relay asserts the pane against it before pressing.'
-                    },
-                    model: { type: 'string', description: 'A label from list_models. An unambiguous prefix is enough.' }
-                },
-                required: ['session_id', 'workspace_id', 'model']
-            },
-            run: async (args) => {
-                const sessionId = need(args, 'session_id');
-                const workspaceId = need(args, 'workspace_id');
-                const model = need(args, 'model');
-                const data = await call(routes.defaultModel.path(sessionId), {
-                    method: routes.defaultModel.method,
-                    body: { workspaceId, model },
-                    timeoutMs: WRITE_TIMEOUT_MS
-                });
-                if (!data.ok)
-                    throw new Error(data.error ?? 'the default model did not change');
-                return `${data.defaultModel ?? model} is now the default and selected for this chat`;
-            }
-        },
-        {
-            name: 'set_agent_options',
-            description: 'Change how a chat’s agent runs: model, reasoning effort, plan mode, fast mode. Conductor keeps these in its composer and nowhere else, so this is the only way to reach them — a prompt cannot. DRIVES THE REAL UI and steals focus for a few seconds. The change is confirmed against Conductor’s database before this answers. Applies to the NEXT turn, so set it before send_prompt, not during one. Ask the user before re-pointing a chat they did not name at a different model.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    session_id: { type: 'string' },
-                    workspace_id: {
-                        type: 'string',
-                        description: 'Strongly recommended: it is what the relay asserts against before pressing anything.'
-                    },
-                    model: { type: 'string', description: 'A label from list_models. An unambiguous prefix is enough.' },
-                    effort: { type: 'string', enum: ['none', 'low', 'medium', 'high', 'xhigh', 'max', 'ultracode'] },
-                    plan: { type: 'boolean', description: 'Conductor’s Plan checkbox.' },
-                    fast: {
-                        type: 'boolean',
-                        description: 'Fast mode. Only some models offer it; a missing button is reported, not ignored.'
-                    }
-                },
-                required: ['session_id']
-            },
-            run: async (args) => {
-                const sessionId = need(args, 'session_id');
-                const patch = {
-                    model: str(args.model),
-                    effort: str(args.effort),
-                    plan: typeof args.plan === 'boolean' ? args.plan : undefined,
-                    fast: typeof args.fast === 'boolean' ? args.fast : undefined,
-                    workspaceId: str(args.workspace_id)
-                };
-                if (patch.model === undefined &&
-                    patch.effort === undefined &&
-                    patch.plan === undefined &&
-                    patch.fast === undefined)
-                    throw new Error('nothing to change — pass at least one of model, effort, plan, fast');
-                const data = await call(routes.agent.path(sessionId), {
-                    method: routes.agent.method,
-                    body: patch,
-                    timeoutMs: WRITE_TIMEOUT_MS
-                });
-                if (!data.ok)
-                    throw new Error(data.error ?? 'the change did not land');
-                // The re-read row is the receipt, so report *it* rather than what was asked for.
-                const s = data.session;
-                return s
-                    ? `now: ${[s.model, s.claude_effort_level, s.permission_mode, s.fast_mode ? 'fast' : null].filter(Boolean).join(' · ')}`
-                    : 'applied';
-            }
-        },
-        {
-            name: 'set_workspace_status',
-            description: 'Set a workspace’s status in Conductor’s sidebar (backlog, in-progress, in-review, done, canceled). Drives the real UI through the sidebar row menu, but changes nothing on screen. A collapsed section hides its rows from Accessibility, so folded sections are opened, used, and folded back — which makes this run a few seconds longer.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    workspace_id: { type: 'string' },
-                    status: { type: 'string', enum: ['backlog', 'in-progress', 'in-review', 'done', 'canceled'] }
-                },
-                required: ['workspace_id', 'status']
-            },
-            run: async (args) => {
-                const id = need(args, 'workspace_id');
-                const status = need(args, 'status');
-                const data = await call(routes.workspaceStatus.path(id), {
-                    method: routes.workspaceStatus.method,
-                    body: { status },
-                    timeoutMs: WRITE_TIMEOUT_MS
-                });
-                if (!data.ok)
-                    throw new Error(data.error ?? 'the status change did not land');
-                return `status set to ${status}`;
-            }
-        },
-        {
-            name: 'dev_server',
-            description: 'Inspect, start or stop a workspace’s configured Conductor Run task and tailnet preview. Use this instead of launching a long-lived development server from a shell: Conductor supplies the workspace ports, enforces run-mode rules and owns process cleanup, while the relay avoids duplicate starts. Status is the default and touches no UI. Start and stop DRIVE THE REAL UI and can steal focus for a few seconds; confirm before controlling a workspace the user did not name. Starting requires Tailscale and, when status lists multiple Run configs, an exact run_config_id.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    workspace_id: { type: 'string', description: 'The live local workspace to control.' },
-                    action: {
-                        type: 'string',
-                        enum: ['status', 'start', 'stop'],
-                        description: 'Default status. Start and stop use Conductor’s managed Run task.'
-                    },
-                    run_config_id: {
-                        type: 'string',
-                        description: 'Exact ID printed by status. Only valid for start; required when more than one is listed.'
-                    }
-                },
-                required: ['workspace_id']
-            },
-            run: async (args) => {
-                const id = need(args, 'workspace_id');
-                const action = str(args.action) ?? 'status';
-                if (action !== 'status' && action !== 'start' && action !== 'stop')
-                    throw new Error('action is invalid');
-                const runConfigId = str(args.run_config_id);
-                if (args.run_config_id !== undefined && !runConfigId)
-                    throw new Error('run_config_id must be a non-empty string');
-                if (runConfigId && action !== 'start')
-                    throw new Error('run_config_id is only valid with action start');
-                if (action === 'status') {
-                    const state = await call(routes.devServer.path(id));
-                    return formatDevServer(state);
-                }
-                const route = action === 'start' ? routes.startDevServer : routes.stopDevServer;
-                const result = await call(route.path(id), {
-                    method: route.method,
-                    ...(action === 'start' && runConfigId ? { body: { runConfigId } } : {}),
-                    timeoutMs: WRITE_TIMEOUT_MS
-                });
-                if (!result.ok)
-                    throw new Error(result.error ?? `could not ${action} the dev server`);
-                const headline = action === 'start'
-                    ? result.changed === false
-                        ? 'already running'
-                        : 'started'
-                    : result.changed === false
-                        ? 'already stopped'
-                        : 'stopped';
-                return formatDevServer(result, headline);
-            }
-        },
-        {
-            name: 'archive_workspace',
-            description: 'Archive a workspace — Conductor’s own ⌘⇧A, which deletes its worktree and takes any agent still working in it down with it. The chat survives archiving and stays readable through search_chats and read_chat. Drives the real UI: it focuses the workspace on the Mac first, so confirm with the user before archiving one they did not name. A workspace with an agent working is refused unless stop_agents is true.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    workspace_id: { type: 'string' },
-                    stop_agents: {
-                        type: 'boolean',
-                        description: 'Archive even though agents are still working here, ending their turns.'
-                    }
-                },
-                required: ['workspace_id']
-            },
-            run: async (args) => {
-                const id = need(args, 'workspace_id');
-                const data = await call(routes.archiveWorkspace.path(id), {
-                    method: routes.archiveWorkspace.method,
-                    body: { stopAgents: args.stop_agents === true },
-                    timeoutMs: WRITE_TIMEOUT_MS
-                });
-                if (!data.ok)
-                    throw new Error(data.error ?? 'the archive did not land');
-                if (data.alreadyArchived)
-                    return 'already archived';
-                return `archived ${data.workspace ? workspaceTitle(data.workspace) : id}`;
-            }
-        },
-        {
-            name: 'dismiss_prompt',
-            description: 'Throw away a prompt the relay is still holding — a new workspace’s first prompt waiting on setup, or one parked behind a locked Mac. Touches no UI. list_workspaces shows these; a failed one stays visible until it is dismissed, on purpose. Pass session_id for a parked prompt, workspace_id for a first prompt.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    session_id: { type: 'string', description: 'Dismiss the prompt parked for this chat.' },
-                    workspace_id: { type: 'string', description: 'Dismiss this workspace’s undelivered first prompt.' }
-                }
-            },
-            run: async (args) => {
-                const sessionId = str(args.session_id);
-                const workspaceId = str(args.workspace_id);
-                // Both would be two deletes wearing one name, and the caller could not tell which
-                // half failed — so it is one or the other, never both.
-                if (!sessionId && !workspaceId)
-                    throw new Error('pass session_id or workspace_id');
-                if (sessionId && workspaceId)
-                    throw new Error('pass session_id or workspace_id, not both');
-                const route = sessionId ? routes.dismissParkedPrompt : routes.dismissFirstPrompt;
-                await call(route.path((sessionId ?? workspaceId)), { method: route.method });
-                return 'dismissed';
-            }
-        },
-        {
-            name: 'keep_awake',
-            description: 'Read or set the window that holds this Mac awake with the lid shut. Touches no UI. This is what keeps the relay reachable at all, so a long unattended run wants it: without it a closed lid sleeps the Mac and every agent on it stops. Needs `conductor-remote nosleep setup` to have been run once; without that the status says so and holding fails. Releasing a window while the lid is shut sleeps the Mac straight away.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    action: {
-                        type: 'string',
-                        enum: ['status', 'hold', 'release'],
-                        description: 'Default status.'
-                    },
-                    seconds: { type: 'number', description: 'How long to hold it awake. Required for hold.' }
-                }
-            },
-            run: async (args) => {
-                const action = str(args.action) ?? 'status';
-                if (action === 'status') {
-                    const s = await call(routes.nosleep.path());
-                    if (!s.available)
-                        return 'unavailable — run `conductor-remote nosleep setup` on the Mac first';
-                    if (!s.armed)
-                        return `sleeping normally; a window can be up to ${s.maxSeconds}s`;
-                    return `awake${s.until ? `, expires ${relative(s.until)}` : ' until stopped'} (pid ${s.pid})`;
-                }
-                if (action === 'release') {
-                    const r = await call(routes.disarmNoSleep.path(), { method: routes.disarmNoSleep.method });
-                    if (!r.ok)
-                        throw new Error(r.error ?? 'could not release the window');
-                    return r.willSleep ? 'released — the lid is shut, so the Mac is going to sleep now' : 'released';
-                }
-                if (action !== 'hold')
-                    throw new Error(`unknown action ${action}`);
-                const seconds = num(args.seconds);
-                if (seconds === undefined)
-                    throw new Error('seconds is required for hold');
-                const r = await call(routes.armNoSleep.path(), {
-                    method: routes.armNoSleep.method,
-                    body: { seconds }
-                });
-                if (!r.ok)
-                    throw new Error(r.error ?? 'could not hold the Mac awake');
-                return `awake${r.state.until ? `, expires ${relative(r.state.until)}` : ''}`;
-            }
-        },
-        {
-            name: 'relay_logs',
-            description: 'The relay’s own log — why a send failed, whether Conductor refused Accessibility, what the network did. Touches no UI. Default is the running relay’s captured console; `file` tails the daemon’s log on disk, which is the only place a *previous* process’s crash survives. Secrets are redacted before it leaves the relay.',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    file: {
-                        type: 'string',
-                        enum: ['relay.log', 'relay.err.log'],
-                        description: 'Omit for this process’s live log.'
-                    },
-                    limit: { type: 'number', description: 'Most recent N lines. Default 200, max 2000.' },
-                    contains: {
-                        type: 'string',
-                        description: 'Keep only lines containing this (case-insensitive). Filtered here, not by the relay.'
-                    }
-                }
-            },
-            run: async (args) => {
-                const file = str(args.file);
-                const limit = Math.min(2000, Math.max(1, Math.trunc(num(args.limit) ?? 200)));
-                const q = new URLSearchParams({ limit: String(limit) });
-                if (file)
-                    q.set('file', file);
-                const data = await call(`${routes.logs.path()}?${q}`);
-                const needle = str(args.contains)?.toLowerCase();
-                const kept = needle ? data.entries.filter(e => e.text.toLowerCase().includes(needle)) : data.entries;
-                if (!kept.length)
-                    return needle ? `no line in ${data.source} matches ${needle}` : `${data.source} is empty`;
-                const lines = kept.map(e => `${stamp(e.t)} ${e.level === 'info' ? '' : `${e.level.toUpperCase()} `}${clip(e.text, 2000)}`);
-                // Whose log this is decides what it proves: an unmanaged relay's files belong to a
-                // *different* process, so a clean tail there says nothing about the one just called.
-                const head = data.managed
-                    ? data.source
-                    : `${data.source} (written by the LaunchAgent, not the relay just called)`;
-                return [`— ${head}, ${kept.length} lines —`, ...lines].join('\n');
-            }
-        }
-    ];
-}
-const ok = (id, result) => ({ jsonrpc: '2.0', id: id ?? null, result });
-const err = (id, code, message) => ({
-    jsonrpc: '2.0',
-    id: id ?? null,
-    error: { code, message }
-});
-/**
- * Handle one JSON-RPC message. Returns null for a notification, which by spec takes
- * no reply at all — stdio writes nothing and HTTP answers 202.
- */
-export async function handleRpc(tools, req) {
-    const notification = req.id === undefined || req.id === null;
-    switch (req.method) {
-        case 'initialize': {
-            const asked = str(req.params?.protocolVersion);
-            return ok(req.id, {
-                // Echo the client's version when we know it, else name our newest. A client
-                // that can't live with the answer disconnects, which is the spec's own path.
-                protocolVersion: asked && PROTOCOL_VERSIONS.includes(asked) ? asked : PROTOCOL_VERSIONS[0],
-                capabilities: { tools: {} },
-                serverInfo: SERVER_INFO,
-                instructions: INSTRUCTIONS
-            });
-        }
-        case 'notifications/initialized':
-        case 'notifications/cancelled':
-            return null;
-        case 'ping':
-            return notification ? null : ok(req.id, {});
-        case 'tools/list':
-            return ok(req.id, {
-                tools: tools.map(t => ({ name: t.name, description: t.description, inputSchema: t.inputSchema }))
-            });
-        case 'tools/call': {
-            const name = str(req.params?.name);
-            const tool = tools.find(t => t.name === name);
-            if (!tool)
-                return err(req.id, -32602, `unknown tool: ${name}`);
-            const args = req.params?.arguments ?? {};
-            try {
-                const text = await tool.run(args);
-                return ok(req.id, { content: [{ type: 'text', text: text || '(no output)' }] });
-            }
-            catch (e) {
-                // A tool failure is a result the model should see and can act on, not a
-                // protocol error that would hide the reason behind a transport code.
-                const message = e instanceof Error ? e.message : String(e);
-                return ok(req.id, { content: [{ type: 'text', text: message }], isError: true });
-            }
-        }
-        default:
-            return notification ? null : err(req.id, -32601, `method not found: ${req.method}`);
-    }
-}