@wenrwa/marketplace-cli 0.7.7 → 0.8.1

package/dist/__tests__/bridge-crew-translator.test.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * oc-18 — Claude Code crew bundle -> OpenCode files.
+ *
+ * Formats verified against opencode-ai@1.18.35 (`opencode agent list`,
+ * `opencode debug agent <n>`, `opencode debug skill`): agents load from
+ * `.opencode/agent/<name>.md` (NOT from `.claude/agents`), `permission` is the
+ * tool gate, `.claude/skills/**` loads natively, `AGENTS.md` is the rules file.
+ */
+const crewTranslator_1 = require("../bridge/crewTranslator");
+const MARK = '## Prompt Defense Baseline';
+const FENCE = '<!-- HIVEOP:CONTEXT:START -->\nfiles\n<!-- HIVEOP:CONTEXT:END -->';
+const FIXTURE = {
+    'CLAUDE.md': `# Crew\n\n${FENCE}\n`,
+    '.claude/agents/reviewer.md': `---\nname: reviewer\ndescription: "Reviews diffs: strict"\ntools: Read, Grep, Glob\nmodel: sonnet\ncolor: blue\n---\n\nYou review.\n\n${MARK}\nBe safe.\n`,
+    '.claude/agents/builder.md': `---\nname: builder\ndescription: Builds things\n---\nYou build.\n${MARK}\n`,
+    '.claude/skills/run-crew/SKILL.md': '---\nname: run-crew\ndescription: x\n---\nrun\n',
+    '.claude/handoff/PROTOCOL.md': 'blackboard',
+};
+describe('mapClaudeToolsToPermission', () => {
+    it('absent or empty tools inherit everything (no permission block)', () => {
+        expect((0, crewTranslator_1.mapClaudeToolsToPermission)(undefined)).toBeUndefined();
+        expect((0, crewTranslator_1.mapClaudeToolsToPermission)('')).toBeUndefined();
+    });
+    it('is an allowlist: unlisted known tools are denied', () => {
+        expect((0, crewTranslator_1.mapClaudeToolsToPermission)('Read, Grep, Glob')).toEqual({
+            edit: 'deny', bash: 'deny', webfetch: 'deny', websearch: 'deny', task: 'deny', todowrite: 'deny',
+        });
+    });
+    it('folds Write/Edit/MultiEdit/NotebookEdit into edit and keeps bash when listed', () => {
+        expect((0, crewTranslator_1.mapClaudeToolsToPermission)('Write, Bash, WebFetch')).toEqual({
+            websearch: 'deny', task: 'deny', todowrite: 'deny',
+        });
+        expect((0, crewTranslator_1.mapClaudeToolsToPermission)('MultiEdit')).toMatchObject({ bash: 'deny' });
+        expect((0, crewTranslator_1.mapClaudeToolsToPermission)('MultiEdit')).not.toHaveProperty('edit');
+    });
+    it('accepts an array and ignores mcp__ entries and unknown names', () => {
+        expect((0, crewTranslator_1.mapClaudeToolsToPermission)(['Read', 'mcp__x__y', 'Bogus'])).toMatchObject({ edit: 'deny', bash: 'deny' });
+    });
+});
+describe('translateClaudeAgentToOpencode', () => {
+    it('emits mode subagent, quoted description, permission, body; drops model/name/color/tools', () => {
+        const out = (0, crewTranslator_1.translateClaudeAgentToOpencode)(FIXTURE['.claude/agents/reviewer.md']);
+        const { data, body } = (0, crewTranslator_1.parseFrontmatter)(out);
+        expect(data.mode).toBe('subagent');
+        expect(data.description).toBe('Reviews diffs: strict');
+        expect(data).not.toHaveProperty('model');
+        expect(data).not.toHaveProperty('tools');
+        expect(data).not.toHaveProperty('color');
+        expect(data).not.toHaveProperty('name');
+        expect(out).toContain('permission:\n  edit: deny');
+        expect(body).toContain(MARK);
+    });
+    it('preserves CRLF', () => {
+        const crlf = '---\r\ndescription: d\r\ntools: Read\r\n---\r\nbody\r\n';
+        const out = (0, crewTranslator_1.translateClaudeAgentToOpencode)(crlf);
+        expect(out).toContain('\r\n');
+        expect(out.replace(/\r\n/g, '')).not.toContain('\n');
+    });
+    it('a file with no frontmatter still becomes a valid subagent', () => {
+        const out = (0, crewTranslator_1.translateClaudeAgentToOpencode)('just a prompt');
+        expect((0, crewTranslator_1.parseFrontmatter)(out).data.mode).toBe('subagent');
+        expect(out).toContain('just a prompt');
+    });
+});
+describe('translateCrewBundleForOpencode (golden)', () => {
+    const out = (0, crewTranslator_1.translateCrewBundleForOpencode)(FIXTURE);
+    it('maps paths', () => {
+        expect(Object.keys(out).sort()).toEqual([
+            '.claude/handoff/PROTOCOL.md',
+            '.claude/skills/run-crew/SKILL.md',
+            '.opencode/agent/builder.md',
+            '.opencode/agent/reviewer.md',
+            'AGENTS.md',
+        ]);
+    });
+    it('reviewer golden', () => {
+        expect(out['.opencode/agent/reviewer.md']).toBe(`---\ndescription: "Reviews diffs: strict"\nmode: subagent\npermission:\n  edit: deny\n  bash: deny\n  webfetch: deny\n  websearch: deny\n  task: deny\n  todowrite: deny\n---\n\nYou review.\n\n${MARK}\nBe safe.\n`);
+    });
+    it('builder (no tools) has no permission block', () => {
+        expect(out['.opencode/agent/builder.md']).toBe(`---\ndescription: "Builds things"\nmode: subagent\n---\nYou build.\n${MARK}\n`);
+    });
+    it('skills and handoff pass through byte-identical', () => {
+        expect(out['.claude/skills/run-crew/SKILL.md']).toBe(FIXTURE['.claude/skills/run-crew/SKILL.md']);
+        expect(out['.claude/handoff/PROTOCOL.md']).toBe('blackboard');
+    });
+    it('CLAUDE.md fenced region round-trips into AGENTS.md with the same markers, byte for byte', () => {
+        expect(out['AGENTS.md']).toBe(FIXTURE['CLAUDE.md']);
+        expect(out['AGENTS.md']).toContain('<!-- HIVEOP:CONTEXT:START -->');
+        expect(out['AGENTS.md']).toContain('<!-- HIVEOP:CONTEXT:END -->');
+    });
+    it('is pure: input untouched, same output twice', () => {
+        const copy = JSON.stringify(FIXTURE);
+        expect((0, crewTranslator_1.translateCrewBundleForOpencode)(FIXTURE)).toEqual(out);
+        expect(JSON.stringify(FIXTURE)).toBe(copy);
+    });
+    it('never emits a model field (billing is locked to the agent model via the gateway whitelist)', () => {
+        for (const [p, c] of Object.entries(out))
+            if (p.startsWith('.opencode/'))
+                expect(c).not.toMatch(/^model:/m);
+    });
+});

