@wenrwa/marketplace-cli 0.7.8 → 0.8.1

package/dist/bridge/contextWriter.js

@@ -66,6 +66,7 @@ exports.writeContext = writeContext;
  * never a sibling workspace. An unsafe workspaceId writes NOTHING.
  */
 const path = __importStar(require("path"));
+const contextFile_1 = require("./contextFile");
 const bundleInstaller_1 = require("./bundleInstaller");
 const workGraphPointer_1 = require("./workGraphPointer");
 const memoryPointer_1 = require("./memoryPointer");
@@ -119,13 +120,32 @@ function writeContext(input, deps) {
         return { workspaceRoot: null, claudeMdPath: null, action: 'skipped' };
     }
     const workspaceRoot = path.posix.resolve(deps.reposBaseDir, input.workspaceId);
-    const claudeMdPath = path.posix.resolve(workspaceRoot, 'CLAUDE.md');
-    // Belt-and-suspenders: prove containment (CLAUDE.md is a fixed segment, so
+    const fileAt = (name) => path.posix.resolve(workspaceRoot, name);
+    const targets = (0, contextFile_1.contextTargets)(input.engine, (f) => deps.exists(fileAt(f)));
+    // Belt-and-suspenders: prove containment (the names are fixed segments, so
     // this can only fail if isSafeWorkspaceId ever regresses).
