@rallycry/conveyor-agent 10.13.50 → 10.13.52

package/dist/{chunk-36VMMHYD.js → chunk-ZTLGCN5G.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-UAGIXPYD.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,
@@ -3799,8 +3846,237 @@ var ClaudeCodeHarness = class {
 
 // src/harness/pty/session.ts
 import { randomUUID } from "crypto";
-import { mkdtemp, mkdir as mkdir3, rm as rm2 } from "fs/promises";
-import { join as join4, dirname } from "path";
+import { mkdtemp, mkdir as mkdir3, rm as rm2, writeFile as writeFile5 } from "fs/promises";
+import { join as join5, dirname } from "path";
+
+// src/harness/opencode/plugin.ts
+import { writeFile } from "fs/promises";
+import { join } from "path";
+var OPENCODE_EVENTS_FILE_ENV = "CONVEYOR_OPENCODE_EVENTS_FILE";
+var CONVEYOR_PLUGIN_SOURCE = `import { appendFileSync } from "node:fs";
+
+export const ConveyorEventsPlugin = async () => ({
+  event: async ({ event }) => {
+    const sink = process.env.${OPENCODE_EVENTS_FILE_ENV};
+    if (!sink || !event || event.type === "message.part.delta") return;
+    try {
+      appendFileSync(sink, JSON.stringify(event) + "\\n");
+    } catch {
+      // Never let a sink hiccup break the user's opencode session.
+    }
+  },
+});
+`;
+async function stageOpenCodePlugin(tempDir) {
+  const pluginPath = join(tempDir, "conveyor-events-plugin.mjs");
+  const eventsSinkPath = join(tempDir, "opencode-events.ndjson");
+  await writeFile(pluginPath, CONVEYOR_PLUGIN_SOURCE, "utf8");
+  await writeFile(eventsSinkPath, "", "utf8");
+  return { pluginPath, eventsSinkPath };
+}
+
+// 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 busSessionIdOf(event) {
+  const direct = event.properties?.sessionID;
+  if (typeof direct === "string" && direct.length > 0) return direct;
+  const viaInfo = event.properties?.info?.sessionID;
+  return typeof viaInfo === "string" && viaInfo.length > 0 ? viaInfo : null;
+}
+function isIdleEvent(event) {
+  if (event.type === "session.idle") return true;
+  return event.type === "session.status" && event.properties?.status?.type === "idle";
+}
+function isBusyEvent(event) {
+  return event.type === "session.status" && event.properties?.status?.type === "busy";
+}
+function busInfoOf(event) {
+  if (event.type !== "message.updated") return null;
+  return event.properties?.info ?? null;
+}
+function busPartOf(event) {
+  if (event.type !== "message.part.updated") return null;
+  return event.properties?.part ?? 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/event-source.ts
+var MAX_TRACKED_MESSAGES = 200;
+var OpenCodeEventSource = class {
+  constructor(emit, onSessionId) {
+    this.emit = emit;
+    this.onSessionId = onSessionId;
+  }
+  emit;
+  onSessionId;
+  roles = /* @__PURE__ */ new Map();
+  usage = { inputTokens: 0, outputTokens: 0, totalCostUsd: 0 };
+  assistantText = "";
+  /** Busy has been seen and idle has not — a turn is in flight on the bus. */
+  active = false;
+  latchedSessionId = null;
+  /** The opencode-assigned session id, once any event has carried it. */
+  get sessionId() {
+    return this.latchedSessionId;
+  }
+  /**
+   * Ingest one parsed sink record. Self-arming: `busy` opens a turn (resetting
+   * the accumulators) whether it came from our pasted prompt or a human typing
+   * into the parked TUI — the passive case is exactly why turn state cannot
+   * only reset from beginTurn.
+   */
+  handleRecord(raw) {
+    if (typeof raw !== "object" || raw === null) return;
+    const event = raw;
+    this.latchSessionId(event);
+    const info = busInfoOf(event);
+    if (info?.id && info.role) this.trackRole(info.id, info.role);
+    if (isBusyEvent(event)) {
+      if (!this.active) this.beginBusTurn();
+      return;
+    }
+    if (isIdleEvent(event)) {
+      this.finishBusTurn();
+      return;
+    }
+    if (event.type === "session.error") {
+      this.finishBusTurn(describeSessionError(event));
+      return;
+    }
+    this.handlePart(event);
+  }
+  handlePart(event) {
+    const part = busPartOf(event);
+    if (!part) return;
+    if (!this.active) this.beginBusTurn();
+    if (typeof part.messageID !== "string" || this.roles.get(part.messageID) !== "assistant") {
+      return;
+    }
+    accumulateUsage({ part }, this.usage);
+    const mapped = mapOpenCodeEvent({ part });
+    if (!mapped) return;
+    this.emit(mapped);
+    if (mapped.type === "assistant") {
+      const block = mapped.message.content[0];
+      if (block?.type === "text" && block.text) this.assistantText += block.text;
+    }
+  }
+  beginBusTurn() {
+    this.active = true;
+    this.usage = { inputTokens: 0, outputTokens: 0, totalCostUsd: 0 };
+    this.assistantText = "";
+  }
+  /** Idle (or an error) closes the turn exactly once. */
+  finishBusTurn(error) {
+    if (!this.active) return;
+    this.active = false;
+    this.emit(
+      error ? buildResultEvent(1, this.usage, "", "", error) : buildResultEvent(0, this.usage, this.assistantText.trim(), "")
+    );
+  }
+  latchSessionId(event) {
+    if (this.latchedSessionId) return;
+    const id = busSessionIdOf(event);
+    if (!id) return;
+    this.latchedSessionId = id;
+    this.onSessionId?.(id);
+  }
+  trackRole(id, role) {
+    this.roles.set(id, role);
+    if (this.roles.size > MAX_TRACKED_MESSAGES) {
+      const oldest = this.roles.keys().next().value;
+      if (oldest !== void 0) this.roles.delete(oldest);
+    }
+  }
+};
+function describeSessionError(event) {
+  const error = event.properties?.error;
+  if (error && typeof error.message === "string") return error.message;
+  return `opencode reported a session error: ${JSON.stringify(event.properties ?? {}).slice(0, 300)}`;
+}
 
 // src/harness/pty/event-queue.ts
 var AsyncEventQueue = class {
@@ -4081,14 +4357,16 @@ function mapTranscriptRecord(raw) {
 // src/harness/pty/jsonl-tailer.ts
 var POLL_INTERVAL_MS = 25;
 var JsonlTailer = class {
-  constructor(path2, onEvent, onRawRecord) {
+  constructor(path2, onEvent, onRawRecord, mapRecord = mapTranscriptRecord) {
     this.path = path2;
     this.onEvent = onEvent;
     this.onRawRecord = onRawRecord;
+    this.mapRecord = mapRecord;
   }
   path;
   onEvent;
   onRawRecord;
+  mapRecord;
   offset = 0;
   buffer = "";
   timer = null;
@@ -4161,7 +4439,7 @@ var JsonlTailer = class {
       return;
     }
     this.onRawRecord?.(parsed);
-    const event = mapTranscriptRecord(parsed);
+    const event = this.mapRecord(parsed);
     if (event) this.onEvent(event);
   }
 };
@@ -4354,17 +4632,17 @@ function mapChatRecords(raw) {
 }
 
 // src/harness/pty/settings.ts
-import { mkdir, writeFile, chmod } from "fs/promises";
+import { mkdir, writeFile as writeFile2, chmod } from "fs/promises";
 import { homedir } from "os";
-import { join } from "path";
+import { join as join2 } from "path";
 function claudeConfigHome() {
-  return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR ?? join2(homedir(), ".claude");
 }
 function projectSlug(cwd) {
   return cwd.replace(/\//g, "-");
 }
 function sessionTranscriptPath(cwd, sessionId) {
-  return join(claudeConfigHome(), "projects", projectSlug(cwd), `${sessionId}.jsonl`);
+  return join2(claudeConfigHome(), "projects", projectSlug(cwd), `${sessionId}.jsonl`);
 }
 var ALLOW_RULES = [
   "Bash",
@@ -4567,10 +4845,10 @@ function buildPreToolUseHooks(helperPath, gateAllTools) {
   ];
 }
 async function writeHookSettings(dir, opts = {}) {
-  const helperPath = join(dir, "hook-helper.cjs");
-  const settingsPath = join(dir, "settings.json");
+  const helperPath = join2(dir, "hook-helper.cjs");
+  const settingsPath = join2(dir, "settings.json");
   await mkdir(dir, { recursive: true });
-  await writeFile(helperPath, HOOK_HELPER_SOURCE, "utf8");
+  await writeFile2(helperPath, HOOK_HELPER_SOURCE, "utf8");
   await chmod(helperPath, 493);
   const settings = {
     // Pre-accept Claude Code's "Bypass Permissions mode" disclaimer. Build-capable
@@ -4607,80 +4885,10 @@ async function writeHookSettings(dir, opts = {}) {
       ]
     }
   };
-  await writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf8");
+  await writeFile2(settingsPath, JSON.stringify(settings, null, 2), "utf8");
   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;
@@ -4795,8 +5003,8 @@ var PtyOutputCoalescer = class {
 // src/harness/pty/tool-server.ts
 import { createServer as createServer2 } from "http";
 import { z as z9 } from "zod";
-import { writeFile as writeFile2 } from "fs/promises";
-import { join as join2 } from "path";
+import { writeFile as writeFile3 } from "fs/promises";
+import { join as join3 } from "path";
 import { randomBytes } from "crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -4986,20 +5194,20 @@ 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 };
-  const mcpConfigPath = join2(tempDir, "mcp-config.json");
-  await writeFile2(mcpConfigPath, JSON.stringify({ mcpServers: config }, null, 2), "utf8");
-  return { servers, mcpConfigPath };
+  if (Object.keys(config).length === 0) return { servers, mcpConfigPath: null, entries: config };
+  const mcpConfigPath = join3(tempDir, "mcp-config.json");
+  await writeFile3(mcpConfigPath, JSON.stringify({ mcpServers: config }, null, 2), "utf8");
+  return { servers, mcpConfigPath, entries: config };
 }
 
 // src/harness/pty/credentials.ts
-import { chmod as chmod2, mkdir as mkdir2, readFile, rm, writeFile as writeFile3 } from "fs/promises";
+import { chmod as chmod2, mkdir as mkdir2, readFile, rm, writeFile as writeFile4 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 var SYNTH_TOKEN_TTL_MS = 365 * 24 * 60 * 60 * 1e3;
 var REFRESH_SKEW_MS = 30 * 24 * 60 * 60 * 1e3;
 function claudeCredentialsPath() {
-  return join3(claudeConfigHome(), ".credentials.json");
+  return join4(claudeConfigHome(), ".credentials.json");
 }
 function isConveyorCloudEnv(env = process.env) {
   return Boolean(env.CLAUDESPACE_NAME || env.CODESPACE_NAME || env.CODESPACES);
@@ -5090,7 +5298,7 @@ async function writeWithReadBackRetry(io2, contents, delaysMs = READ_BACK_DELAYS
 }
 function fsWriteIo(path2, mode) {
   return {
-    write: (contents) => writeFile3(path2, contents, mode === void 0 ? "utf8" : { encoding: "utf8", mode }),
+    write: (contents) => writeFile4(path2, contents, mode === void 0 ? "utf8" : { encoding: "utf8", mode }),
     read: () => readRaw(path2)
   };
 }
@@ -5162,7 +5370,7 @@ async function sanitizeApprovedApiKeys(oauthToken) {
 }
 function claudeJsonPath() {
   const configDir = process.env.CLAUDE_CONFIG_DIR;
-  return configDir ? join3(configDir, ".claude.json") : join3(homedir2(), ".claude.json");
+  return configDir ? join4(configDir, ".claude.json") : join4(homedir2(), ".claude.json");
 }
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
@@ -5255,7 +5463,7 @@ function planClaudeJsonSeed(existingRaw, trustCwd, oauthIdentity) {
   return changed ? JSON.stringify(config) : null;
 }
 function conveyorOauthMarkerPath() {
-  return join3(claudeConfigHome(), "conveyor-oauth-account.json");
+  return join4(claudeConfigHome(), "conveyor-oauth-account.json");
 }
 function parseOauthIdentity(raw) {
   if (!raw || raw.trim() === "") return null;
@@ -5339,7 +5547,8 @@ var ClaudeTuiAdapter = class {
     resume: true,
     structuredEvents: true,
     prefill: true,
-    passiveTurns: true
+    passiveTurns: true,
+    rawPromptGate: false
   };
   resolveBinary(env = process.env) {
     return env.CONVEYOR_CLAUDE_BIN ?? "claude";
@@ -5415,6 +5624,12 @@ var PtySession = class {
   lastTurnCleanResult = false;
   socket = null;
   tailer = null;
+  // opencode structured-events state: the sink-record interpreter, and the
+  // opencode-assigned session id it latched (reported via a synthetic init and
+  // used for `--session` resume — opencode manages its own lineage, unlike
+  // Claude's deterministic transcript UUIDs).
+  opencodeSource = null;
+  reportedOpenCodeId = null;
   pty = null;
   tempDir = "";
   sawResult = false;
@@ -5425,6 +5640,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;
@@ -5516,9 +5745,18 @@ var PtySession = class {
     const tail = cleanTerminalOutput(this.recentOutput, MAX_DIAGNOSTIC_OUTPUT);
     return tail ? redact(tail).output : "";
   }
-  /** The deterministic session UUID this process is bound to. */
+  /**
+   * The session identity this process is bound to. For Claude, the
+   * deterministic lineage UUID; for opencode, the `ses_…` id the engine
+   * assigned (latched from the plugin events), which wins once known so a
+   * respawn's explicit resume target matches.
+   */
   get sessionUuid() {
-    return this.resume ?? this.options.sessionId;
+    return this.reportedOpenCodeId ?? this.resume ?? this.options.sessionId;
+  }
+  /** The opencode-assigned session id, or null (always null for Claude). */
+  get reportedSessionId() {
+    return this.reportedOpenCodeId;
   }
   /** Fingerprint of the spawn-time options a reused process cannot change. */
   get spawnFingerprint() {
@@ -5533,9 +5771,19 @@ var PtySession = class {
    * Whether this parked process can serve a turn wanting `resume`/`fingerprint`.
    * Requires: live (not torn down / not exited), idle (no turn draining), a
    * matching resume target, and matching spawn options.
+   *
+   * The resume match is adapter-shaped. Claude's resume tokens are transcript
+   * files, so an undefined `resume` means "start a fresh conversation" and
+   * must NOT reuse a parked process bound to an old one. opencode manages its
+   * own lineage — the executor can never learn its `ses_…` ids from disk, so
+   * every follow-up arrives with `resume` undefined; there, the live parked
+   * process IS the conversation, and reuse is keyed on the id the plugin
+   * events latched. Gating on `reportedOpenCodeId` (which Claude sessions
+   * never set) keeps the Claude semantics byte-identical.
    */
   canReuse(resume, fingerprint) {
-    return !this._toreDown && !this.exited && this.activeQueue === null && resume !== void 0 && resume === this.sessionUuid && fingerprint === this.spawnFingerprint;
+    const resumeMatches = resume === void 0 ? this.reportedOpenCodeId !== null : resume === this.sessionUuid;
+    return !this._toreDown && !this.exited && this.activeQueue === null && resumeMatches && fingerprint === this.spawnFingerprint;
   }
   get hookSocketPath() {
     return this.socket ? this.socket.socketPath : null;
@@ -5663,11 +5911,14 @@ var PtySession = class {
       return;
     }
     try {
-      if (this.adapter.capabilities.structuredEvents) {
+      if (this.adapter.capabilities.structuredEvents && this.adapter.id === "opencode") {
+        const extras = await this.startOpenCodeEventSources();
+        await this.spawn(void 0, void 0, extras);
+      } else if (this.adapter.capabilities.structuredEvents) {
         const { settingsPath, socketPath } = await this.startStructuredEventSources(sessionId);
         await this.spawn(settingsPath, socketPath);
       } else {
-        this.tempDir = await mkdtemp(join4(sessionTempBase(), "conveyor-pty-"));
+        this.tempDir = await mkdtemp(join5(sessionTempBase(), "conveyor-pty-"));
         await this.spawn();
         this.pushEvent({
           type: "system",
@@ -5696,6 +5947,61 @@ var PtySession = class {
       throw err;
     }
   }
+  /**
+   * Allocate the opencode structured-event sources: the in-process tool
+   * servers (shared with the Claude path — the same loopback StreamableHTTP
+   * servers, consumed via config `mcp` entries instead of `--mcp-config`),
+   * the instructions file carrying the system prompt, the staged Conveyor
+   * events plugin, and a tailer on its sink. Returns the spawn extras the
+   * adapter bakes into OPENCODE_CONFIG_CONTENT.
+   *
+   * The tailer routes every parsed record to the OpenCodeEventSource, which
+   * owns per-turn state (roles, usage, busy/idle) and feeds the mapped events
+   * through the SAME handleTranscriptEvent path Claude records take — so
+   * nudge-disarm, passive buffering, and result-ends-turn run unchanged. The
+   * synthetic `system init` reports the opencode-assigned session id the
+   * moment it is known, which is how the runner learns the resume target.
+   */
+  async startOpenCodeEventSources() {
+    this.tempDir = await mkdtemp(join5(sessionTempBase(), "conveyor-pty-"));
+    const { servers, entries } = await startToolServers(
+      this.options.mcpServers ?? {},
+      this.tempDir
+    );
+    this.toolServers = servers;
+    const { pluginPath, eventsSinkPath } = await stageOpenCodePlugin(this.tempDir);
+    let instructionsPath;
+    const systemPrompt = this.options.appendSystemPrompt;
+    if (systemPrompt && systemPrompt.trim() !== "") {
+      instructionsPath = join5(this.tempDir, "conveyor-instructions.md");
+      await writeFile5(instructionsPath, systemPrompt, "utf8");
+    }
+    this.opencodeSource = new OpenCodeEventSource(
+      (event) => this.handleTranscriptEvent(event),
+      (id) => {
+        this.reportedOpenCodeId = id;
+        this.pushEvent({
+          type: "system",
+          subtype: "init",
+          session_id: id,
+          model: this.options.model
+        });
+      }
+    );
+    this.tailer = new JsonlTailer(
+      eventsSinkPath,
+      () => void 0,
+      (raw) => this.opencodeSource?.handleRecord(raw),
+      () => null
+    );
+    this.tailer.start(0);
+    return {
+      mcpEntries: entries,
+      eventsSinkPath,
+      pluginPath,
+      ...instructionsPath ? { instructionsPath } : {}
+    };
+  }
   /**
    * Allocate the Claude-style structured-event sources: the PostToolUse hook
    * socket, the per-run settings file, the in-process tool servers, and the
@@ -5704,8 +6010,8 @@ var PtySession = class {
    * paths spawn() must wire into the child's argv/env.
    */
   async startStructuredEventSources(sessionId) {
-    this.tempDir = await mkdtemp(join4(sessionTempBase(), "conveyor-pty-"));
-    const socketPath = join4(this.tempDir, "hook.sock");
+    this.tempDir = await mkdtemp(join5(sessionTempBase(), "conveyor-pty-"));
+    const socketPath = join5(this.tempDir, "hook.sock");
     this.socket = new HookSocketServer(
       socketPath,
       (progress) => this.handleProgress(progress),
@@ -5910,19 +6216,21 @@ var PtySession = class {
     this.toolServers = servers;
     this.mcpConfigPath = mcpConfigPath;
   }
-  async spawn(settingsPath, socketPath) {
+  async spawn(settingsPath, socketPath, opencodeExtras) {
+    const resume = this.reportedOpenCodeId ?? this.resume;
     const spec = this.adapter.buildSpawn({
       options: this.options,
-      ...this.resume ? { resume: this.resume } : {},
+      ...resume ? { resume } : {},
       ...settingsPath ? { settingsPath } : {},
       ...socketPath ? { hookSocketPath: socketPath } : {},
       // Only this config: ignore the user's ~/.claude.json / project .mcp.json
       // so the agent's tool set is deterministic (and a stale personal conveyor
       // server doesn't load).
-      ...this.mcpConfigPath ? { mcpConfigPath: this.mcpConfigPath } : {}
+      ...this.mcpConfigPath ? { mcpConfigPath: this.mcpConfigPath } : {},
+      ...opencodeExtras ?? {}
     });
-    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 +6248,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);
@@ -6206,7 +6600,7 @@ var PtySession = class {
 // src/harness/pty/config-home-health.ts
 import { lstat, mkdir as mkdir4, symlink, unlink as unlink2 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var MOUNT_DISCONNECT_CODES = /* @__PURE__ */ new Set(["ENOTCONN", "EIO", "ESTALE", "ENXIO"]);
 var MOUNT_DISCONNECT_MESSAGES = [
   "socket is not connected",
@@ -6222,10 +6616,10 @@ function isMountDisconnectError(err) {
   return MOUNT_DISCONNECT_MESSAGES.some((needle) => lower.includes(needle));
 }
 function podLocalConfigHome() {
-  return join5(homedir3(), ".claude-local");
+  return join6(homedir3(), ".claude-local");
 }
 function sharedConfigHomePath() {
-  return join5(homedir3(), ".claude");
+  return join6(homedir3(), ".claude");
 }
 function isConfigHomeFallbackActive() {
   return claudeConfigHome() === podLocalConfigHome();
@@ -6256,7 +6650,7 @@ async function repointSharedConfigHomeSymlink(fallback, log) {
 }
 async function isConfigHomeMountDead(cwd) {
   try {
-    await mkdir4(join5(claudeConfigHome(), "projects", projectSlug(cwd)), { recursive: true });
+    await mkdir4(join6(claudeConfigHome(), "projects", projectSlug(cwd)), { recursive: true });
     return false;
   } catch (err) {
     return isMountDisconnectError(err);
@@ -6265,7 +6659,7 @@ async function isConfigHomeMountDead(cwd) {
 async function ensureUsableClaudeConfigHome(cwd, log) {
   const configHome = claudeConfigHome();
   try {
-    await mkdir4(join5(configHome, "projects", projectSlug(cwd)), { recursive: true });
+    await mkdir4(join6(configHome, "projects", projectSlug(cwd)), { recursive: true });
     return { configHome, fellBack: false };
   } catch (err) {
     if (!isMountDisconnectError(err)) throw err;
@@ -6279,7 +6673,7 @@ async function ensureUsableClaudeConfigHome(cwd, log) {
       }
     );
     process.env.CLAUDE_CONFIG_DIR = fallback;
-    await mkdir4(join5(fallback, "projects", projectSlug(cwd)), { recursive: true });
+    await mkdir4(join6(fallback, "projects", projectSlug(cwd)), { recursive: true });
     await repointSharedConfigHomeSymlink(fallback, log);
     return { configHome: fallback, fellBack: true };
   }
@@ -6300,6 +6694,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({
@@ -6355,7 +6754,7 @@ var PtyHarness = class _PtyHarness {
     }
   }
   async *executeQuery(opts) {
-    const want = opts.resume ?? opts.options.resume;
+    const want = opts.resume ?? opts.options.resume ?? this.parked?.reportedSessionId ?? void 0;
     const fingerprint = this.fingerprintOf(opts.options);
     let session;
     if (this.parked?.canReuse(want, fingerprint) && !await this.parkedHomeDied(opts.options)) {
@@ -6610,21 +7009,499 @@ 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 join7 } 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 = join7(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 join8 } 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 ?? join8(env.HOME ?? homedir4(), ".local", "share");
+  return join8(dataHome, "opencode", "auth.json");
+}
+function opencodeConfigPath(env) {
+  const configHome = env.XDG_CONFIG_HOME ?? join8(env.HOME ?? homedir4(), ".config");
+  return join8(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, pluginPath } = 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 (pluginPath) config.plugin = [`file://${pluginPath}`];
+  config.permission = {
+    "*": "allow",
+    ...readOnly ? Object.fromEntries(MUTATING_TOOLS.map((tool2) => [tool2, "deny"])) : {}
+  };
+  if (Object.keys(config).length === 0) return null;
+  return JSON.stringify(config);
+}
+
+// src/harness/opencode/index.ts
+import { mkdtemp as mkdtemp2, rm as rm3, writeFile as writeFile6 } from "fs/promises";
+import { join as join9 } 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(join9(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 = join9(this.tempDir, "conveyor-instructions.md");
+    await writeFile6(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 = {
+    // `--session <ses_…>` continues the id the plugin events latched.
+    resume: true,
+    structuredEvents: true,
+    // The input box tolerates paste-without-submit, but manual prefill has no
+    // card users yet — keep the initial-query behavior unchanged for now.
+    prefill: false,
+    // Plugin events arriving while parked ARE the passive signal.
+    passiveTurns: true,
+    // opencode silently discards early stdin while the TUI paints; the pasted
+    // text itself is lost, so the readiness probe must gate the first write
+    // even though structured events exist now.
+    rawPromptGate: true
+  };
+  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 configContent = buildOpenCodeConfigContent({
+      entries: input.mcpEntries ?? {},
+      systemPromptPath: input.instructionsPath ?? null,
+      readOnly: input.options.permissionMode === "plan",
+      pluginPath: input.pluginPath ?? null
+    });
+    if (configContent) env.OPENCODE_CONFIG_CONTENT = configContent;
+    if (input.eventsSinkPath) env[OPENCODE_EVENTS_FILE_ENV] = input.eventsSinkPath;
+    const model = resolveOpenCodeModel(this.env, input.options.model);
+    const args = [];
+    if (model) args.push("--model", model);
+    if (input.resume) args.push("--session", input.resume);
+    return { file: this.resolveBinary(), args, env };
+  }
+  async prepareEnvironment() {
+    await prepareOpenCodeCredentials(this.env);
+  }
+  spawnFingerprint(input) {
+    return JSON.stringify([
+      "opencode",
+      input.model,
+      input.cwd,
+      input.permissionMode,
+      input.appendSystemPrompt ?? ""
+    ]);
+  }
+  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 +7542,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 +7663,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 +7712,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 +7725,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 +11031,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 join10 } from "path";
 var MIME_BY_EXT = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -10205,7 +11082,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 : join10(config.workspaceDir, path2);
       const mimeType = inferMimeType(filePath);
       const info = await statWorkspacePath(filePath);
       if (!info.isFile) {
@@ -10717,7 +11594,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 join11, 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 +11639,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 = join11(workspaceDir, toRelativePath(link.path));
     const stat = await statWorkspacePath(absolutePath);
     const wantsDirectory = expectsDirectory(link.type);
     if (!stat.exists) {
@@ -11435,38 +12312,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 +12324,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 +12479,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 +13202,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 +13294,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 +13345,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 +13375,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 +13426,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 +13485,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 +13503,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 +13543,8 @@ async function* watchForParkedTui(inner, host, opts) {
           state,
           waitMs,
           silenceTimeoutMs,
-          opts?.probeMountDead
+          opts?.probeMountDead,
+          opts?.disableWedgeAbort
         );
         if (outcome === "abandon") return;
         continue;
@@ -12740,7 +13591,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 +13646,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 +13676,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 +13720,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 +13749,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 +13764,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 +13858,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 +13931,14 @@ async function runWithRetry(initialQuery, context, host, options) {
 }
 
 // src/runner/query-bridge.ts
-var logger5 = createServiceLogger("QueryBridge");
+var logger6 = createServiceLogger("QueryBridge");
 function resolveHarnessKind() {
-  return process.env.CONVEYOR_FORCE_SDK_CARDS === "1" ? "sdk" : "pty";
+  if (process.env.CONVEYOR_FORCE_SDK_CARDS === "1") return "sdk";
+  return "pty";
+}
+function resolveCardTui(mode) {
+  if (mode === "code-review") return "claude-code";
+  return resolveTuiKindFromEnv(process.env);
 }
 function buildPtyBridge(connection, onBackgroundTaskDone) {
   return {
@@ -13109,7 +13969,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 +14113,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 +14141,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 +14330,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 +14435,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 +14454,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 +14470,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 +14486,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 +14513,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 +16096,12 @@ var SessionRunner = class _SessionRunner {
 };
 
 // src/setup/config.ts
-import { join as join9 } from "path";
+import { join as join12 } 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(join12(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 +16156,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 +16175,6 @@ export {
   flushPendingChanges,
   pushToOrigin,
   buildProjectTools,
-  TuiUnavailableError,
-  findOnPath,
   resolvePlaywrightMcpServer,
   resolveSessionStart,
   parseUsageGauges,
@@ -15328,4 +16189,4 @@ export {
   loadConveyorConfig,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-36VMMHYD.js.map
+//# sourceMappingURL=chunk-ZTLGCN5G.js.map