autodev-cli 1.4.86 → 1.4.93

package/out/agentBackup/layout.js

@@ -72,6 +72,7 @@ exports.WORKSPACE_DIRS = [
     '.autodev',
     path.posix.join('media', 'profile'),
     path.posix.join('media', 'skills'),
+    path.posix.join('.claude', 'skills'),
 ];
 /**
  * Identity/connection settings in `.autodev/settings.json` that are scoped to a

package/out/agentBackup/layout.js.map

@@ -1 +1 @@
-{"version":3,"file":"layout.js","sourceRoot":"","sources":["../../src/agentBackup/layout.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"layout.js","sourceRoot":"","sources":["../../src/agentBackup/layout.ts"],"names":[],"mappings":"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"}

package/out/commands/mcpOperate.js

@@ -45,6 +45,7 @@ const readline = __importStar(require("readline"));
 const child_process_1 = require("child_process");
 const url_1 = require("url");
 const settingsLoader_1 = require("../core/settingsLoader");
+const modelInfo_1 = require("../core/modelInfo");
 const officeSocket_1 = require("../officeSocket");
 const presenceGuard_1 = require("../presenceGuard");
 const fileBrowser_1 = require("../fileBrowser");
@@ -52,9 +53,11 @@ const gitRequest_1 = require("../git/gitRequest");
 const manager_1 = require("../vnc/manager");
 const manager_2 = require("../rdp/manager");
 const projectMcp_1 = require("../core/projectMcp");
+const projectSkills_1 = require("../core/projectSkills");
 const configManager_1 = require("../configManager");
 const version_1 = require("../version");
 const liveNarration_1 = require("../core/liveNarration");
+const redactSecrets_1 = require("../core/redactSecrets");
 /**
  * `autodev mcp-operate` — run a local stdio MCP server that lets a pure MCP
  * client (Claude Desktop/Code, etc.) operate a pixel-office character with NO
@@ -67,8 +70,12 @@ const liveNarration_1 = require("../core/liveNarration");
  * single command — no remote-server approval friction, and the key/url stay in
  * autodev config instead of being pasted into the client.
  *
- *   claude mcp add pixel-office -- autodev mcp-operate --key <api_key> --url <…/api/office-mcp>
+ *   claude mcp add pixel-office-<agent-slug> -- autodev mcp-operate --key <api_key> --url <…/api/office-mcp>
  *   # or, inside a bound workspace, just:  autodev mcp-operate
+ *
+ * Name each server pixel-office-<agent-slug> (not a bare "pixel-office"): one MCP
+ * client / Claude session can then operate SEVERAL office characters at once, each
+ * under its own server name, instead of every agent colliding on one shared name.
  */
 /** Derive the operator-MCP URL from a bound workspace's serverBaseUrl. */
 function officeMcpUrl(serverBaseUrl) {
@@ -169,15 +176,18 @@ function proxy(endpoint, key, body) {
 function mcpOperateCommand(program) {
     program
         .command('mcp-operate [path]')
-        .description('Run a stdio MCP server that operates a pixel-office agent (bridges to …/api/office-mcp). Add it with: claude mcp add pixel-office -- autodev mcp-operate --key <api_key> --url <url>')
+        .description('Run an MCP server that operates a pixel-office agent (bridges to …/api/office-mcp). Adds two bridge-synthesized tools on top of the office tools: wait_for_events (block on live office activity) and ask_user (ask the user a decision / multi-step wizard and BLOCK for their answer). Speaks stdio by default; add --http-port to run a PERSISTENT streamable-HTTP sidecar an opencode `type: remote` MCP can attach to. Add stdio with: claude mcp add pixel-office-<agent-slug> -- autodev mcp-operate --key <api_key> --url <url> (per-agent name lets one client run several characters at once). All outbound agent content (hook events, tool output, assistant narration, task results / A2A replies) is secret-redacted before it leaves the machine.')
         .option('--url <url>', 'Operator MCP URL (…/api/office-mcp). Default: derived from the workspace binding.')
         .option('--key <apiKey>', 'The character api_key (Bearer). Default: the workspace serverApiKey.')
+        .option('--http-port <port>', 'Run a persistent MCP-over-HTTP (Streamable HTTP) server on this port instead of stdio. Point an opencode `type: remote` MCP at http://<host>:<port>/mcp.', (v) => parseInt(v, 10))
+        .option('--http-host <host>', 'Bind address for --http-port (default 127.0.0.1).')
         .option('--no-socket', 'Do not open the presence WebSocket (stay on poll-based presence only).')
         .option('--file-browser', 'Serve the office file browser for this MCP-only agent (read/write files in the workspace over the office file browser).')
         .option('--git', 'Serve the office git panel for this MCP-only agent (status/diff/stage/commit/branch in the workspace over the office git panel).')
         .option('--vnc', 'Serve office VNC remote-desktop sessions for this MCP-only agent (input forwarding + framebuffer streaming).')
         .option('--rdp', 'Serve office RDP remote-desktop sessions for this MCP-only agent (input forwarding + framebuffer streaming).')
         .option('--mcp-update', 'Honor mcp_update frames: sync remote-supplied MCP config into the workspace (relaunch to pick up spawn changes).')
+        .option('--skill-update', 'Honor skill_update frames: sync remote-supplied Claude Code skills into the workspace (.claude/skills/<slug>/SKILL.md; live-reloads, no relaunch).')
         .action(async (workspacePath, opts) => {
         const cwd = workspacePath ? path.resolve(workspacePath) : process.cwd();
         let settings = (0, settingsLoader_1.loadSettingsForRoot)(cwd);
@@ -191,6 +201,7 @@ function mcpOperateCommand(program) {
         let vncEnabled = opts.vnc === true || settings.vncEnabled === true;
         let rdpEnabled = opts.rdp === true || settings.rdpEnabled === true;
         let mcpUpdateEnabled = opts.mcpUpdate === true || settings.mcpUpdateEnabled === true;
+        let skillUpdateEnabled = opts.skillUpdate === true || settings.skillUpdateEnabled === true;
         if (!endpoint || !key) {
             process.stderr.write('autodev mcp-operate: need --url and --key (or run inside a workspace bound to an office).\n');
             process.exit(1);
@@ -229,6 +240,29 @@ function mcpOperateCommand(program) {
             description: "Block until new office activity arrives over the live socket (or a timeout), then return it. Teammates' messages, status changes, task assignments and tool activity stream in as they happen — call this in a loop to react in real time. Returns any buffered events immediately.",
             inputSchema: { type: 'object', properties: { timeout_seconds: { type: 'integer', description: 'Max seconds to wait for the next event (default 25, max 55).' } }, required: [] },
         };
+        // ── Blocking user-decision tool (ask_user) ───────────────────────────────
+        // Ask the user to make a real decision — a single question OR a multi-step
+        // wizard — and BLOCK until they answer in the pixel-office chat, then return
+        // their answer so the model continues. Bridge-synthesized like WAIT_TOOL, so
+        // it reaches every provider (claude/opencode/grok/copilot) uniformly. The
+        // office holds the request state; this tool just creates it and polls.
+        const ASK_USER_TOOL = {
+            name: 'ask_user',
+            description: "Ask the user to make a decision and BLOCK for their answer. Use for genuine either/or choices the user must make. Provide clear options; set allow_other to let them type a custom answer; use steps for a multi-step wizard. Single question: pass { question, options, allow_other?, multi_select? }. Wizard: pass { title?, steps: [{ question, options, allow_other?, multi_select? }] }. Each option is a string OR an object { label, description }. IMPORTANT: if the call returns 'Still waiting...', call ask_user AGAIN with the SAME { request_id } it gives you (do NOT create a new question) — keep re-calling until you get the user's answer.",
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    question: { type: 'string', description: 'The decision to ask (single-question form).' },
+                    options: { type: 'array', description: 'Choices for the single question — strings, or { label, description } objects.', items: {} },
+                    allow_other: { type: 'boolean', description: 'Let the user type a custom free-text answer in addition to the listed options.' },
+                    multi_select: { type: 'boolean', description: 'Let the user pick more than one option.' },
+                    title: { type: 'string', description: 'Optional title shown above a multi-step wizard.' },
+                    steps: { type: 'array', description: 'Wizard steps (multi-step form) — each { question, options, allow_other?, multi_select? }.', items: { type: 'object' } },
+                    request_id: { type: 'string', description: 'Resume waiting for an EXISTING request (do NOT create a new one). Pass the id from a prior "Still waiting" ask_user result to keep polling until the user answers.' },
+                },
+                required: [],
+            },
+        };
         // ── Presence WebSocket (optional; --no-socket disables) ──────────────────
         // Holds a live connection so the office shows this MCP agent genuinely
         // online, and surfaces task/message pushes to the client as MCP
@@ -257,7 +291,20 @@ function mcpOperateCommand(program) {
             const id = body.id !== undefined && body.id !== null ? body.id : `wsreq-${++wsReqSeq}`;
             const k = String(id);
             const timer = setTimeout(() => { wsPending.delete(k); reject(new Error('operator_request timed out')); }, 20_000);
-            wsPending.set(k, (resp) => { clearTimeout(timer); resolve(resp); });
+            wsPending.set(k, (resp) => {
+                clearTimeout(timer);
+                // A JSON-RPC error with no result (e.g. a stale long-running WS server
+                // missing a newly-added office tool) → REJECT so callOffice fails over
+                // to the HTTP proxy, which php-fpm always serves with fresh code. A
+                // normal result resolves. Without this, a stale WS silently returns an
+                // empty result and callers like ask_user hard-fail on JSON.parse('').
+                if (resp && resp['error'] && (resp['result'] === undefined || resp['result'] === null)) {
+                    reject(new Error(String(resp['error']?.message ?? 'operator_response error')));
+                }
+                else {
+                    resolve(resp);
+                }
+            });
             socket.sendFrame({ type: 'operator_request', id, method: body.method, params: body.params ?? {} });
         });
         // Prefer the socket when ready; fall back to HTTP otherwise (startup handshake,
@@ -299,6 +346,7 @@ function mcpOperateCommand(program) {
             vncEnabled = opts.vnc === true || settings.vncEnabled === true;
             rdpEnabled = opts.rdp === true || settings.rdpEnabled === true;
             mcpUpdateEnabled = opts.mcpUpdate === true || settings.mcpUpdateEnabled === true;
+            skillUpdateEnabled = opts.skillUpdate === true || settings.skillUpdateEnabled === true;
             applyRemoteDesktopSettings();
         };
         // ── Live MCP-config reload (mcp_update frame) ────────────────────────────
@@ -333,6 +381,33 @@ function mcpOperateCommand(program) {
                 logErr(`⚠️ MCP update failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         };
+        // ── Live skill reload (skill_update frame) ───────────────────────────────
+        // The office pushes the agent's FULL effective skill set. Skills live-reload
+        // (Claude re-reads .claude/skills each run), so there is nothing to relaunch —
+        // sanitize, full-replace on disk, fold prose for non-Claude providers, report.
+        const handleSkillUpdate = (skills) => {
+            reloadBridgeSettings();
+            if (!skillUpdateEnabled) {
+                logErr('🔒 skill_update ignored — skillUpdateEnabled is off (set it in .autodev/settings.json or pass --skill-update to allow)');
+                return;
+            }
+            logErr('🧩 skill_update received — validating and writing .claude/skills…');
+            const { safe, rejected } = (0, projectSkills_1.sanitizeRemoteSkills)(cwd, skills);
+            if (rejected.length) {
+                logErr(`⚠️ skill_update dropped ${rejected.length} entr${rejected.length === 1 ? 'y' : 'ies'}: ${rejected.map(r => `${r.name} (${r.reason})`).join(', ')}`);
+            }
+            try {
+                const { written, removed } = (0, projectSkills_1.saveProjectSkills)(cwd, safe);
+                if (!(0, projectSkills_1.providerConsumesSkills)(settings.provider)) {
+                    (0, projectSkills_1.foldSkillsIntoProfile)(cwd, safe);
+                }
+                void configManager_1.ConfigManager.reportProjectSkills(cwd, written, logErr);
+                logErr(`✅ skills synced — wrote ${written.length}, removed ${removed.length} (.claude/skills). Live-reloads on the next run — no relaunch.`);
+            }
+            catch (err) {
+                logErr(`⚠️ skill update failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        };
         // ── Presence socket lifecycle (runtime-driven, self-healing) ─────────────
         // Whether the bridge holds the presence socket is decided at RUNTIME from
         // ACTUAL loop presence, NOT a static config flag. A co-located `autodev
@@ -377,6 +452,10 @@ function mcpOperateCommand(program) {
             log: (l) => process.stderr.write(l + '\n'),
             meta: {
                 provider: 'mcp-operator', cliVersion: version_1.CLI_VERSION,
+                // The MCP-only agent's worker provider drives real turns; announce its
+                // effective model (undefined when it runs an account default) so the
+                // office can badge the model. 'mcp-operator' is only the transport marker.
+                model: (0, modelInfo_1.resolveConfiguredModel)(settings),
                 fileBrowserEnabled, gitEnabled, vncEnabled, rdpEnabled,
                 // Announce the desktop host/port too (parity with the loop's meta) so
                 // the office persists the real target instead of defaulting to :5900.
@@ -458,6 +537,14 @@ function mcpOperateCommand(program) {
                     }
                     return;
                 }
+                // Live skill reload frame from the office (full effective skill set).
+                if (msgType === 'skill_update') {
+                    const skills = msg['skills'];
+                    if (Array.isArray(skills)) {
+                        handleSkillUpdate(skills);
+                    }
+                    return;
+                }
                 const notice = describePush(msg);
                 if (notice) {
                     // Buffer for wait_for_events (the reliable real-time path)…
@@ -586,7 +673,9 @@ function mcpOperateCommand(program) {
             let transcriptOffset = 0;
             const seenAsst = new Set(); // assistant-entry uuids already forwarded
             const forwardAssistant = (text) => {
-                const msg = text.trim();
+                // Redact secrets from the assistant prose BEFORE it leaves the machine
+                // — this bubble is stored + rendered in the office chat.
+                const msg = (0, redactSecrets_1.redactSecrets)(text.trim());
                 if (!msg || !socket) {
                     return;
                 }
@@ -721,7 +810,9 @@ function mcpOperateCommand(program) {
                                 continue;
                             }
                             ev._session_name = sessionNameForHooks; // so the office can label it
-                            socket.sendFrame({ type: 'hook_event', data: ev });
+                            // Redact secrets from the whole hook object (tool_input.command,
+                            // tool_response, file contents, …) before it leaves the machine.
+                            socket.sendFrame({ type: 'hook_event', data: (0, redactSecrets_1.redactDeep)(ev) });
                             const name = ev['hook_event_name'] || ev['hook'] || ev['event'] || '';
                             if (WORKING_HOOKS.has(name)) {
                                 sawWork = true;
@@ -906,7 +997,8 @@ function mcpOperateCommand(program) {
                     }
                     await officeTool('start_task', { task_id: t.id });
                     const result = await runWorker(`You are working as the office agent in this workspace. Complete this task using your own tools (edit/create files as needed), then briefly summarize what you did.\n\nTASK: ${t.title}`);
-                    await officeTool('complete_task', { task_id: t.id, result: (result || 'Done.').slice(0, 1500) });
+                    // The worker summary is stored + shown in the office task feed — redact secrets.
+                    await officeTool('complete_task', { task_id: t.id, result: (0, redactSecrets_1.redactSecrets)((result || 'Done.').slice(0, 1500)) });
                     logErr(`🤖 autonomy: completed task ${t.id} (${t.title.slice(0, 40)})`);
                 }
                 // A2A: reply to direct messages (check_messages). The worker composes a
@@ -920,7 +1012,8 @@ function mcpOperateCommand(program) {
                     }
                     const reply = (await runWorker(`A teammate "${m.from}" sent you this message in the office:\n\n"${m.body}"\n\nIf a reply is warranted, output ONLY the reply text — concise, and do NOT ask a question back unless truly essential. If the message needs work in this workspace, do it, then reply with what you did. If no reply is needed, output exactly: NO_REPLY`)).trim();
                     if (reply && !/^NO_REPLY/i.test(reply)) {
-                        await officeTool('send_message', { to: m.from, message: reply.slice(0, 1000) });
+                        // The A2A reply is delivered + shown in the office chat — redact secrets.
+                        await officeTool('send_message', { to: m.from, message: (0, redactSecrets_1.redactSecrets)(reply.slice(0, 1000)) });
                         logErr(`🤖 autonomy: replied to ${m.from}`);
                         replied++;
                     }
@@ -974,20 +1067,15 @@ function mcpOperateCommand(program) {
                 process.stdout.write('', () => process.exit(0));
             }
         };
-        rl.on('line', async (line) => {
-            const t = line.trim();
-            if (!t) {
-                return;
-            }
-            let req;
-            try {
-                req = JSON.parse(t);
-            }
-            catch {
-                return;
-            }
+        // ── Single JSON-RPC request path (shared by stdio + HTTP) ────────────────
+        // Process ONE inbound MCP message and return the response object to send
+        // back, or null for a notification / message with no reply. Both the stdio
+        // line reader and the HTTP handler call this, so wait_for_events blocking,
+        // tools/list augmentation, and notification forwarding all live in ONE place
+        // regardless of transport.
+        const dispatch = async (req) => {
             // Notifications (no id) are one-way — nothing to reply. Forward the
-            // handshake ones opportunistically but never write a response for them.
+            // handshake ones opportunistically but never return a response for them.
             if (req.id === undefined || req.id === null) {
                 if (typeof req.method === 'string' && req.method.startsWith('notifications/')) {
                     // Fire-and-forget over the socket when ready, else HTTP.
@@ -998,7 +1086,7 @@ function mcpOperateCommand(program) {
                         proxy(endpoint, key, req).catch(() => { });
                     }
                 }
-                return;
+                return null;
             }
             // Local tool: wait_for_events — stream office activity from the socket
             // instead of proxying to the server. Blocks until an event (or timeout).
@@ -1014,13 +1102,151 @@ function mcpOperateCommand(program) {
                     const text = events.length
                         ? `Office activity (${events.length} event${events.length === 1 ? '' : 's'}):\n${events.join('\n')}\n\nUse get_events / check_messages for detail, then call wait_for_events again to keep listening.`
                         : `No new events in ${secs}s. Call wait_for_events again to keep listening.`;
-                    send({ jsonrpc: '2.0', id: req.id, result: { content: [{ type: 'text', text }] } });
+                    return { jsonrpc: '2.0', id: req.id, result: { content: [{ type: 'text', text }] } };
+                }
+                finally {
+                    inflight--;
+                    maybeExit();
+                }
+            }
+            // Local blocking tool: ask_user — create a user-decision request in the
+            // office and BLOCK until the user answers in pixel-office chat (or a cap
+            // elapses). Poll get_choice_answer in SHORT calls (never one long call:
+            // the WS proxy caps at 20s, HTTP at 120s) and keep the agent's status
+            // fresh so it doesn't flip to idle while blocked. inflight++/maybeExit
+            // exactly like wait_for_events keeps the process alive while waiting.
+            if (req.method === 'tools/call' && params?.name === 'ask_user') {
+                inflight++;
+                // Tunables (mirror wait_for_events' small consts).
+                const ASK_INVOCATION_MS = 50_000; // cap ONE call under opencode's ~60s remote-MCP client timeout; the model re-calls with request_id to keep waiting
+                const ASK_POLL_MS = 3_000; // short poll cadence (office is fast)
+                const ASK_HEARTBEAT_MS = 60_000; // refresh 'waiting' status well under the 120s idle flip
+                try {
+                    const a = (req.params?.arguments) ?? {};
+                    // Call an office tool over the same WS/HTTP channel and read its first
+                    // text-content block (same extraction as officeTool / wait_for_events).
+                    const askOfficeTool = async (name, args) => {
+                        const r = await callOffice({ id: `ask-${name}-${++wsReqSeq}`, method: 'tools/call', params: { name, arguments: args } });
+                        return (r['result']?.content?.[0]?.text) ?? '';
+                    };
+                    // Build create_choice_request arguments: pass through single OR wizard
+                    // form untouched (the office validates the shape).
+                    const createArgs = {};
+                    const isWizard = Array.isArray(a['steps']);
+                    if (isWizard) {
+                        createArgs.steps = a['steps'];
+                        if (typeof a['title'] === 'string') {
+                            createArgs.title = a['title'];
+                        }
+                    }
+                    else {
+                        if (a['question'] !== undefined) {
+                            createArgs.question = a['question'];
+                        }
+                        if (a['options'] !== undefined) {
+                            createArgs.options = a['options'];
+                        }
+                        if (a['allow_other'] !== undefined) {
+                            createArgs.allow_other = a['allow_other'];
+                        }
+                        if (a['multi_select'] !== undefined) {
+                            createArgs.multi_select = a['multi_select'];
+                        }
+                    }
+                    // Format the office's answer array into readable text for the model.
+                    const fmtOne = (ans) => {
+                        const other = ans?.otherText ? String(ans.otherText) : '';
+                        if (Array.isArray(ans?.values) && ans.values.length > 0) {
+                            const v = ans.values.map((x) => `"${String(x)}"`).join(', ');
+                            return other ? `${v} (other: "${other}")` : v;
+                        }
+                        const hasValue = ans?.value !== undefined && ans?.value !== null && String(ans.value) !== '';
+                        if (hasValue) {
+                            return other ? `"${String(ans.value)}" (other: "${other}")` : `"${String(ans.value)}"`;
+                        }
+                        // Free-text only (no preset option chosen): show the typed answer directly.
+                        return other ? `"${other}"` : '"(no answer)"';
+                    };
+                    const formatAnswers = (answers) => {
+                        if (!Array.isArray(answers) || answers.length === 0) {
+                            return 'The user answered, but no selection was returned.';
+                        }
+                        if (!isWizard && answers.length === 1) {
+                            return `The user chose: ${fmtOne(answers[0])}`;
+                        }
+                        const steps = a['steps'] ?? [];
+                        const lines = answers.map((ans) => {
+                            const idx = typeof ans?.stepIndex === 'number' ? ans.stepIndex : 0;
+                            const q = steps[idx]?.question ?? `step ${idx + 1}`;
+                            return `Step ${idx + 1} (${q}): ${fmtOne(ans)}`;
+                        });
+                        return `The user completed the wizard:\n${lines.join('\n')}`;
+                    };
+                    // 1) Create the request — UNLESS resuming an existing one (request_id
+                    // passed back after a prior "Still waiting" return). Resuming avoids
+                    // re-asking and lets a long wait span several short sub-60s calls.
+                    let requestId = typeof a['request_id'] === 'string' ? String(a['request_id']).trim() : '';
+                    if (!requestId) {
+                        try {
+                            const createText = await askOfficeTool('create_choice_request', createArgs);
+                            const parsed = JSON.parse(createText);
+                            requestId = (parsed?.request_id ?? '').toString();
+                        }
+                        catch (e) {
+                            return { jsonrpc: '2.0', id: req.id, result: { content: [{ type: 'text', text: 'Could not create the user-decision request: ' + (e?.message ?? String(e)) + '. Nothing was shown to the user.' }] } };
+                        }
+                        if (!requestId) {
+                            return { jsonrpc: '2.0', id: req.id, result: { content: [{ type: 'text', text: 'The office did not return a request id — the user-decision request was not created, so no question reached the user.' }] } };
+                        }
+                    }
+                    // 2) BLOCK: re-poll get_choice_answer in short calls; heartbeat status.
+                    const started = Date.now();
+                    let lastBeat = Date.now();
+                    while (!closed) {
+                        // Return BEFORE the client's request timeout (opencode's remote MCP
+                        // caps a single call at ~60s). The request stays open server-side;
+                        // the model re-calls ask_user with this request_id to keep waiting.
+                        if (Date.now() - started > ASK_INVOCATION_MS) {
+                            return { jsonrpc: '2.0', id: req.id, result: { content: [{ type: 'text', text: `Still waiting for the user to answer — the question is live in the office chat. To keep waiting, call ask_user AGAIN with { "request_id": "${requestId}" } (do NOT create a new question).` }] } };
+                        }
+                        let statusText = '';
+                        try {
+                            statusText = await askOfficeTool('get_choice_answer', { request_id: requestId });
+                        }
+                        catch {
+                            statusText = '';
+                        }
+                        let status = 'pending';
+                        let answers = null;
+                        if (statusText) {
+                            try {
+                                const p = JSON.parse(statusText);
+                                status = p.status ?? 'pending';
+                                answers = p.answers ?? null;
+                            }
+                            catch { /* keep pending */ }
+                        }
+                        if (status === 'answered') {
+                            return { jsonrpc: '2.0', id: req.id, result: { content: [{ type: 'text', text: formatAnswers(answers) }] } };
+                        }
+                        if (status === 'cancelled') {
+                            return { jsonrpc: '2.0', id: req.id, result: { content: [{ type: 'text', text: 'The user dismissed the request without answering.' }] } };
+                        }
+                        // Heartbeat: keep the agent marked 'waiting' (best-effort) so it does
+                        // not flip to idle after ~120s while genuinely blocked on the user.
+                        if (Date.now() - lastBeat > ASK_HEARTBEAT_MS) {
+                            lastBeat = Date.now();
+                            askOfficeTool('set_status', { status: 'waiting' }).catch(() => { });
+                        }
+                        await new Promise((res) => { const t = setTimeout(res, ASK_POLL_MS); t.unref?.(); });
+                    }
+                    // Tool torn down (stdin closed / shutdown) before the user answered.
+                    return { jsonrpc: '2.0', id: req.id, result: { content: [{ type: 'text', text: 'The ask_user request was interrupted before the user answered.' }] } };
                 }
                 finally {
                     inflight--;
                     maybeExit();
                 }
-                return;
             }
             inflight++;
             try {
@@ -1029,20 +1255,134 @@ function mcpOperateCommand(program) {
                 if (req.method === 'tools/list') {
                     const result = res['result'];
                     if (result && Array.isArray(result.tools)) {
-                        result.tools.push(WAIT_TOOL);
+                        result.tools.push(WAIT_TOOL, ASK_USER_TOOL);
                     }
                 }
-                send(res);
+                return res;
             }
             catch (e) {
-                send({ jsonrpc: '2.0', id: req.id, error: { code: -32603, message: 'proxy error: ' + (e?.message ?? String(e)) } });
+                return { jsonrpc: '2.0', id: req.id, error: { code: -32603, message: 'proxy error: ' + (e?.message ?? String(e)) } };
             }
             finally {
                 inflight--;
                 maybeExit();
             }
-        });
-        rl.on('close', () => { closed = true; maybeExit(); });
+        };
+        // ── Transport: persistent HTTP (Streamable HTTP) OR stdio ────────────────
+        // opencode's `type: remote` MCP client (MCP.connectRemote) tries Streamable
+        // HTTP first — POST JSON-RPC to the configured `url`, Accept
+        // `application/json, text/event-stream` — then falls back to legacy SSE. It
+        // also opens a standalone GET SSE stream after `initialized` but TOLERATES a
+        // 405 there. So the persistent sidecar needs only: POST → single JSON-RPC
+        // reply as `application/json` (202 for notification-only bodies), GET → 405
+        // (no server-initiated stream; office activity reaches the model via the
+        // wait_for_events tool, exactly as over stdio). This lets ONE always-on
+        // bridge serve both `opencode serve` and every `opencode run` with no
+        // stdio-spawn dependency and no flap.
+        if (opts.httpPort) {
+            const httpHost = opts.httpHost || '127.0.0.1';
+            const sessionId = crypto.randomUUID();
+            const httpServer = http.createServer((hreq, hres) => {
+                // No standalone server→client SSE stream: the client tolerates 405 on
+                // the GET it opens after `initialized` (if(status===405)return).
+                if (hreq.method === 'GET') {
+                    hres.writeHead(405, { 'Content-Type': 'text/plain' });
+                    hres.end('Method Not Allowed');
+                    return;
+                }
+                // Session teardown — acknowledge and move on (stateless bridge).
+                if (hreq.method === 'DELETE') {
+                    hres.writeHead(204);
+                    hres.end();
+                    return;
+                }
+                if (hreq.method !== 'POST') {
+                    hres.writeHead(405, { 'Content-Type': 'text/plain' });
+                    hres.end('Method Not Allowed');
+                    return;
+                }
+                let body = '';
+                hreq.on('data', (c) => { body += c; if (body.length > 8 * 1024 * 1024) {
+                    hreq.destroy();
+                } });
+                hreq.on('end', async () => {
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(body);
+                    }
+                    catch {
+                        hres.writeHead(400, { 'Content-Type': 'application/json' });
+                        hres.end(JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } }));
+                        return;
+                    }
+                    const batch = Array.isArray(parsed);
+                    const msgs = (batch ? parsed : [parsed]);
+                    const isInit = msgs.some((m) => m && m.method === 'initialize');
+                    const responses = [];
+                    for (const m of msgs) {
+                        try {
+                            const r = await dispatch(m);
+                            if (r) {
+                                responses.push(r);
+                            }
+                        }
+                        catch (e) {
+                            if (m && m.id !== undefined && m.id !== null) {
+                                responses.push({ jsonrpc: '2.0', id: m.id, error: { code: -32603, message: 'bridge error: ' + (e?.message ?? String(e)) } });
+                            }
+                        }
+                    }
+                    // Notification/response-only body → 202 Accepted, no content.
+                    if (responses.length === 0) {
+                        hres.writeHead(202, isInit ? { 'Mcp-Session-Id': sessionId } : {});
+                        hres.end();
+                        return;
+                    }
+                    const headers = { 'Content-Type': 'application/json' };
+                    if (isInit) {
+                        headers['Mcp-Session-Id'] = sessionId;
+                    }
+                    hres.writeHead(200, headers);
+                    hres.end(JSON.stringify(batch ? responses : responses[0]));
+                });
+                hreq.on('error', () => { try {
+                    hres.writeHead(400);
+                    hres.end();
+                }
+                catch { /* ignore */ } });
+            });
+            httpServer.on('error', (e) => {
+                process.stderr.write(`autodev mcp-operate: HTTP server error — ${e instanceof Error ? e.message : String(e)}\n`);
+                process.exit(1);
+            });
+            httpServer.listen(opts.httpPort, httpHost, () => {
+                process.stderr.write(`autodev mcp-operate: persistent Streamable-HTTP MCP listening on http://${httpHost}:${opts.httpPort}/mcp (point an opencode \`type: remote\` MCP at this URL).\n`);
+            });
+            // No stdin client in HTTP mode — do NOT read/close on stdin (a detached
+            // sidecar has stdin closed, which would otherwise trip maybeExit). The
+            // HTTP server keeps the process alive.
+            rl.close();
+        }
+        else {
+            rl.on('line', async (line) => {
+                const t = line.trim();
+                if (!t) {
+                    return;
+                }
+                let req;
+                try {
+                    req = JSON.parse(t);
+                }
+                catch {
+                    return;
+                }
+                const resp = await dispatch(req);
+                if (resp) {
+                    send(resp);
+                }
+            });
+            rl.on('close', () => { closed = true; maybeExit(); });
+        }
     });
 }
 //# sourceMappingURL=mcpOperate.js.map