@wenrwa/marketplace-cli 0.7.8 → 0.8.2

package/dist/bridge/relayClient.js

@@ -56,6 +56,7 @@ exports.startRelayClient = startRelayClient;
  * that) — on re-pair the pane sends `attach` again and gets a fresh
  * `replay`, exactly as it would against the local server.
  */
+const agentLaunch_1 = require("./agentLaunch");
 const resumeDetector_1 = require("./resumeDetector");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -976,7 +977,7 @@ function startRelayClient(opts) {
                     case 'open': {
                         // Capture into locals so the async .then closures below keep the
                         // discriminated-union narrowing TS would otherwise drop.
-                        const { cols, rows, workspaceId, repoUrl, autonomous, connectToken, gitCredential, gitIdentity } = frame;
+                        const { cols, rows, workspaceId, repoUrl, autonomous, connectToken, gitCredential, gitIdentity, opencode } = frame;
                         // pucc-14 multiplex: the RELAY owns the session id (== agentId) and
                         // stamps it on the open + every later frame. Honor it so the PTY is
                         // registered under exactly that id and container→pane frames demux
@@ -1059,9 +1060,17 @@ function startRelayClient(opts) {
                             // no override, so realPty spawns $SHELL and autolaunch.sh turns it
                             // into claude. Present (laptop) → `claude` explicitly, since
                             // nothing on a user's machine does that for us.
-                            const launch = opts.resolveLaunch?.({ workspaceId, sessionId: relaySessionId, autonomous }) ?? null;
-                            if (launch && opts.commandExists && !opts.commandExists(launch.command)) {
-                                const message = `${launch.command} not found on PATH — install Claude Code CLI on this machine`;
+                            let launch = opts.resolveLaunch?.({ workspaceId, sessionId: relaySessionId, autonomous, opencode, connectToken }) ?? null;
+                            let refusal = null;
+                            if (launch && launch.command === 'opencode' && opts.prepareOpencodeLaunch) {
+                                const prepared = opts.prepareOpencodeLaunch({ ...launch, env: launch.env ?? {} });
+                                if (prepared.ok)
+                                    launch = prepared.launch;
+                                else
+                                    refusal = prepared.message;
+                            }
+                            if (launch && (refusal || (opts.commandExists && !opts.commandExists(launch.command)))) {
+                                const message = refusal ?? (0, agentLaunch_1.missingCommandMessage)(launch.command);
                                 console.error(`[bridge] refusing PTY spawn — ${message}`);
                                 send(socket, {
                                     t: 'error',
@@ -1116,7 +1125,11 @@ function startRelayClient(opts) {
                               delay or fail an `opened`.
                             */
                             if (workspaceId && opts.refreshContextPointers) {
-                                void Promise.resolve(opts.refreshContextPointers({ workspaceId })).catch((err) => {
+                                void Promise.resolve(opts.refreshContextPointers({
+                                    workspaceId,
+                                    // oc-23: the relay-injected env names the agent's engine; absent = Claude.
+                                    ...(injectedEnv?.WENRWA_AGENT_ENGINE ? { engine: injectedEnv.WENRWA_AGENT_ENGINE } : {}),
+                                })).catch((err) => {
                                     console.error('[bridge] context pointer refresh failed (non-fatal):', err);
                                 });
                             }
@@ -1294,7 +1307,12 @@ function startRelayClient(opts) {
                             });
                             break;
                         }
-                        const result = opts.installBundle({ workspaceId: frame.workspaceId, files: frame.files ?? {} });
+                        const result = opts.installBundle({
+                            workspaceId: frame.workspaceId,
+                            files: frame.files ?? {},
+                            // oc-18: the arena names the target agent's engine; absent = Claude.
+                            ...(frame.engine ? { engine: frame.engine } : {}),
+                        });
                         send(socket, {
                             t: 'bundle-installed',
                             workspaceId: frame.workspaceId,
@@ -1401,7 +1419,11 @@ function startRelayClient(opts) {
                         // rejection can only come from a bug in the writer, never from the
                         // brief fetch (which resolves null on any failure, PRD D2), so it
                         // is answered rather than thrown into an unhandled rejection.
-                        Promise.resolve(opts.writeContext({ workspaceId: frame.workspaceId, content: frame.content ?? '' }))
+                        Promise.resolve(opts.writeContext({
+                            workspaceId: frame.workspaceId,
+                            content: frame.content ?? '',
+                            ...(frame.engine ? { engine: frame.engine } : {}),
+                        }))
                             .then((result) => {
                             send(socket, {
                                 t: 'context-written',
@@ -1568,7 +1590,7 @@ function startRelayClient(opts) {
                             });
                             break;
                         }
-                        const result = opts.readTranscript({ workspaceId, agentId: frame.agentId });
+                        const result = opts.readTranscript({ workspaceId, agentId: frame.agentId, engine: frame.engine, opencodeSessionId: frame.opencodeSessionId });
                         send(socket, {
                             t: 'transcript-content',
                             requestId,
@@ -1975,6 +1997,9 @@ function startRelayClient(opts) {
                         sessionId: rec.sessionId,
                         ...(Array.isArray(rec.filePaths) && rec.filePaths.length ? { filePaths: rec.filePaths } : {}),
                         ...(typeof rec.thinking === 'string' ? { thinking: rec.thinking } : {}),
+                        // oc-22 — carry ONLY 'needs_you' (the OpenCode plugin's prompt signal);
+                        // Claude's 'tool'/'stop' kinds stay dropped so its frames are unchanged.
+                        ...(rec.kind === 'needs_you' ? { kind: 'needs_you' } : {}),
                     });
                 }
                 catch { /* skip a malformed line, keep tailing */ }

package/dist/bridge/screenshotAttach.d.ts

@@ -30,4 +30,6 @@ export declare function handleScreenshotFrame(frame: {
 }, sessions: {
     list(): string[];
     cwdOf(id: string): string | undefined;
+    engineOf?(id: string): string | undefined;
+    writeTo?(id: string, data: string): boolean;
 }, deps?: ScreenshotDeps): Promise<Record<string, unknown>>;

package/dist/bridge/screenshotAttach.js

@@ -150,7 +150,9 @@ async function handleScreenshotFrame(frame, sessions, deps = exports.realScreens
                         return fail('too-large');
                     if ((0, attachmentWriter_1.sniffImageExt)(data)) {
                         const r = (0, attachmentWriter_1.writeAttachment)({ root, name, dataBase64: data.toString('base64') }, deps.attachment);
-                        return r.ok ? { ...head, ok: true, path: r.path, bytes: r.bytes } : fail(r.reason);
+                        return r.ok
+                            ? { ...head, ok: true, path: r.path, bytes: r.bytes, ...((0, attachmentWriter_1.pasteIfOpencode)(sessions, frame.sessionId, r.path) ? { pasted: true } : {}) }
+                            : fail(r.reason);
                     }
                     // Present but not (yet) an image — maybe still being written.
                     last = 'not-image';

package/dist/bridge/server.d.ts

@@ -2,6 +2,7 @@ import { SessionManager } from './sessionManager';
 import { ValidatePathResult } from './localPathValidation';
 import { PickFolderResult } from './folderPicker';
 import { LocalAddCoreResult } from './localAdd';
+import type { PreparedLaunch } from './opencodeBinary';
 import { VerifyOriginResult } from './originVerification';
 import { PublishResult } from './localPublish';
 import { PublishPreflightResult } from './publishPreflight';
@@ -108,6 +109,14 @@ export interface BridgeServerOpts {
      * crashes the open — see the 'open' handler below.
      */
     commandExists?: (command: string) => boolean;
+    /** oc-25 — resolves/provisions OpenCode for an `opencode` launch: returns the
+     *  launch to spawn (absolute binary, or a progress waiter while the bridge
+     *  installs the pinned copy) or a refusal message. Absent → bare `opencode`. */
+    prepareOpencodeLaunch?: (launch: {
+        command: string;
+        args: string[];
+        env: Record<string, string>;
+    }) => PreparedLaunch;
     /**
      * psp-01 (production bug, 2026-09-14; supersedes bres-01's `hasSessionHistory`)
      * — does Claude Code already have a conversation on disk for THIS AGENT at
@@ -229,6 +238,12 @@ export interface BridgeServerOpts {
      * bridge.ts) — see the 'open' handler's agentId branch.
      */
     hiveOpSettingsPath?: string;
+    /** oc-07 — resolved installed MCP server + API URL for local OpenCode agents (same as mcpRegister's). */
+    mcpServer?: {
+        command: string;
+        args: string[];
+    };
+    mcpApiUrl?: string;
     /**
      * rival-10 — every file touch of a LOCAL WORKSPACE AGENT (an `open` with
      * agentId + workspaceId), handed on for the ranked rival feed. The hook

package/dist/bridge/server.js

@@ -561,6 +561,8 @@ function startBridgeServer(opts) {
                         sessionId: rec.sessionId,
                         ...(rec.filePaths ? { filePaths: rec.filePaths } : {}),
                         ...(rec.thinking !== undefined ? { thinking: rec.thinking } : {}),
+                        // oc-22 — an OpenCode permission/question prompt; absent for everything else.
+                        ...(rec.kind ? { kind: rec.kind } : {}),
                     });
                 }
             },
@@ -731,15 +733,27 @@ function startBridgeServer(opts) {
                             // folder still falls back to $HOME for its PTY cwd, but the
                             // workgraph MCP pin should still match whatever workspace the
                             // arena client actually asked to open.
-                            const launch = (0, agentLaunch_1.resolveAgentLaunch)({
+                            let launch = (0, agentLaunch_1.resolveAgentLaunch)({
                                 autonomous: !!frame.autonomous,
+                                ...(frame.opencode ? { opencode: frame.opencode } : {}),
+                                ...(frame.connectToken ? { connectToken: frame.connectToken } : {}),
+                                ...(opts.mcpServer ? { mcpServer: opts.mcpServer } : {}),
+                                ...(opts.mcpApiUrl ? { apiUrl: opts.mcpApiUrl } : {}),
                                 ...(cwd ? { sessionPin: { agentId, exists: agentSessionExists } } : {}),
                                 ...(opts.activityFile && opts.hiveOpSettingsPath
                                     ? { activity: { settingsPath: opts.hiveOpSettingsPath, sessionId: agentId, activityFile: opts.activityFile } }
                                     : {}),
                                 ...(frame.workspaceId ? { workspaceId: frame.workspaceId } : {}),
                             });
-                            const claudeAvailable = opts.commandExists ? opts.commandExists(launch.command) : true;
+                            let refusal = null;
+                            if (launch.command === 'opencode' && opts.prepareOpencodeLaunch) {
+                                const prepared = opts.prepareOpencodeLaunch(launch);
+                                if (prepared.ok)
+                                    launch = prepared.launch;
+                                else
+                                    refusal = prepared.message;
+                            }
+                            const claudeAvailable = !refusal && (opts.commandExists ? opts.commandExists(launch.command) : true);
                             if (!claudeAvailable) {
                                 // Never crash on a missing binary: open a plain session (no
                                 // command override — realPty's $SHELL default) so the pane
@@ -765,7 +779,11 @@ function startBridgeServer(opts) {
                                     send(ws, {
                                         t: 'data',
                                         sessionId,
-                                        data: '\r\n\x1b[31mclaude not found on PATH — install Claude Code CLI, then reopen this pane.\x1b[0m\r\n',
+                                        data: refusal
+                                            ? `\r\n\x1b[31m${refusal}\x1b[0m\r\n`
+                                            : launch.command === 'opencode'
+                                                ? `\r\n\x1b[31m${(0, agentLaunch_1.missingCommandMessage)('opencode')}, then reopen this pane.\x1b[0m\r\n`
+                                                : '\r\n\x1b[31mclaude not found on PATH — install Claude Code CLI, then reopen this pane.\x1b[0m\r\n',
                                     });
                                 }).catch((err) => {
                                     console.error('[bridge] session attach failed:', err);

package/dist/bridge/sessionManager.d.ts

@@ -141,6 +141,11 @@ export declare class SessionManager {
      *  session or one opened without a resolved folder (a bare shell). Lets the
      *  attach path re-announce the root to a reattaching pane — see Session.cwd. */
     cwdOf(id: string): string | undefined;
+    /** oc-16 — the engine a live session was launched as (undefined: bare shell/unknown). */
+    engineOf(id: string): 'claude' | 'opencode' | undefined;
+    /** oc-16 — write straight to a live session's PTY, no pane attachment needed
+     *  (the `attach-file` frame is handled outside any attach handle). */
+    writeTo(id: string, data: string): boolean;
     /**
      * `id` (pucc-14): honor a caller-supplied session id instead of minting a
      * random one. In relay multiplex mode the RELAY owns the session id (it is the

package/dist/bridge/sessionManager.js

@@ -114,6 +114,19 @@ class SessionManager {
     cwdOf(id) {
         return this.sessions.get(id)?.cwd;
     }
+    /** oc-16 — the engine a live session was launched as (undefined: bare shell/unknown). */
+    engineOf(id) {
+        return this.sessions.get(id)?.engine;
+    }
+    /** oc-16 — write straight to a live session's PTY, no pane attachment needed
+     *  (the `attach-file` frame is handled outside any attach handle). */
+    writeTo(id, data) {
+        const s = this.sessions.get(id);
+        if (!s || s.exited)
+            return false;
+        s.pty.write(data);
+        return true;
+    }
     /**
      * `id` (pucc-14): honor a caller-supplied session id instead of minting a
      * random one. In relay multiplex mode the RELAY owns the session id (it is the
@@ -140,7 +153,13 @@ class SessionManager {
         const spawnOne = (size) => isClaude
             ? (0, launchSupervisor_1.superviseLaunch)(this.factory, { ...opts, ...size }, this.launchSupervisor)
             : this.factory.spawn({ ...opts, ...size });
-        const gated = this.launchGate && (isClaude || this.everyOpenIsAgentLaunch);
+        // oc-08 — an OpenCode launch is staggered like any agent launch, but is NOT
+        // supervised: launchSupervisor's retries are Claude Code wording
+        // ("Session ID ... already in use" / "No conversation found") and would
+        // never match OpenCode's output. OpenCode resumes by a captured id
+        // (`-s`), and a stale one surfaces as OpenCode's own error in the pane.
+        const isOpencode = opts.command === 'opencode';
+        const gated = this.launchGate && (isClaude || isOpencode || this.everyOpenIsAgentLaunch);
         const pty = gated
             ? this.launchGate.launch(spawnOne, { cols: opts.cols, rows: opts.rows })
             : spawnOne({ cols: opts.cols, rows: opts.rows });
@@ -154,6 +173,7 @@ class SessionManager {
             attachEpoch: 0,
             exited: false,
             cwd: opts.cwd,
+            engine: isOpencode ? 'opencode' : isClaude ? 'claude' : undefined,
         };
         pty.onData((data) => {
             // Single write path to the PTY itself is untouched (ADR-0028) — this is

package/dist/commands/bridge.js

@@ -70,10 +70,12 @@ const realPty_1 = require("../bridge/realPty");
 const config_1 = require("../bridge/config");
 const mcpRegister_1 = require("../bridge/mcpRegister");
 const mcpInstall_1 = require("../bridge/mcpInstall");
+const opencodeBinary_1 = require("../bridge/opencodeBinary");
 const autostart_1 = require("../bridge/autostart");
 const repoCheckout_1 = require("../bridge/repoCheckout");
 const bundleInstaller_1 = require("../bridge/bundleInstaller");
 const agentLaunch_1 = require("../bridge/agentLaunch");
+const opencodeConfig_1 = require("../bridge/opencodeConfig");
 const contextWriter_1 = require("../bridge/contextWriter");
 const memoryBrief_1 = require("../bridge/memoryBrief");
 const containerFileRelay_1 = require("../bridge/containerFileRelay");
@@ -170,6 +172,20 @@ function bridgeApiUrl() {
 // RELAY_URL/RELAY_TOKEN env vars are the container-friendly fallback (the
 // image sets these instead of passing CLI flags), and a URL with no token
 // anywhere is a startup error rather than a confusing runtime failure.
+/**
+ * oc-08 — OpenCode is usable only if it is on PATH AND at least the minimum
+ * version oc-04 verified (the local lane runs the user's own install, which
+ * can be anything). Missing and too-old get the same install hint.
+ */
+function opencodeUsable() {
+    try {
+        const out = (0, child_process_1.execFileSync)('opencode', ['--version'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000 });
+        return (0, opencodeConfig_1.opencodeVersionOk)(out);
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * lws-06 / fcct-27 — is a binary on PATH? Best-effort and shared: the loopback
  * lane degrades to a shell + a red in-pane line when `claude` is missing, the
@@ -177,7 +193,46 @@ function bridgeApiUrl() {
  * pane). One implementation so the two lanes can never disagree about whether
  * this machine can run Claude Code.
  */
+/**
+ * oc-25 — ONE provisioner for the process, so the loopback lane and the crew
+ * relay lane (and every pane) share a single in-flight OpenCode install.
+ */
+const opencodeProvisioner = (0, opencodeBinary_1.createOpencodeProvisioner)(path.join(os.homedir(), '.wen-market', 'opencode'), {
+    exists: (p) => fs.existsSync(p),
+    writeFile: (p, c) => fs.writeFileSync(p, c),
+    mkdirp: (d) => fs.mkdirSync(d, { recursive: true }),
+    rm: (p) => fs.rmSync(p, { force: true }),
+    runNpm: (args, env) => new Promise((resolve) => {
+        (0, child_process_1.execFile)(process.platform === 'win32' ? 'npm.cmd' : 'npm', args, { env, timeout: opencodeBinary_1.OPENCODE_INSTALL_TIMEOUT_MS }, (err, _out, stderr) => {
+            resolve({ code: err ? (typeof err.code === 'number' ? err.code : 1) : 0, stderr: String(stderr ?? '') });
+        });
+    }),
+    pathOpencode: () => {
+        try {
+            const abs = (0, child_process_1.execFileSync)(process.platform === 'win32' ? 'where' : 'command', process.platform === 'win32' ? ['opencode'] : ['-v', 'opencode'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], shell: process.platform !== 'win32' }).split(/\r?\n/)[0].trim();
+            if (!abs)
+                return null;
+            return { path: abs, version: opencodeVersionOf(abs) };
+        }
+        catch {
+            return null;
+        }
+    },
+    versionOf: (bin) => opencodeVersionOf(bin),
+    env: process.env,
+    platform: process.platform,
+});
+function opencodeVersionOf(bin) {
+    try {
+        return (0, child_process_1.execFileSync)(bin, ['--version'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 15000 });
+    }
+    catch {
+        return null;
+    }
+}
 function commandExistsOnPath(command) {
+    if (command === 'opencode')
+        return opencodeUsable();
     try {
         (0, child_process_1.execFileSync)(process.platform === 'win32' ? 'where' : 'command', process.platform === 'win32' ? [command] : ['-v', command], { stdio: 'ignore', shell: process.platform !== 'win32' });
         return true;
@@ -722,8 +777,8 @@ exports.bridgeCommand = new commander_1.Command('bridge')
             // workspace checkout under the same /data/repos/<workspaceId> root. Pure
             // file writes (path-safe + idempotent) — Claude Code orchestrates the
             // crew natively next run; the credits crewExecutionEngine is never called.
-            installBundle: ({ workspaceId, files }) => {
-                const result = (0, bundleInstaller_1.installBundle)({ workspaceId, files }, {
+            installBundle: ({ workspaceId, files, engine }) => {
+                const result = (0, bundleInstaller_1.installBundle)({ workspaceId, files, engine }, {
                     reposBaseDir,
                     mkdirp: (dir) => fs.mkdirSync(dir, { recursive: true }),
                     writeFile: (p, content) => fs.writeFileSync(p, content),
@@ -755,7 +810,7 @@ exports.bridgeCommand = new commander_1.Command('bridge')
               only sends one when the pilot has files selected, so most workspaces
               never got the pointers at all.
             */
-            refreshContextPointers: async ({ workspaceId }) => {
+            refreshContextPointers: async ({ workspaceId, engine }) => {
                 const memoryAvailable = Boolean(process.env.WENRWA_CONNECT_TOKEN);
                 // 2026-10-02 — the same reply says whether this is a MATCH workspace.
                 const briefInfo = memoryAvailable ? await (0, memoryBrief_1.fetchWorkspaceBrief)(workspaceId) : null;
@@ -763,6 +818,7 @@ exports.bridgeCommand = new commander_1.Command('bridge')
                 const result = (0, contextWriter_1.writeContext)({
                     workspaceId,
                     pointersOnly: true,
+                    engine,
                     workGraphAvailable: Boolean(process.env.WENRWA_CONNECT_TOKEN),
                     memoryAvailable,
                     memoryBrief,
@@ -778,7 +834,7 @@ exports.bridgeCommand = new commander_1.Command('bridge')
                     console.log(chalk_1.default.green(`✓ Context pointers ${result.action} → workspace ${workspaceId}`));
                 }
             },
-            writeContext: async ({ workspaceId, content }) => {
+            writeContext: async ({ workspaceId, content, engine }) => {
                 // wmr-03 — the workspace's memory brief, fetched at manifest time so
                 // the agent has it in context from its next turn. Never blocks the
                 // write: fetchWorkspaceBrief resolves null on any failure (PRD D2), and
@@ -791,6 +847,7 @@ exports.bridgeCommand = new commander_1.Command('bridge')
                 const result = (0, contextWriter_1.writeContext)({
                     workspaceId,
                     content,
+                    engine,
                     // wgcp-01 — same gate as checkStorageQuota above: WENRWA_CONNECT_TOKEN
                     // is only injected at container boot when this workspace actually has
                     // MCP world-wiring (hosted-container.service.ts's machineEnv). Absent
@@ -809,7 +866,7 @@ exports.bridgeCommand = new commander_1.Command('bridge')
                     writeFile: (p, c) => fs.writeFileSync(p, c),
                     mkdirp: (dir) => fs.mkdirSync(dir, { recursive: true }),
                 });
-                console.log(chalk_1.default.green(`✓ Context manifest ${result.action} → workspace ${workspaceId} (CLAUDE.md)`));
+                console.log(chalk_1.default.green(`✓ Context manifest ${result.action} → workspace ${workspaceId} (${path.posix.basename(result.claudeMdPath ?? 'CLAUDE.md')})`));
                 return { action: result.action, claudeMdPath: result.claudeMdPath };
             },
             // cve-06 (ADR-0047 / ADR-0032): read ONE file out of
@@ -844,7 +901,9 @@ exports.bridgeCommand = new commander_1.Command('bridge')
             // straight to the SAME pure claudeTranscriptReader.ts that derives
             // the path exactly as autolaunch.sh names it (psp-01: agentId ==
             // the .jsonl filename).
-            readTranscript: ({ workspaceId, agentId }) => (0, claudeTranscriptReader_1.readAgentTranscript)(reposBaseDir, workspaceId, agentId, {
+            readTranscript: ({ workspaceId, agentId, engine, opencodeSessionId }) => (0, claudeTranscriptReader_1.readAgentTranscript)(reposBaseDir, workspaceId, agentId, {
+                engine,
+                opencodeSessionId,
                 existsSync: (p) => fs.existsSync(p),
                 statSize: (p) => fs.statSync(p).size,
                 readFileUtf8: (p) => fs.readFileSync(p, 'utf-8'),
@@ -1066,6 +1125,8 @@ exports.bridgeCommand = new commander_1.Command('bridge')
         port: Number(opts.port),
         activityFile,
         hiveOpSettingsPath,
+        ...(mcpInstall.ok ? { mcpServer: { command: mcpInstall.command, args: mcpInstall.args } } : {}),
+        mcpApiUrl: bridgeApiUrl(),
         // tchp-18: the loopback changes reporter is opt-in; without this the
         // tchp-12 machinery never constructs on a laptop and local panels sit
         // on "Waiting for changes…" forever.
@@ -1187,6 +1248,7 @@ exports.bridgeCommand = new commander_1.Command('bridge')
         // agent's PTY, so a missing install surfaces a clear in-pane error
         // line (server.ts) instead of a raw spawn ENOENT crash.
         commandExists: (command) => commandExistsOnPath(command),
+        prepareOpencodeLaunch: (l) => opencodeProvisioner.prepare(l),
         // psp-01 — real on-disk check: does THIS AGENT already have a Claude
         // Code conversation for this cwd (a "<agentId>.jsonl" transcript)?
         // Drives server.ts's per-agent session-pin decision on the
@@ -1288,8 +1350,12 @@ exports.bridgeCommand = new commander_1.Command('bridge')
             // opt-in consents to, and the consent copy says so; it does NOT change
             // what an ordinary local agent does (that still honours its own flag,
             // default off — ADR-0035).
-            resolveLaunch: ({ sessionId }) => (0, agentLaunch_1.resolveAgentLaunch)({
+            resolveLaunch: ({ sessionId, opencode, connectToken }) => (0, agentLaunch_1.resolveAgentLaunch)({
                 autonomous: true,
+                ...(opencode ? { opencode } : {}),
+                ...(connectToken ? { connectToken } : {}),
+                ...(mcpInstall.ok ? { mcpServer: { command: mcpInstall.command, args: mcpInstall.args } } : {}),
+                apiUrl: bridgeApiUrl(),
                 ...(activityFile && hiveOpSettingsPath && sessionId
                     ? { activity: { settingsPath: hiveOpSettingsPath, sessionId, activityFile } }
                     : {}),
@@ -1297,6 +1363,7 @@ exports.bridgeCommand = new commander_1.Command('bridge')
             // A missing binary is refused rather than degraded to a shell — a crew
             // member has no pane to print a red line into.
             commandExists: (command) => commandExistsOnPath(command),
+            prepareOpencodeLaunch: (l) => opencodeProvisioner.prepare(l),
             // fcct-27 — this is what keeps "crews may run here" from becoming "the
             // platform may drive any terminal on this machine". Both lanes share one
             // SessionManager by necessity, so without it the relay could attach to,
@@ -1318,13 +1385,13 @@ exports.bridgeCommand = new commander_1.Command('bridge')
             // with no brief and no error anywhere. The local workspace's root comes
             // from the folder registry — no base dir can derive a folder the user
             // named themselves.
-            installBundle: ({ workspaceId, files }) => {
+            installBundle: ({ workspaceId, files, engine }) => {
                 const entry = (0, folderRegistry_1.findEntryByWorkspaceId)((0, folderRegistry_1.loadFolderRegistry)(), workspaceId);
                 if (!entry) {
                     console.error(chalk_1.default.red(`✗ Crew bundle for unknown local workspace ${workspaceId} — nothing written`));
                     return { written: [], skipped: [] };
                 }
-                const result = (0, bundleInstaller_1.installBundle)({ workspaceId, files }, {
+                const result = (0, bundleInstaller_1.installBundle)({ workspaceId, files, engine }, {
                     reposBaseDir: '',
                     workspaceRoot: entry.path,
                     mkdirp: (dir) => fs.mkdirSync(dir, { recursive: true }),

package/hooks/opencode-plugin.mjs

@@ -0,0 +1,186 @@
+// HiveOp OpenCode activity plugin (oc-06). Self-contained ESM: no imports beyond node:*.
+// Writes the SAME JSONL lines as the Claude Code hooks (hooks/post-tool-use.js, stop.js)
+// to $HIVEOP_ACTIVITY_FILE, which the bridge already tails. Copies of this file live in
+// infra/terminal-image/opencode/ (hosted) and cli/hooks/ (local); a test keeps them identical.
+//
+// Event -> line:
+//   tool.execute.before / .after   -> kind 'tool'  (working, thinking "<Verb> <file>")
+//   session.idle, session.status idle -> kind 'stop' (idle, thinking '')
+//   permission.asked, question.asked  -> kind 'needs_you' (thinking 'Waiting for you')
+//   permission.replied                -> kind 'tool', tool '' (working, thinking 'Working')
+//   session.updated (primary session, real title) -> OSC 0 pane title (oc-17), written to /dev/tty
+//     because OpenCode's own title ("OpenCode" / "OC | <title>") is switched off by the launch
+//     (OPENCODE_DISABLE_TERMINAL_TITLE=1): the app's auto-title ingestion shows the title verbatim.
+// No-op without HIVEOP_ACTIVITY_FILE and WENRWA_SESSION_ID; nothing ever throws into OpenCode.
+// ONLY plugin functions may be exported: OpenCode loads every export as a plugin, and a helper
+// export breaks every prompt (Plugin.trigger reads hooks off its return value).
+import fs from 'node:fs'
+import path from 'node:path'
+
+// OpenCode tool ids -> the Claude Code names the bridge/touch tracker already understand.
+const TOOL_NAME = {
+  read: 'Read', edit: 'Edit', write: 'Write', patch: 'MultiEdit', multiedit: 'MultiEdit', bash: 'Bash',
+}
+const FILE_TOOLS = new Set(['Read', 'Edit', 'Write', 'Update', 'Create', 'MultiEdit', 'NotebookEdit'])
+const VERB = {
+  Read: 'Reading', Edit: 'Editing', Write: 'Writing', Update: 'Updating',
+  Create: 'Creating', MultiEdit: 'Editing', NotebookEdit: 'Editing', Bash: 'Running',
+}
+const MAX_BASH_PATHS = 5
+
+// Same algorithm as hooks/post-tool-use.js extractBashPaths (kept in step by a parity test).
+function extractBashPaths(command, pathExists, cwd) {
+  if (!command || typeof command !== 'string') return []
+  const tokens = command.match(/"[^"]*"|'[^']*'|[^\s;|&()<>]+/g) || []
+  const root = (cwd || '').replace(/\/+$/, '')
+  const out = []
+  const seen = new Set()
+  const bare = (s) => s.replace(/^['"]|['"]$/g, '').replace(/[),;]+$/, '')
+  for (let i = 1; i < tokens.length; i++) {
+    const prev = bare(tokens[i - 1])
+    if (prev === 'cd' || prev === 'pushd') continue
+    const t = bare(tokens[i])
+    if (!t || t.startsWith('-')) continue
+    const norm = t.replace(/\/+$/, '')
+    if (!norm || seen.has(norm)) continue
+    if (norm === '.' || (root && norm === root)) continue
+    let ok = false
+    try { ok = !!pathExists(t) } catch { ok = false }
+    if (!ok) continue
+    seen.add(norm)
+    out.push(t)
+    if (out.length >= MAX_BASH_PATHS) break
+  }
+  return out
+}
+
+const exists = (p) => { try { return fs.existsSync(p) } catch { return false } }
+
+/** Build the 'tool' record fields for an OpenCode tool call. */
+function toolRecord(toolId, args) {
+  const tool = typeof toolId === 'string' ? (TOOL_NAME[toolId.toLowerCase()] || toolId) : ''
+  const a = args && typeof args === 'object' ? args : {}
+  const paths = []
+  for (const k of ['filePath', 'file_path', 'notebook_path']) if (typeof a[k] === 'string') paths.push(a[k])
+  const filePaths = FILE_TOOLS.has(tool)
+    ? paths.filter((p, i) => p && paths.indexOf(p) === i)
+    : tool === 'Bash' ? extractBashPaths(a.command, exists, process.cwd()) : []
+  const base = filePaths.length ? String(filePaths[0]).split('/').pop() : ''
+  return { kind: 'tool', tool, filePaths, thinking: (VERB[tool] || 'Working') + (base ? ' ' + base : '') }
+}
+
+function append(extra, env) {
+  try {
+    const file = env.HIVEOP_ACTIVITY_FILE
+    const sessionId = env.WENRWA_SESSION_ID || ''
+    if (!file || !sessionId) return
+    fs.mkdirSync(path.dirname(file), { recursive: true })
+    fs.appendFileSync(file, JSON.stringify({ sessionId, workspaceId: env.WENRWA_WORKSPACE_ID || '', ...extra }) + '\n')
+  } catch {}
+}
+
+// OpenCode's placeholder titles until the title generator runs ("New session - <iso>").
+const DEFAULT_TITLE = /^(New session|Child session) - \d{4}-\d{2}-\d{2}T/
+const MAX_TITLE = 80
+
+/** oc-17: the OSC 0 sequence for a session.updated event's info, or '' (sub-agent, placeholder, empty). */
+function titleSequence(info) {
+  if (!info || info.parentID || typeof info.title !== 'string') return ''
+  const t = info.title.replace(/[\u0000-\u001f\u007f-\u009f]/g, ' ').replace(/\s+/g, ' ').trim()
+  if (!t || DEFAULT_TITLE.test(t)) return ''
+  return '\x1b]0;' + (t.length > MAX_TITLE ? t.slice(0, MAX_TITLE - 1) + '\u2026' : t) + '\x07'
+}
+
+let lastTitle = ''
+function setPaneTitle(info, ttyPath = '/dev/tty') {
+  try {
+    const seq = titleSequence(info)
+    if (!seq || seq === lastTitle) return
+    const fd = fs.openSync(ttyPath, 'a')
+    try { fs.writeSync(fd, seq) } finally { fs.closeSync(fd) }
+    lastTitle = seq
+  } catch {}
+}
+
+let reportedToGateway = ''
+
+/**
+ * oc-05 (hosted): POST the primary session's id to $HIVEOP_GATEWAY_URL/hiveop/session, authenticated
+ * by the per-agent gateway token (it already identifies the agent). Best-effort: one retry, never
+ * throws, no-op without gateway env. Last one wins server-side, so a fresh session after a
+ * "Session not found" fallback replaces the dead id.
+ */
+async function reportSessionToGateway(id, env = process.env) {
+  try {
+    const base = String(env.HIVEOP_GATEWAY_URL || '').replace(/\/+$/, '')
+    const token = env.HIVEOP_GATEWAY_TOKEN || ''
+    if (!id || !base || !token || id === reportedToGateway) return
+    reportedToGateway = id // claimed up front so a burst of events posts once; released on failure
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        const res = await fetch(`${base}/hiveop/session`, {
+          method: 'POST',
+          headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },
+          body: JSON.stringify({ sessionId: id }),
+          signal: AbortSignal.timeout(5000),
+        })
+        if (res.ok) return
+        if (res.status < 500) break
+      } catch {}
+      await new Promise((r) => setTimeout(r, 1500))
+    }
+    if (reportedToGateway === id) reportedToGateway = ''
+  } catch {}
+}
+
+/**
+ * oc-05 hook point: capture the generated id of an agent's PRIMARY session so the next launch
+ * can `opencode -s <id>`. Sub-agent sessions (info.parentID) never overwrite it.
+ * Local lane: first id is written to a file under HIVEOP_OPENCODE_SESSIONS_DIR (keyed by agent).
+ * Hosted lane: the id is POSTed to the gateway (see reportSessionToGateway).
+ */
+function captureSessionId(event, env = process.env) {
+  try {
+    const p = (event && event.properties) || {}
+    if (!event || event.type !== 'session.created' || (p.info && p.info.parentID)) return
+    const id = p.sessionID || (p.info && p.info.id) || ''
+    void reportSessionToGateway(id, env)
+    const agentId = env.WENRWA_AGENT_ID || ''
+    if (!agentId) return
+    const dir = env.HIVEOP_OPENCODE_SESSIONS_DIR || '/data/.hiveop/opencode-sessions'
+    fs.mkdirSync(dir, { recursive: true })
+    const f = path.join(dir, agentId)
+    if (!fs.existsSync(f)) fs.writeFileSync(f, id)
+  } catch {}
+}
+
+export const HiveOp = async () => {
+  const env = process.env
+  let lastKind = ''
+  const emit = (extra) => {
+    // session.status idle and session.idle both fire per turn end: write one stop line.
+    if (extra.kind === 'stop' && lastKind === 'stop') return
+    lastKind = extra.kind
+    append({ ...extra, ...(extra.kind === 'stop' ? { thinking: '' } : {}) }, env)
+  }
+  return {
+    event: async ({ event }) => {
+      try {
+        if (!event) return
+        const p = event.properties || {}
+        if (event.type === 'session.created') captureSessionId(event, env)
+        else if (event.type === 'session.updated') setPaneTitle(p.info, env.HIVEOP_TITLE_TTY || '/dev/tty')
+        else if (event.type === 'session.idle') emit({ kind: 'stop' })
+        else if (event.type === 'session.status' && p.status && p.status.type === 'idle') emit({ kind: 'stop' })
+        else if (event.type === 'permission.asked' || event.type === 'question.asked') emit({ kind: 'needs_you', thinking: 'Waiting for you' })
+        else if (event.type === 'permission.replied') emit({ kind: 'tool', tool: '', filePaths: [], thinking: 'Working' })
+      } catch {}
+    },
+    'tool.execute.before': async (input, output) => {
+      try { emit(toolRecord(input && input.tool, (output && output.args) || (input && input.args))) } catch {}
+    },
+    'tool.execute.after': async (input, output) => {
+      try { emit(toolRecord(input && input.tool, (input && input.args) || (output && output.args))) } catch {}
+    },
+  }
+}