@rallycry/conveyor-agent 10.13.50 → 10.13.51

package/dist/{chunk-36VMMHYD.js → chunk-EQO7QFGN.js}

@@ -26,21 +26,30 @@ import {
 import {
   MAX_BETWEEN_TURN_BUFFER,
   MAX_DIAGNOSTIC_OUTPUT,
+  buildExitErrors,
   buildPromptBytes,
+  buildSpawnArgs,
+  cleanTerminalOutput,
   inheritedEnv,
   killPtyWithEscalation,
+  needsRawReadyGate,
   parseUserQuestions,
   renderPromptContentText,
+  resolveClaudeBinary,
   resolvePlanDialogTiming,
   resolvePtySpawn,
+  resolveRawTuiProbeTiming,
   resolveSubmitNudgeTiming,
   resolveSubmitRedeliveryMaxAttempts,
   resolveSubmitSettleMs,
+  sawTerminalSetup,
+  sentinelEchoed,
   sessionTempBase,
   sleep,
+  spawnOptionsFingerprint,
   transcriptSize,
   turnOptionsFrom
-} from "./chunk-XR6H326I.js";
+} from "./chunk-KZQBYSMN.js";
 
 // src/setup/bootstrap.ts
 var BOOTSTRAP_TIMEOUT_MS = 3e4;
@@ -1728,7 +1737,11 @@ import { z as z6 } from "zod";
 import { z as z7 } from "zod";
 var EXTERNAL_AGENT_MESSAGE_SOURCE = "external_agent";
 var DEFAULT_SONNET_MODEL = "claude-sonnet-5";
+var DEFAULT_OPUS_MODEL = "claude-opus-5";
+var DEFAULT_HAIKU_MODEL = "claude-haiku-4-5-20251001";
 var FABLE_MODEL = "claude-fable-5";
