@rallycry/conveyor-agent 10.13.51 → 10.13.52

package/dist/{chunk-EQO7QFGN.js → chunk-ZTLGCN5G.js}

@@ -49,7 +49,7 @@ import {
   spawnOptionsFingerprint,
   transcriptSize,
   turnOptionsFrom
-} from "./chunk-KZQBYSMN.js";
+} from "./chunk-UAGIXPYD.js";
 
 // src/setup/bootstrap.ts
 var BOOTSTRAP_TIMEOUT_MS = 3e4;
@@ -3846,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 {
@@ -4128,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;
@@ -4208,7 +4439,7 @@ var JsonlTailer = class {
       return;
     }
     this.onRawRecord?.(parsed);
-    const event = mapTranscriptRecord(parsed);
+    const event = this.mapRecord(parsed);
     if (event) this.onEvent(event);
   }
 };
@@ -4401,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",
@@ -4614,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
@@ -4654,7 +4885,7 @@ 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 };
 }
 
@@ -4772,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";
@@ -4964,19 +5195,19 @@ async function startToolServers(mcpServers, tempDir) {
     config[name] = { type: "http", url, headers: { Authorization: `Bearer ${token}` } };
   }
   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");
+  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);
@@ -5067,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)
   };
 }
@@ -5139,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 : {};
@@ -5232,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;
@@ -5316,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";
@@ -5392,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;
@@ -5507,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() {
@@ -5524,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;
@@ -5654,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",
@@ -5687,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
@@ -5695,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),
@@ -5901,16 +6216,18 @@ 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 spawn2 = await resolvePtySpawn();
     const pty = spawn2(spec.file, spec.args, {
@@ -6283,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",
@@ -6299,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();
@@ -6333,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);
@@ -6342,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;
@@ -6356,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 };
   }
