@wenrwa/marketplace-cli 0.7.8 → 0.8.2

package/dist/__tests__/opencode-plugin.test.js

@@ -0,0 +1,197 @@
+"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 });
+/**
+ * oc-06 — the OpenCode activity plugin must write the SAME lines the Claude
+ * Code hooks write. Expected lines for tool/stop are produced by running the
+ * REAL hooks (so the contract cannot drift); the plugin (ESM) is driven in a
+ * child node process.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const opencodePlugin_1 = require("../bridge/opencodePlugin");
+const ROOT = path.join(__dirname, '..', '..');
+const LOCAL_PLUGIN = path.join(ROOT, 'hooks', 'opencode-plugin.mjs');
+const HOSTED_PLUGIN = path.join(ROOT, '..', 'infra', 'terminal-image', 'opencode', 'hiveop-plugin.mjs');
+const HOOKS = path.join(ROOT, 'hooks');
+function tmp() { return fs.mkdtempSync(path.join(os.tmpdir(), 'oc06-')); }
+function runPlugin(calls, env, plugin = LOCAL_PLUGIN) {
+    const script = `
+    const { HiveOp } = await import(process.argv[1]);
+    const h = await HiveOp({});
+    for (const c of JSON.parse(process.argv[2])) {
+      if ('event' in c) await h.event({ event: c.event });
+      else await h[c.hook](c.input, c.output);
+    }`;
+    const base = { ...process.env };
+    delete base.HIVEOP_ACTIVITY_FILE;
+    delete base.WENRWA_SESSION_ID;
+    (0, child_process_1.execFileSync)(process.execPath, ['--input-type=module', '-e', script, plugin, JSON.stringify(calls)], {
+        env: { ...base, ...env },
+    });
+}
+function runClaudeHook(file, event, af, cwd) {
+    (0, child_process_1.execFileSync)(process.execPath, [path.join(HOOKS, file)], {
+        input: JSON.stringify(event), cwd,
+        env: { ...process.env, WENRWA_SESSION_ID: 's1', WENRWA_WORKSPACE_ID: 'w1', HIVEOP_ACTIVITY_FILE: af },
+    });
+}
+const lines = (f) => fs.existsSync(f) ? fs.readFileSync(f, 'utf8').trim().split('\n').filter(Boolean).map((l) => JSON.parse(l)) : [];
+const ENV = (af) => ({ WENRWA_SESSION_ID: 's1', WENRWA_WORKSPACE_ID: 'w1', HIVEOP_ACTIVITY_FILE: af });
+describe('opencode plugin activity lines (oc-06)', () => {
+    let dir;
+    let af;
+    let ref;
+    beforeEach(() => { dir = tmp(); af = path.join(dir, 'a.jsonl'); ref = path.join(dir, 'ref.jsonl'); });
+    it('tool.execute.before for edit matches the Claude PostToolUse Edit line', () => {
+        runClaudeHook('post-tool-use.js', { tool_name: 'Edit', tool_input: { file_path: '/repo/src/foo.ts' } }, ref);
+        runPlugin([{ hook: 'tool.execute.before', input: { tool: 'edit', sessionID: 'x' }, output: { args: { filePath: '/repo/src/foo.ts' } } }], ENV(af));
+        expect(lines(af)).toEqual(lines(ref));
+        expect(lines(af)[0]).toMatchObject({ kind: 'tool', tool: 'Edit', thinking: 'Editing foo.ts' });
+    });
+    it('tool.execute.after emits the same working line (args from input)', () => {
+        runClaudeHook('post-tool-use.js', { tool_name: 'Read', tool_input: { file_path: '/repo/a.ts' } }, ref);
+        runPlugin([{ hook: 'tool.execute.after', input: { tool: 'read', args: { filePath: '/repo/a.ts' } }, output: {} }], ENV(af));
+        expect(lines(af)).toEqual(lines(ref));
+    });
+    it('bash with an existing path matches the Claude hook (bash path extraction parity)', () => {
+        const f = path.join(dir, 'real.txt');
+        fs.writeFileSync(f, 'x');
+        runClaudeHook('post-tool-use.js', { tool_name: 'Bash', tool_input: { command: `cat ${f}` } }, ref, dir);
+        runPlugin([{ hook: 'tool.execute.before', input: { tool: 'bash' }, output: { args: { command: `cat ${f}` } } }], ENV(af));
+        const got = lines(af);
+        expect(got).toEqual(lines(ref));
+        expect(got[0].filePaths).toEqual([f]);
+    });
+    it('unknown tool and missing args fall back to Working', () => {
+        runClaudeHook('post-tool-use.js', { tool_name: 'mcp_thing', tool_input: {} }, ref);
+        runPlugin([{ hook: 'tool.execute.before', input: { tool: 'mcp_thing' }, output: {} }], ENV(af));
+        expect(lines(af)).toEqual(lines(ref));
+    });
+    it('session.idle matches the Claude Stop line', () => {
+        runClaudeHook('stop.js', {}, ref);
+        runPlugin([{ event: { type: 'session.idle', properties: { sessionID: 'o' } } }], ENV(af));
+        expect(lines(af)).toEqual(lines(ref));
+    });
+    it('session.status idle is a stop; idle then session.idle writes ONE stop; busy writes nothing', () => {
+        runPlugin([
+            { event: { type: 'session.status', properties: { status: { type: 'busy' } } } },
+            { event: { type: 'session.status', properties: { status: { type: 'idle' } } } },
+            { event: { type: 'session.idle', properties: {} } },
+        ], ENV(af));
+        expect(lines(af).map((l) => l.kind)).toEqual(['stop']);
+    });
+    it('a stop after new work is written again', () => {
+        runPlugin([
+            { event: { type: 'session.idle', properties: {} } },
+            { hook: 'tool.execute.before', input: { tool: 'bash' }, output: { args: {} } },
+            { event: { type: 'session.idle', properties: {} } },
+        ], ENV(af));
+        expect(lines(af).map((l) => l.kind)).toEqual(['stop', 'tool', 'stop']);
+    });
+    it('permission.asked and question.asked are needs_you; permission.replied is working', () => {
+        runPlugin([
+            { event: { type: 'permission.asked', properties: {} } },
+            { event: { type: 'permission.replied', properties: {} } },
+            { event: { type: 'question.asked', properties: {} } },
+        ], ENV(af));
+        expect(lines(af)).toEqual([
+            { sessionId: 's1', workspaceId: 'w1', kind: 'needs_you', thinking: 'Waiting for you' },
+            { sessionId: 's1', workspaceId: 'w1', kind: 'tool', tool: '', filePaths: [], thinking: 'Working' },
+            { sessionId: 's1', workspaceId: 'w1', kind: 'needs_you', thinking: 'Waiting for you' },
+        ]);
+    });
+    it('is a no-op without HIVEOP_ACTIVITY_FILE, and without a session id (like the hooks)', () => {
+        runPlugin([{ event: { type: 'session.idle', properties: {} } }], { WENRWA_SESSION_ID: 's1' });
+        runPlugin([{ event: { type: 'session.idle', properties: {} } }], { HIVEOP_ACTIVITY_FILE: af });
+        expect(fs.existsSync(af)).toBe(false);
+    });
+    it('swallows write errors and malformed input', () => {
+        const blocker = path.join(dir, 'file');
+        fs.writeFileSync(blocker, '');
+        expect(() => runPlugin([
+            { event: { type: 'session.idle', properties: {} } },
+            { event: null },
+            { hook: 'tool.execute.before', input: null, output: null },
+        ], ENV(path.join(blocker, 'sub', 'a.jsonl')))).not.toThrow();
+    });
+    it('session.created capture is kept behind captureSessionId (primary only)', () => {
+        const sess = path.join(dir, 'sessions');
+        const env = { ...ENV(af), WENRWA_AGENT_ID: 'ag1', HIVEOP_OPENCODE_SESSIONS_DIR: sess };
+        runPlugin([
+            { event: { type: 'session.created', properties: { sessionID: 'ses_main', info: {} } } },
+            { event: { type: 'session.created', properties: { sessionID: 'ses_sub', info: { parentID: 'ses_main' } } } },
+        ], env);
+        expect(fs.readFileSync(path.join(sess, 'ag1'), 'utf8')).toBe('ses_main');
+        expect(fs.existsSync(af)).toBe(false);
+    });
+    it('the hosted and local copies are byte-identical', () => {
+        expect(fs.readFileSync(LOCAL_PLUGIN, 'utf8')).toBe(fs.readFileSync(HOSTED_PLUGIN, 'utf8'));
+    });
+});
+describe('opencode plugin local helper (oc-06, for oc-08)', () => {
+    it('resolves the bundled plugin that ships in the package', () => {
+        const p = (0, opencodePlugin_1.resolveOpenCodePluginPath)();
+        expect(p).toBe(LOCAL_PLUGIN);
+        expect(fs.existsSync(p)).toBe(true);
+    });
+    it('builds a plugin config fragment with an encoded file URL', () => {
+        expect((0, opencodePlugin_1.buildOpenCodePluginConfig)('/a b/opencode-plugin.mjs')).toEqual({ plugin: ['file:///a%20b/opencode-plugin.mjs'] });
+    });
+});
+// OpenCode loads EVERY export of a plugin module as a plugin and reads hooks off
+// whatever it returns. A helper export (e.g. a string-returning function) yields
+// no hooks object, and OpenCode's Plugin.trigger then throws on every prompt —
+// found live in image v62 against a fake gateway ("evaluating 'N.config'").
+describe('module shape OpenCode loads', () => {
+    for (const plugin of [LOCAL_PLUGIN, HOSTED_PLUGIN]) {
+        it(`${path.basename(plugin)}: every export is a plugin that resolves to a hooks object`, () => {
+            const script = `
+        const mod = await import(process.argv[1]);
+        const bad = [];
+        for (const [name, fn] of Object.entries(mod)) {
+          if (typeof fn !== 'function') { bad.push(name + ':not-a-function'); continue; }
+          const h = await fn({});
+          if (!h || typeof h !== 'object') bad.push(name + ':no-hooks');
+        }
+        process.stdout.write(JSON.stringify({ names: Object.keys(mod), bad }));`;
+            const out = JSON.parse((0, child_process_1.execFileSync)(process.execPath, ['--input-type=module', '-e', script, plugin]).toString());
+            expect(out.bad).toEqual([]);
+            expect(out.names).toContain('HiveOp');
+        });
+    }
+});

package/dist/__tests__/opencode-title.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/opencode-title.test.js

@@ -0,0 +1,99 @@
+"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 });
+/**
+ * oc-17 -- OpenCode sets its own OSC title ("OpenCode" at home / for an untitled
+ * session, "OC | <title>" otherwise; observed on 1.18.35). The app ingests the OSC
+ * title verbatim, so the launch turns OpenCode's title off
+ * (OPENCODE_DISABLE_TERMINAL_TITLE=1) and the HiveOp plugin writes the bare session
+ * title itself. The plugin is driven in a child node process; HIVEOP_TITLE_TTY stands
+ * in for /dev/tty.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const opencodeConfig_1 = require("../bridge/opencodeConfig");
+const ROOT = path.join(__dirname, '..', '..');
+const PLUGINS = [
+    path.join(ROOT, 'hooks', 'opencode-plugin.mjs'),
+    path.join(ROOT, '..', 'infra', 'terminal-image', 'opencode', 'hiveop-plugin.mjs'),
+];
+function titlesFor(plugin, infos) {
+    const tty = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'oc17-')), 'tty');
+    fs.writeFileSync(tty, '');
+    const script = `
+    const { HiveOp } = await import(process.argv[1]);
+    const h = await HiveOp({});
+    for (const info of JSON.parse(process.argv[2])) await h.event({ event: { type: 'session.updated', properties: { info } } });`;
+    (0, child_process_1.execFileSync)('node', ['--input-type=module', '-e', script, plugin, JSON.stringify(infos)], {
+        env: { PATH: process.env.PATH, HIVEOP_TITLE_TTY: tty },
+    });
+    return fs.readFileSync(tty, 'utf-8');
+}
+const osc = (t) => `\x1b]0;${t}\x07`;
+describe.each(PLUGINS.map((p) => [path.basename(p), p]))('oc-17 pane title (%s)', (_n, plugin) => {
+    it('writes the bare session title as OSC 0, no "OC | " prefix', () => {
+        expect(titlesFor(plugin, [{ id: 'ses_1', title: 'Fix the login redirect' }])).toBe(osc('Fix the login redirect'));
+    });
+    it('ignores the placeholder titles OpenCode starts every session with', () => {
+        expect(titlesFor(plugin, [
+            { id: 'ses_1', title: 'New session - 2026-10-11T03:29:07.080Z' },
+            { id: 'ses_2', title: 'Child session - 2026-10-11T03:29:07.080Z' },
+        ])).toBe('');
+    });
+    it('ignores sub-agent sessions and events without a title', () => {
+        expect(titlesFor(plugin, [{ id: 'ses_2', parentID: 'ses_1', title: 'Explore repo' }, { id: 'ses_1' }, null])).toBe('');
+    });
+    it('writes a changed title once, not once per event', () => {
+        const out = titlesFor(plugin, [
+            { id: 'ses_1', title: 'First' }, { id: 'ses_1', title: 'First' }, { id: 'ses_1', title: 'Second' },
+        ]);
+        expect(out).toBe(osc('First') + osc('Second'));
+    });
+    it('strips control characters (no escape injection from a model-written title) and caps length', () => {
+        const out = titlesFor(plugin, [{ id: 'ses_1', title: 'ok\x1b]0;evil\x07 title' }, { id: 'ses_1', title: 'x'.repeat(200) }]);
+        expect(out).toBe(osc('ok ]0;evil title') + osc('x'.repeat(79) + '…'));
+    });
+});
+describe('oc-17 launch env', () => {
+    it("switches OpenCode's own terminal title off", () => {
+        expect(opencodeConfig_1.OPENCODE_QUIET_ENV.OPENCODE_DISABLE_TERMINAL_TITLE).toBe('1');
+    });
+    it('hosted autolaunch exports the same switch', () => {
+        const sh = fs.readFileSync(path.join(ROOT, '..', 'infra', 'terminal-image', 'autolaunch.sh'), 'utf-8');
+        expect(sh).toMatch(/export [^\n]*OPENCODE_DISABLE_TERMINAL_TITLE=1/);
+    });
+});

package/dist/__tests__/opencode-transcript-reader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/opencode-transcript-reader.test.js

@@ -0,0 +1,156 @@
+"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 });
+/**
+ * oc-17 -- OpenCode transcript reads. The fixture DB uses the table shapes captured from
+ * opencode-ai@1.18.35 (session / message / part, JSON in `data`) and is built with the
+ * sqlite3 CLI; the suite skips (loudly) where that CLI is missing.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const claudeTranscriptReader_1 = require("../bridge/claudeTranscriptReader");
+const opencodeTranscriptReader_1 = require("../bridge/opencodeTranscriptReader");
+const HAVE_SQLITE = (0, child_process_1.spawnSync)('sqlite3', ['-version']).status === 0;
+const AGENT = '22222222-2222-2222-2222-222222222222';
+const OLD = 'ses_old111';
+const NEW = 'ses_new222';
+const SUB = 'ses_sub333';
+const j = (o) => JSON.stringify(o).replace(/'/g, "''");
+function makeRoot() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'oc17-db-'));
+    const db = (0, opencodeTranscriptReader_1.opencodeDbPath)(AGENT, { dataRoot: root });
+    fs.mkdirSync(path.dirname(db), { recursive: true });
+    const sql = `
+    CREATE TABLE session (id text PRIMARY KEY, parent_id text, title text NOT NULL, time_created integer NOT NULL, time_updated integer NOT NULL);
+    CREATE TABLE message (id text PRIMARY KEY, session_id text NOT NULL, time_created integer NOT NULL, time_updated integer NOT NULL, data text NOT NULL);
+    CREATE TABLE part (id text PRIMARY KEY, message_id text NOT NULL, session_id text NOT NULL, time_created integer NOT NULL, time_updated integer NOT NULL, data text NOT NULL);
+    INSERT INTO session VALUES ('${OLD}', NULL, 'old', 1, 10), ('${NEW}', NULL, 'new', 2, 50), ('${SUB}', '${NEW}', 'sub', 3, 90);
+    INSERT INTO message VALUES ('msg_a', '${OLD}', 5, 5, '${j({ role: 'user' })}');
+    INSERT INTO part VALUES ('prt_a', 'msg_a', '${OLD}', 5, 5, '${j({ type: 'text', text: 'old question' })}');
+    INSERT INTO message VALUES ('msg_1', '${NEW}', 1791671762759, 1, '${j({ role: 'user' })}');
+    INSERT INTO part VALUES ('prt_1', 'msg_1', '${NEW}', 1, 1, '${j({ type: 'text', text: "it's RUNTOOL please" })}');
+    INSERT INTO message VALUES ('msg_2', '${NEW}', 1791671762800, 1, '${j({ role: 'assistant' })}');
+    INSERT INTO part VALUES ('prt_2a', 'msg_2', '${NEW}', 1, 1, '${j({ type: 'step-start' })}');
+    INSERT INTO part VALUES ('prt_2b', 'msg_2', '${NEW}', 1, 1, '${j({ type: 'reasoning', text: 'hidden thoughts' })}');
+    INSERT INTO part VALUES ('prt_2c', 'msg_2', '${NEW}', 1, 1, '${j({ type: 'tool', tool: 'bash', callID: 'call_1', state: { status: 'completed', input: { command: 'echo hi' }, output: 'hi\n' } })}');
+    INSERT INTO part VALUES ('prt_2d', 'msg_2', '${NEW}', 1, 1, '${j({ type: 'tool', tool: 'read', callID: 'call_2', state: { status: 'error', input: { filePath: '/x' }, error: 'ENOENT' } })}');
+    INSERT INTO message VALUES ('msg_3', '${NEW}', 1791671762900, 1, '${j({ role: 'assistant' })}');
+    INSERT INTO part VALUES ('prt_3', 'msg_3', '${NEW}', 1, 1, '${j({ type: 'text', text: 'Done.' })}');
+    INSERT INTO message VALUES ('msg_s', '${SUB}', 9, 9, '${j({ role: 'user' })}');
+    INSERT INTO part VALUES ('prt_s', 'msg_s', '${SUB}', 9, 9, '${j({ type: 'text', text: 'subagent chatter' })}');`;
+    (0, child_process_1.execFileSync)('sqlite3', [db, sql]);
+    return root;
+}
+const lines = (s) => s.trim().split('\n').map((l) => JSON.parse(l));
+const d = HAVE_SQLITE ? describe : describe.skip;
+d('readOpencodeTranscript (oc-17)', () => {
+    let root;
+    beforeAll(() => { root = makeRoot(); });
+    it('reads the newest root session as Claude-shaped jsonl (text, tool_use, tool_result; no reasoning, no sub-agents)', () => {
+        const r = (0, opencodeTranscriptReader_1.readOpencodeTranscript)(AGENT, undefined, { dataRoot: root });
+        expect(r.ok).toBe(true);
+        const out = lines(r.content);
+        expect(out.map((l) => l.type)).toEqual(['user', 'assistant', 'user', 'assistant']);
+        expect(out[0].message).toEqual({ role: 'user', content: [{ type: 'text', text: "it's RUNTOOL please" }] });
+        expect(out[0].sessionId).toBe(NEW);
+        expect(out[0].timestamp).toBe(new Date(1791671762759).toISOString());
+        expect(out[1].message.content).toEqual([
+            { type: 'tool_use', id: 'call_1', name: 'bash', input: { command: 'echo hi' } },
+            { type: 'tool_use', id: 'call_2', name: 'read', input: { filePath: '/x' } },
+        ]);
+        expect(out[2].message.content).toEqual([
+            { type: 'tool_result', tool_use_id: 'call_1', content: 'hi\n' },
+            { type: 'tool_result', tool_use_id: 'call_2', is_error: true, content: 'ENOENT' },
+        ]);
+        expect(out[3].message.content).toEqual([{ type: 'text', text: 'Done.' }]);
+        expect(r.content).not.toMatch(/hidden thoughts|subagent chatter|old question/);
+    });
+    it('reads a pinned session id', () => {
+        const r = (0, opencodeTranscriptReader_1.readOpencodeTranscript)(AGENT, OLD, { dataRoot: root });
+        expect(lines(r.content)[0].message.content[0].text).toBe('old question');
+    });
+    it('refuses a session id that is not ses_<alnum> (no SQL injection) and an unknown one', () => {
+        expect((0, opencodeTranscriptReader_1.readOpencodeTranscript)(AGENT, "x' OR '1'='1", { dataRoot: root })).toEqual({ ok: false, reason: 'not-found' });
+        expect((0, opencodeTranscriptReader_1.readOpencodeTranscript)(AGENT, 'ses_nope', { dataRoot: root })).toEqual({ ok: false, reason: 'not-found' });
+    });
+    it('is not-found when the agent has no database', () => {
+        expect((0, opencodeTranscriptReader_1.readOpencodeTranscript)('33333333-3333-3333-3333-333333333333', undefined, { dataRoot: root }))
+            .toEqual({ ok: false, reason: 'not-found' });
+    });
+    it('never writes: the database file is byte-identical after a read', () => {
+        const db = (0, opencodeTranscriptReader_1.opencodeDbPath)(AGENT, { dataRoot: root });
+        const before = fs.readFileSync(db);
+        (0, opencodeTranscriptReader_1.readOpencodeTranscript)(AGENT, undefined, { dataRoot: root });
+        expect(fs.readFileSync(db).equals(before)).toBe(true);
+    });
+    it('the default driver answers a plain SELECT', () => {
+        const db = (0, opencodeTranscriptReader_1.opencodeDbPath)(AGENT, { dataRoot: root });
+        expect((0, opencodeTranscriptReader_1.defaultSqliteQuery)(db, 'SELECT count(*) AS n FROM session')).toEqual([{ n: 3 }]);
+    });
+});
+describe('readAgentTranscript engine dispatch (oc-17)', () => {
+    const noClaude = { existsSync: (p) => p.endsWith('opencode.db'), env: { CLAUDE_CONFIG_DIR: undefined }, homedir: () => '/root' };
+    it('falls through to the OpenCode reader when there is no Claude jsonl but an OpenCode db', () => {
+        const query = jest.fn()
+            .mockReturnValueOnce([{ id: 'ses_abc' }])
+            .mockReturnValueOnce([{ id: 'm1', time_created: 1, data: '{"role":"user"}' }])
+            .mockReturnValueOnce([{ message_id: 'm1', data: '{"type":"text","text":"hi"}' }]);
+        const r = (0, claudeTranscriptReader_1.readAgentTranscript)('/data/repos', 'ws-1', AGENT, { ...noClaude, opencode: { dataRoot: '/d', query } });
+        expect(r.ok && JSON.parse(r.content.trim()).message.content[0].text).toBe('hi');
+    });
+    it('engine: "opencode" skips the Claude file even when one exists', () => {
+        const query = jest.fn().mockReturnValue([]);
+        const r = (0, claudeTranscriptReader_1.readAgentTranscript)('/data/repos', 'ws-1', AGENT, {
+            existsSync: () => true, engine: 'opencode', opencode: { dataRoot: '/d', query },
+        });
+        expect(r).toEqual({ ok: false, reason: 'not-found' });
+        expect(query).toHaveBeenCalled();
+    });
+    it('engine: "claude_code" never probes the OpenCode db', () => {
+        const query = jest.fn();
+        const r = (0, claudeTranscriptReader_1.readAgentTranscript)('/data/repos', 'ws-1', AGENT, {
+            ...noClaude, engine: 'claude_code', opencode: { dataRoot: '/d', query },
+        });
+        expect(r).toEqual({ ok: false, reason: 'not-found' });
+        expect(query).not.toHaveBeenCalled();
+    });
+    it('answers transcript-unavailable when no sqlite driver exists', () => {
+        const query = () => { throw new Error('sqlite-unavailable'); };
+        const r = (0, claudeTranscriptReader_1.readAgentTranscript)('/data/repos', 'ws-1', AGENT, { ...noClaude, opencode: { dataRoot: '/d', query } });
+        expect(r).toEqual({ ok: false, reason: 'transcript-unavailable' });
+    });
+});

package/dist/bridge/activityTail.d.ts

@@ -11,6 +11,13 @@ export interface ActivityRecord {
      * a record written before this field existed, or any malformed value.
      */
     tool?: string;
