@wenrwa/marketplace-cli 0.7.8 → 0.8.1

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>;

package/dist/bridge/attachmentWriter.js

@@ -38,6 +38,8 @@ exports.sniffImageExt = sniffImageExt;
 exports.safeAttachmentStem = safeAttachmentStem;
 exports.writeAttachment = writeAttachment;
 exports.attachmentRootFor = attachmentRootFor;
+exports.pastePayloadFor = pastePayloadFor;
+exports.pasteIfOpencode = pasteIfOpencode;
 exports.handleAttachFrame = handleAttachFrame;
 /**
  * Terminal attach — save a screenshot NEXT TO the agent that will read it.
@@ -154,6 +156,24 @@ function attachmentRootFor(sessions, sessionId) {
         return null;
     return sessions.cwdOf(sessionId) ?? os.homedir();
 }
+/**
+ * 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.
+ */
+function pastePayloadFor(engine, filePath) {
+    if (engine !== 'opencode')
+        return null;
+    return `\x1b[200~${filePath.replace(/ /g, '\\ ')}\x1b[201~`;
+}
+/** 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). */
+function pasteIfOpencode(sessions, sessionId, filePath) {
+    const paste = pastePayloadFor(sessions.engineOf?.(sessionId), filePath);
+    return paste !== null && sessions.writeTo?.(sessionId, paste) === true;
+}
 /**
  * The whole `attach-file` frame → `file-attached` reply, shared verbatim by
  * the local server and the relay client so the two lanes cannot drift.
@@ -168,5 +188,8 @@ function handleAttachFrame(frame, sessions, deps = exports.realAttachmentDeps) {
     if (!root)
         return { ...head, ok: false, reason: 'no-session' };
     const result = writeAttachment({ root, name: typeof frame.name === 'string' ? frame.name : 'image', dataBase64: typeof frame.data === 'string' ? frame.data : '' }, deps);
-    return result.ok ? { ...head, ok: true, path: result.path, bytes: result.bytes } : { ...head, ok: false, reason: result.reason };
+    if (!result.ok)
+        return { ...head, ok: false, reason: result.reason };
+    const pasted = pasteIfOpencode(sessions, frame.sessionId, result.path);
+    return { ...head, ok: true, path: result.path, bytes: result.bytes, ...(pasted ? { pasted: true } : {}) };
 }

package/dist/bridge/bundleInstaller.d.ts

@@ -27,6 +27,8 @@ export interface BundleInstallerDeps {
     readFile?: (filePath: string) => string;
     remove?: (filePath: string) => void;
 }
+/** oc-18 — which engine's file layout this bundle is installed as. */
+export type BundleEngine = 'claude' | 'opencode';
 export type SkipReason = 'unsafe' | 'unmanaged';
 export interface InstallBundleResult {
     /** The absolute workspace checkout root, or null if the workspaceId itself was unsafe. */
@@ -53,4 +55,5 @@ export declare function isSafeWorkspaceId(workspaceId: string): boolean;
 export declare function installBundle(bundle: {
     workspaceId: string;
     files: FileMap;
+    engine?: BundleEngine | string;
 }, deps: BundleInstallerDeps): InstallBundleResult;

package/dist/bridge/bundleInstaller.js

@@ -65,6 +65,7 @@ exports.installBundle = installBundle;
  *     the crew files.
  */
 const path = __importStar(require("path"));
+const crewTranslator_1 = require("./crewTranslator");
 /**
  * The marker every forged crew member carries. Its presence is what
  * distinguishes a file this installer put there from one the pilot wrote by
@@ -89,11 +90,24 @@ function isSafeWorkspaceId(workspaceId) {
         workspaceId !== '.' &&
         workspaceId !== '..');
 }
-/** Only the crew-managed surface is writable: `.claude/**` + `CLAUDE.md`. */
-function isManaged(normalizedRel) {
-    return normalizedRel === 'CLAUDE.md' || normalizedRel.startsWith('.claude/');
+/**
+ * Only the crew-managed surface is writable: `.claude/**` + `CLAUDE.md`, plus
+ * (oc-18, engine=opencode only) `.opencode/agent/**` + `AGENTS.md`. The widening
+ * is per-call: a Claude install can never write OpenCode paths and vice versa.
+ */
+function isManaged(normalizedRel, engine) {
+    if (normalizedRel === 'CLAUDE.md' || normalizedRel.startsWith('.claude/'))
+        return true;
+    return engine === 'opencode' && (normalizedRel === 'AGENTS.md' || normalizedRel.startsWith(`${crewTranslator_1.OPENCODE_AGENT_DIR}/`));
 }
 function installBundle(bundle, deps) {
+    // oc-18: anything but an explicit 'opencode' is the Claude path, unchanged.
+    const engine = bundle.engine === 'opencode' ? 'opencode' : 'claude';
+    const agentsDirRel = engine === 'opencode' ? crewTranslator_1.OPENCODE_AGENT_DIR : AGENTS_DIR_REL;
+    // Translate BEFORE the path checks so the translated paths are the ones vetted.
+    const sourceFiles = engine === 'opencode'
+        ? (0, crewTranslator_1.translateCrewBundleForOpencode)(bundle.files ?? {})
+        : (bundle.files ?? {});
     const written = [];
     const skipped = [];
     const pruned = [];
@@ -106,7 +120,7 @@ function installBundle(bundle, deps) {
     const workspaceRoot = deps.workspaceRoot
         ? path.posix.resolve(deps.workspaceRoot)
         : path.posix.resolve(deps.reposBaseDir, bundle.workspaceId);
-    for (const [rawRel, content] of Object.entries(bundle.files ?? {})) {
+    for (const [rawRel, content] of Object.entries(sourceFiles)) {
         // Reject obvious escapes up front: empty, null byte, absolute (posix or
         // Windows-drive). Absolute paths would make path.posix.resolve ignore the
         // workspace root entirely.
@@ -130,7 +144,7 @@ function installBundle(bundle, deps) {
             continue;
         }
         // Managed surface only.
-        if (!isManaged(normalized)) {
+        if (!isManaged(normalized, engine)) {
             skipped.push({ path: rawRel, reason: 'unmanaged' });
             continue;
         }
@@ -157,14 +171,14 @@ function installBundle(bundle, deps) {
         - and any error reading the directory abandons pruning entirely — an
           install that wrote its files must not fail because cleanup could not.
     */
-    const installedAgents = new Set(written.filter((rel) => rel.startsWith(`${AGENTS_DIR_REL}/`)));
+    const installedAgents = new Set(written.filter((rel) => rel.startsWith(`${agentsDirRel}/`)));
     if (installedAgents.size > 0 && deps.listDir && deps.readFile && deps.remove) {
-        const agentsDir = path.posix.resolve(workspaceRoot, AGENTS_DIR_REL);
+        const agentsDir = path.posix.resolve(workspaceRoot, agentsDirRel);
         try {
             for (const name of deps.listDir(agentsDir)) {
                 if (!name.endsWith('.md'))
                     continue;
-                const rel = `${AGENTS_DIR_REL}/${name}`;
+                const rel = `${agentsDirRel}/${name}`;
                 if (installedAgents.has(rel))
                     continue;
                 const full = path.posix.resolve(agentsDir, name);

package/dist/bridge/claudeTranscriptReader.d.ts

@@ -1,4 +1,5 @@
 import { type ClaudeSessionHistoryDeps } from './claudeSessionHistory';
+import { type OpencodeTranscriptDeps } from './opencodeTranscriptReader';
 /** 20MB — generous for a jsonl transcript (a real multi-hour session
  *  comfortably fits) while still refusing a runaway file rather than
  *  holding it all in memory and shipping it down one WS frame. */
@@ -8,12 +9,17 @@ export type ReadAgentTranscriptResult = {
     content: string;
 } | {
     ok: false;
-    reason: 'not-found' | 'invalid-agent-id' | 'too-large';
+    reason: 'not-found' | 'invalid-agent-id' | 'too-large' | 'transcript-unavailable';
 };
 export interface ClaudeTranscriptReaderDeps extends ClaudeSessionHistoryDeps {
     existsSync?: (p: string) => boolean;
     statSize?: (p: string) => number;
     readFileUtf8?: (p: string) => string;
+    /** oc-17: which reader. Absent -> Claude's jsonl when present, else the agent's OpenCode DB. */
+    engine?: 'claude_code' | 'opencode';
+    /** oc-17: OpenCode session id to read (absent -> the newest root session). */
+    opencodeSessionId?: string;
+    opencode?: OpencodeTranscriptDeps;
 }
 /** Read ONE agent's transcript out of `<reposBaseDir>/<workspaceId>`'s
  *  Claude Code project directory. Never writes, never caches — a single

package/dist/bridge/claudeTranscriptReader.js

@@ -70,6 +70,7 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const claudeSessionHistory_1 = require("./claudeSessionHistory");
 const bundleInstaller_1 = require("./bundleInstaller");
+const opencodeTranscriptReader_1 = require("./opencodeTranscriptReader");
 /** 20MB — generous for a jsonl transcript (a real multi-hour session
  *  comfortably fits) while still refusing a runaway file rather than
  *  holding it all in memory and shipping it down one WS frame. */
@@ -101,8 +102,17 @@ function readAgentTranscript(reposBaseDir, workspaceId, agentId, deps = {}) {
     const workspaceRoot = path.posix.resolve(reposBaseDir, workspaceId);
     const projectDir = path.join((0, claudeSessionHistory_1.claudeConfigDir)(deps), 'projects', (0, claudeSessionHistory_1.claudeProjectSlug)(workspaceRoot));
     const transcriptPath = path.join(projectDir, `${agentId}.jsonl`);
-    if (!existsSync(transcriptPath))
-        return { ok: false, reason: 'not-found' };
+    const readOpencode = () => (0, opencodeTranscriptReader_1.readOpencodeTranscript)(agentId, deps.opencodeSessionId, { existsSync, ...deps.opencode });
+    if (deps.engine === 'opencode')
+        return readOpencode();
+    if (!existsSync(transcriptPath)) {
+        if (deps.engine === 'claude_code')
+            return { ok: false, reason: 'not-found' };
+        // oc-17: no Claude jsonl -- an OpenCode agent's history lives in its own DB.
+        return existsSync((0, opencodeTranscriptReader_1.opencodeDbPath)(agentId, { existsSync, ...deps.opencode }))
+            ? readOpencode()
+            : { ok: false, reason: 'not-found' };
+    }
     let size;
     try {
         size = statSize(transcriptPath);

package/dist/bridge/contextFile.d.ts

@@ -0,0 +1,20 @@
+/**
+ * oc-23 — which project-instructions file an engine reads. ONE mapping, shared by
+ * every writer that puts HiveOp context into a checkout.
+ *
+ * Claude Code reads CLAUDE.md. OpenCode reads AGENTS.md, and falls back to
+ * CLAUDE.md only while AGENTS.md is absent (oc-18 notes), so a region written
+ * to CLAUDE.md alone is invisible to an OpenCode agent the moment a crew
+ * bundle or anything else creates AGENTS.md.
+ */
+export declare const CLAUDE_CONTEXT_FILE = "CLAUDE.md";
+export declare const OPENCODE_CONTEXT_FILE = "AGENTS.md";
+export type ContextFile = typeof CLAUDE_CONTEXT_FILE | typeof OPENCODE_CONTEXT_FILE;
+/** The signal the launch already carries: `WENRWA_AGENT_ENGINE` / the relay `opencode` block. Unknown = Claude. */
+export declare function contextFileFor(engine: string | null | undefined): ContextFile;
+/**
+ * Files to write for one engine's context: its own, plus the sibling when that
+ * already exists. One checkout can hold a Claude agent and an OpenCode agent;
+ * a file nobody has asked for is never created, but one that exists stays current.
+ */
+export declare function contextTargets(engine: string | null | undefined, exists: (file: ContextFile) => boolean): ContextFile[];

package/dist/bridge/contextFile.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENCODE_CONTEXT_FILE = exports.CLAUDE_CONTEXT_FILE = void 0;
+exports.contextFileFor = contextFileFor;
+exports.contextTargets = contextTargets;
+/**
+ * oc-23 — which project-instructions file an engine reads. ONE mapping, shared by
+ * every writer that puts HiveOp context into a checkout.
+ *
+ * Claude Code reads CLAUDE.md. OpenCode reads AGENTS.md, and falls back to
+ * CLAUDE.md only while AGENTS.md is absent (oc-18 notes), so a region written
+ * to CLAUDE.md alone is invisible to an OpenCode agent the moment a crew
+ * bundle or anything else creates AGENTS.md.
+ */
+exports.CLAUDE_CONTEXT_FILE = 'CLAUDE.md';
+exports.OPENCODE_CONTEXT_FILE = 'AGENTS.md';
+/** The signal the launch already carries: `WENRWA_AGENT_ENGINE` / the relay `opencode` block. Unknown = Claude. */
+function contextFileFor(engine) {
+    return engine === 'opencode' ? exports.OPENCODE_CONTEXT_FILE : exports.CLAUDE_CONTEXT_FILE;
+}
+/**
+ * Files to write for one engine's context: its own, plus the sibling when that
+ * already exists. One checkout can hold a Claude agent and an OpenCode agent;
+ * a file nobody has asked for is never created, but one that exists stays current.
+ */
+function contextTargets(engine, exists) {
+    const own = contextFileFor(engine);
+    const other = own === exports.CLAUDE_CONTEXT_FILE ? exports.OPENCODE_CONTEXT_FILE : exports.CLAUDE_CONTEXT_FILE;
+    return exists(other) ? [own, other] : [own];
+}

package/dist/bridge/contextWriter.d.ts

@@ -18,8 +18,11 @@ export type ContextWriteAction = 'created' | 'replaced' | 'appended' | 'removed'
 export interface ContextWriteResult {
     /** The workspace checkout root, or null if the workspaceId was unsafe. */
     workspaceRoot: string | null;
-    /** The CLAUDE.md path that was written, or null if nothing was written. */
+    /** The engine's own context file (CLAUDE.md, or AGENTS.md for opencode), or null if nothing was written.
+     *  Name kept for the wire contract; see `contextPaths` for every file touched. */
     claudeMdPath: string | null;
+    /** oc-23 — every context file this write touched (the engine's own first). */
+    contextPaths?: string[];
     /** What happened. `skipped` = unsafe workspaceId (nothing written). */
     action: ContextWriteAction;
 }
@@ -54,4 +57,10 @@ export declare function writeContext(input: {
      * selected files or on a browser being connected at all.
      */
     pointersOnly?: boolean;
+    /**
+     * oc-23 — the engine of the agent this write is for (`WENRWA_AGENT_ENGINE`).
+     * `opencode` targets AGENTS.md; anything else CLAUDE.md. A sibling file that
+     * already exists is kept in sync (see contextFile.contextTargets).
+     */
+    engine?: string;
 }, deps: ContextWriterDeps): ContextWriteResult;