package/dist/__tests__/bridge-install-bundle-frame.test.js

@@ -92,6 +92,30 @@ describe('relay client — install-bundle frame (pucc-int-04)', () => {
         handle.close();
         await closeRelay(relay.wss);
     });
+    it('oc-18: passes the frame engine through to the installer (and omits it when absent)', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const calls = [];
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            installBundle: (bundle) => { calls.push(bundle); return { written: [], skipped: [] }; },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'install-bundle', workspaceId: 'ws-7', files: {}, engine: 'opencode' }));
+        await q.next();
+        ws.send(JSON.stringify({ t: 'install-bundle', workspaceId: 'ws-7', files: {} }));
+        await q.next();
+        expect(calls).toEqual([
+            { workspaceId: 'ws-7', files: {}, engine: 'opencode' },
+            { workspaceId: 'ws-7', files: {} },
+        ]);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
     it('errors (never crashes) when no installer is wired', async () => {
         const relay = await startFakeRelay();
         const sessions = new sessionManager_1.SessionManager(makeFactory());

package/dist/__tests__/bridge-loopback-opencode-open.test.d.ts

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

package/dist/__tests__/bridge-loopback-opencode-open.test.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * oc-20 — a local pane opened from the browser over the loopback bridge launches
+ * OpenCode when the `open` frame carries the server-delivered block, and stays
+ * Claude Code when it does not.
+ */
+const ws_1 = __importDefault(require("ws"));
+const server_1 = require("../bridge/server");
+const sessionManager_1 = require("../bridge/sessionManager");
+const ORIGIN = 'https://app.hiveop.io';
+const TOKEN = 'tok';
+const block = { engine: 'opencode', model: 'moonshotai/kimi-k2', gatewayUrl: 'https://api.example.test/api/v1/opencode/v1', gatewayToken: 'hgw_abc' };
+describe('loopback open (browser -> bridge)', () => {
+    let handle;
+    let spawns;
+    beforeEach(async () => {
+        spawns = [];
+        const pty = { write() { }, resize() { }, kill() { }, onData() { }, onExit() { } };
+        handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN, allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager({ spawn: (o) => { spawns.push(o); return pty; } }),
+            resolveLocalAgentCwd: () => '/tmp/proj',
+            commandExists: () => true,
+        });
+    });
+    afterEach(async () => { await handle.close(); });
+    const open = async (extra) => {
+        const ws = new ws_1.default(`ws://127.0.0.1:${handle.port}`, { headers: { origin: ORIGIN } });
+        await new Promise((r) => ws.on('open', r));
+        ws.send(JSON.stringify({ v: 1, token: TOKEN }));
+        const opened = new Promise((r) => ws.on('message', (m) => { if (JSON.parse(String(m)).t === 'opened')
+            r(null); }));
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, agentId: 'a1', workspaceId: 'w1', ...extra }));
+        await opened;
+        ws.close();
+    };
+    it('spawns opencode with the gateway env when the frame carries the block', async () => {
+        await open({ opencode: block });
+        expect(spawns[0].command).toBe('opencode');
+        expect(spawns[0].env).toMatchObject({ HIVEOP_GATEWAY_TOKEN: 'hgw_abc' });
+    });
+    it('spawns claude when there is no block (Claude Code panes unchanged)', async () => {
+        await open({});
+        expect(spawns[0].command).toBe('claude');
+        expect(spawns[0].env?.HIVEOP_GATEWAY_TOKEN).toBeUndefined();
+    });
+});