+var PREVIOUS_SONNET_MODEL = "claude-sonnet-4-6";
+var PREVIOUS_OPUS_MODEL = "claude-opus-4-8";
 var PTY_STREAM_PORT_BASE = 7420;
 var PTY_STREAM_PORT_ATTEMPTS = 8;
 function encodePtyStreamFrame(frame) {
@@ -1800,6 +1813,14 @@ var checkpointPathSchema = z.string().transform(normalizeCheckpointPath).pipe(
 var secretNameSchema = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
 var checkpointKeySchema = z.string().regex(/^[0-9a-f]{64}$/);
 var checkpointDigestRefSchema = z.string().regex(/^[^\s@]+@sha256:[0-9a-f]{64}$/);
+var ACTIONS_PREBAKE_REGISTRY_PATTERN = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?(?::(?:[1-9][0-9]{0,4}))?(?:\/[a-z0-9]+(?:[._-][a-z0-9]+)*)*$/;
+var actionsPrebakeRegistrySchema = z.string().trim().min(1).regex(
+  ACTIONS_PREBAKE_REGISTRY_PATTERN,
+  "Actions prebake registry must be a lowercase host[:port] with an optional path prefix"
+).refine((value) => {
+  const port = /:([0-9]+)(?:\/|$)/.exec(value)?.[1];
+  return !port || Number(port) <= 65535;
+}, "Actions prebake registry port must be between 1 and 65535");
 function uniqueSortedArray(item, minimum = 0) {
   return z.array(item).min(minimum).superRefine((values, ctx) => {
     if (new Set(values).size !== values.length) {
@@ -3174,6 +3195,30 @@ var AGENT_STATUS_REASON_USER_QUESTION = "user_question";
 var TASK_CHAT_HISTORY_LIMIT = 20;
 var PM_CHAT_HISTORY_LIMIT = 40;
 var AGENT_CHAT_HISTORY_FETCH_LIMIT = Math.max(TASK_CHAT_HISTORY_LIMIT, PM_CHAT_HISTORY_LIMIT) + 10;
+function formatModelId(provider, model) {
+  return `${provider}/${model}`;
+}
+function anthropicEntry(model, label, inputPerMillion, outputPerMillion, experimental = false) {
+  return {
+    provider: "anthropic",
+    model,
+    id: formatModelId("anthropic", model),
+    label,
+    format: "anthropic-messages",
+    inputPrice: inputPerMillion / 1e6,
+    outputPrice: outputPerMillion / 1e6,
+    supportsTools: true,
+    ...experimental ? { experimental: true } : {}
+  };
+}
+var ANTHROPIC_CATALOG = [
+  anthropicEntry(DEFAULT_OPUS_MODEL, "Opus 5 Latest", 15, 75),
+  anthropicEntry(PREVIOUS_OPUS_MODEL, "Opus 4.8", 15, 75),
+  anthropicEntry(DEFAULT_SONNET_MODEL, "Sonnet 5 Latest", 3, 15),
+  anthropicEntry(PREVIOUS_SONNET_MODEL, "Sonnet 4.6", 3, 15),
+  anthropicEntry(DEFAULT_HAIKU_MODEL, "Haiku 4.5", 0.8, 4),
+  anthropicEntry(FABLE_MODEL, "Fable 5 (experimental)", 10, 50, true)
+];
 var HUMAN_PROSE_WRITING_STYLE = `## Writing style for humans
 When you write prose a person will read \u2014 chat messages, plan updates, PR titles and bodies, PR review guides (the \`publish_review_guide\` overview and section explanations), review comments \u2014 follow these rules (based on ASD-STE100 Simplified Technical English):
 - Use active voice. Say who does what ("The API rejects the request", not "the request is rejected").
@@ -3760,6 +3805,8 @@ function defineTool(name, description, schema, handler, options) {
 import { query, tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
 import { z as z8 } from "zod";
 var ClaudeCodeHarness = class {
+  /** The SDK stream is itself the structured-event source. */
+  emitsStructuredEvents = true;
   async *executeQuery(opts) {
     const sdkEvents = query({
       prompt: opts.prompt,
@@ -4611,76 +4658,6 @@ async function writeHookSettings(dir, opts = {}) {
   return { settingsPath, helperPath };
 }
 
-// src/harness/pty/spawn-args.ts
-function resolveClaudeBinary() {
-  return process.env.CONVEYOR_CLAUDE_BIN ?? "claude";
-}
-function buildSpawnArgs(input) {
-  const args = [];
-  if (input.resume) {
-    args.push("--resume", input.resume);
-  } else if (input.sessionId) {
-    args.push("--session-id", input.sessionId);
-  }
-  args.push("--model", input.model);
-  if (input.permissionMode === "bypassPermissions") {
-    args.push("--dangerously-skip-permissions");
-  } else {
-    args.push("--permission-mode", "plan");
-  }
-  args.push("--settings", input.settingsPath);
-  if (input.appendSystemPrompt) {
-    args.push("--append-system-prompt", input.appendSystemPrompt);
-  }
-  if (input.mcpConfigPath) {
-    args.push("--mcp-config", input.mcpConfigPath);
-    if (input.strictMcpConfig) {
-      args.push("--strict-mcp-config");
-    }
-  }
-  return args;
-}
-function spawnOptionsFingerprint(input) {
-  return JSON.stringify([
-    input.model,
-    input.permissionMode,
-    input.appendSystemPrompt ?? "",
-    input.cwd
-  ]);
-}
-var ANSI_CSI = new RegExp(`${String.fromCharCode(27)}\\[[0-9;?]*[ -/]*[@-~]`, "g");
-function cleanTerminalOutput(raw, maxChars = 1200) {
-  const noAnsi = raw.replace(ANSI_CSI, "");
-  let out = "";
-  for (const ch of noAnsi) {
-    const code = ch.charCodeAt(0);
-    if (ch === "\r" || ch === "\n") out += "\n";
-    else if (ch === "	") out += ch;
-    else if (code < 32 || code === 127) continue;
-    else out += ch;
-  }
-  const lines = out.split("\n").map((line) => line.trimEnd()).filter((line) => line.trim().length > 0);
-  const text = lines.join("\n").trim();
-  return text.length > maxChars ? `\u2026${text.slice(-maxChars)}` : text;
-}
-function isMissingBinaryFailure(tail) {
-  return /execvp\(\d+\) failed|no such file or directory|command not found/i.test(tail);
-}
-function buildExitErrors(exitCode, rawOutput, binary) {
-  const errors = [`claude exited (code ${exitCode}) without a result`];
-  const tail = cleanTerminalOutput(rawOutput);
-  if (isMissingBinaryFailure(tail)) {
-    errors.push(
-      `The \`${binary}\` CLI could not be started \u2014 it is not installed or not on PATH. Install the Claude Code CLI in this environment (npm i -g @anthropic-ai/claude-code) or set CONVEYOR_CLAUDE_BIN to its absolute path.`
-    );
-  }
-  if (tail) {
-    errors.push(`Last terminal output before exit:
-${tail}`);
-  }
-  return errors;
-}
-
 // src/execution/redactor.ts
 var REDACTED = "<redacted>";
 var BEARER_RE = /\b(Bearer\s+)[A-Za-z0-9_\-.]{20,}/g;
@@ -4986,10 +4963,10 @@ async function startToolServers(mcpServers, tempDir) {
     servers.push(server);
     config[name] = { type: "http", url, headers: { Authorization: `Bearer ${token}` } };
   }
-  if (Object.keys(config).length === 0) return { servers, mcpConfigPath: null };
+  if (Object.keys(config).length === 0) return { servers, mcpConfigPath: null, entries: config };
   const mcpConfigPath = join2(tempDir, "mcp-config.json");
   await writeFile2(mcpConfigPath, JSON.stringify({ mcpServers: config }, null, 2), "utf8");
-  return { servers, mcpConfigPath };
+  return { servers, mcpConfigPath, entries: config };
 }
 
 // src/harness/pty/credentials.ts
@@ -5425,6 +5402,20 @@ var PtySession = class {
   recentOutput = "";
   coalescer = null;
   _toreDown = false;
+  // Raw-TUI input detection (see awaitRawTuiInputLive). `probeWindow`, when
+  // non-null, accumulates raw output so a probe can look for its own sentinel
+  // coming back.
+  spawnedAt = 0;
+  // Set once the child writes a DEC private mode — it owns the tty from then on,
+  // so the kernel no longer echoes our keystrokes and a sentinel coming back is
+  // attributable to the app's own repaint.
+  sawTerminalSetup = false;
+  probeWindow = null;
+  // Whether this process has already taken a prompt write. Only the FIRST one
+  // waits on readiness: once the TUI is up, later writes (a multi-message
+  // prompt, a follow-up turn) must go straight through — output is flowing
+  // while the model works, so a quiet check would block until the turn ended.
+  wroteToProcess = false;
   exitListeners = [];
   idleListeners = [];
   abortHandler = null;
@@ -5921,8 +5912,8 @@ var PtySession = class {
       // server doesn't load).
       ...this.mcpConfigPath ? { mcpConfigPath: this.mcpConfigPath } : {}
     });
-    const spawn = await resolvePtySpawn();
-    const pty = spawn(spec.file, spec.args, {
+    const spawn2 = await resolvePtySpawn();
+    const pty = spawn2(spec.file, spec.args, {
       name: "xterm-color",
       cols: this.cols,
       rows: this.rows,
@@ -5940,15 +5931,101 @@ var PtySession = class {
     }
     pty.onData((data) => {
       this.coalescer?.write(data);
+      if (!this.sawTerminalSetup && sawTerminalSetup(data)) this.sawTerminalSetup = true;
+      if (this.probeWindow !== null) this.probeWindow += data;
       this.recentOutput = (this.recentOutput + data).slice(-MAX_DIAGNOSTIC_OUTPUT);
     });
     pty.onExit((event) => {
       void this.finalizeOnExit(event.exitCode);
     });
+    this.spawnedAt = Date.now();
+    this.sawTerminalSetup = false;
+    this.probeWindow = null;
+    this.wroteToProcess = false;
     this.pty = pty;
   }
+  /** Open a fresh probe-observation window over raw output. */
+  openProbeWindow() {
+    this.probeWindow = "";
+  }
+  /**
+   * Write `bytes`, then wait up to `ackMs` for the TUI to render `sentinel` back.
+   * Positive proof that a live input box consumed the keystrokes.
+   */
+  async writeAndAwaitEcho(bytes, sentinel, timing) {
+    this.openProbeWindow();
+    this.writeStdin(bytes);
+    const deadline = Date.now() + timing.ackMs;
+    while (Date.now() < deadline) {
+      if (this._toreDown) return false;
+      if (sentinelEchoed(this.probeWindow ?? "", sentinel)) return true;
+      await sleep(timing.pollMs);
+    }
+    return false;
+  }
+  /**
+   * Wait until a raw-relay TUI's input box is DEMONSTRABLY accepting keystrokes,
+   * by typing a short sentinel and watching for the TUI to render it back, then
+   * erasing it. Readiness is detected, never inferred from elapsed time.
+   *
+   * A structured-events TUI does not need this: `armSubmitNudge` re-presses
+   * Enter until a transcript record proves the turn started. A raw adapter has
+   * no such evidence, so the nudge is deliberately never armed for it — its
+   * single paste + Enter is the only shot, and one fired during startup is
+   * discarded with no trace, leaving the card parked on an empty input box.
+   *
+   * See resolveRawTuiProbeTiming for the measurements behind this, including the
+   * signals that were tried and rejected (DECSET 2004, output-quiet windows, and
+   * "any output after a keystroke" — all of which report ready too early).
+   */
+  async awaitRawTuiInputLive() {
+    if (!needsRawReadyGate(this.adapter.capabilities)) return;
+    const timing = resolveRawTuiProbeTiming();
+    const { sentinel } = timing;
+    const start = this.spawnedAt || Date.now();
+    const setupDeadline = start + timing.firstOutputMaxMs;
+    while (!this._toreDown && Date.now() < setupDeadline) {
+      if (this.sawTerminalSetup) break;
+      await sleep(timing.pollMs);
+    }
+    if (this._toreDown) return;
+    const deadline = start + timing.maxMs;
+    let live = false;
+    let probes = 0;
+    while (!this._toreDown && Date.now() < deadline) {
+      probes++;
+      if (await this.writeAndAwaitEcho(sentinel, sentinel, timing)) {
+        live = true;
+        break;
+      }
+      await sleep(timing.retryMs);
+    }
+    if (this._toreDown) return;
+    if (!live) {
+      process.stderr.write(
+        `[conveyor-agent] raw TUI never echoed the input probe after ${probes} attempt(s) in ${Date.now() - start}ms \u2014 pasting anyway
+`
+      );
+      this.probeWindow = null;
+      return;
+    }
+    for (let round = 0; round < probes && !this._toreDown; round++) {
+      const gone = !await this.writeAndAwaitEcho(
+        "\x7F".repeat(sentinel.length),
+        sentinel,
+        timing
+      );
+      if (gone) break;
+    }
+    this.probeWindow = null;
+  }
   async deliverPrompt(text) {
     if (text === "" && !this.adapter.capabilities.prefill) return;
+    if (!this.wroteToProcess) {
+      await this.awaitRawTuiInputLive();
+      if (this._toreDown) return;
+      this.wroteToProcess = true;
+    }
     this.writeStdin(this.adapter.encodePromptBytes(text));
     if (this.turn.promptDelivery === "prefill") return;
     this.deliveredTexts.push(text);
@@ -6300,6 +6377,11 @@ var PtyHarness = class _PtyHarness {
   bridge;
   adapter;
   static log = createServiceLogger("pty-harness");
+  /** Delegated to the adapter: Claude tails a transcript + hook socket, while a
+   *  raw-relay TUI (opencode) has no trusted event source at all. */
+  get emitsStructuredEvents() {
+    return this.adapter.capabilities.structuredEvents;
+  }
   /** Fingerprint of the spawn-time options a reused process cannot change. */
   fingerprintOf(options) {
     return this.adapter.spawnFingerprint({
@@ -6610,21 +6692,564 @@ var PtyHarness = class _PtyHarness {
   }
 };
 
+// src/harness/opencode/index.ts
+import { spawn } from "child_process";
+
+// src/harness/pty/adapters/types.ts
+import { accessSync, constants, statSync } from "fs";
+import { join as join6 } from "path";
+var TuiUnavailableError = class extends Error {
+  constructor(tui, message) {
+    super(message);
+    this.tui = tui;
+    this.name = "TuiUnavailableError";
+  }
+  tui;
+};
+function isExecutable(path2) {
+  try {
+    if (!statSync(path2).isFile()) return false;
+    accessSync(path2, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findOnPath(binary, env = process.env) {
+  if (binary.includes("/")) {
+    return isExecutable(binary) ? binary : null;
+  }
+  for (const dir of (env.PATH ?? "").split(":")) {
+    if (!dir) continue;
+    const candidate = join6(dir, binary);
+    if (isExecutable(candidate)) return candidate;
+  }
+  return null;
+}
+
+// src/harness/pty/adapters/opencode-auth.ts
+import { promises as fs } from "fs";
+import { dirname as dirname2, join as join7 } from "path";
+import { homedir as homedir4 } from "os";
+var logger = createServiceLogger("opencode-auth");
+var OPENCODE_CODEX_PLUGIN = "opencode-openai-codex-auth@4.4.0";
+var PLUGIN_PACKAGE = "opencode-openai-codex-auth";
+function opencodeAuthPath(env) {
+  const dataHome = env.XDG_DATA_HOME ?? join7(env.HOME ?? homedir4(), ".local", "share");
+  return join7(dataHome, "opencode", "auth.json");
+}
+function opencodeConfigPath(env) {
+  const configHome = env.XDG_CONFIG_HOME ?? join7(env.HOME ?? homedir4(), ".config");
+  return join7(configHome, "opencode", "opencode.json");
+}
+function parseOauthSeed(b64) {
+  if (!b64) return null;
+  try {
+    const parsed = JSON.parse(Buffer.from(b64, "base64").toString("utf8"));
+    if (typeof parsed.access === "string" && typeof parsed.refresh === "string" && typeof parsed.expires === "number") {
+      return { access: parsed.access, refresh: parsed.refresh, expires: parsed.expires };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function shouldSeed(existingEntry, seed) {
+  if (!existingEntry || typeof existingEntry !== "object") return true;
+  const entry = existingEntry;
+  if (entry.type !== "oauth") return true;
+  if (typeof entry.access !== "string" || typeof entry.refresh !== "string") return true;
+  if (typeof entry.expires !== "number") return true;
+  return entry.expires < seed.expires;
+}
+async function readJsonFile(path2) {
+  try {
+    return JSON.parse(await fs.readFile(path2, "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function writeJsonFile(path2, value) {
+  await fs.mkdir(dirname2(path2), { recursive: true });
+  await fs.writeFile(path2, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+}
+async function ensureAuthEntry(env, seed) {
+  const path2 = opencodeAuthPath(env);
+  const store = await readJsonFile(path2);
+  if (!shouldSeed(store.openai, seed)) {
+    logger.info("opencode oauth store is fresher than the seed; leaving it alone");
+    return;
+  }
+  store.openai = {
+    type: "oauth",
+    access: seed.access,
+    refresh: seed.refresh,
+    expires: seed.expires
+  };
+  await writeJsonFile(path2, store);
+  logger.info("seeded opencode oauth store entry");
+}
+async function ensurePluginConfig(env) {
+  const path2 = opencodeConfigPath(env);
+  const config = await readJsonFile(path2);
+  const plugins = Array.isArray(config.plugin) ? config.plugin : [];
+  const isOurs = (p) => typeof p === "string" && (p === PLUGIN_PACKAGE || p.startsWith(`${PLUGIN_PACKAGE}@`));
+  const hasExactPin = plugins.includes(OPENCODE_CODEX_PLUGIN);
+  const hasStalePin = plugins.some((p) => isOurs(p) && p !== OPENCODE_CODEX_PLUGIN);
+  if (hasExactPin && !hasStalePin) return;
+  const kept = plugins.filter((p) => !isOurs(p));
+  config.plugin = [...kept, OPENCODE_CODEX_PLUGIN];
+  await writeJsonFile(path2, config);
+  logger.info("ensured opencode codex-auth plugin in config");
+}
+async function seedOpenCodeOauth(env) {
+  const seed = parseOauthSeed(env.CONVEYOR_OPENCODE_OAUTH);
+  if (!seed) return;
+  try {
+    await ensureAuthEntry(env, seed);
+    await ensurePluginConfig(env);
+  } catch (err) {
+    logger.warn(
+      `failed to seed opencode oauth store: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+
+// src/harness/opencode/credentials.ts
+var PROVIDER_KEY_ENV = {
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY"
+};
+var DEFAULT_OPENCODE_PROVIDER = "openai";
+function buildOpenCodeCredentialEnv(source) {
+  const set = {};
+  const oauthActive = Boolean(source.CONVEYOR_OPENCODE_OAUTH);
+  const key = source.CONVEYOR_AGENT_KEY;
+  const provider = source.CONVEYOR_AGENT_PROVIDER ?? DEFAULT_OPENCODE_PROVIDER;
+  const keyEnvVar = PROVIDER_KEY_ENV[provider];
+  if (key && keyEnvVar && !oauthActive) set[keyEnvVar] = key;
+  return { set, unset: ["CONVEYOR_AGENT_KEY", "CONVEYOR_OPENCODE_OAUTH"] };
+}
+async function prepareOpenCodeCredentials(source = process.env) {
+  await seedOpenCodeOauth(source);
+}
+function buildOpenCodeChildEnv(source, configContent) {
+  const env = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (typeof value === "string") env[key] = value;
+  }
+  const { set, unset } = buildOpenCodeCredentialEnv(source);
+  for (const key of unset) delete env[key];
+  Object.assign(env, set);
+  if (configContent) env.OPENCODE_CONFIG_CONTENT = configContent;
+  return env;
+}
+function resolveOpenCodeModel(source, optionsModel) {
+  const model = source.CONVEYOR_AGENT_MODEL ?? optionsModel;
+  if (!model) return void 0;
+  if (model.includes("/")) return model;
+  const provider = source.CONVEYOR_AGENT_PROVIDER ?? DEFAULT_OPENCODE_PROVIDER;
+  return `${provider}/${model}`;
+}
+
+// src/harness/opencode/spawn.ts
+function resolveOpenCodeBinary(env = process.env) {
+  const override = env.CONVEYOR_OPENCODE_BIN;
+  const found = override ? findOnPath(override, env) : findOnPath("opencode", env);
+  if (!found) {
+    throw new TuiUnavailableError(
+      "opencode",
+      "The opencode CLI is not available in this environment. It must be baked into the pod image (see Dockerfile.base) \u2014 re-run Build Image for this project, or set CONVEYOR_OPENCODE_BIN to its absolute path."
+    );
+  }
+  return found;
+}
+var PROMPT_MAX_CHARS = 96e3;
+var MUTATING_TOOLS = ["edit", "bash", "external_directory"];
+function buildRunArgs(input) {
+  const args = ["run", "--dir", input.cwd, "--format", "json", "--auto"];
+  if (input.model) {
+    args.push("--model", input.model);
+  }
+  if (input.resumeSessionId) args.push("--session", input.resumeSessionId);
+  args.push(truncatePrompt(input.prompt));
+  return args;
+}
+function truncatePrompt(prompt) {
+  if (prompt.length <= PROMPT_MAX_CHARS) return prompt;
+  return `${prompt.slice(0, PROMPT_MAX_CHARS)}
+
+[prompt truncated at ${PROMPT_MAX_CHARS} characters]`;
+}
+function buildOpenCodeConfigContent(input) {
+  const { entries, systemPromptPath, readOnly } = input;
+  const mcp = {};
+  for (const [name, entry] of Object.entries(entries)) {
+    if (entry.type === "http") {
+      mcp[name] = {
+        type: "remote",
+        url: entry.url,
+        enabled: true,
+        ...Object.keys(entry.headers).length > 0 ? { headers: entry.headers } : {}
+      };
+    } else {
+      mcp[name] = {
+        type: "local",
+        command: [entry.command, ...entry.args ?? []],
+        enabled: true,
+        ...entry.env ? { environment: entry.env } : {}
+      };
+    }
+  }
+  const config = {};
+  if (Object.keys(mcp).length > 0) config.mcp = mcp;
+  if (systemPromptPath) config.instructions = [systemPromptPath];
+  if (readOnly) {
+    config.permission = {
+      "*": "allow",
+      ...Object.fromEntries(MUTATING_TOOLS.map((tool2) => [tool2, "deny"]))
+    };
+  }
+  if (Object.keys(config).length === 0) return null;
+  return JSON.stringify(config);
+}
+
+// src/harness/opencode/events.ts
+function parseOpenCodeLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("{")) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+function numberAt(source, ...keys) {
+  let cursor = source;
+  for (const key of keys) {
+    if (typeof cursor !== "object" || cursor === null) return 0;
+    cursor = cursor[key];
+  }
+  return typeof cursor === "number" && Number.isFinite(cursor) ? cursor : 0;
+}
+function accumulateUsage(event, into) {
+  const part = event.part;
+  if (!part) return;
+  into.inputTokens += numberAt(part.tokens, "input");
+  into.outputTokens += numberAt(part.tokens, "output");
+  const cost = part.cost;
+  if (typeof cost === "number" && Number.isFinite(cost)) into.totalCostUsd += cost;
+}
+function mapOpenCodeEvent(event) {
+  const part = event.part;
+  if (!part) return null;
+  if (part.type === "text") return mapTextPart(part);
+  if (part.type === "tool") return mapToolPart(part);
+  return null;
+}
+function mapTextPart(part) {
+  const text = typeof part.text === "string" ? part.text : "";
+  if (text.trim() === "") return null;
+  return {
+    type: "assistant",
+    message: { role: "assistant", content: [{ type: "text", text }] }
+  };
+}
+function mapToolPart(part) {
+  const status = part.state?.status;
+  if (status !== "completed" && status !== "error") return null;
+  return {
+    type: "assistant",
+    message: {
+      role: "assistant",
+      content: [
+        {
+          type: "tool_use",
+          name: typeof part.tool === "string" ? part.tool : "unknown",
+          input: part.state?.input ?? {},
+          ...typeof part.id === "string" ? { id: part.id } : {}
+        }
+      ]
+    }
+  };
+}
+function errorMessageOf(event) {
+  if (event.type !== "error") return null;
+  const error = event.error;
+  const message = typeof error?.data?.message === "string" ? error.data.message : null;
+  const name = typeof error?.name === "string" ? error.name : "error";
+  const status = typeof error?.data?.statusCode === "number" ? ` (HTTP ${error.data.statusCode})` : "";
+  return message ? `${name}${status}: ${message}` : `${name}${status}`;
+}
+function sessionIdOf(event) {
+  return typeof event.sessionID === "string" && event.sessionID.length > 0 ? event.sessionID : null;
+}
+function buildResultEvent(exitCode, usage, assistantText, stderrTail, reportedError) {
+  if (exitCode === 0) {
+    return {
+      type: "result",
+      subtype: "success",
+      // The runner substitutes "Task completed." for an empty summary, so a run
+      // that only used tools still reads sensibly in chat.
+      result: assistantText,
+      total_cost_usd: usage.totalCostUsd
+    };
+  }
+  const errors = reportedError ? [reportedError] : [`opencode run exited with code ${exitCode}`];
+  if (stderrTail.trim()) errors.push(`stderr:
+${stderrTail.trim()}`);
+  return { type: "result", subtype: "error", errors };
+}
+
+// src/harness/opencode/index.ts
+import { mkdtemp as mkdtemp2, rm as rm3, writeFile as writeFile4 } from "fs/promises";
+import { join as join8 } from "path";
+var MAX_STDERR_TAIL = 4e3;
+var OpenCodeHeadlessHarness = class {
+  /** NDJSON from `--format json` is a trusted structured source. */
+  emitsStructuredEvents = true;
+  /** opencode's session id from the last run, for `--session` on the next turn. */
+  lastSessionId = null;
+  /** MCP tool servers started for the in-flight run. */
+  toolServers = [];
+  tempDir = "";
+  /** The same in-process MCP handle the PTY path uses — tools are identical. */
+  createMcpServer(config) {
+    return new PtyMcpServer(config.name, config.tools);
+  }
+  /** opencode's own session id, exposed so the runner can persist lineage. */
+  get sessionId() {
+    return this.lastSessionId;
+  }
+  async *executeQuery(opts) {
+    const prompt = await collectPrompt(opts.prompt);
+    const binary = resolveOpenCodeBinary(process.env);
+    await prepareOpenCodeCredentials(process.env);
+    this.tempDir = await mkdtemp2(join8(sessionTempBase(), "opencode-headless-"));
+    const { servers, entries } = await startToolServers(
+      opts.options.mcpServers ?? {},
+      this.tempDir
+    );
+    this.toolServers = servers;
+    const args = buildRunArgs({
+      prompt,
+      cwd: opts.options.cwd,
+      model: resolveOpenCodeModel(process.env, opts.options.model),
+      // `resume` is Claude-transcript-derived, so it is always absent here (there
+      // is no Claude session file for an opencode run). Falling back to the id
+      // opencode itself reported is what makes a multi-turn card keep its
+      // conversation instead of starting fresh on every message.
+      resumeSessionId: opts.resume ?? this.lastSessionId
+    });
+    const readOnly = opts.options.allowDangerouslySkipPermissions === false;
+    const systemPromptPath = await this.writeSystemPrompt(opts.options.appendSystemPrompt);
+    const configContent = buildOpenCodeConfigContent({
+      entries,
+      systemPromptPath,
+      readOnly
+    });
+    const queue = new AsyncEventQueue();
+    const usage = { inputTokens: 0, outputTokens: 0, totalCostUsd: 0 };
+    let assistantText = "";
+    let stderrTail = "";
+    let reportedError = null;
+    const child = spawn(binary, args, {
+      cwd: opts.options.cwd,
+      // stdin IGNORED — an open pipe makes `opencode run` block forever.
+      stdio: ["ignore", "pipe", "pipe"],
+      env: buildOpenCodeChildEnv(process.env, configContent)
+    });
+    const abort = opts.options.abortController;
+    const onAbort = () => {
+      child.kill("SIGTERM");
+    };
+    abort?.signal.addEventListener("abort", onAbort, { once: true });
+    let carry = "";
+    const ingest = (line) => {
+      const { text, error } = this.ingestLine(line, usage, queue);
+      if (text) assistantText += text;
+      if (error) reportedError = error;
+    };
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      carry += chunk;
+      const lines = carry.split("\n");
+      carry = lines.pop() ?? "";
+      for (const line of lines) ingest(line);
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderrTail = (stderrTail + chunk).slice(-MAX_STDERR_TAIL);
+    });
+    const exited = new Promise((resolve) => {
+      child.once("error", () => resolve(-1));
+      child.once("close", (code) => resolve(code ?? -1));
+    });
+    const finish = (async () => {
+      const code = await exited;
+      ingest(carry);
+      queue.push(buildResultEvent(code, usage, assistantText.trim(), stderrTail, reportedError));
+      queue.close();
+    })();
+    try {
+      for await (const event of queue.drain()) yield event;
+      await finish;
+    } finally {
+      abort?.signal.removeEventListener("abort", onAbort);
+      if (!child.killed) child.kill("SIGTERM");
+      await this.cleanup();
+    }
+  }
+  /**
+   * Persist the Conveyor system prompt (task context, plan, mode instructions)
+   * so it can be referenced by the config's `instructions`. opencode has no
+   * `--append-system-prompt`; without this the card runs with no context at all.
+   */
+  async writeSystemPrompt(text) {
+    if (!text || text.trim() === "") return null;
+    const path2 = join8(this.tempDir, "conveyor-instructions.md");
+    await writeFile4(path2, text, "utf8");
+    return path2;
+  }
+  /**
+   * Parse one NDJSON line and push whatever it maps to. Returns assistant text so
+   * the caller can accumulate the turn's summary; the session id is latched here
+   * because every event carries it and any one of them will do.
+   */
+  ingestLine(line, usage, queue) {
+    const none = { text: "", error: null };
+    const parsed = parseOpenCodeLine(line);
+    if (!parsed) return none;
+    const sid = sessionIdOf(parsed);
+    if (sid) this.lastSessionId = sid;
+    accumulateUsage(parsed, usage);
+    const error = errorMessageOf(parsed);
+    if (error) return { text: "", error };
+    const mapped = mapOpenCodeEvent(parsed);
+    if (!mapped) return none;
+    queue.push(mapped);
+    if (mapped.type !== "assistant") return none;
+    const block = mapped.message.content[0];
+    return { text: block?.type === "text" && block.text ? block.text : "", error: null };
+  }
+  async dispose() {
+    await this.cleanup();
+  }
+  async cleanup() {
+    for (const server of this.toolServers) await server.close().catch(() => void 0);
+    this.toolServers = [];
+    if (this.tempDir) {
+      await rm3(this.tempDir, { recursive: true, force: true }).catch(() => void 0);
+      this.tempDir = "";
+    }
+  }
+};
+async function collectPrompt(prompt) {
+  if (typeof prompt === "string") return prompt;
+  const parts = [];
+  for await (const message of prompt) {
+    const content = message?.message?.content;
+    if (typeof content === "string") parts.push(content);
+    else if (Array.isArray(content)) {
+      for (const block of content) {
+        const b = block;
+        if (b?.type === "text" && typeof b.text === "string") parts.push(b.text);
+      }
+    }
+  }
+  return parts.join("\n\n");
+}
+
 // src/harness/index.ts
-function createHarness(kind = "sdk", ptyBridge) {
-  return kind === "pty" ? new PtyHarness(ptyBridge) : new ClaudeCodeHarness();
+function supportsImageBlocks(kind) {
+  return kind === "sdk";
+}
+function createHarness(kind = "sdk", ptyBridge, adapter) {
+  if (kind === "opencode") return new OpenCodeHeadlessHarness();
+  if (kind !== "pty") return new ClaudeCodeHarness();
+  return adapter ? new PtyHarness(ptyBridge, adapter) : new PtyHarness(ptyBridge);
+}
+
+// src/harness/pty/adapters/opencode.ts
+var OpenCodeTuiAdapter = class {
+  constructor(env = process.env) {
+    this.env = env;
+  }
+  env;
+  id = "opencode";
+  capabilities = {
+    resume: false,
+    structuredEvents: false,
+    prefill: false,
+    passiveTurns: false
+  };
+  resolveBinary(env = this.env) {
+    const override = env.CONVEYOR_OPENCODE_BIN;
+    const found = override ? findOnPath(override, env) : findOnPath("opencode", env);
+    if (!found) {
+      throw new TuiUnavailableError(
+        "opencode",
+        "The opencode CLI is not available in this environment. It must be baked into the pod image (see Dockerfile.base) \u2014 re-run Build Image for this project, or set CONVEYOR_OPENCODE_BIN to its absolute path."
+      );
+    }
+    return found;
+  }
+  buildSpawn(input) {
+    const env = { ...inheritedEnv() };
+    const credentials = buildOpenCodeCredentialEnv(this.env);
+    for (const key of credentials.unset) delete env[key];
+    Object.assign(env, credentials.set);
+    const model = resolveOpenCodeModel(this.env, input.options.model);
+    const args = [];
+    if (model) args.push("--model", model);
+    return { file: this.resolveBinary(), args, env };
+  }
+  async prepareEnvironment() {
+    await prepareOpenCodeCredentials(this.env);
+  }
+  spawnFingerprint(input) {
+    return JSON.stringify(["opencode", input.model, input.cwd]);
+  }
+  encodePromptBytes(text) {
+    return buildPromptBytes(text);
+  }
+  buildExitErrors(exitCode, rawOutput) {
+    const errors = [`opencode exited (code ${exitCode}) without a result`];
+    const tail = cleanTerminalOutput(rawOutput);
+    if (tail) errors.push(`Last terminal output before exit:
+${tail}`);
+    return errors;
+  }
+};
+
+// src/harness/pty/adapters/index.ts
+function resolveTuiKindFromEnv(env) {
+  const raw = env.CONVEYOR_TUI ?? "claude-code";
+  if (TUI_KINDS.includes(raw)) return raw;
+  throw new Error(`Unknown TUI "${raw}" in CONVEYOR_TUI (expected: ${TUI_KINDS.join(", ")})`);
+}
+function resolveTuiAdapter(kind = "claude-code") {
+  switch (kind) {
+    case "claude-code":
+      return new ClaudeTuiAdapter();
+    case "opencode":
+      return new OpenCodeTuiAdapter();
+    default:
+      throw new Error(`Unknown TUI kind: ${kind}`);
+  }
 }
 
 // src/harness/pty/stream-server.ts
 import net from "net";
-var logger = createServiceLogger("PtyStreamServer");
+var logger2 = createServiceLogger("PtyStreamServer");
 var RING_MAX_CHARS = 256 * 1024;
 var PtyStreamServer = class {
   constructor(options) {
     this.options = options;
     this.server = net.createServer((socket) => this.handleConnection(socket));
     this.server.on("error", (err) => {
-      logger.warn(`PTY stream server error: ${err.message}`);
+      logger2.warn(`PTY stream server error: ${err.message}`);
     });
   }
   options;
@@ -6665,7 +7290,7 @@ var PtyStreamServer = class {
         return port;
       }
     }
-    logger.warn(`PTY stream server could not bind any port in ${base}..${base + attempts - 1}`);
+    logger2.warn(`PTY stream server could not bind any port in ${base}..${base + attempts - 1}`);
     return null;
   }
   tryListen(port) {
@@ -6786,7 +7411,7 @@ var PtyStreamServer = class {
 };
 
 // src/harness/pty/direct-stream.ts
-var logger2 = createServiceLogger("PtyDirectStream");
+var logger3 = createServiceLogger("PtyDirectStream");
 var RELAY_COALESCE_MS = 2e3;
 var RELAY_MAX_BUFFER_CHARS = 48 * 1024;
 var DirectStreamController = class {
@@ -6835,7 +7460,7 @@ var DirectStreamController = class {
     });
     void created.listen().then((port) => this.onListening(created, port)).catch((err) => {
       this.starting = false;
-      logger2.warn(
+      logger3.warn(
         `PTY stream server failed to start: ${err instanceof Error ? err.message : String(err)}`
       );
     });
@@ -6848,7 +7473,7 @@ var DirectStreamController = class {
     }
     this.server = created;
     this.reporter.reportPtyStream(port);
-    logger2.info(`PTY stream server listening on ${port} (session ${this.reporter.sessionId})`);
+    logger3.info(`PTY stream server listening on ${port} (session ${this.reporter.sessionId})`);
   }
   /** Push the min box across both transports to the pty. */
   applyDims() {
@@ -10154,7 +10779,7 @@ function buildMutationTools(connection, config) {
 }
 
 // src/tools/attachment-tools.ts
-import { basename, extname, isAbsolute, join as join6 } from "path";
+import { basename, extname, isAbsolute, join as join9 } from "path";
 var MIME_BY_EXT = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -10205,7 +10830,7 @@ ${snippet}`;
 function buildUploadAttachmentTool(connection, config) {
   return defineContractTool(uploadAttachmentContract, async ({ path: path2, title, tags }) => {
     try {
-      const filePath = isAbsolute(path2) ? path2 : join6(config.workspaceDir, path2);
+      const filePath = isAbsolute(path2) ? path2 : join9(config.workspaceDir, path2);
       const mimeType = inferMimeType(filePath);
       const info = await statWorkspacePath(filePath);
       if (!info.isFile) {
@@ -10717,7 +11342,7 @@ import { z as z16 } from "zod";
 
 // src/execution/context-path-verifier.ts
 import { readFile as readFile2 } from "fs/promises";
-import { isAbsolute as isAbsolute2, join as join7, normalize } from "path";
+import { isAbsolute as isAbsolute2, join as join10, normalize } from "path";
 var PROBLEM_TEXT = {
   not_found: "does not exist in the repo",
   expected_folder: "is a file, not a folder \u2014 use type 'file', 'rule', or 'doc'",
@@ -10762,7 +11387,7 @@ async function verifyContextPaths(links, workspaceDir) {
       problems.push({ type: link.type, path: link.path, reason: shape });
       continue;
     }
-    const absolutePath = join7(workspaceDir, toRelativePath(link.path));
+    const absolutePath = join10(workspaceDir, toRelativePath(link.path));
     const stat = await statWorkspacePath(absolutePath);
     const wantsDirectory = expectsDirectory(link.type);
     if (!stat.exists) {
@@ -11435,38 +12060,6 @@ function createConveyorMcpServer(harness, connection, config, context, agentMode
   });
 }
 
-// src/harness/pty/adapters/types.ts
-import { accessSync, constants, statSync } from "fs";
-import { join as join8 } from "path";
-var TuiUnavailableError = class extends Error {
-  constructor(tui, message) {
-    super(message);
-    this.tui = tui;
-    this.name = "TuiUnavailableError";
-  }
-  tui;
-};
-function isExecutable(path2) {
-  try {
-    if (!statSync(path2).isFile()) return false;
-    accessSync(path2, constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function findOnPath(binary, env = process.env) {
-  if (binary.includes("/")) {
-    return isExecutable(binary) ? binary : null;
-  }
-  for (const dir of (env.PATH ?? "").split(":")) {
-    if (!dir) continue;
-    const candidate = join8(dir, binary);
-    if (isExecutable(candidate)) return candidate;
-  }
-  return null;
-}
-
 // src/execution/playwright-mcp.ts
 var PLAYWRIGHT_MCP_BINARIES = ["playwright-mcp", "mcp-server-playwright"];
 var PLAYWRIGHT_MCP_ARGS = ["--browser", "chromium", "--headless", "--no-sandbox", "--isolated"];
@@ -11479,7 +12072,7 @@ function resolvePlaywrightMcpServer(env = process.env) {
 }
 
 // src/execution/event-handlers.ts
-var logger3 = createServiceLogger("event-handlers");
+var logger4 = createServiceLogger("event-handlers");
 function safeVoid(promise, context) {
   if (promise && typeof promise.catch === "function") {
     promise.catch((err) => {
@@ -11634,7 +12227,7 @@ async function emitResultEvent(event, host, context, startTime, lastAssistantUsa
 }
 function handleRateLimitEvent(event, host) {
   const { rate_limit_info } = event;
-  logger3.info("Rate limit event received", { rate_limit_info });
+  logger4.info("Rate limit event received", { rate_limit_info });
   const status = rate_limit_info.status;
   const utilization = rate_limit_info.utilization ?? (status === "rejected" ? 1 : void 0);
   if (utilization !== void 0 && rate_limit_info.rateLimitType) {
@@ -12357,7 +12950,7 @@ function buildCanUseTool(host) {
 }
 
 // src/execution/query-executor.ts
-var logger4 = createServiceLogger("QueryExecutor");
+var logger5 = createServiceLogger("QueryExecutor");
 var IMAGE_ERROR_PATTERN2 = /Could not process image/i;
 var RETRY_DELAYS_MS2 = [6e4, 12e4, 18e4, 3e5];
 function buildHooks(host) {
@@ -12449,7 +13042,7 @@ function repairTornSessionFile(path2) {
     }
     if (keepEnd === content.length) return false;
     truncateSync(path2, Buffer.byteLength(content.slice(0, keepEnd), "utf8"));
-    logger4.warn("Repaired torn transcript before resume", {
+    logger5.warn("Repaired torn transcript before resume", {
       path: path2,
       trimmedBytes: content.length - keepEnd
     });
@@ -12500,10 +13093,11 @@ function buildQueryOptions(host, context) {
     permissionMode: needsCanUseTool ? "plan" : "bypassPermissions",
     allowDangerouslySkipPermissions: !needsCanUseTool,
     canUseTool: buildCanUseTool(host),
-    // The spawned CLI never sees `systemPrompt` (an SDK-only option) — deliver
-    // the same text via `--append-system-prompt`. PTY-only: the SDK harness
-    // already receives it through systemPrompt.append.
-    ...host.harnessKind === "pty" && systemPromptText ? { appendSystemPrompt: systemPromptText } : {},
+    // A spawned CLI never sees `systemPrompt` (an SDK-only option) — deliver the
+    // same text via `appendSystemPrompt`, which each spawning harness routes its
+    // own way (`claude --append-system-prompt`; opencode an `instructions` file).
+    // Without this an opencode card would run with no task context at all.
+    ...host.harnessKind !== "sdk" && systemPromptText ? { appendSystemPrompt: systemPromptText } : {},
     // Auto mode pre-exit (residual sessions only — auto now boots post-exit):
     // after the ExitPlanMode hook allows the call, the CLI's plan dialog still
     // renders — press Enter so the autonomous agent continues building in the
@@ -12529,7 +13123,7 @@ function buildQueryOptions(host, context) {
     disallowedTools: buildDisallowedTools(settings, mode, host.hasExitedPlanMode),
     enableFileCheckpointing: settings.enableFileCheckpointing,
     stderr: (data) => {
-      logger4.warn("Claude Code stderr", { data: data.trimEnd() });
+      logger5.warn("Claude Code stderr", { data: data.trimEnd() });
     }
   };
 }
@@ -12580,16 +13174,16 @@ async function buildFollowUpPrompt(host, context, followUpContent) {
 
 The team says:
 ${followUpText}` : followUpText;
-  const isPty = host.harnessKind === "pty";
+  const skipImages = !supportsImageBlocks(host.harnessKind);
   if (isPmMode) {
-    const prompt = buildMultimodalPrompt(textPrompt, context, isPty);
+    const prompt = buildMultimodalPrompt(textPrompt, context, skipImages);
     if (followUpImages.length > 0 && Array.isArray(prompt)) {
       prompt.push(...followUpImages);
     }
     return prompt;
   }
   if (followUpImages.length > 0) {
-    if (isPty) {
+    if (skipImages) {
       const refs = followUpImages.map(
         () => `[Image attachment \u2014 use list_task_files / get_attachment to view]`
       );
@@ -12639,7 +13233,7 @@ function abortWatchedTurn(host, stderrLine, chatMessage) {
   host.connection.sendEvent({ type: "error", message: chatMessage });
   host.abortController?.abort();
 }
-async function handleTurnSilence(host, state, waitMs, silenceTimeoutMs, probeMountDead) {
+async function handleTurnSilence(host, state, waitMs, silenceTimeoutMs, probeMountDead, disableWedgeAbort) {
   if (state.abortedAsWedged) {
     process.stderr.write(
       "[conveyor-agent] Wedged turn did not settle after abort \u2014 abandoning the turn stream\n"
@@ -12657,6 +13251,10 @@ async function handleTurnSilence(host, state, waitMs, silenceTimeoutMs, probeMou
     return "keep_waiting";
   }
   if (state.silentMs < silenceTimeoutMs) return "keep_waiting";
+  if (disableWedgeAbort) {
+    state.silentMs = 0;
+    return "keep_waiting";
+  }
   if (isHeavyGateActive()) {
     state.silentMs = 0;
     return "keep_waiting";
@@ -12693,7 +13291,8 @@ async function* watchForParkedTui(inner, host, opts) {
           state,
           waitMs,
           silenceTimeoutMs,
-          opts?.probeMountDead
+          opts?.probeMountDead,
+          opts?.disableWedgeAbort
         );
         if (outcome === "abandon") return;
         continue;
@@ -12740,7 +13339,7 @@ async function runSdkQuery(host, context, followUpContent, promptDeliveryOverrid
     await runFollowUpQuery(host, context, options, resume, followUpContent);
     return;
   }
-  if (isDiscoveryLike && (resume || host.harnessKind !== "pty")) {
+  if (isDiscoveryLike && (resume || host.harnessKind === "sdk")) {
     return;
   }
   await runInitialQuery(host, context, options, resume, promptDelivery);
@@ -12795,9 +13394,12 @@ async function runPassiveTurn(host, context) {
 }
 async function trackAndRun(host, context, options, agentQuery) {
   if (host.harnessKind === "pty" && options.promptDelivery !== "prefill") {
-    agentQuery = watchForParkedTui(agentQuery, host, {
-      probeMountDead: () => isConfigHomeMountDead(options.cwd)
-    });
+    const rawRelay = host.harness.emitsStructuredEvents === false;
+    agentQuery = watchForParkedTui(
+      agentQuery,
+      host,
+      rawRelay ? { disableWedgeAbort: true } : { probeMountDead: () => isConfigHomeMountDead(options.cwd) }
+    );
   }
   host.activeQuery = agentQuery;
   try {
@@ -12822,9 +13424,10 @@ function selectInitialPromptInput(promptDelivery, initialPrompt, context, baseAp
     };
   }
   return {
-    // On the PTY harness image blocks would be pasted into the TUI as text —
-    // the prompt body already links each image (get_attachment / downloadUrl).
-    prompt: buildMultimodalPrompt(initialPrompt, context, harnessKind === "pty"),
+    // Only the SDK takes image blocks: a PTY would paste them into the TUI as
+    // text and headless opencode passes argv — the prompt body already links
+    // each image (get_attachment / downloadUrl).
+    prompt: buildMultimodalPrompt(initialPrompt, context, !supportsImageBlocks(harnessKind)),
     appendSystemPrompt: baseAppendSystemPrompt
   };
 }
@@ -12865,7 +13468,7 @@ async function buildRetryQuery(host, context, options, lastErrorWasImage) {
   const retryPrompt = buildMultimodalPrompt(
     await buildInitialPrompt(host.config.mode, context, host.isAuto, host.agentMode),
     context,
-    lastErrorWasImage || host.harnessKind === "pty"
+    lastErrorWasImage || !supportsImageBlocks(host.harnessKind)
   );
   return host.harness.executeQuery({
     prompt: host.createInputStream(retryPrompt),
@@ -12894,7 +13497,7 @@ async function handleAuthError(context, host, options) {
   const freshPrompt = buildMultimodalPrompt(
     await buildInitialPrompt(host.config.mode, context, host.isAuto, host.agentMode),
     context,
-    host.harnessKind === "pty"
+    !supportsImageBlocks(host.harnessKind)
   );
   const freshQuery = host.harness.executeQuery({
     prompt: host.createInputStream(freshPrompt),
@@ -12909,7 +13512,7 @@ async function handleStaleSession(context, host, options) {
   const freshPrompt = buildMultimodalPrompt(
     await buildInitialPrompt(host.config.mode, context, host.isAuto, host.agentMode),
     context,
-    host.harnessKind === "pty"
+    !supportsImageBlocks(host.harnessKind)
   );
   const freshQuery = host.harness.executeQuery({
     prompt: host.createInputStream(freshPrompt),
@@ -13003,7 +13606,7 @@ async function handleUsageCapRejection(context, host, options, rateLimitType, re
   const freshPrompt = buildMultimodalPrompt(
     await buildInitialPrompt(host.config.mode, context, host.isAuto, host.agentMode),
     context,
-    host.harnessKind === "pty"
+    !supportsImageBlocks(host.harnessKind)
   );
   const freshQuery = host.harness.executeQuery({
     prompt: host.createInputStream(freshPrompt),
@@ -13076,9 +13679,14 @@ async function runWithRetry(initialQuery, context, host, options) {
 }
 
 // src/runner/query-bridge.ts
-var logger5 = createServiceLogger("QueryBridge");
-function resolveHarnessKind() {
-  return process.env.CONVEYOR_FORCE_SDK_CARDS === "1" ? "sdk" : "pty";
+var logger6 = createServiceLogger("QueryBridge");
+function resolveHarnessKind(mode) {
+  if (process.env.CONVEYOR_FORCE_SDK_CARDS === "1") return "sdk";
+  return resolveCardTui(mode) === "opencode" ? "opencode" : "pty";
+}
+function resolveCardTui(mode) {
+  if (mode === "code-review") return "claude-code";
+  return resolveTuiKindFromEnv(process.env);
 }
 function buildPtyBridge(connection, onBackgroundTaskDone) {
   return {
@@ -13099,7 +13707,7 @@ var QueryBridge = class {
     this.mode = mode;
     this.runnerConfig = runnerConfig;
     this.callbacks = callbacks;
-    const harnessKind = resolveHarnessKind();
+    const harnessKind = resolveHarnessKind(runnerConfig.mode);
     this.harnessKind = harnessKind;
     let bridge;
     if (harnessKind === "pty") {
@@ -13109,7 +13717,11 @@ var QueryBridge = class {
       );
       bridge = this.directStream.bridge;
     }
-    this.harness = createHarness(harnessKind, bridge);
+    this.harness = createHarness(
+      harnessKind,
+      bridge,
+      harnessKind === "pty" ? resolveTuiAdapter(resolveCardTui(runnerConfig.mode)) : void 0
+    );
   }
   connection;
   mode;
@@ -13249,9 +13861,9 @@ var QueryBridge = class {
       const msg = err instanceof Error ? err.message : String(err);
       const isAbort = this._stopped || /abort/i.test(msg);
       if (isAbort) {
-        logger5.info("Query stopped by user", { error: msg });
+        logger6.info("Query stopped by user", { error: msg });
       } else {
-        logger5.error("Query execution failed", { error: msg });
+        logger6.error("Query execution failed", { error: msg });
         this.connection.sendEvent({ type: "error", message: msg });
       }
     } finally {
@@ -13277,9 +13889,9 @@ var QueryBridge = class {
       const msg = err instanceof Error ? err.message : String(err);
       const isAbort = this._stopped || /abort/i.test(msg);
       if (isAbort) {
-        logger5.info("Passive turn stopped", { error: msg });
+        logger6.info("Passive turn stopped", { error: msg });
       } else {
-        logger5.error("Passive turn failed", { error: msg });
+        logger6.error("Passive turn failed", { error: msg });
         this.connection.sendEvent({ type: "error", message: msg });
       }
     } finally {
@@ -13466,11 +14078,11 @@ function parseResetInstant(rowText, now, defaultTz = localTimeZone()) {
 
 // src/usage/parse-usage.ts
 var ESC = "\\u001b";
-var ANSI_CSI2 = new RegExp(`${ESC}\\[[0-9;?]*[ -/]*[@-~]`, "g");
+var ANSI_CSI = new RegExp(`${ESC}\\[[0-9;?]*[ -/]*[@-~]`, "g");
 var ANSI_OSC = new RegExp(`${ESC}\\][^\\u0007${ESC}]*(?:\\u0007|${ESC}\\\\)`, "g");
 var BAR_GLYPHS = /[─-▟]/g;
 function normalizeUsageText(stdout) {
-  return stdout.replace(ANSI_CSI2, "").replace(ANSI_OSC, "").replace(BAR_GLYPHS, " ").replace(/\r/g, "");
+  return stdout.replace(ANSI_CSI, "").replace(ANSI_OSC, "").replace(BAR_GLYPHS, " ").replace(/\r/g, "");
 }
 function parseUsageGauges(stdout, now = Date.now(), defaultTz) {
   const text = normalizeUsageText(stdout);
@@ -13571,10 +14183,10 @@ var UsageProbeRun = class {
   }
 };
 async function runUsageProbe(deps = {}) {
-  let spawn = deps.spawn;
-  if (!spawn) {
+  let spawn2 = deps.spawn;
+  if (!spawn2) {
     try {
-      spawn = await resolvePtySpawn();
+      spawn2 = await resolvePtySpawn();
     } catch {
       return "";
     }
@@ -13590,7 +14202,7 @@ async function runUsageProbe(deps = {}) {
   return new Promise((resolve) => {
     let child;
     try {
-      child = spawn(binary, [], {
+      child = spawn2(binary, [], {
         name: "xterm-256color",
         cols: 120,
         rows: 45,
@@ -13606,7 +14218,7 @@ async function runUsageProbe(deps = {}) {
 }
 
 // src/execution/usage-sampler.ts
-var logger6 = createServiceLogger("usage-sampler");
+var logger7 = createServiceLogger("usage-sampler");
 function isAttributable(identity, sessionToken) {
   if (!identity) return { ok: true };
   if (identity.hasRefreshToken) {
@@ -13622,7 +14234,7 @@ async function sampleKeyUsage(token, probe = () => runUsageProbe(), hasSubscript
   try {
     const attributable = isAttributable(await readIdentity(), token);
     if (!attributable.ok) {
-      logger6.info("usage sample skipped \u2014 credentials not attributable to this session's key", {
+      logger7.info("usage sample skipped \u2014 credentials not attributable to this session's key", {
         reason: attributable.reason
       });
       return [];
@@ -13649,14 +14261,14 @@ async function sampleKeyUsage(token, probe = () => runUsageProbe(), hasSubscript
       });
     }
     if (samples.length === 0) {
-      logger6.info("usage sample produced no gauges", {
+      logger7.info("usage sample produced no gauges", {
         stdoutLength: stdout.length,
         stdoutHead: stdout.slice(0, 200).replaceAll("\n", " ")
       });
     }
     return samples;
   } catch (error) {
-    logger6.info("usage sample failed", {
+    logger7.info("usage sample failed", {
       error: error instanceof Error ? error.message : String(error)
     });
     return [];
@@ -15232,12 +15844,12 @@ var SessionRunner = class _SessionRunner {
 };
 
 // src/setup/config.ts
-import { join as join9 } from "path";
+import { join as join11 } from "path";
 var DEVCONTAINER_PATH = ".devcontainer/conveyor/devcontainer.json";
 var DEVCONTAINER_PORT_DENY_LIST = /* @__PURE__ */ new Set([5432, 6379, 9200]);
 async function loadForwardPorts(workspaceDir) {
   try {
-    const raw = await readWorkspaceFile(join9(workspaceDir, DEVCONTAINER_PATH));
+    const raw = await readWorkspaceFile(join11(workspaceDir, DEVCONTAINER_PATH));
     const parsed = JSON.parse(raw);
     const ports = (parsed.forwardPorts ?? []).filter(
       (p) => typeof p === "number" && !DEVCONTAINER_PORT_DENY_LIST.has(p)
@@ -15292,16 +15904,15 @@ export {
   applyBootstrapToEnv,
   AgentConnection,
   DEFAULT_SONNET_MODEL,
-  TUI_KINDS,
   isPermissionDeniedError,
   DEFAULT_LIFECYCLE_CONFIG,
   Lifecycle,
-  cleanTerminalOutput,
   buildSynthesizedCredentials,
   claudeJsonPath,
-  ClaudeTuiAdapter,
   createServiceLogger,
   PtyHarness,
+  resolveTuiKindFromEnv,
+  resolveTuiAdapter,
   workspacePathExists,
   GIT_TIMEOUT_MS,
   hasUncommittedChanges,
@@ -15312,8 +15923,6 @@ export {
   flushPendingChanges,
   pushToOrigin,
   buildProjectTools,
-  TuiUnavailableError,
-  findOnPath,
   resolvePlaywrightMcpServer,
   resolveSessionStart,
   parseUsageGauges,
@@ -15328,4 +15937,4 @@ export {
   loadConveyorConfig,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-36VMMHYD.js.map
+//# sourceMappingURL=chunk-EQO7QFGN.js.map