+    /**
+     * oc-22 — ONLY ever 'needs_you' (the OpenCode plugin's permission/question
+     * prompt). Every other kind the hooks write ('tool', 'stop') is deliberately
+     * left off: the outward frame for Claude Code stays byte-identical, and the
+     * relay still tells a stop from a tool use by shape.
+     */
+    kind?: 'needs_you';
 }
 export interface ActivityTailOpts {
     /** Path to the JSONL file the local hooks append to. */

package/dist/bridge/activityTail.js

@@ -105,6 +105,7 @@ function startActivityTail(opts) {
                     ...(Array.isArray(rec.filePaths) && rec.filePaths.length ? { filePaths: rec.filePaths } : {}),
                     ...(typeof rec.thinking === 'string' ? { thinking: rec.thinking } : {}),
                     ...(typeof rec.tool === 'string' ? { tool: rec.tool } : {}),
+                    ...(rec.kind === 'needs_you' ? { kind: 'needs_you' } : {}),
                 });
             }
             catch {

package/dist/bridge/agentLaunch.d.ts

@@ -78,7 +78,35 @@ export interface SessionPin {
      *  (claudeSessionHistory.ts's hasAgentSessionHistory). */
     exists: boolean;
 }
+/**
+ * oc-08 — what the SERVER delivers with a session start for a local OpenCode
+ * agent (never the OpenRouter key; the token is the per-agent gateway token,
+ * ADR-0013). Absent / engine !== 'opencode' → the Claude path, byte-identical.
+ */
+export interface OpencodeLaunchInput {
+    engine?: string;
+    model?: string | null;
+    /** Full OpenAI-compatible base URL of the metering gateway. */
+    gatewayUrl?: string | null;
+    gatewayToken?: string | null;
+    /** OpenCode's own captured session id (`ses_...`); absent on first launch. */
+    sessionId?: string | null;
+}
+/** The message shown when a launch command is not usable on this machine. */
+export declare function missingCommandMessage(command: string): string;
 export declare function resolveAgentLaunch(opts: {
+    /** oc-08 — engine-aware launch; see OpencodeLaunchInput. */
+    opencode?: OpencodeLaunchInput;
+    /** Connect token (WENRWA_CONNECT_TOKEN) — adds the MCP server for opencode. */
+    connectToken?: string;
+    /** oc-07 — the installed MCP server (mcpInstall.ts), the same absolute
+     *  command mcpRegister gives Claude. Absent → npx fallback. */
+    mcpServer?: {
+        command: string;
+        args: string[];
+    };
+    /** oc-07 — MARKETPLACE_API_URL for the MCP server (as mcpRegister passes it). */
+    apiUrl?: string;
     autonomous?: boolean;
     activity?: AgentActivityWiring;
     sessionPin?: SessionPin;

package/dist/bridge/agentLaunch.js

@@ -1,15 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HIVEOP_CONTEXT_ENV_VALUE = exports.HIVEOP_CONTEXT_ENV_VAR = void 0;
+exports.missingCommandMessage = missingCommandMessage;
 exports.resolveAgentLaunch = resolveAgentLaunch;
 const localContextWriter_1 = require("./localContextWriter");
+const opencodeConfig_1 = require("./opencodeConfig");
 /** lws-08 — env var name a spawned `claude` (or any tooling inspecting its
  *  own environment) can read to find the pushed context manifest. */
 exports.HIVEOP_CONTEXT_ENV_VAR = 'HIVEOP_CONTEXT_FILE';
 /** lws-08 — re-exported from localContextWriter.ts (the single source of
  *  truth for where the manifest actually lands) so this can never drift. */
 exports.HIVEOP_CONTEXT_ENV_VALUE = localContextWriter_1.LOCAL_CONTEXT_RELATIVE_PATH;
+/** The message shown when a launch command is not usable on this machine. */
+function missingCommandMessage(command) {
+    return command === 'opencode'
+        ? `opencode not found on PATH (or older than the minimum) — ${opencodeConfig_1.OPENCODE_INSTALL_HINT}`
+        : `${command} not found on PATH — install Claude Code CLI on this machine`;
+}
 function resolveAgentLaunch(opts) {
+    const oc = opts.opencode;
+    if (oc && oc.engine === 'opencode' && oc.model && oc.gatewayUrl && oc.gatewayToken) {
+        return resolveOpencodeLaunch(opts, { model: oc.model, gatewayUrl: oc.gatewayUrl, gatewayToken: oc.gatewayToken, sessionId: oc.sessionId });
+    }
     const args = opts.autonomous ? ['--dangerously-skip-permissions'] : [];
     if (opts.activity)
         args.push('--settings', opts.activity.settingsPath);
@@ -27,3 +39,40 @@ function resolveAgentLaunch(opts) {
         env.WENRWA_WORKSPACE_ID = opts.workspaceId;
     return { command: 'claude', args, env };
 }
+/** oc-08 — the OpenCode branch. Resume is `-s <captured id>` only; the id is
+ *  captured from the first run, never chosen (oc-04 s3). No Claude flags, no
+ *  --settings hook file: activity for OpenCode rides its plugin (oc-06). */
+function resolveOpencodeLaunch(opts, oc) {
+    const args = [];
+    if ((0, opencodeConfig_1.isCapturedOpencodeSessionId)(oc.sessionId))
+        args.push('-s', oc.sessionId);
+    const config = (0, opencodeConfig_1.buildOpencodeConfig)({
+        model: oc.model,
+        gatewayBaseUrl: oc.gatewayUrl,
+        autonomous: !!opts.autonomous,
+        withMcp: !!opts.connectToken,
+        // oc-23: Claude loads .hiveop/context.md via its SessionStart hook; OpenCode has none, so it reads it as instructions.
+        instructions: [exports.HIVEOP_CONTEXT_ENV_VALUE],
+        ...(opts.mcpServer ? { mcpCommand: [opts.mcpServer.command, ...opts.mcpServer.args] } : {}),
+        ...(opts.apiUrl ? { mcpEnvPassthrough: ['MARKETPLACE_API_URL'] } : {}),
+    });
+    const env = {
+        [exports.HIVEOP_CONTEXT_ENV_VAR]: exports.HIVEOP_CONTEXT_ENV_VALUE,
+        ...opencodeConfig_1.OPENCODE_QUIET_ENV,
+        OPENCODE_CONFIG_CONTENT: JSON.stringify(config),
+        [opencodeConfig_1.OPENCODE_GATEWAY_TOKEN_ENV]: oc.gatewayToken,
+    };
+    if (opts.connectToken)
+        env.WENRWA_CONNECT_TOKEN = opts.connectToken;
+    if (opts.connectToken && opts.apiUrl)
+        env.MARKETPLACE_API_URL = opts.apiUrl;
+    if (opts.activity) {
+        env.WENRWA_SESSION_ID = opts.activity.sessionId;
+        env.HIVEOP_ACTIVITY_FILE = opts.activity.activityFile;
+    }
+    if (opts.sessionPin)
+        env.WENRWA_AGENT_ID = opts.sessionPin.agentId;
+    if (opts.workspaceId)
+        env.WENRWA_WORKSPACE_ID = opts.workspaceId;
+    return { command: 'opencode', args, env };
+}

package/dist/bridge/attachmentWriter.d.ts

@@ -39,6 +39,20 @@ export declare function attachmentRootFor(sessions: {
     list(): string[];
     cwdOf(id: string): string | undefined;
 }, sessionId: unknown): string | null;
+/**
+ * oc-16 — what to type into the PTY after the file is written, per engine.
+ * Claude Code: nothing (the pane types the path itself; bytes unchanged).
+ * OpenCode: the path as a BRACKETED PASTE with no Enter — its TUI detects an
+ * image file path on the paste event (a bare typed path is not guaranteed to
+ * attach) and the user keeps typing. Spaces are backslash-escaped.
+ */
+export declare function pastePayloadFor(engine: string | undefined, filePath: string): string | null;
+/** Paste the path into an OpenCode session's prompt; true when it was written
+ *  (`pasted` in the reply tells the pane not to type the path itself). */
+export declare function pasteIfOpencode(sessions: {
+    engineOf?(id: string): string | undefined;
+    writeTo?(id: string, data: string): boolean;
+}, sessionId: string, filePath: string): boolean;
 /**
  * The whole `attach-file` frame → `file-attached` reply, shared verbatim by
  * the local server and the relay client so the two lanes cannot drift.
@@ -51,4 +65,6 @@ export declare function handleAttachFrame(frame: {
 }, sessions: {
     list(): string[];
     cwdOf(id: string): string | undefined;
+    engineOf?(id: string): string | undefined;
+    writeTo?(id: string, data: string): boolean;
 }, deps?: AttachmentDeps): Record<string, unknown>;