@@ -6437,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)) {
@@ -6697,7 +7014,7 @@ import { spawn } from "child_process";
 
 // src/harness/pty/adapters/types.ts
 import { accessSync, constants, statSync } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var TuiUnavailableError = class extends Error {
   constructor(tui, message) {
     super(message);
@@ -6721,7 +7038,7 @@ function findOnPath(binary, env = process.env) {
   }
   for (const dir of (env.PATH ?? "").split(":")) {
     if (!dir) continue;
-    const candidate = join6(dir, binary);
+    const candidate = join7(dir, binary);
     if (isExecutable(candidate)) return candidate;
   }
   return null;
@@ -6729,18 +7046,18 @@ function findOnPath(binary, env = process.env) {
 
 // src/harness/pty/adapters/opencode-auth.ts
 import { promises as fs } from "fs";
-import { dirname as dirname2, join as join7 } from "path";
+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 ?? join7(env.HOME ?? homedir4(), ".local", "share");
-  return join7(dataHome, "opencode", "auth.json");
+  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 ?? join7(env.HOME ?? homedir4(), ".config");
-  return join7(configHome, "opencode", "opencode.json");
+  const configHome = env.XDG_CONFIG_HOME ?? join8(env.HOME ?? homedir4(), ".config");
+  return join8(configHome, "opencode", "opencode.json");
 }
 function parseOauthSeed(b64) {
   if (!b64) return null;
@@ -6883,7 +7200,7 @@ function truncatePrompt(prompt) {
 [prompt truncated at ${PROMPT_MAX_CHARS} characters]`;
 }
 function buildOpenCodeConfigContent(input) {
-  const { entries, systemPromptPath, readOnly } = input;
+  const { entries, systemPromptPath, readOnly, pluginPath } = input;
   const mcp = {};
   for (const [name, entry] of Object.entries(entries)) {
     if (entry.type === "http") {
@@ -6905,106 +7222,18 @@ function buildOpenCodeConfigContent(input) {
   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 (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/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";
+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. */
@@ -7026,7 +7255,7 @@ var OpenCodeHeadlessHarness = class {
     const prompt = await collectPrompt(opts.prompt);
     const binary = resolveOpenCodeBinary(process.env);
     await prepareOpenCodeCredentials(process.env);
-    this.tempDir = await mkdtemp2(join8(sessionTempBase(), "opencode-headless-"));
+    this.tempDir = await mkdtemp2(join9(sessionTempBase(), "opencode-headless-"));
     const { servers, entries } = await startToolServers(
       opts.options.mcpServers ?? {},
       this.tempDir
@@ -7108,8 +7337,8 @@ var OpenCodeHeadlessHarness = class {
    */
   async writeSystemPrompt(text) {
     if (!text || text.trim() === "") return null;
-    const path2 = join8(this.tempDir, "conveyor-instructions.md");
-    await writeFile4(path2, text, "utf8");
+    const path2 = join9(this.tempDir, "conveyor-instructions.md");
+    await writeFile6(path2, text, "utf8");
     return path2;
   }
   /**
@@ -7179,10 +7408,18 @@ var OpenCodeTuiAdapter = class {
   env;
   id = "opencode";
   capabilities = {
-    resume: false,
-    structuredEvents: false,
+    // `--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,
-    passiveTurns: 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;
@@ -7200,16 +7437,31 @@ var OpenCodeTuiAdapter = class {
     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]);
+    return JSON.stringify([
+      "opencode",
+      input.model,
+      input.cwd,
+      input.permissionMode,
+      input.appendSystemPrompt ?? ""
+    ]);
   }
   encodePromptBytes(text) {
     return buildPromptBytes(text);
@@ -10779,7 +11031,7 @@ function buildMutationTools(connection, config) {
 }
 
 // src/tools/attachment-tools.ts
-import { basename, extname, isAbsolute, join as join9 } from "path";
+import { basename, extname, isAbsolute, join as join10 } from "path";
 var MIME_BY_EXT = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -10830,7 +11082,7 @@ ${snippet}`;
 function buildUploadAttachmentTool(connection, config) {
   return defineContractTool(uploadAttachmentContract, async ({ path: path2, title, tags }) => {
     try {
-      const filePath = isAbsolute(path2) ? path2 : join9(config.workspaceDir, path2);
+      const filePath = isAbsolute(path2) ? path2 : join10(config.workspaceDir, path2);
       const mimeType = inferMimeType(filePath);
       const info = await statWorkspacePath(filePath);
       if (!info.isFile) {
@@ -11342,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 join10, 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'",
@@ -11387,7 +11639,7 @@ async function verifyContextPaths(links, workspaceDir) {
       problems.push({ type: link.type, path: link.path, reason: shape });
       continue;
     }
-    const absolutePath = join10(workspaceDir, toRelativePath(link.path));
+    const absolutePath = join11(workspaceDir, toRelativePath(link.path));
     const stat = await statWorkspacePath(absolutePath);
     const wantsDirectory = expectsDirectory(link.type);
     if (!stat.exists) {
@@ -13680,9 +13932,9 @@ async function runWithRetry(initialQuery, context, host, options) {
 
 // src/runner/query-bridge.ts
 var logger6 = createServiceLogger("QueryBridge");
-function resolveHarnessKind(mode) {
+function resolveHarnessKind() {
   if (process.env.CONVEYOR_FORCE_SDK_CARDS === "1") return "sdk";
-  return resolveCardTui(mode) === "opencode" ? "opencode" : "pty";
+  return "pty";
 }
 function resolveCardTui(mode) {
   if (mode === "code-review") return "claude-code";
@@ -13707,7 +13959,7 @@ var QueryBridge = class {
     this.mode = mode;
     this.runnerConfig = runnerConfig;
     this.callbacks = callbacks;
-    const harnessKind = resolveHarnessKind(runnerConfig.mode);
+    const harnessKind = resolveHarnessKind();
     this.harnessKind = harnessKind;
     let bridge;
     if (harnessKind === "pty") {
@@ -15844,12 +16096,12 @@ var SessionRunner = class _SessionRunner {
 };
 
 // src/setup/config.ts
-import { join as join11 } 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(join11(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)
@@ -15937,4 +16189,4 @@ export {
   loadConveyorConfig,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-EQO7QFGN.js.map
+//# sourceMappingURL=chunk-ZTLGCN5G.js.map