@wenrwa/marketplace-cli 0.7.8 → 0.8.1

package/dist/bridge/opencodeTranscriptReader.js

@@ -0,0 +1,178 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSqliteQuery = void 0;
+exports.opencodeDbPath = opencodeDbPath;
+exports.opencodeRowsToJsonl = opencodeRowsToJsonl;
+exports.readOpencodeTranscript = readOpencodeTranscript;
+/**
+ * oc-17 — the OpenCode half of the wte-10 transcript read. Claude Code keeps
+ * one jsonl per agent; OpenCode (1.18.x, oc-04 findings) keeps every session
+ * in ONE SQLite file, `$XDG_DATA_HOME/opencode/opencode.db`, tables
+ *   session(id 'ses_…', parent_id, title, time_created, time_updated, …)
+ *   message(id, session_id, time_created, data JSON {role, time, …})
+ *   part(id, message_id, session_id, data JSON {type: text|tool|reasoning|…})
+ * Hosted lane: XDG_DATA_HOME is per AGENT (autolaunch.sh):
+ *   <WENRWA_OPENCODE_DATA_ROOT or /data/.opencode>/<agentId>/share/opencode/opencode.db
+ *
+ * The result is re-serialised as Claude-shaped jsonl (user / assistant lines,
+ * tool_use + tool_result blocks) so every consumer of the Claude transcript
+ * reads an OpenCode agent's without knowing the engine. Read-only: the DB is
+ * opened read-only (node:sqlite, else the `sqlite3` CLI); nothing is written,
+ * cached or kept. With neither available the answer is the typed
+ * 'transcript-unavailable' refusal, never a crash.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const claudeTranscriptReader_1 = require("./claudeTranscriptReader");
+const SESSION_ID = /^ses_[A-Za-z0-9]+$/;
+/** Where the hosted launch put this agent's OpenCode database. */
+function opencodeDbPath(agentId, deps = {}) {
+    const root = deps.dataRoot ?? process.env.WENRWA_OPENCODE_DATA_ROOT ?? '/data/.opencode';
+    return path.join(root, agentId, 'share', 'opencode', 'opencode.db');
+}
+/** Default driver: node:sqlite (Node >= 22.5, the image runs 24), else the sqlite3 CLI. */
+const defaultSqliteQuery = (dbPath, sql) => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { DatabaseSync } = require('node:sqlite');
+        const db = new DatabaseSync(dbPath, { readOnly: true });
+        try {
+            return db.prepare(sql).all();
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (e) {
+        const code = e?.code;
+        if (code !== 'MODULE_NOT_FOUND' && code !== 'ERR_UNKNOWN_BUILTIN_MODULE')
+            throw e;
+    }
+    try {
+        const out = (0, child_process_1.execFileSync)('sqlite3', ['-readonly', '-json', dbPath, sql], {
+            encoding: 'utf-8',
+            maxBuffer: 4 * claudeTranscriptReader_1.MAX_TRANSCRIPT_BYTES,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return out.trim() ? JSON.parse(out) : [];
+    }
+    catch (e) {
+        if (e?.code === 'ENOENT')
+            throw new Error('sqlite-unavailable');
+        throw e;
+    }
+};
+exports.defaultSqliteQuery = defaultSqliteQuery;
+function parseJson(v) {
+    try {
+        const o = JSON.parse(String(v));
+        return o && typeof o === 'object' ? o : {};
+    }
+    catch {
+        return {};
+    }
+}
+const iso = (ms) => (typeof ms === 'number' ? new Date(ms).toISOString() : undefined);
+/** Pure: OpenCode message/part rows -> Claude-shaped jsonl lines. */
+function opencodeRowsToJsonl(sessionId, messages, parts) {
+    const byMessage = new Map();
+    for (const p of parts) {
+        const list = byMessage.get(String(p.message_id)) ?? [];
+        list.push(parseJson(p.data));
+        byMessage.set(String(p.message_id), list);
+    }
+    const lines = [];
+    const emit = (type, content, ts) => {
+        if (!content.length)
+            return;
+        lines.push(JSON.stringify({ type, sessionId, timestamp: iso(ts), message: { role: type, content } }));
+    };
+    for (const m of messages) {
+        const info = parseJson(m.data);
+        const role = info.role === 'assistant' ? 'assistant' : 'user';
+        const content = [];
+        const results = [];
+        for (const part of byMessage.get(String(m.id)) ?? []) {
+            if (part.type === 'text' && typeof part.text === 'string' && part.text) {
+                content.push({ type: 'text', text: part.text });
+            }
+            else if (part.type === 'file') {
+                content.push({ type: 'text', text: `[file: ${part.filename ?? part.mime ?? 'attachment'}]` });
+            }
+            else if (part.type === 'tool' && role === 'assistant') {
+                const st = part.state ?? {};
+                content.push({ type: 'tool_use', id: part.callID, name: part.tool, input: st.input ?? {} });
+                if (st.status === 'completed') {
+                    results.push({ type: 'tool_result', tool_use_id: part.callID, content: String(st.output ?? '') });
+                }
+                else if (st.status === 'error') {
+                    results.push({ type: 'tool_result', tool_use_id: part.callID, is_error: true, content: String(st.error ?? '') });
+                }
+            }
+        }
+        emit(role, content, m.time_created);
+        emit('user', results, m.time_created);
+    }
+    return lines.length ? lines.join('\n') + '\n' : '';
+}
+/** Read ONE agent's OpenCode transcript. `sessionId` pins a session; absent -> the newest root session. */
+function readOpencodeTranscript(agentId, sessionId, deps = {}) {
+    const existsSync = deps.existsSync ?? fs.existsSync;
+    const query = deps.query ?? exports.defaultSqliteQuery;
+    if (sessionId !== undefined && !SESSION_ID.test(sessionId))
+        return { ok: false, reason: 'not-found' };
+    const db = opencodeDbPath(agentId, deps);
+    if (!existsSync(db))
+        return { ok: false, reason: 'not-found' };
+    try {
+        const sessions = sessionId
+            ? query(db, `SELECT id FROM session WHERE id = '${sessionId}'`)
+            : query(db, 'SELECT id FROM session WHERE parent_id IS NULL ORDER BY time_updated DESC LIMIT 1');
+        const id = sessions[0]?.id;
+        if (typeof id !== 'string' || !SESSION_ID.test(id))
+            return { ok: false, reason: 'not-found' };
+        const messages = query(db, `SELECT id, time_created, data FROM message WHERE session_id = '${id}' ORDER BY time_created, id`);
+        const parts = query(db, `SELECT message_id, data FROM part WHERE session_id = '${id}' ORDER BY message_id, id`);
+        const content = opencodeRowsToJsonl(id, messages, parts);
+        if (Buffer.byteLength(content) > claudeTranscriptReader_1.MAX_TRANSCRIPT_BYTES)
+            return { ok: false, reason: 'too-large' };
+        return { ok: true, content };
+    }
+    catch {
+        return { ok: false, reason: 'transcript-unavailable' };
+    }
+}

package/dist/bridge/relayClient.d.ts

@@ -1,3 +1,22 @@
+/**
+ * ht-05 — Terminal Bridge relay mode (dial-out).
+ *
+ * Instead of listening on localhost for browser connections (server.ts),
+ * this DIALS OUT to the platform relay over a single outbound wss
+ * connection, authenticates with a per-container relay token, and serves
+ * the same v1 frame protocol (see PROTOCOL.md) through the existing
+ * SessionManager. Multi-session multiplexing is unchanged: every frame
+ * already carries a sessionId, so one outbound socket serves every session
+ * exactly like the local server serves them over N inbound sockets.
+ *
+ * PTYs live in the SessionManager, not the socket — a relay drop never
+ * kills a session. This module owns only: dialing out, the auth frame,
+ * frame routing through SessionManager, and reconnect-with-backoff. It
+ * does no scrollback bookkeeping of its own (SessionManager already does
+ * that) — on re-pair the pane sends `attach` again and gets a fresh
+ * `replay`, exactly as it would against the local server.
+ */
+import { type OpencodeLaunchInput } from './agentLaunch';
 import { SessionManager } from './sessionManager';
 import { MemInfo } from './containerMemory';
 import { BrowserDriver } from './browserDriver';
@@ -163,6 +182,8 @@ export interface RelayClientOpts {
         workspaceId?: string;
         sessionId?: string;
         autonomous?: boolean;
+        opencode?: OpencodeLaunchInput;
+        connectToken?: string;
     }) => {
         command: string;
         args: string[];
@@ -214,6 +235,7 @@ export interface RelayClientOpts {
     installBundle?: (bundle: {
         workspaceId: string;
         files: Record<string, string>;
+        engine?: string;
     }) => {
         written: string[];
         skipped: Array<{
@@ -237,10 +259,12 @@ export interface RelayClientOpts {
      */
     refreshContextPointers?: (args: {
         workspaceId: string;
+        engine?: string;
     }) => void | Promise<void>;
     writeContext?: (manifest: {
         workspaceId: string;
         content: string;
+        engine?: string;
     }) => {
         action: string;
         claudeMdPath: string | null;
@@ -307,12 +331,14 @@ export interface RelayClientOpts {
     readTranscript?: (args: {
         workspaceId: string;
         agentId: string;
+        engine?: 'claude_code' | 'opencode';
+        opencodeSessionId?: string;
     }) => {
         ok: true;
         content: string;
     } | {
         ok: false;
-        reason: 'not-found' | 'invalid-agent-id' | 'too-large';
+        reason: 'not-found' | 'invalid-agent-id' | 'too-large' | 'transcript-unavailable';
     };
     /** Injectable for tests: defaults to `new WebSocket(url)` from `ws`. */
     wsFactory?: (url: string) => WebSocketLike;

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,9 @@ 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;
+                            const launch = opts.resolveLaunch?.({ workspaceId, sessionId: relaySessionId, autonomous, opencode, connectToken }) ?? null;
                             if (launch && opts.commandExists && !opts.commandExists(launch.command)) {
-                                const message = `${launch.command} not found on PATH — install Claude Code CLI on this machine`;
+                                const message = (0, agentLaunch_1.missingCommandMessage)(launch.command);
                                 console.error(`[bridge] refusing PTY spawn — ${message}`);
                                 send(socket, {
                                     t: 'error',
@@ -1116,7 +1117,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 +1299,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 +1411,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 +1582,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 +1989,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

@@ -229,6 +229,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 } : {}),
                     });
                 }
             },
@@ -733,6 +735,10 @@ function startBridgeServer(opts) {
                             // arena client actually asked to open.
                             const 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 } }
@@ -765,7 +771,9 @@ 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: 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

@@ -74,6 +74,7 @@ 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 +171,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
@@ -178,6 +193,8 @@ function bridgeApiUrl() {
  * this machine can run Claude Code.
  */
 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 +739,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 +772,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 +780,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 +796,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 +809,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 +828,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 +863,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 +1087,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.
@@ -1288,8 +1311,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 } }
                     : {}),
@@ -1318,13 +1345,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 }),