-    if (claudeMdPath !== workspaceRoot + '/CLAUDE.md') {
+    if (targets.some((f) => fileAt(f) !== workspaceRoot + '/' + f)) {
         return { workspaceRoot: null, claudeMdPath: null, action: 'skipped' };
     }
-    const existing = deps.exists(claudeMdPath) ? deps.readFile(claudeMdPath) : null;
+    const paths = targets.map(fileAt);
+    // A file that does not exist yet is seeded from the other one, so a first
+    // AGENTS.md carries the user's own CLAUDE.md guidance instead of hiding it
+    // (OpenCode ignores CLAUDE.md once AGENTS.md exists).
+    const seed = paths.find((p) => deps.exists(p)) ?? null;
+    let primary = 'noop';
+    paths.forEach((target, i) => {
+        const action = writeContextFile(input, target, seed, workspaceRoot, deps);
+        if (i === 0)
+            primary = action;
+    });
+    return { workspaceRoot, claudeMdPath: paths[0], contextPaths: paths, action: primary };
+}
+function writeContextFile(input, claudeMdPath, seedPath, workspaceRoot, deps) {
+    const existing = deps.exists(claudeMdPath)
+        ? deps.readFile(claudeMdPath)
+        : seedPath && deps.exists(seedPath)
+            ? deps.readFile(seedPath)
+            : null;
     // wgcp-01 — the pointer rides IN the region, ahead of the arena's pushed
     // file content, but is decided entirely by the caller (workGraphAvailable):
     // absent/false is byte-identical to pre-wgcp-01 behavior (the pointer never
@@ -178,7 +198,7 @@ function writeContext(input, deps) {
     // ── Empty content → remove the region cleanly (or no-op). ──
     if (isEmpty) {
         if (!hasRegion) {
-            return { workspaceRoot, claudeMdPath, action: 'noop' };
+            return 'noop';
         }
         // Tidy only the seam we own: drop the trailing newlines of the head and the
         // leading newlines of the tail (the blank line inserted on append), never
@@ -189,22 +209,22 @@ function writeContext(input, deps) {
         if (out.length > 0)
             out = out.replace(/\n*$/, '\n');
         deps.writeFile(claudeMdPath, out);
-        return { workspaceRoot, claudeMdPath, action: 'removed' };
+        return 'removed';
     }
     const region = regionBlock(content);
     // ── Region already present → replace in place (idempotent). ──
     if (hasRegion) {
         deps.writeFile(claudeMdPath, before + region + after);
-        return { workspaceRoot, claudeMdPath, action: 'replaced' };
+        return 'replaced';
     }
     deps.mkdirp?.(workspaceRoot);
     // ── No CLAUDE.md yet → create it holding just the region. ──
     if (existing === null) {
         deps.writeFile(claudeMdPath, region + '\n');
-        return { workspaceRoot, claudeMdPath, action: 'created' };
+        return 'created';
     }
     // ── CLAUDE.md present, no region → append the region after user content. ──
     const sep = existing.length === 0 ? '' : (existing.endsWith('\n') ? '\n' : '\n\n');
     deps.writeFile(claudeMdPath, existing + sep + region + '\n');
-    return { workspaceRoot, claudeMdPath, action: 'appended' };
+    return 'appended';
 }

package/dist/bridge/crewTranslator.d.ts

@@ -0,0 +1,41 @@
+/**
+ * oc-18 — translate a forged Claude Code crew bundle into OpenCode's files.
+ * Pure: FileMap in, FileMap out, no I/O.
+ *
+ * Verified against opencode-ai@1.18.35 (oc-18 notes in issues/oc-18-*.md):
+ *   - agents load from `.opencode/agent/<name>.md` (filename = name); they are
+ *     NOT read from `.claude/agents`, so each subagent must be translated;
+ *   - frontmatter: description, mode (primary|subagent|all), permission; the
+ *     body is the prompt. `tools:` still works but is the legacy spelling, so
+ *     we emit `permission`;
+ *   - `.claude/skills/**\/SKILL.md` is read natively -> passthrough;
+ *   - `AGENTS.md` is the project rules file (CLAUDE.md is only a fallback when
+ *     AGENTS.md is absent) -> CLAUDE.md content moves there verbatim, so the
+ *     HIVEOP fence markers survive unchanged.
+ *
+ * `model` is DROPPED on purpose. An OpenCode agent's provider list is pinned to
+ * the single gateway-whitelisted model its owner chose (ADR-0013); a subagent
+ * with no model inherits its caller's, so it bills at that model. A Claude
+ * alias like `sonnet` would name a model the gateway refuses.
+ */
+export type FileMap = Record<string, string>;
+export declare const OPENCODE_AGENT_DIR = ".opencode/agent";
+/**
+ * Claude's `tools:` is an allowlist (absent = inherit all); OpenCode's default
+ * is allow, so the allowlist becomes `deny` for each gated tool not listed.
+ * Read/Grep/Glob/LS are never gated. `mcp__*` entries and unknown names are
+ * ignored: OpenCode cannot deny "all MCP" without naming servers, and the
+ * agent's own allow-all setting governs MCP anyway.
+ */
+export declare function mapClaudeToolsToPermission(tools: string | string[] | undefined): Record<string, 'deny'> | undefined;
+export interface Frontmatter {
+    data: Record<string, string>;
+    body: string;
+    /** True when the source used CRLF line endings. */
+    crlf: boolean;
+}
+/** Minimal YAML-subset reader: `key: value`, quoted values, `|`/`>` blocks. */
+export declare function parseFrontmatter(src: string): Frontmatter;
+/** One Claude subagent file -> one OpenCode agent file. */
+export declare function translateClaudeAgentToOpencode(src: string): string;
+export declare function translateCrewBundleForOpencode(bundle: FileMap): FileMap;

package/dist/bridge/crewTranslator.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * oc-18 — translate a forged Claude Code crew bundle into OpenCode's files.
+ * Pure: FileMap in, FileMap out, no I/O.
+ *
+ * Verified against opencode-ai@1.18.35 (oc-18 notes in issues/oc-18-*.md):
+ *   - agents load from `.opencode/agent/<name>.md` (filename = name); they are
+ *     NOT read from `.claude/agents`, so each subagent must be translated;
+ *   - frontmatter: description, mode (primary|subagent|all), permission; the
+ *     body is the prompt. `tools:` still works but is the legacy spelling, so
+ *     we emit `permission`;
+ *   - `.claude/skills/**\/SKILL.md` is read natively -> passthrough;
+ *   - `AGENTS.md` is the project rules file (CLAUDE.md is only a fallback when
+ *     AGENTS.md is absent) -> CLAUDE.md content moves there verbatim, so the
+ *     HIVEOP fence markers survive unchanged.
+ *
+ * `model` is DROPPED on purpose. An OpenCode agent's provider list is pinned to
+ * the single gateway-whitelisted model its owner chose (ADR-0013); a subagent
+ * with no model inherits its caller's, so it bills at that model. A Claude
+ * alias like `sonnet` would name a model the gateway refuses.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENCODE_AGENT_DIR = void 0;
+exports.mapClaudeToolsToPermission = mapClaudeToolsToPermission;
+exports.parseFrontmatter = parseFrontmatter;
+exports.translateClaudeAgentToOpencode = translateClaudeAgentToOpencode;
+exports.translateCrewBundleForOpencode = translateCrewBundleForOpencode;
+exports.OPENCODE_AGENT_DIR = '.opencode/agent';
+const CLAUDE_AGENTS_PREFIX = '.claude/agents/';
+/** Claude tool name -> OpenCode permission key. Read-class tools are never denied. */
+const TOOL_TO_PERMISSION = {
+    Write: 'edit', Edit: 'edit', MultiEdit: 'edit', NotebookEdit: 'edit',
+    Bash: 'bash',
+    WebFetch: 'webfetch',
+    WebSearch: 'websearch',
+    Task: 'task',
+    TodoWrite: 'todowrite',
+};
+/** Order is the emitted order (golden-tested). */
+const GATED = ['edit', 'bash', 'webfetch', 'websearch', 'task', 'todowrite'];
+/**
+ * Claude's `tools:` is an allowlist (absent = inherit all); OpenCode's default
+ * is allow, so the allowlist becomes `deny` for each gated tool not listed.
+ * Read/Grep/Glob/LS are never gated. `mcp__*` entries and unknown names are
+ * ignored: OpenCode cannot deny "all MCP" without naming servers, and the
+ * agent's own allow-all setting governs MCP anyway.
+ */
+function mapClaudeToolsToPermission(tools) {
+    const list = (Array.isArray(tools) ? tools : (tools ?? '').split(','))
+        .map((t) => t.trim())
+        .filter(Boolean);
+    if (list.length === 0)
+        return undefined;
+    const allowed = new Set(list.map((t) => TOOL_TO_PERMISSION[t]).filter(Boolean));
+    const out = {};
+    for (const key of GATED)
+        if (!allowed.has(key))
+            out[key] = 'deny';
+    return out;
+}
+/** Minimal YAML-subset reader: `key: value`, quoted values, `|`/`>` blocks. */
+function parseFrontmatter(src) {
+    const crlf = src.includes('\r\n');
+    const text = src.replace(/\r\n/g, '\n');
+    const m = /^---\n([\s\S]*?)\n---[ \t]*(?:\n|$)/.exec(text);
+    if (!m)
+        return { data: {}, body: text, crlf };
+    const data = {};
+    const lines = m[1].split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const kv = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(lines[i]);
+        if (!kv)
+            continue;
+        let v = kv[2].trim();
+        if (/^[|>][+-]?$/.test(v)) {
+            const block = [];
+            while (i + 1 < lines.length && /^\s+\S|^\s*$/.test(lines[i + 1]))
+                block.push(lines[++i].trim());
+            v = block.join(v.startsWith('|') ? '\n' : ' ').trim();
+        }
+        else if (v.startsWith('"') && v.endsWith('"') && v.length >= 2) {
+            try {
+                v = JSON.parse(v);
+            }
+            catch {
+                v = v.slice(1, -1);
+            }
+        }
+        else if (v.startsWith("'") && v.endsWith("'") && v.length >= 2) {
+            v = v.slice(1, -1).replace(/''/g, "'");
+        }
+        data[kv[1]] = v;
+    }
+    return { data, body: text.slice(m[0].length), crlf };
+}
+/** One Claude subagent file -> one OpenCode agent file. */
+function translateClaudeAgentToOpencode(src) {
+    const { data, body, crlf } = parseFrontmatter(src);
+    const head = ['---'];
+    if (data.description)
+        head.push(`description: ${JSON.stringify(data.description)}`);
+    head.push('mode: subagent');
+    const perm = mapClaudeToolsToPermission(data.tools);
+    if (perm) {
+        head.push('permission:');
+        for (const [k, v] of Object.entries(perm))
+            head.push(`  ${k}: ${v}`);
+    }
+    head.push('---');
+    // A frontmatter-less source keeps its text; with frontmatter the body already
+    // carries its own leading newline(s), which is why the join adds just one.
+    const out = head.join('\n') + '\n' + body;
+    return crlf ? out.replace(/\n/g, '\r\n') : out;
+}
+function translateCrewBundleForOpencode(bundle) {
+    const out = {};
+    for (const [rel, content] of Object.entries(bundle ?? {})) {
+        if (rel.startsWith(CLAUDE_AGENTS_PREFIX) && rel.endsWith('.md') && !rel.slice(CLAUDE_AGENTS_PREFIX.length).includes('/')) {
+            out[`${exports.OPENCODE_AGENT_DIR}/${rel.slice(CLAUDE_AGENTS_PREFIX.length)}`] = translateClaudeAgentToOpencode(content);
+        }
+        else if (rel === 'CLAUDE.md') {
+            out['AGENTS.md'] = content;
+        }
+        else {
+            out[rel] = content;
+        }
+    }
+    return out;
+}

package/dist/bridge/launchSupervisor.d.ts

@@ -25,6 +25,10 @@
  * `No conversation found with session ID: <uuid>` (rendered by the TUI).
  * Both arrive on the PTY, so matching the combined output catches both.
  *
+ * Claude Code ONLY (oc-08): SessionManager never wraps an `opencode` launch
+ * here — these regexes are Claude's wording. OpenCode resumes with `-s <captured
+ * id>` and a stale id shows OpenCode's own error in the pane.
+ *
  * Both lanes: the local bridge (loopback + crew relay on a laptop) spawns
  * `claude` through here. The hosted container does NOT — it spawns $SHELL and
  * infra/terminal-image/autolaunch.sh runs `claude`, so the same rules live

package/dist/bridge/opencodeConfig.d.ts

@@ -0,0 +1,41 @@
+/**
+ * oc-08 — the CANONICAL OpenCode launch config (docs/prd/opencode-engine.md,
+ * ADR-0013, shape verified in oc-04). Pure: no I/O, no process.env.
+ *
+ * The hosted lane (infra/terminal-image/opencode/build-config.js, oc-05) must
+ * emit the SAME JSON for the same inputs; a parity test on each side should pin
+ * it. The OpenRouter key is NEVER an input here: the only credential OpenCode
+ * ever holds is the per-agent gateway token, and it is passed by reference
+ * (`{env:HIVEOP_GATEWAY_TOKEN}`) so it never appears inside the JSON.
+ */
+/** Oldest OpenCode the local lane accepts. 1.18.35 is the version oc-04 verified
+ *  (`permission.asked` / `session.idle` events, `-s <id>` resume, quiet env). */
+export declare const OPENCODE_MIN_VERSION = "1.18.35";
+export declare const OPENCODE_INSTALL_HINT = "Install OpenCode: npm i -g opencode-ai@>=1.18.35";
+/** Every outbound call OpenCode makes at startup besides the gateway (oc-04 s5). */
+export declare const OPENCODE_QUIET_ENV: Readonly<Record<string, string>>;
+export declare const OPENCODE_PROVIDER_ID = "hiveop";
+export declare const OPENCODE_GATEWAY_TOKEN_ENV = "HIVEOP_GATEWAY_TOKEN";
+export interface OpencodeConfigInput {
+    /** Chosen model id (the gateway's catalogue id, e.g. an OpenRouter slug). */
+    model: string;
+    /** Full OpenAI-compatible base URL, i.e. `<api>/api/v1/opencode/v1`. */
+    gatewayBaseUrl: string;
+    /** permission "allow" when true (autonomous agent), OpenCode's default otherwise. */
+    autonomous?: boolean;
+    /** Add the wenrwa-marketplace MCP server (token read from env, not inlined). */
+    withMcp?: boolean;
+    /** argv of the MCP server; defaults to npx. */
+    mcpCommand?: string[];
+    /** Extra env var NAMES the MCP server needs, passed by reference (`{env:NAME}`), never inlined. */
+    mcpEnvPassthrough?: string[];
+    /** Project-relative files OpenCode loads as extra instructions. The local lane passes the
+     *  bridge's `.hiveop/context.md` (oc-23): OpenCode has no SessionStart hook to inject it. */
+    instructions?: string[];
+}
+export declare function buildOpencodeConfig(input: OpencodeConfigInput): Record<string, unknown>;
+/** OpenCode session ids are generated by OpenCode (`ses_...`); anything else
+ *  (e.g. the uuid oc-01 pre-mints on the row) would fail "Session not found". */
+export declare const isCapturedOpencodeSessionId: (id: unknown) => id is string;
+/** True iff `versionOutput` (from `opencode --version`) is >= the minimum. */
+export declare function opencodeVersionOk(versionOutput: string | null | undefined, min?: string): boolean;

package/dist/bridge/opencodeConfig.js

@@ -0,0 +1,107 @@
+"use strict";
+/**
+ * oc-08 — the CANONICAL OpenCode launch config (docs/prd/opencode-engine.md,
+ * ADR-0013, shape verified in oc-04). Pure: no I/O, no process.env.
+ *
+ * The hosted lane (infra/terminal-image/opencode/build-config.js, oc-05) must
+ * emit the SAME JSON for the same inputs; a parity test on each side should pin
+ * it. The OpenRouter key is NEVER an input here: the only credential OpenCode
+ * ever holds is the per-agent gateway token, and it is passed by reference
+ * (`{env:HIVEOP_GATEWAY_TOKEN}`) so it never appears inside the JSON.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCapturedOpencodeSessionId = exports.OPENCODE_GATEWAY_TOKEN_ENV = exports.OPENCODE_PROVIDER_ID = exports.OPENCODE_QUIET_ENV = exports.OPENCODE_INSTALL_HINT = exports.OPENCODE_MIN_VERSION = void 0;
+exports.buildOpencodeConfig = buildOpencodeConfig;
+exports.opencodeVersionOk = opencodeVersionOk;
+/** Oldest OpenCode the local lane accepts. 1.18.35 is the version oc-04 verified
+ *  (`permission.asked` / `session.idle` events, `-s <id>` resume, quiet env). */
+exports.OPENCODE_MIN_VERSION = '1.18.35';
+exports.OPENCODE_INSTALL_HINT = `Install OpenCode: npm i -g opencode-ai@>=${exports.OPENCODE_MIN_VERSION}`;
+/** Every outbound call OpenCode makes at startup besides the gateway (oc-04 s5). */
+exports.OPENCODE_QUIET_ENV = Object.freeze({
+    OPENCODE_DISABLE_MODELS_FETCH: '1',
+    OPENCODE_DISABLE_AUTOUPDATE: '1',
+    OPENCODE_DISABLE_SHARE: '1',
+    OPENCODE_DISABLE_LSP_DOWNLOAD: '1',
+    // oc-17: the HiveOp plugin sets the pane title itself (a bare "OpenCode" would clobber the auto-title).
+    OPENCODE_DISABLE_TERMINAL_TITLE: '1',
+    npm_config_offline: 'true',
+});
+exports.OPENCODE_PROVIDER_ID = 'hiveop';
+exports.OPENCODE_GATEWAY_TOKEN_ENV = 'HIVEOP_GATEWAY_TOKEN';
+function buildOpencodeConfig(input) {
+    const { model } = input;
+    const config = {
+        $schema: 'https://opencode.ai/config.json',
+        autoupdate: false,
+        share: 'disabled',
+        enabled_providers: [exports.OPENCODE_PROVIDER_ID],
+        model: `${exports.OPENCODE_PROVIDER_ID}/${model}`,
+        // OpenCode makes a second, billed "title" call on the small model.
+        small_model: `${exports.OPENCODE_PROVIDER_ID}/${model}`,
+        provider: {
+            [exports.OPENCODE_PROVIDER_ID]: {
+                npm: '@ai-sdk/openai-compatible',
+                name: 'HiveOp',
+                options: {
+                    baseURL: input.gatewayBaseUrl,
+                    apiKey: `{env:${exports.OPENCODE_GATEWAY_TOKEN_ENV}}`,
+                },
+                whitelist: [model],
+                models: {
+                    [model]: {
+                        name: model,
+                        attachment: true,
+                        tool_call: true,
+                        modalities: { input: ['text', 'image'], output: ['text'] },
+                        limit: { context: 200000, output: 8192 },
+                    },
+                },
+            },
+        },
+    };
+    if (input.instructions && input.instructions.length > 0)
+        config.instructions = [...input.instructions];
+    if (input.autonomous)
+        config.permission = 'allow';
+    if (input.withMcp) {
+        // oc-07: OPENCODE_QUIET_ENV sets npm_config_offline=true for the pane; a bare
+        // npx MCP server inherits it and cannot fetch itself on a cold npm cache
+        // ("MCP error -32000: Connection closed"). Override it for npx only.
+        const cmd = input.mcpCommand ?? ['npx', '@wenrwa/marketplace-mcp'];
+        const usesNpx = /(^|[\\/])npx(\.cmd)?$/.test(cmd[0] ?? '');
+        config.mcp = {
+            'wenrwa-marketplace': {
+                type: 'local',
+                command: cmd,
+                environment: {
+                    WENRWA_CONNECT_TOKEN: '{env:WENRWA_CONNECT_TOKEN}',
+                    ...Object.fromEntries((input.mcpEnvPassthrough ?? []).map((n) => [n, `{env:${n}}`])),
+                    ...(usesNpx ? { npm_config_offline: 'false' } : {}),
+                },
+                enabled: true,
+            },
+        };
+    }
+    return config;
+}
+/** OpenCode session ids are generated by OpenCode (`ses_...`); anything else
+ *  (e.g. the uuid oc-01 pre-mints on the row) would fail "Session not found". */
+const isCapturedOpencodeSessionId = (id) => typeof id === 'string' && /^ses_[A-Za-z0-9]+$/.test(id);
+exports.isCapturedOpencodeSessionId = isCapturedOpencodeSessionId;
+const parseVersion = (v) => {
+    const m = /(\d+)\.(\d+)\.(\d+)/.exec(v);
+    return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+};
+/** True iff `versionOutput` (from `opencode --version`) is >= the minimum. */
+function opencodeVersionOk(versionOutput, min = exports.OPENCODE_MIN_VERSION) {
+    const got = parseVersion(versionOutput ?? '');
+    const want = parseVersion(min);
+    if (!got)
+        return false;
+    for (let i = 0; i < 3; i++) {
+        if (got[i] !== want[i])
+            return got[i] > want[i];
+    }
+    return true;
+}

package/dist/bridge/opencodePlugin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * oc-06 — the HiveOp OpenCode activity plugin (cli/hooks/opencode-plugin.mjs,
+ * shipped in the npm package beside the Claude hooks). The local launch
+ * resolver (oc-08) merges `buildOpenCodePluginConfig()` into the agent's
+ * OPENCODE_CONFIG_CONTENT; OpenCode loads plugins from `plugin: [file URL]`
+ * (the path the oc-04 spike verified). Hosted uses the copy under
+ * /opt/hiveop/opencode/ via the same key.
+ */
+export declare function resolveOpenCodePluginPath(hooksDir?: string): string;
+/** Config fragment to merge into OpenCode's config. pathToFileURL encodes spaces. */
+export declare function buildOpenCodePluginConfig(pluginPath?: string): {
+    plugin: string[];
+};

package/dist/bridge/opencodePlugin.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOpenCodePluginPath = resolveOpenCodePluginPath;
+exports.buildOpenCodePluginConfig = buildOpenCodePluginConfig;
+const path = __importStar(require("path"));
+const url_1 = require("url");
+/**
+ * oc-06 — the HiveOp OpenCode activity plugin (cli/hooks/opencode-plugin.mjs,
+ * shipped in the npm package beside the Claude hooks). The local launch
+ * resolver (oc-08) merges `buildOpenCodePluginConfig()` into the agent's
+ * OPENCODE_CONFIG_CONTENT; OpenCode loads plugins from `plugin: [file URL]`
+ * (the path the oc-04 spike verified). Hosted uses the copy under
+ * /opt/hiveop/opencode/ via the same key.
+ */
+function resolveOpenCodePluginPath(hooksDir = path.join(__dirname, '..', '..', 'hooks')) {
+    return path.join(hooksDir, 'opencode-plugin.mjs');
+}
+/** Config fragment to merge into OpenCode's config. pathToFileURL encodes spaces. */
+function buildOpenCodePluginConfig(pluginPath = resolveOpenCodePluginPath()) {
+    return { plugin: [(0, url_1.pathToFileURL)(pluginPath).href] };
+}

package/dist/bridge/opencodeTranscriptReader.d.ts

@@ -0,0 +1,24 @@
+export type SqliteRow = Record<string, unknown>;
+/** Run one read-only SELECT. Throws 'sqlite-unavailable' when no driver exists. */
+export type SqliteQuery = (dbPath: string, sql: string) => SqliteRow[];
+export type OpencodeTranscriptResult = {
+    ok: true;
+    content: string;
+} | {
+    ok: false;
+    reason: 'not-found' | 'too-large' | 'transcript-unavailable';
+};
+export interface OpencodeTranscriptDeps {
+    /** Root holding one dir per agent (default $WENRWA_OPENCODE_DATA_ROOT or /data/.opencode). */
+    dataRoot?: string;
+    existsSync?: (p: string) => boolean;
+    query?: SqliteQuery;
+}
+/** Where the hosted launch put this agent's OpenCode database. */
+export declare function opencodeDbPath(agentId: string, deps?: OpencodeTranscriptDeps): string;
+/** Default driver: node:sqlite (Node >= 22.5, the image runs 24), else the sqlite3 CLI. */
+export declare const defaultSqliteQuery: SqliteQuery;
+/** Pure: OpenCode message/part rows -> Claude-shaped jsonl lines. */
+export declare function opencodeRowsToJsonl(sessionId: string, messages: SqliteRow[], parts: SqliteRow[]): string;
+/** Read ONE agent's OpenCode transcript. `sessionId` pins a session; absent -> the newest root session. */
+export declare function readOpencodeTranscript(agentId: string, sessionId: string | undefined, deps?: OpencodeTranscriptDeps): OpencodeTranscriptResult;