@wenrwa/marketplace-cli 0.7.8 → 0.8.2

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;

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/opencodeBinary.d.ts

@@ -0,0 +1,47 @@
+export declare const OPENCODE_PACKAGE = "opencode-ai";
+export declare const OPENCODE_INSTALL_TIMEOUT_MS: number;
+export interface OpencodeBinaryDeps {
+    exists: (p: string) => boolean;
+    writeFile: (p: string, content: string) => void;
+    mkdirp: (dir: string) => void;
+    rm: (p: string) => void;
+    /** Run npm with exactly this env. Resolves { code } (never rejects on non-zero). */
+    runNpm: (args: string[], env: NodeJS.ProcessEnv) => Promise<{
+        code: number;
+        stderr?: string;
+    }>;
+    /** PATH lookup: absolute path + `--version` output of the `opencode` on PATH, or null. */
+    pathOpencode: () => {
+        path: string;
+        version: string | null;
+    } | null;
+    /** `<bin> --version` output, or null if it will not run. */
+    versionOf: (bin: string) => string | null;
+    env: NodeJS.ProcessEnv;
+    platform: NodeJS.Platform;
+}
+export interface LaunchShape {
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+}
+export type PreparedLaunch = {
+    ok: true;
+    launch: LaunchShape;
+} | {
+    ok: false;
+    message: string;
+};
+export declare function managedPrefix(baseDir: string, version?: string): string;
+export declare const managedBin: (prefix: string) => string;
+/** Short lines on purpose: a narrow pane wraps long ones badly. */
+export declare function opencodeInstallFailureLines(reason: string): string[];
+/** POSIX sh waiter: progress now, then exec once the bridge marks the install ready (or print the failure). */
+export declare const OPENCODE_WAIT_SCRIPT: string;
+export declare function createOpencodeProvisioner(baseDir: string, deps: OpencodeBinaryDeps): {
+    managedBin: string;
+    /** Resolve (or start provisioning) and return the launch to spawn. Synchronous. */
+    prepare(launch: LaunchShape): PreparedLaunch;
+    /** Test seam: resolves when the in-flight install (if any) settles. */
+    settled: () => Promise<void>;
+};