package/dist/__tests__/bridge-opencode-launch.test.d.ts

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

package/dist/__tests__/bridge-opencode-launch.test.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * oc-08 — the local bridge launches OpenCode agents.
+ * Resolver per engine (exact command/args/env), the install hint, the minimum
+ * version, `-s` only for a captured id, and the relay lane carrying the
+ * server-delivered launch block through to the spawn.
+ */
+const ws_1 = require("ws");
+const agentLaunch_1 = require("../bridge/agentLaunch");
+const opencodeConfig_1 = require("../bridge/opencodeConfig");
+const relayClient_1 = require("../bridge/relayClient");
+const sessionManager_1 = require("../bridge/sessionManager");
+const GW = 'https://api.example.test/api/v1/opencode/v1';
+const oc = (extra = {}) => ({
+    engine: 'opencode', model: 'moonshotai/kimi-k2', gatewayUrl: GW, gatewayToken: 'hgw_abc', ...extra,
+});
+describe('oc-07 — local MCP entry', () => {
+    const mcpOf = (l) => JSON.parse(l.env.OPENCODE_CONFIG_CONTENT).mcp['wenrwa-marketplace'];
+    it('uses the resolved installed server (never npx) and passes MARKETPLACE_API_URL by reference', () => {
+        const l = (0, agentLaunch_1.resolveAgentLaunch)({
+            opencode: oc(), connectToken: 'tok',
+            mcpServer: { command: '/usr/bin/node', args: ['/h/.wen-market/mcp/dist/index.js'] },
+            apiUrl: 'https://api.example.test/api/v1',
+        });
+        const m = mcpOf(l);
+        expect(m.command).toEqual(['/usr/bin/node', '/h/.wen-market/mcp/dist/index.js']);
+        expect(m.environment).toEqual({
+            WENRWA_CONNECT_TOKEN: '{env:WENRWA_CONNECT_TOKEN}',
+            MARKETPLACE_API_URL: '{env:MARKETPLACE_API_URL}',
+        });
+        expect(l.env.MARKETPLACE_API_URL).toBe('https://api.example.test/api/v1');
+        expect(l.env.OPENCODE_CONFIG_CONTENT).not.toContain('tok"');
+    });
+    it('npx fallback must not inherit npm_config_offline=true', () => {
+        const l = (0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc(), connectToken: 'tok' });
+        expect(l.env.npm_config_offline).toBe('true'); // the pane itself stays quiet
+        const m = mcpOf(l);
+        expect(m.command).toEqual(['npx', '@wenrwa/marketplace-mcp']);
+        expect(m.environment.npm_config_offline).toBe('false');
+    });
+    it('no connect token -> no mcp entry', () => {
+        expect(JSON.parse((0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc(), mcpServer: { command: 'n', args: [] } }).env.OPENCODE_CONFIG_CONTENT).mcp).toBeUndefined();
+    });
+});
+describe('resolveAgentLaunch per engine', () => {
+    it('Claude path is unchanged when no opencode block, or engine is claude_code', () => {
+        const base = (0, agentLaunch_1.resolveAgentLaunch)({ autonomous: true, workspaceId: 'w1' });
+        expect(base).toEqual({
+            command: 'claude',
+            args: ['--dangerously-skip-permissions'],
+            env: { HIVEOP_CONTEXT_FILE: '.hiveop/context.md', WENRWA_WORKSPACE_ID: 'w1' },
+        });
+        expect((0, agentLaunch_1.resolveAgentLaunch)({ autonomous: true, workspaceId: 'w1', opencode: { engine: 'claude_code' } })).toEqual(base);
+        // an opencode engine without a token/model/url must NOT half-launch
+        expect((0, agentLaunch_1.resolveAgentLaunch)({ opencode: { engine: 'opencode', model: 'm' } }).command).toBe('claude');
+    });
+    it('opencode: command, args, env, and no gateway token on the Claude path', () => {
+        const l = (0, agentLaunch_1.resolveAgentLaunch)({ autonomous: false, opencode: oc(), workspaceId: 'w1', sessionPin: { agentId: 'a1', exists: true } });
+        expect(l.command).toBe('opencode');
+        expect(l.args).toEqual([]);
+        expect(l.env).toMatchObject({
+            ...opencodeConfig_1.OPENCODE_QUIET_ENV,
+            HIVEOP_GATEWAY_TOKEN: 'hgw_abc',
+            WENRWA_WORKSPACE_ID: 'w1',
+            WENRWA_AGENT_ID: 'a1',
+            HIVEOP_CONTEXT_FILE: '.hiveop/context.md',
+        });
+        const claude = (0, agentLaunch_1.resolveAgentLaunch)({ workspaceId: 'w1' });
+        expect(claude.env.HIVEOP_GATEWAY_TOKEN).toBeUndefined();
+        expect(claude.env.OPENCODE_CONFIG_CONTENT).toBeUndefined();
+    });
+    it('config JSON: gateway provider, single model, small_model, no secrets inline', () => {
+        const l = (0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc() });
+        const cfg = JSON.parse(l.env.OPENCODE_CONFIG_CONTENT);
+        expect(cfg).toMatchObject({
+            autoupdate: false, share: 'disabled', enabled_providers: ['hiveop'],
+            model: 'hiveop/moonshotai/kimi-k2', small_model: 'hiveop/moonshotai/kimi-k2',
+        });
+        expect(cfg.provider.hiveop.options).toEqual({ baseURL: GW, apiKey: '{env:HIVEOP_GATEWAY_TOKEN}' });
+        expect(cfg.provider.hiveop.whitelist).toEqual(['moonshotai/kimi-k2']);
+        expect(cfg.permission).toBeUndefined();
+        expect(cfg.mcp).toBeUndefined();
+        expect(l.env.OPENCODE_CONFIG_CONTENT).not.toContain('hgw_abc');
+        expect(JSON.stringify(l)).not.toMatch(/OPENROUTER|sk-or-/i);
+    });
+    it('autonomous -> permission allow; connect token -> MCP server by env reference', () => {
+        const l = (0, agentLaunch_1.resolveAgentLaunch)({ autonomous: true, connectToken: 'ct_1', opencode: oc() });
+        const cfg = JSON.parse(l.env.OPENCODE_CONFIG_CONTENT);
+        expect(cfg.permission).toBe('allow');
+        expect(cfg.mcp['wenrwa-marketplace']).toMatchObject({
+            type: 'local', enabled: true, environment: { WENRWA_CONNECT_TOKEN: '{env:WENRWA_CONNECT_TOKEN}' },
+        });
+        expect(l.env.WENRWA_CONNECT_TOKEN).toBe('ct_1');
+        expect(l.env.OPENCODE_CONFIG_CONTENT).not.toContain('ct_1');
+    });
+    it('-s only when a CAPTURED (ses_) id exists; a pre-minted uuid never resumes', () => {
+        expect((0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc() }).args).toEqual([]);
+        expect((0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc({ sessionId: 'ses_29fabc123' }) }).args).toEqual(['-s', 'ses_29fabc123']);
+        expect((0, agentLaunch_1.resolveAgentLaunch)({ opencode: oc({ sessionId: '2b7c1e0a-1111-4222-8333-444455556666' }) }).args).toEqual([]);
+        expect((0, opencodeConfig_1.isCapturedOpencodeSessionId)('ses_x; rm -rf')).toBe(false);
+    });
+    it('buildOpencodeConfig is pure and deterministic', () => {
+        const i = { model: 'm', gatewayBaseUrl: GW, autonomous: true, withMcp: true };
+        expect((0, opencodeConfig_1.buildOpencodeConfig)(i)).toEqual((0, opencodeConfig_1.buildOpencodeConfig)(i));
+    });
+});
+describe('install hint and minimum version', () => {
+    it('hint mirrors the Claude message', () => {
+        expect(opencodeConfig_1.OPENCODE_INSTALL_HINT).toBe(`Install OpenCode: npm i -g opencode-ai@>=${opencodeConfig_1.OPENCODE_MIN_VERSION}`);
+        expect((0, agentLaunch_1.missingCommandMessage)('opencode')).toContain(opencodeConfig_1.OPENCODE_INSTALL_HINT);
+        expect((0, agentLaunch_1.missingCommandMessage)('claude')).toBe('claude not found on PATH — install Claude Code CLI on this machine');
+    });
+    it('version gate', () => {
+        expect((0, opencodeConfig_1.opencodeVersionOk)('1.18.35')).toBe(true);
+        expect((0, opencodeConfig_1.opencodeVersionOk)('opencode 1.18.36\n')).toBe(true);
+        expect((0, opencodeConfig_1.opencodeVersionOk)('1.19.0')).toBe(true);
+        expect((0, opencodeConfig_1.opencodeVersionOk)('2.0.0')).toBe(true);
+        expect((0, opencodeConfig_1.opencodeVersionOk)('1.18.34')).toBe(false);
+        expect((0, opencodeConfig_1.opencodeVersionOk)('0.99.99')).toBe(false);
+        expect((0, opencodeConfig_1.opencodeVersionOk)('garbage')).toBe(false);
+        expect((0, opencodeConfig_1.opencodeVersionOk)(null)).toBe(false);
+    });
+});
+class FakePty {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    write() { }
+    resize() { }
+    kill() { }
+    onData() { }
+    onExit() { }
+}
+function setup() {
+    const ptys = [];
+    const factory = { spawn: (o) => { const p = new FakePty(o); ptys.push(p); return p; } };
+    return new Promise((resolve) => {
+        const wss = new ws_1.WebSocketServer({ port: 0, host: '127.0.0.1' });
+        wss.on('listening', () => resolve({ wss, port: wss.address().port, ptys, factory }));
+    });
+}
+describe('relay lane carries the server-delivered opencode block', () => {
+    it('spawns opencode with the gateway env; refuses with the install hint when missing', async () => {
+        const { wss, port, ptys, factory } = await setup();
+        const frames = [];
+        let conn;
+        const got = new Promise((r) => wss.on('connection', (ws) => { conn = ws; ws.on('message', (m) => frames.push(JSON.parse(String(m)))); r(); }));
+        let exists = true;
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${port}`, relayToken: 'tok',
+            sessions: new sessionManager_1.SessionManager(factory),
+            resolveLaunch: (o) => (0, agentLaunch_1.resolveAgentLaunch)({ autonomous: true, opencode: o.opencode, connectToken: o.connectToken }),
+            commandExists: () => exists,
+        });
+        await got;
+        const wait = async (pred) => { for (let i = 0; i < 100; i++) {
+            const f = frames.find(pred);
+            if (f)
+                return f;
+            await new Promise((r) => setTimeout(r, 10));
+        } throw new Error('timeout'); };
+        conn.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'a-1', workspaceId: 'w', connectToken: 'ct_9', opencode: oc({ sessionId: 'ses_abc' }) }));
+        await wait((f) => f.t === 'opened');
+        expect(ptys[0].opts.command).toBe('opencode');
+        expect(ptys[0].opts.args).toEqual(['-s', 'ses_abc']);
+        expect(ptys[0].opts.env).toMatchObject({ HIVEOP_GATEWAY_TOKEN: 'hgw_abc', OPENCODE_DISABLE_MODELS_FETCH: '1', WENRWA_CONNECT_TOKEN: 'ct_9' });
+        exists = false;
+        conn.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'a-2', workspaceId: 'w', opencode: oc() }));
+        const err = await wait((f) => f.t === 'error' && f.sessionId === 'a-2');
+        expect(err.message).toContain(opencodeConfig_1.OPENCODE_INSTALL_HINT);
+        expect(ptys).toHaveLength(1);
+        handle.close();
+        for (const c of wss.clients)
+            c.terminate();
+        await new Promise((r) => wss.close(r));
+    });
+});

package/dist/__tests__/bridge-relay-pucc14.test.js

@@ -331,6 +331,34 @@ describe('relay client — hooks-based activity tail (fcct-25)', () => {
         handle.close();
         await closeRelay(relay.wss);
     });
+    it('oc-22: forwards an OpenCode needs_you record as an activity frame carrying kind', async () => {
+        fs.writeFileSync(activityFile, '');
+        process.env.HIVEOP_ACTIVITY_FILE = activityFile;
+        const relay = await startFakeRelay();
+        const { factory } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        let tick = null;
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            setIntervalFn: (cb) => { tick = cb; return 1; },
+            clearIntervalFn: () => { },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        fs.appendFileSync(activityFile, JSON.stringify({ sessionId: 'agent-A', workspaceId: 'ws-7', kind: 'needs_you', thinking: 'Waiting for you' }) + '\n');
+        tick();
+        expect(await q.next()).toEqual({
+            t: 'activity',
+            sessionId: 'agent-A',
+            thinking: 'Waiting for you',
+            kind: 'needs_you',
+        });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
     it('never schedules the tail when HIVEOP_ACTIVITY_FILE is unset (no stray fs polling)', async () => {
         delete process.env.HIVEOP_ACTIVITY_FILE;
         const relay = await startFakeRelay();

package/dist/__tests__/bridge-server.test.js

@@ -814,6 +814,38 @@ describe('bridge WebSocket server — fcct-24 local-workspace-agent activity', (
             await handle.close();
         }
     });
+    it('oc-22: local lane — an OpenCode needs_you record reaches the app as an activity frame carrying kind', async () => {
+        const file = fs.mkdtempSync(path.join(os.tmpdir(), 'oc22-server-activity-')) + '/activity.jsonl';
+        fs.writeFileSync(file, '');
+        const factory = { spawn: () => new FakePty() };
+        const tickBox = { fn: null };
+        const handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN,
+            allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager(factory),
+            resolveLocalAgentCwd: () => '/Users/dev/my-project',
+            activityFile: file,
+            hiveOpSettingsPath: '/Users/t/.wen-market/claude-hooks-settings.json',
+            activityScheduleInterval: (cb) => { tickBox.fn = cb; return 'h'; },
+            activityCancelInterval: () => { },
+        });
+        try {
+            const { ws, q } = await openAndAuth(handle.port);
+            ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, agentId: 'agent-1', workspaceId: 'ws-1' }));
+            await q.next();
+            fs.appendFileSync(file, JSON.stringify({ sessionId: 'agent-1', kind: 'needs_you', thinking: 'Waiting for you' }) + '\n');
+            tickBox.fn?.();
+            expect(await q.next()).toEqual({ t: 'activity', sessionId: 'agent-1', thinking: 'Waiting for you', kind: 'needs_you' });
+            // Claude's records carry kind 'tool'/'stop' — the outward frame must stay exactly as it was.
+            fs.appendFileSync(file, JSON.stringify({ sessionId: 'agent-1', kind: 'stop', thinking: '' }) + '\n');
+            tickBox.fn?.();
+            expect(await q.next()).toEqual({ t: 'activity', sessionId: 'agent-1', thinking: '' });
+            ws.close();
+        }
+        finally {
+            await handle.close();
+        }
+    });
 });
 // lws — GET /local-file/:workspaceId?path=…&token=… . Same origin+token gate
 // as /local-tree; the interesting part is that refusal REASONS survive as

package/dist/__tests__/opencode-config-parity.test.d.ts

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

package/dist/__tests__/opencode-config-parity.test.js

@@ -0,0 +1,85 @@
+"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-05/oc-08 — ONE config contract. The hosted image builds OPENCODE_CONFIG_CONTENT with
+ * infra/terminal-image/opencode/build-config.js (the image may carry an older CLI, so it does
+ * not import the compiled builder); this pins it deep-equal to the canonical
+ * buildOpencodeConfig for equivalent inputs, and the quiet env identical.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const opencodeConfig_1 = require("../bridge/opencodeConfig");
+const INFRA = path.join(__dirname, '..', '..', '..', 'infra', 'terminal-image');
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const hosted = require(path.join(INFRA, 'opencode', 'build-config.js'));
+const BASE = {
+    WENRWA_AGENT_MODEL: 'anthropic/claude-sonnet-4.5',
+    HIVEOP_GATEWAY_URL: 'https://api.wenrwa.com/api/v1/opencode/v1',
+    HIVEOP_GATEWAY_TOKEN: 'hgw_x',
+};
+const table = [
+    { name: 'supervised, no mcp', env: BASE, autonomous: false, withMcp: false },
+    { name: 'autonomous', env: { ...BASE, HT_AUTONOMOUS: '1' }, autonomous: true, withMcp: false },
+    { name: 'mcp', env: { ...BASE, WENRWA_CONNECT_TOKEN: 'tok' }, autonomous: false, withMcp: true },
+    { name: 'autonomous + mcp, other model', env: { ...BASE, WENRWA_AGENT_MODEL: 'moonshotai/kimi-k2', HT_AUTONOMOUS: '1', WENRWA_CONNECT_TOKEN: 'tok' }, autonomous: true, withMcp: true },
+];
+describe('hosted build-config.js == CLI buildOpencodeConfig', () => {
+    it.each(table)('$name', ({ env, autonomous, withMcp }) => {
+        const canonical = {
+            ...(0, opencodeConfig_1.buildOpencodeConfig)({
+                model: env.WENRWA_AGENT_MODEL,
+                gatewayBaseUrl: env.HIVEOP_GATEWAY_URL,
+                autonomous,
+                withMcp,
+                mcpCommand: ['marketplace-mcp'],
+                mcpEnvPassthrough: ['MARKETPLACE_API_URL'],
+            }),
+            plugin: [hosted.PLUGIN_URL],
+        };
+        expect(hosted.buildConfig(env)).toEqual(canonical);
+    });
+    it('quiet env is identical, and autolaunch.sh exports exactly it', () => {
+        expect(hosted.QUIET_ENV).toEqual({ ...opencodeConfig_1.OPENCODE_QUIET_ENV });
+        const sh = fs.readFileSync(path.join(INFRA, 'autolaunch.sh'), 'utf8');
+        for (const [k, v] of Object.entries(opencodeConfig_1.OPENCODE_QUIET_ENV)) {
+            expect(sh).toMatch(new RegExp(`(^|\\s)${k}=${v}(\\s|$)`, 'm'));
+        }
+    });
+    it('the hosted plugin URL is the file the Dockerfile installs', () => {
+        expect(fs.readFileSync(path.join(INFRA, 'Dockerfile'), 'utf8')).toContain('COPY opencode/hiveop-plugin.mjs /opt/hiveop/opencode/hiveop-plugin.mjs');
+        expect(hosted.PLUGIN_URL).toBe('file:///opt/hiveop/opencode/hiveop-plugin.mjs');
+    });
+});

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

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