autodev-cli 1.4.86 → 1.4.94

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,12 @@ 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");
+const graphStore_1 = require("../graphStore");
 /**
  * `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 +71,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 +177,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 +202,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 +241,195 @@ 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: [],
+            },
+        };
+        // ── Project graph (durable, shared, cross-session memory) ────────────────
+        // A typed knowledge/work graph persisted under `<workspace>/.autodev/graph/`.
+        // DISTINCT from prose memory: structured, sourced, versioned facts that many
+        // agents read and write across sessions. The graph tools below are
+        // bridge-synthesized (handled locally, never proxied to the office) so they
+        // reach every provider uniformly — like wait_for_events / ask_user.
+        const graphRunId = `run-${new Date().toISOString().replace(/[^0-9]/g, '').slice(0, 14)}-${crypto.randomBytes(2).toString('hex')}`;
+        const graphIdentity = {
+            agentId: String(settings.agentName
+                || settings.characterName
+                || settings.name
+                || path.basename(cwd) || 'agent'),
+            runId: graphRunId,
+        };
+        const graph = new graphStore_1.GraphStore(cwd, graphIdentity);
+        const GRAPH_TOOLS = [
+            {
+                name: 'graph_add_node',
+                description: `Write a typed fact to the durable PROJECT GRAPH (\`.autodev/graph/\`, shared across agents and sessions — the graph persists after your context is gone). This is NOT prose memory; it is a structured, sourced, versioned graph. Node types: ${graphStore_1.NODE_TYPES.join(' | ')}. Provenance (your run + agent id) is attached automatically. INVARIANTS enforced: a 'claim' needs source:"file:line"/url/source-node-id OR inference:true; an 'artifact' needs version; an 'evaluation' needs rubric. Entities dedupe by name (idempotent — re-adding merges aliases). Returns the node id to link with graph_add_edge.`,
+                inputSchema: { type: 'object', properties: {
+                        type: { type: 'string', description: `One of: ${graphStore_1.NODE_TYPES.join(', ')}` },
+                        name: { type: 'string', description: 'Short label / surface form of the fact.' },
+                        id: { type: 'string', description: 'Pin an id to upsert an existing node (optional; entities auto-dedupe by name).' },
+                        body: { type: 'string', description: 'Fuller detail (optional).' },
+                        source: { type: 'string', description: 'Where the fact came from: a file:line, url, or a source-node id. Required for claims unless inference:true.' },
+                        inference: { type: 'boolean', description: 'Set true for a claim that is your reasoning, not a cited source.' },
+                        version: { type: 'string', description: 'For artifacts: the version/commit/semver this node describes.' },
+                        rubric: { type: 'string', description: 'For evaluations: the criteria judged against.' },
+                        aliases: { type: 'array', description: 'Other names for this entity.', items: { type: 'string' } },
+                        props: { type: 'object', description: 'Arbitrary structured attributes.' },
+                    }, required: ['type', 'name'] },
+            },
+            {
+                name: 'graph_add_edge',
+                description: `Link two project-graph nodes with a typed, optionally-sourced edge. Edge types: ${graphStore_1.EDGE_TYPES.join(' | ')}. Pass the from/to node ids returned by graph_add_node or graph_query.`,
+                inputSchema: { type: 'object', properties: {
+                        type: { type: 'string', description: `One of: ${graphStore_1.EDGE_TYPES.join(', ')}` },
+                        from: { type: 'string', description: 'Source node id.' },
+                        to: { type: 'string', description: 'Target node id.' },
+                        source: { type: 'string', description: 'Evidence for this relationship (optional).' },
+                        props: { type: 'object' },
+                    }, required: ['type', 'from', 'to'] },
+            },
+            {
+                name: 'graph_query',
+                description: 'Search the project graph for nodes by type and/or free text. Returns matching nodes (freshest first) with ids to expand or link. Superseded nodes are hidden unless include_superseded is set.',
+                inputSchema: { type: 'object', properties: {
+                        type: { type: 'string', description: 'Filter by node type.' },
+                        text: { type: 'string', description: 'Case-insensitive substring over name/body/aliases.' },
+                        id: { type: 'string', description: 'Fetch one node by id.' },
+                        include_superseded: { type: 'boolean' },
+                        limit: { type: 'integer', description: 'Max results (default 30, max 200).' },
+                    }, required: [] },
+            },
+            {
+                name: 'graph_neighbors',
+                description: "Build task context FROM the graph (not a dump): resolve a node/entity by id or name, expand 1-3 hops over allowed edge types, and return a small, citable subgraph. Call this at the START of a task to recall what the swarm already knows before acting.",
+                inputSchema: { type: 'object', properties: {
+                        id: { type: 'string', description: 'Center node id (or use name).' },
+                        name: { type: 'string', description: 'Center node by name/alias (resolved to the node).' },
+                        hops: { type: 'integer', description: 'Expansion depth 1-3 (default 1).' },
+                        edge_types: { type: 'array', description: 'Restrict traversal to these edge types.', items: { type: 'string' } },
+                        limit: { type: 'integer', description: 'Max edges to return (default 40).' },
+                    }, required: [] },
+            },
+            {
+                name: 'graph_supersede',
+                description: "Version a fact instead of deleting it: create a replacement node, link it with a 'supersedes' edge, and flag the old node (which stays addressable). Use when a stored fact changed.",
+                inputSchema: { type: 'object', properties: {
+                        old_id: { type: 'string', description: 'Id of the node being replaced.' },
+                        name: { type: 'string', description: 'Name of the replacement node.' },
+                        body: { type: 'string' }, source: { type: 'string' }, inference: { type: 'boolean' },
+                        version: { type: 'string' }, rubric: { type: 'string' }, props: { type: 'object' },
+                    }, required: ['old_id', 'name'] },
+            },
+            {
+                name: 'graph_stats',
+                description: 'Health of the project graph: node/edge counts by type, superseded count, isolated (unlinked) nodes, contradictions, and open questions. Use to spot gaps worth filling.',
+                inputSchema: { type: 'object', properties: {}, required: [] },
+            },
+        ];
+        const graphToolNames = new Set(GRAPH_TOOLS.map((t) => t.name));
+        // Serialize a node/edge compactly for the model — stable ids for citation.
+        const fmtNode = (n) => {
+            const tags = [];
+            if (n.source) {
+                tags.push(`src=${n.source}`);
+            }
+            if (n.version) {
+                tags.push(`v=${n.version}`);
+            }
+            if (n.inference) {
+                tags.push('inference');
+            }
+            if (n.supersededBy) {
+                tags.push(`superseded→${n.supersededBy}`);
+            }
+            const body = n.body ? ` — ${n.body.replace(/\s+/g, ' ').slice(0, 160)}` : '';
+            return `- [${n.id}] ${n.type} "${n.name}"${tags.length ? ' (' + tags.join(', ') + ')' : ''}${body}`;
+        };
+        const handleGraphTool = (name, a) => {
+            try {
+                if (name === 'graph_add_node') {
+                    const { node, created } = graph.addNode({
+                        type: String(a.type ?? ''), name: String(a.name ?? ''),
+                        id: a.id ? String(a.id) : undefined, body: a.body ? String(a.body) : undefined,
+                        source: a.source ? String(a.source) : undefined,
+                        inference: a.inference === true || undefined,
+                        version: a.version ? String(a.version) : undefined,
+                        rubric: a.rubric ? String(a.rubric) : undefined,
+                        aliases: Array.isArray(a.aliases) ? a.aliases.map(String) : undefined,
+                        props: (a.props && typeof a.props === 'object') ? a.props : undefined,
+                    });
+                    return `${created ? 'Created' : 'Updated'} node [${node.id}] ${node.type} "${node.name}". Link it with graph_add_edge.`;
+                }
+                if (name === 'graph_add_edge') {
+                    const e = graph.addEdge({
+                        type: String(a.type ?? ''), from: String(a.from ?? ''), to: String(a.to ?? ''),
+                        source: a.source ? String(a.source) : undefined,
+                        props: (a.props && typeof a.props === 'object') ? a.props : undefined,
+                    });
+                    return `Added edge [${e.id}]: (${e.from}) -${e.type}-> (${e.to}).`;
+                }
+                if (name === 'graph_query') {
+                    const rows = graph.query({
+                        type: a.type ? String(a.type) : undefined, text: a.text ? String(a.text) : undefined,
+                        id: a.id ? String(a.id) : undefined, includeSuperseded: a.include_superseded === true,
+                        limit: a.limit ? Number(a.limit) : undefined,
+                    });
+                    return rows.length ? `${rows.length} node(s):\n${rows.map(fmtNode).join('\n')}` : 'No matching nodes. Add facts with graph_add_node.';
+                }
+                if (name === 'graph_neighbors') {
+                    const res = graph.neighbors({
+                        idOrName: String(a.id ?? a.name ?? ''), hops: a.hops ? Number(a.hops) : undefined,
+                        edgeTypes: Array.isArray(a.edge_types) ? a.edge_types.map(String) : undefined,
+                        limit: a.limit ? Number(a.limit) : undefined,
+                    });
+                    if (!res) {
+                        return `No node matches "${String(a.id ?? a.name ?? '')}". Try graph_query first.`;
+                    }
+                    const edgeLines = res.edges.map((e) => `- (${e.from}) -${e.type}-> (${e.to})${e.source ? ` [src=${e.source}]` : ''}`);
+                    return `Context around [${res.center.id}] "${res.center.name}":\nNODES (${res.nodes.length}):\n${res.nodes.map(fmtNode).join('\n')}\nEDGES (${res.edges.length}):\n${edgeLines.join('\n') || '(none)'}`;
+                }
+                if (name === 'graph_supersede') {
+                    const { oldId, node } = graph.supersede(String(a.old_id ?? ''), {
+                        type: '', name: String(a.name ?? ''), body: a.body ? String(a.body) : undefined,
+                        source: a.source ? String(a.source) : undefined, inference: a.inference === true || undefined,
+                        version: a.version ? String(a.version) : undefined, rubric: a.rubric ? String(a.rubric) : undefined,
+                        props: (a.props && typeof a.props === 'object') ? a.props : undefined,
+                    });
+                    return `Superseded [${oldId}] with [${node.id}] "${node.name}". The old node stays addressable.`;
+                }
+                if (name === 'graph_stats') {
+                    const s = graph.stats();
+                    const byType = (m) => Object.entries(m).map(([k, v]) => `${k}:${v}`).join(', ') || '(none)';
+                    return `Project graph @ ${graph.path}\nnodes=${s.nodeCount} (${byType(s.nodesByType)})\nedges=${s.edgeCount} (${byType(s.edgesByType)})\nsuperseded=${s.superseded} · isolated=${s.isolated} · contradictions=${s.contradictions} · openQuestions=${s.openQuestions}`;
+                }
+                return `unknown graph tool: ${name}`;
+            }
+            catch (e) {
+                if (e instanceof graphStore_1.GraphInvariantError) {
+                    return `Rejected (graph invariant): ${e.message}`;
+                }
+                return `graph error: ${e?.message ?? String(e)}`;
+            }
+        };
         // ── 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 +458,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 +513,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 +548,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 +619,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 +704,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 +840,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 +977,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 +1164,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 +1179,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 +1234,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 +1253,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 +1269,160 @@ 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 tools: graph_* — read/write the durable project graph on local
+            // disk (.autodev/graph/). Handled here, never proxied to the office, so
+            // every provider gets the same persistent shared memory. Synchronous and
+            // fast (a JSONL append / in-memory replay), so no inflight bookkeeping.
+            if (req.method === 'tools/call' && typeof params?.name === 'string' && graphToolNames.has(params.name)) {
+                const args = (req.params?.arguments) ?? {};
+                const text = handleGraphTool(params.name, args);
+                return { jsonrpc: '2.0', id: req.id, result: { content: [{ type: 'text', text }] } };
+            }
+            // 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 +1431,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, ...GRAPH_TOOLS);
                     }
                 }
-                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