@khalilgharbaoui/opencode-claude-code-plugin 0.40.0 → 0.42.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/claude-code-language-model.ts
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 
 // src/ids.ts
 import { randomInt } from "crypto";
@@ -1719,6 +1719,10 @@ function cliSupportsPermissionPrompts(v) {
   if (!v) return false;
   return gte(v, { major: 2, minor: 1, patch: 263 });
 }
+function cliSupportsDontAsk(v) {
+  if (!v) return false;
+  return gte(v, { major: 2, minor: 1, patch: 263 });
+}
 function cliSupportsSideQuestion(v) {
   if (!v) return false;
   return gte(v, { major: 2, minor: 1, patch: 258 });
@@ -1728,6 +1732,43 @@ function cliSupportsThinking(v) {
   return gte(v, { major: 2, minor: 0, patch: 0 });
 }
 var flagSupport = /* @__PURE__ */ new Map();
+var headlessSupport = /* @__PURE__ */ new Map();
+function detectHeadlessSupport(cliPath) {
+  const key = `${cliPath}\0headless`;
+  const cached = headlessSupport.get(key);
+  if (cached) return cached;
+  let deadlineKill = false;
+  const promise = (async () => {
+    try {
+      const execution = execFileAsync(cliPath, [
+        "--print",
+        "--input-format",
+        "stream-json",
+        "--output-format",
+        "stream-json",
+        "--help"
+      ], { timeout: probeTimeoutMs, killSignal: "SIGKILL", maxBuffer: 4 * 1024 * 1024 });
+      execution.child.stdin?.end();
+      const { stdout } = await execution;
+      if (!/^\s*Usage:/im.test(stdout) || !/^\s*Options:/im.test(stdout)) return "unknown";
+      const flags = ["--print", "--input-format", "--output-format"];
+      if (!flags.every((flag) => new RegExp(`^\\s+(?:-[A-Za-z],\\s+)?${flag}(?:\\s|,|$)`, "m").test(stdout))) {
+        return "unsupported";
+      }
+      return stdout.includes("stream-json") ? "supported" : "unknown";
+    } catch (error) {
+      deadlineKill = killedByDeadline(error);
+      const stderr = error?.stderr;
+      if (typeof stderr === "string" && /^(?:error: )?(?:unknown|unrecognized|unsupported) option ['"]?--(?:print|input-format|output-format)(?:['"\s]|$)/im.test(stderr)) {
+        return "unsupported";
+      }
+      return "unknown";
+    }
+  })();
+  headlessSupport.set(key, promise);
+  forgetDeadlineKill(headlessSupport, key, promise, () => deadlineKill);
+  return promise;
+}
 function detectCliSupportsFlag(cliPath, flag) {
   const key = `${cliPath}\0${flag}`;
   const cached = flagSupport.get(key);
@@ -4496,6 +4537,20 @@ function summarizePermissionPreset(provider, options, defaultProxyTools = DEFAUL
     overrides: resolved.overridden
   };
 }
+function interactivePermissionPosture(input) {
+  if (!isReadOnlyPermissionMode(input.permissionMode)) {
+    return { permissionMode: input.permissionMode, restricted: false, allow: input.allow };
+  }
+  if (!input.supportsReadOnly) return null;
+  const refused = new Set(READ_ONLY_DISALLOWED_CLI_TOOLS);
+  return {
+    permissionMode: "dontAsk",
+    restricted: true,
+    allow: input.allow.filter(
+      (rule) => !rule.startsWith("mcp__") && !refused.has(rule.split("(")[0].trim())
+    )
+  };
+}
 function isReadOnlyPermissionMode(mode) {
   return mode === READ_ONLY_PERMISSION_MODE;
 }
@@ -4575,7 +4630,25 @@ async function requestSideQuestion(activeProcess, question, options) {
   if (!question) return { response: SIDE_QUESTION_USAGE, synthetic: true };
   options.abortSignal?.throwIfAborted();
   const { proc, lineEmitter } = activeProcess;
-  if (options.interactive || !proc.stdout) {
+  if (options.interactive) {
+    const askAside = activeProcess.interactiveControl?.askAside;
+    if (!askAside) throw new Error("/btw needs a live interactive Claude Code session.");
+    if (pendingProcesses.has(proc)) {
+      throw new Error("Wait for the current /btw to finish before asking another.");
+    }
+    pendingProcesses.add(proc);
+    try {
+      const response = await askAside(question, {
+        ...options.history === void 0 ? {} : { history: options.history },
+        timeoutMs: options.timeoutMs ?? 12e4,
+        ...options.abortSignal ? { abortSignal: options.abortSignal } : {}
+      });
+      return { response, synthetic: false };
+    } finally {
+      pendingProcesses.delete(proc);
+    }
+  }
+  if (!proc.stdout) {
     throw new Error("/btw requires the headless Claude Code transport; interactive sessions are not supported.");
   }
   if (!cliSupportsSideQuestion(options.cliVersion)) {
@@ -5725,6 +5798,8 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "interactive system prompt disabled; opencode agent prompts will not be appended",
   "interactive transport cancelled the usage-limit auto-continue",
   "interactive transport cannot continue",
+  "interactive transport could not answer the plan approval; stopping the turn",
+  "interactive transport could not stage an image",
   "interactive transport denied a permission prompt",
   "interactive transport dropped non-text content blocks",
   "interactive turn failed",
@@ -6336,6 +6411,10 @@ async function fetchPlanUsage(cliPath, options = {}) {
   const timeoutMs = options.timeoutMs ?? 2e4;
   const run = options.runImpl ?? runCli;
   try {
+    const support = options.headlessSupportImpl ?? (options.runImpl ? void 0 : detectHeadlessSupport);
+    if (support && await support(cliPath) === "unsupported") {
+      return { status: "failed", error: "Plan usage is unavailable: this Claude CLI does not support headless output. Check usage in the Claude CLI directly." };
+    }
     const env = claudeSpawnEnv({ ignoreAnthropicApiKey: options.ignoreAnthropicApiKey });
     const stdout = await run(
       cliPath,
@@ -8055,6 +8134,9 @@ The complete prior conversation appears above. The synthesis instructions follow
 `
       });
     }
+    if (opts.compactionInstructions?.trim()) {
+      content.push({ type: "text", text: opts.compactionInstructions });
+    }
   } else if (includeHistoryContext) {
     const historyContext = compactConversationHistory(prompt);
     if (historyContext) {
@@ -8510,8 +8592,10 @@ async function resolveSkillPluginDirs(opts) {
 
 // src/claude-session-wrapper.ts
 import { EventEmitter as EventEmitter4 } from "events";
-import { existsSync as existsSync4 } from "fs";
+import { randomUUID as randomUUID5 } from "crypto";
+import { existsSync as existsSync4, writeFileSync as writeFileSync5 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
+import { join as join10 } from "path";
 
 // src/claude-session-bun.ts
 import * as os4 from "os";
@@ -8591,6 +8675,17 @@ var SCREEN_PATTERNS = [
       "i"
     )
   },
+  {
+    // Measured verbatim on 2.1.288: "Claude has written up a plan and is ready
+    // to execute. Would you like to proceed? ❯ 1. Yes, auto-accept edits
+    // 2. Yes, manually approve edits 3. Tell Claude what to change". The
+    // numbered last choice is what a reply quoting the question never has.
+    kind: "plan-approval",
+    pattern: new RegExp(
+      `${words("Would you like to proceed?")}[\\s\\S]{0,400}?\\d\\s*\\.\\s*(?:${words("Tell Claude what to change")}|${words("No, keep planning")})`,
+      "i"
+    )
+  },
   {
     // The question alone is not enough: Claude can write "Do you want to
     // proceed?" in a reply. The dialog always numbers its options.
@@ -8621,6 +8716,13 @@ function highlightedChoice(text) {
   }
   return last === "yes" || last === "no" ? last : null;
 }
+function planApprovalKeys(text) {
+  const approve = /(\d)\s*\.\s*Yes,?\s*(?:and\s*)?manually\s*approve\s*edits/i.exec(text)?.[1] ?? /(\d)\s*\.\s*Yes,?\s*(?:and\s*)?auto-?\s*accept\s*edits/i.exec(text)?.[1] ?? null;
+  const tell = /(\d)\s*\.\s*Tell\s*Claude\s*what\s*to\s*change/i.exec(text)?.[1];
+  if (tell) return { approve, reject: tell, rejectTakesText: true };
+  const keep = /(\d)\s*\.\s*No,?\s*keep\s*planning/i.exec(text)?.[1] ?? null;
+  return { approve, reject: keep, rejectTakesText: false };
+}
 function classifyScreen(text) {
   for (const { kind, pattern } of SCREEN_PATTERNS) {
     const match = pattern.exec(text);
@@ -8712,7 +8814,7 @@ var TurnUsageAccumulator = class {
 var TERMINAL_STOP = /* @__PURE__ */ new Set(["end_turn", "stop_sequence", "max_tokens"]);
 var delay = (ms) => new Promise((r) => setTimeout(r, ms));
 var RAW_KEEP_CHARS = 64 * 1024;
-var SCREEN_WINDOW_CHARS = 16 * 1024;
+var SCREEN_WINDOW_CHARS = 64 * 1024;
 var INTERRUPT_MARKER = "[Request interrupted by user";
 function isInterruptRecord(rec) {
   if (!rec || rec.type !== "user" || !rec.message) return false;
@@ -8726,6 +8828,11 @@ function isInterruptRecord(rec) {
 function isTurnDurationRecord(rec) {
   return rec?.type === "system" && rec.subtype === "turn_duration";
 }
+var normalizedPrompt = (text) => text.replace(/\s+/g, " ").trim();
+function isOwnPromptRecord(rec, normalized) {
+  const content = rec?.type === "user" ? rec.message?.content : void 0;
+  return typeof content === "string" && normalizedPrompt(content) === normalized;
+}
 function resolveConfigDir(configDir) {
   const value = configDir ?? process.env.CLAUDE_CONFIG_DIR;
   if (!value) return path9.join(os4.homedir(), ".claude");
@@ -8760,6 +8867,10 @@ var ClaudeSession = class {
   aborted = false;
   signal;
   resumeSessionId;
+  forkOf;
+  /** A fork whose first turn has not started: its transcript opens with the
+   *  parent's copied conversation, which belongs to no turn of this session. */
+  forkPending = false;
   env;
   onScreen;
   onExit;
@@ -8778,6 +8889,15 @@ var ClaudeSession = class {
   /** The running turn's read state, shared with `flushTranscript`. */
   scan = null;
   turnDenied = [];
+  /** The running turn's `ExitPlanMode` call that has no result yet. */
+  planApprovalToolUseId = null;
+  /** The approval dialog as drawn for one `ExitPlanMode` call, until it is
+   *  answered. Keyed by the call, so a redraw of a dialog already answered
+   *  (the TUI repaints it while it takes the key, measured on 2.1.288) can
+   *  never stand in for the next call's dialog. */
+  planDialog = null;
+  /** This turn's `ExitPlanMode` calls already answered. */
+  answeredPlans = /* @__PURE__ */ new Set();
   abandonTurn = false;
   o;
   constructor(opts = {}) {
@@ -8785,7 +8905,9 @@ var ClaudeSession = class {
     this.configDir = resolveConfigDir(opts.configDir);
     this.explicitConfigDir = opts.configDir ? this.configDir : void 0;
     this.signal = opts.signal;
-    this.resumeSessionId = opts.resumeSessionId;
+    this.resumeSessionId = opts.forkOf ? void 0 : opts.resumeSessionId;
+    this.forkOf = opts.forkOf;
+    this.forkPending = !!opts.forkOf;
     this.env = opts.env;
     this.onScreen = opts.onScreen;
     this.onExit = opts.onExit;
@@ -8828,12 +8950,16 @@ var ClaudeSession = class {
       // Shorter than `bootQuietMs`, so a trust dialog is answered before boot
       // could declare the TUI ready and paste a prompt into it.
       permissionQuietMs: opts.permissionQuietMs ?? 1e3,
-      stopSettleMs: opts.stopSettleMs ?? 750
+      stopSettleMs: opts.stopSettleMs ?? 750,
+      // The decision arrives after opencode's own question round trip, by
+      // which time the dialog has long been drawn; this only bounds a TUI
+      // that never draws it.
+      planDialogWaitMs: opts.planDialogWaitMs ?? 3e4
     };
   }
   /** The CLI arguments this session spawns with. */
   spawnArgs() {
-    const args = this.resumeSessionId ? ["--resume", this.resumeSessionId] : ["--session-id", this.sessionId];
+    const args = this.forkOf ? ["--session-id", this.sessionId, "--resume", this.forkOf, "--fork-session"] : this.resumeSessionId ? ["--resume", this.resumeSessionId] : ["--session-id", this.sessionId];
     if (this.o.model) args.push("--model", this.o.model);
     if (this.o.settingSources !== null && this.o.settingSources !== void 0) {
       args.push("--setting-sources", this.o.settingSources);
@@ -8902,6 +9028,9 @@ var ClaudeSession = class {
     this.raw = (this.raw + chunk).slice(-RAW_KEEP_CHARS);
     this.screen = (this.screen + chunk).slice(-SCREEN_WINDOW_CHARS);
     if (this.o.debug) process.stdout.write(chunk);
+    this.scheduleScreenCheck();
+  }
+  scheduleScreenCheck() {
     this.clearScreenTimer();
     this.screenTimer = setTimeout(() => {
       this.screenTimer = null;
@@ -8957,6 +9086,13 @@ var ClaudeSession = class {
         this.write("\x1B");
         action = "cancelled";
         break;
+      case "plan-approval": {
+        const id = this.planApprovalToolUseId;
+        if (!this.turn || !id || this.answeredPlans.has(id) || this.planDialog?.id === id) return null;
+        this.planDialog = { id, text };
+        action = "parked";
+        break;
+      }
       case "login":
       case "onboarding":
         action = "fatal";
@@ -9095,8 +9231,10 @@ var ClaudeSession = class {
         stopSeenAt: 0,
         end: null,
         sawUserRecord: false,
-        lastBeat: Date.now()
+        lastBeat: Date.now(),
+        awaitingOwnPrompt: this.forkPending ? normalizedPrompt(prompt) : null
       };
+      this.forkPending = false;
       this.scan = scan;
       const deadline = Date.now() + timeout;
       while (Date.now() < deadline) {
@@ -9130,6 +9268,9 @@ var ClaudeSession = class {
       this.turn = null;
       this.scan = null;
       this.abandonTurn = false;
+      this.planApprovalToolUseId = null;
+      this.planDialog = null;
+      this.answeredPlans.clear();
       settle();
     }
   }
@@ -9155,6 +9296,14 @@ var ClaudeSession = class {
         rec = JSON.parse(s);
       } catch {
       }
+      if (scan.awaitingOwnPrompt !== null) {
+        if (!isOwnPromptRecord(rec, scan.awaitingOwnPrompt)) {
+          this.cursor = i + 1;
+          continue;
+        }
+        scan.awaitingOwnPrompt = null;
+      }
+      if (rec) this.notePlanApproval(rec);
       scan.onRecord(s, rec);
       if (rec) {
         if (rec.type === "assistant" && rec.message) {
@@ -9186,6 +9335,74 @@ var ClaudeSession = class {
   flushTranscript() {
     this.scanTranscript();
   }
+  /** Track the turn's `ExitPlanMode` call from the transcript: opened by the
+   *  assistant record that makes it, closed by the result that answers it. */
+  notePlanApproval(rec) {
+    const content = rec?.message?.content;
+    if (!Array.isArray(content)) return;
+    if (rec.type === "assistant") {
+      for (const block of content) {
+        if (block?.type === "tool_use" && block.name === "ExitPlanMode" && typeof block.id === "string") {
+          this.planApprovalToolUseId = block.id;
+          this.scheduleScreenCheck();
+        }
+      }
+    } else if (rec.type === "user" && this.planApprovalToolUseId) {
+      const answered = content.some(
+        (block) => block?.type === "tool_result" && block.tool_use_id === this.planApprovalToolUseId
+      );
+      if (answered) {
+        if (this.planDialog?.id === this.planApprovalToolUseId) this.planDialog = null;
+        this.planApprovalToolUseId = null;
+      }
+    }
+  }
+  /**
+   * The running turn's unanswered `ExitPlanMode` call id, or null. While it is
+   * set the TUI is parked on (or about to draw) the approval dialog, and the
+   * next message is the operator's decision, not a new turn.
+   */
+  get pendingPlanApproval() {
+    return this.turn ? this.planApprovalToolUseId : null;
+  }
+  /**
+   * Answer the plan approval dialog the running turn is parked on. Waits up to
+   * `planDialogWaitMs` for it to be drawn, because the transcript records the
+   * call before the TUI draws the dialog, and resolves false when there is
+   * none to answer or the drawn dialog has no matching choice.
+   */
+  async answerPlanApproval(answer, timeoutMs = this.o.planDialogWaitMs) {
+    const deadline = Date.now() + timeoutMs;
+    let dialog = this.planDialog;
+    while (!dialog || dialog.id !== this.planApprovalToolUseId) {
+      if (!this.turn || this.exited || Date.now() >= deadline) return false;
+      if (Date.now() - this.lastDataAt >= this.o.permissionQuietMs) this.checkScreen();
+      await delay(this.o.pollMs);
+      dialog = this.planDialog;
+    }
+    const keys = planApprovalKeys(dialog.text);
+    const key = answer.approved ? keys.approve : keys.reject;
+    if (!key) return false;
+    this.answeredPlans.add(dialog.id);
+    this.planDialog = null;
+    this.screen = "";
+    this.write(key);
+    if (answer.approved || !keys.rejectTakesText) return true;
+    await this.waitForQuiet();
+    const text = (answer.feedback ?? "").replace(/\s+/g, " ").trim() || "no";
+    this.write(text);
+    await delay(this.o.submitMinMs);
+    this.write("\r");
+    return true;
+  }
+  /** Wait until the PTY has been quiet for `permissionQuietMs`, at most 3 s. */
+  async waitForQuiet() {
+    const until = Date.now() + 3e3;
+    await delay(Math.min(this.o.permissionQuietMs, 3e3));
+    while (Date.now() < until && Date.now() - this.lastDataAt < this.o.permissionQuietMs) {
+      await delay(25);
+    }
+  }
   /**
    * Stop the running turn the way the TUI's own Esc does, and keep the
    * session alive for the next one. Resolves true once the turn ended, false
@@ -9314,7 +9531,14 @@ var ClaudeSession = class {
 };
 
 // src/claude-session-wrapper.ts
-function decodeUserEnvelope(chunk) {
+var IMAGE_EXTENSIONS = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/jpg": "jpg",
+  "image/gif": "gif",
+  "image/webp": "webp"
+};
+function decodeUserEnvelope(chunk, saveImage) {
   let parsed;
   try {
     parsed = JSON.parse(chunk);
@@ -9326,16 +9550,22 @@ function decodeUserEnvelope(chunk) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return chunk;
   const parts = [];
+  const images = [];
   let dropped = 0;
   for (const block of content) {
+    const extension = block?.type === "image" && block.source?.type === "base64" && typeof block.source.data === "string" ? IMAGE_EXTENSIONS[String(block.source.media_type).toLowerCase()] : void 0;
     if (block?.type === "text" && typeof block.text === "string") {
       parts.push(block.text);
+    } else if (extension && saveImage) {
+      const file = saveImage(Buffer.from(block.source.data, "base64"), extension);
+      if (file) images.push(file);
+      else dropped++;
     } else if (block?.type === "tool_result") {
       const v = block.content;
-      const text = typeof v === "string" ? v : Array.isArray(v) ? v.map((i) => i?.type === "text" ? i.text : "").filter(Boolean).join("\n") : "";
+      const text2 = typeof v === "string" ? v : Array.isArray(v) ? v.map((i) => i?.type === "text" ? i.text : "").filter(Boolean).join("\n") : "";
       parts.push(
         `[Tool result${block.tool_use_id ? ` ${block.tool_use_id}` : ""}]
-${text}`
+${text2}`
       );
     } else {
       dropped++;
@@ -9346,10 +9576,61 @@ ${text}`
       dropped
     });
   }
-  return parts.join("\n\n");
+  const text = parts.join("\n\n");
+  return images.length > 0 ? [...images, text].filter(Boolean).join("\n") : text;
+}
+function stageImage(data, extension) {
+  try {
+    const file = join10(pluginTmpDir(), `image-${randomUUID5()}.${extension}`);
+    writeFileSync5(file, data, { mode: 384, flag: "wx" });
+    return file;
+  } catch (err) {
+    log.warn("interactive transport could not stage an image", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return null;
+  }
+}
+var APPROVAL_WORDS = /^(?:y|yes|yep|yeah|ok|okay|sure|approve|approved|proceed|go|go ahead|do it|lgtm)[.!\s]*$/i;
+var HOST_ANNOTATIONS = /<(?:dcp-)?system-reminder>[\s\S]*?<\/(?:dcp-)?system-reminder>|<dcp-message-id>[^<]*<\/dcp-message-id>/g;
+function toolResultText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((item) => item?.type === "text" && typeof item.text === "string" ? item.text : "").join("\n");
+}
+function planApprovalAnswer(raw, toolUseId) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+  }
+  const content = parsed?.type === "user" ? parsed.message?.content : void 0;
+  if (Array.isArray(content)) {
+    const result = content.find(
+      (block) => block?.type === "tool_result" && block.tool_use_id === toolUseId
+    );
+    if (result) {
+      if (result.is_error !== true) return { approved: true };
+      const text = toolResultText(result.content);
+      const feedback = text.startsWith(REJECTED_EXIT_PLAN_MODE_PREFIX) ? text.slice(REJECTED_EXIT_PLAN_MODE_PREFIX.length) : text;
+      return { approved: false, feedback: feedback.trim() || "no" };
+    }
+  }
+  const typed = decodeUserEnvelope(raw).replace(HOST_ANNOTATIONS, "").trim();
+  return APPROVAL_WORDS.test(typed) ? { approved: true } : { approved: false, feedback: typed || "no" };
+}
+function asidePrompt(question, history = []) {
+  return [
+    "(Side question, asked while the main task continues elsewhere. Answer it from this conversation alone, briefly and without using any tools. Do not continue or change the main task.)",
+    ...history.map((exchange) => `Earlier side question: ${exchange.question}
+Your answer: ${exchange.response}`),
+    question.trim()
+  ].join("\n\n");
 }
 function interactiveExtraArgs(opts) {
   const extraArgs = [];
+  if (opts.tools) extraArgs.push("--tools", opts.tools.join(","));
+  if (opts.restricted) extraArgs.push("--restricted");
   if (opts.mcpConfigPaths && opts.mcpConfigPaths.length > 0) {
     extraArgs.push(
       "--mcp-config",
@@ -9507,6 +9788,7 @@ function spawnInteractiveProcess(opts) {
       if (event.action === "accepted") log.info("interactive transport accepted a prompt", data);
       else if (event.action === "fatal") log.error("interactive transport cannot continue", data);
       else if (event.action === "denied") log.warn("interactive transport denied a permission prompt", data);
+      else if (event.action === "parked") log.info("interactive transport is waiting on a plan approval", data);
       else log.warn("interactive transport cancelled the usage-limit auto-continue", data);
     },
     onExit: (code) => {
@@ -9537,7 +9819,7 @@ function spawnInteractiveProcess(opts) {
   let cancelledThrough = 0;
   let queued = 0;
   let chain = Promise.resolve();
-  const runTurn = async (userMsg, turnNumber) => {
+  const runTurn = async (userMsg, turnNumber, images) => {
     const current = () => turnNumber === writes;
     const emit2 = (line) => {
       if (!current()) return;
@@ -9610,12 +9892,62 @@ function spawnInteractiveProcess(opts) {
       );
       if (proc.listenerCount("error") > 0) proc.emit("error", e);
       else lineEmitter.emit("close");
+    } finally {
+      for (const file of images) void unlink2(file).catch(() => {
+      });
     }
   };
-  const enqueueTurn = (userMsg) => {
+  const answerPlan = async (answer) => {
+    log.info("interactive transport answering a plan approval", {
+      sessionId: session.sessionId,
+      approved: answer.approved
+    });
+    const answered = await session.answerPlanApproval(answer).catch(() => false);
+    if (answered) return;
+    log.warn("interactive transport could not answer the plan approval; stopping the turn", {
+      sessionId: session.sessionId
+    });
+    cancelledThrough = writes;
+    await session.interrupt().catch(() => false);
+  };
+  const askAside = async (question, options) => {
+    const forked = existsSync4(session.jsonlPath);
+    const aside = new ClaudeSession({
+      ...opts.tuning,
+      cwd: opts.cwd,
+      cliPath: opts.cliPath,
+      configDir: opts.configDir,
+      model: opts.model,
+      settingSources: opts.settingSources === void 0 ? null : opts.settingSources,
+      extraArgs: interactiveExtraArgs({ ...opts, permissionsAllow: [], permissionMode: "dontAsk" }),
+      ignoreAnthropicApiKey: opts.ignoreAnthropicApiKey,
+      effort: opts.effort ? cliEffortLevel(opts.effort) : void 0,
+      env: opts.env,
+      spawnPty: opts.spawnPty,
+      signal: options.abortSignal,
+      ...forked ? { forkOf: session.sessionId } : {}
+    });
+    log.info("btw: asking a fork of the interactive session", {
+      sessionId: session.sessionId,
+      asideSessionId: aside.sessionId,
+      forked
+    });
+    try {
+      await aside.start();
+      const result = await aside.ask(asidePrompt(question, options.history), options.timeoutMs);
+      const text = result.text.trim();
+      if (!text) throw new Error("the side question got no answer");
+      return text;
+    } finally {
+      aside.dispose();
+      void unlink2(aside.jsonlPath).catch(() => {
+      });
+    }
+  };
+  const enqueueTurn = (userMsg, images = []) => {
     const turnNumber = ++writes;
     queued++;
-    chain = chain.then(() => runTurn(userMsg, turnNumber)).finally(() => {
+    chain = chain.then(() => runTurn(userMsg, turnNumber, images)).finally(() => {
       queued--;
     });
   };
@@ -9624,7 +9956,18 @@ function spawnInteractiveProcess(opts) {
       writable: true,
       write(chunk) {
         const raw = typeof chunk === "string" && chunk.endsWith("\n") ? chunk.slice(0, -1) : chunk;
-        enqueueTurn(decodeUserEnvelope(raw));
+        const planToolUseId = session.pendingPlanApproval;
+        if (planToolUseId) {
+          void answerPlan(planApprovalAnswer(raw, planToolUseId));
+          return true;
+        }
+        const images = [];
+        const text = decodeUserEnvelope(raw, (data, extension) => {
+          const file = stageImage(data, extension);
+          if (file) images.push(file);
+          return file;
+        });
+        enqueueTurn(text, images);
         return true;
       },
       end() {
@@ -9675,17 +10018,45 @@ function spawnInteractiveProcess(opts) {
         cancelledThrough = writes;
         return session.interrupt(timeoutMs);
       },
-      flushTranscript: () => session.flushTranscript()
+      flushTranscript: () => session.flushTranscript(),
+      planApprovalPending: () => session.pendingPlanApproval !== null,
+      askAside
     }
   };
   return ap;
 }
 
+// src/transport.ts
+function requestedTransport(config, env = process.env.CLAUDE_CODE_INTERACTIVE_TRANSPORT) {
+  if (config.transport !== void 0) {
+    if (!["auto", "headless", "interactive"].includes(config.transport)) {
+      throw new Error(`Unknown Claude transport: ${config.transport}`);
+    }
+    return config.transport;
+  }
+  const enabled = config.interactive ?? (env !== void 0 && !["", "0", "false", "no", "off"].includes(env.trim().toLowerCase()));
+  return enabled ? "interactive" : "headless";
+}
+function hasInteractiveTransport() {
+  const runtime = globalThis;
+  return typeof runtime.Bun?.Terminal === "function";
+}
+async function selectTransport(requested, cliPath, available = hasInteractiveTransport()) {
+  if (requested === "headless") return "headless";
+  if (requested === "interactive") {
+    if (!available) throw new Error("Interactive Claude transport requires Bun.Terminal. Run opencode under a Bun runtime with PTY support.");
+    return "interactive";
+  }
+  if (await detectHeadlessSupport(cliPath) !== "unsupported") return "headless";
+  if (!available) throw new Error("Claude no longer supports the headless flags, and Bun.Terminal is unavailable. Run opencode under a Bun runtime with PTY support.");
+  return "interactive";
+}
+
 // src/prompts.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir8 } from "os";
-import { randomUUID as randomUUID5 } from "crypto";
-import { dirname as dirname6, join as join10 } from "path";
+import { randomUUID as randomUUID6 } from "crypto";
+import { dirname as dirname6, join as join11 } from "path";
 function readPromptFileIfPresent(path11) {
   try {
     const content = readFileSync7(path11, "utf8").trim();
@@ -9697,7 +10068,7 @@ function readPromptFileIfPresent(path11) {
 function nearestWorkspaceAgentsPrompt(cwd) {
   let dir = cwd;
   while (true) {
-    const content = readPromptFileIfPresent(join10(dir, "AGENTS.md"));
+    const content = readPromptFileIfPresent(join11(dir, "AGENTS.md"));
     if (content) return content;
     const parent = dirname6(dir);
     if (parent === dir) return void 0;
@@ -9806,8 +10177,8 @@ ${options.compressionSummary.trim()}`
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
   }
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join10(homedir8(), ".config");
-  const globalAgents = readPromptFileIfPresent(join10(configRoot, "opencode", "AGENTS.md"));
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join11(homedir8(), ".config");
+  const globalAgents = readPromptFileIfPresent(join11(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   const forwarded = extraSystemContent.join("\n\n");
   const pushGlobal = !!globalAgents && !forwarded.includes(globalAgents);
@@ -9818,9 +10189,9 @@ ${options.compressionSummary.trim()}`
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path11 = join10(pluginTmpDir(), `opencode-cc-sys-${randomUUID5()}.md`);
+  const path11 = join11(pluginTmpDir(), `opencode-cc-sys-${randomUUID6()}.md`);
   try {
-    writeFileSync5(path11, content, { encoding: "utf8", mode: 384 });
+    writeFileSync6(path11, content, { encoding: "utf8", mode: 384 });
     return path11;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
@@ -10435,7 +10806,6 @@ function decideMcpHotReload(input) {
   if (!input.hasActiveProcess) return decide("no-process");
   const previousHash = input.previousHash ?? null;
   if (previousHash === input.currentHash) return decide("unchanged");
-  if (input.interactive) return decide("skipped-interactive");
   if (input.pendingProxyCalls > 0) return decide("deferred-proxy-calls");
   if (input.turnInFlight) return decide("deferred-turn-in-flight");
   if (input.planQuestionPending) return decide("deferred-plan-question");
@@ -11234,6 +11604,24 @@ function finishWithQuestionCall(state, call) {
   } catch {
   }
 }
+function finishAwaitingPlanApproval(state) {
+  if (state.controllerClosed) return;
+  state.endTextBlock();
+  state.controller.enqueue({
+    type: "finish",
+    finishReason: state.toFinishReason("stop"),
+    usage: state.toUsage(lastCallContextUsage(state.lastCallUsage, state.resultMeta.usage)),
+    providerMetadata: {
+      "claude-code": state.resultMeta
+    }
+  });
+  state.controllerClosed = true;
+  state.cleanupTurn();
+  try {
+    state.controller.close();
+  } catch {
+  }
+}
 function drainNow(state) {
   if (state.drainTimer) {
     clearTimeout(state.drainTimer);
@@ -11830,6 +12218,10 @@ ${plan}
 `
               });
               state.endTextBlock();
+              if (ctx.interactive) {
+                finishAwaitingPlanApproval(state);
+                return;
+              }
             } else if (isWebSearchTool(block2.name) && isWebSearchHandledByCli(ctx.config.webSearch)) {
               state.toolCallsById.delete(block2.id);
               const query = typeof parsedInput?.query === "string" ? parsedInput.query : JSON.stringify(parsedInput);
@@ -12549,8 +12941,11 @@ var ClaudeCodeLanguageModel = class {
     const toFinishReason2 = this.toFinishReason.bind(this);
     const handleControlRequest2 = this.handleControlRequest.bind(this);
     const flagOn = (v) => v !== void 0 && !["", "0", "false", "no", "off"].includes(v.trim().toLowerCase());
-    const interactivePref = this.config.interactive ?? flagOn(process.env.CLAUDE_CODE_INTERACTIVE_TRANSPORT);
-    const useInteractive = interactivePref && typeof globalThis.Bun?.Terminal === "function";
+    const transport = requestedTransport(this.config);
+    const doctor = !compactionMode && scope !== "no-tools" ? parseDoctorCommand(options.prompt) : null;
+    const selectedTransport = doctor ? transport === "interactive" ? "interactive" : "headless" : this.config.transport === void 0 && !hasInteractiveTransport() ? "headless" : this.isTitleRequest(scope, options) && !compactionMode ? "headless" : await Promise.race([selectTransport(transport, this.config.cliPath), turnAbort.whenAborted]);
+    if (turnAbort.aborted) return abortedBeforeWork("selecting the transport");
+    const useInteractive = selectedTransport === "interactive";
     const interactiveBypassRequested = this.config.interactiveBypass ?? flagOn(process.env.CLAUDE_CODE_INTERACTIVE_BYPASS);
     const modelFallbackArmed = attempt?.armed === true && !compactionMode && !useInteractive;
     const sourceAccount = normalizeAccountName(
@@ -12566,7 +12961,6 @@ var ClaudeCodeLanguageModel = class {
     let cliPath = failover.cliPath;
     if (turnAbort.aborted) return abortedBeforeWork("resolving the spawn cwd and account");
     const asideTransportRef = { cliPath, interactive: !!useInteractive };
-    const doctor = !compactionMode && scope !== "no-tools" ? parseDoctorCommand(options.prompt) : null;
     if (doctor) {
       const doctorOptions = {
         cliPath,
@@ -12686,7 +13080,7 @@ var ClaudeCodeLanguageModel = class {
         request: { body: { text: "" } }
       };
     }
-    if (!hasNewUserContent(options.prompt)) {
+    if (!compactionMode && !hasNewUserContent(options.prompt)) {
       log.info("doStream short-circuit: no new user content");
       const stream2 = new ReadableStream({
         start(controller) {
@@ -12836,7 +13230,7 @@ var ClaudeCodeLanguageModel = class {
         sessionKey: sk,
         prompt: options.prompt,
         cliPath,
-        transcriptPath: (id) => join11(configDir, "projects", encodeCwd(cwd), `${id}.jsonl`)
+        transcriptPath: (id) => join12(configDir, "projects", encodeCwd(cwd), `${id}.jsonl`)
       });
       if (resumePoint) {
         setClaudeSessionId(sk, resumePoint.claudeSessionId);
@@ -12859,10 +13253,12 @@ var ClaudeCodeLanguageModel = class {
     const effectivePrompt = failoverAnswer?.kind === "switch" ? buildFailoverContinuationPrompt(options.prompt, failoverAnswer.target) : options.prompt;
     const userMsg = exitPlanModeQuestionResult ?? getClaudeUserMessage(effectivePrompt, includeHistoryContext, {
       compactionMode,
+      compactionInstructions: useInteractive && compactionMode ? extractSystemMessages(effectivePrompt).join("\n\n") : void 0,
       cliToolCallIds: new Set(previousPendingProxyCalls.map((c) => c.toolCallId)),
       stripContextReminders: this.stripContextRemindersEnabled()
     });
-    const resolvedProxy = compactionMode ? null : this.resolvedProxyTools();
+    const ptyPlanMode = useInteractive && !compactionMode && this.config.permissionMode === "plan";
+    const resolvedProxy = compactionMode ? null : ptyPlanMode ? this.resolvedProxyTools()?.filter((def) => def.name !== "write" && def.name !== "edit") ?? null : this.resolvedProxyTools();
     const loadLiveToolInfo = this.createLiveToolInfoLoader();
     const planModeQuestionActive = await this.resolvePlanModeQuestion(
       compactionMode,
@@ -12898,6 +13294,13 @@ var ClaudeCodeLanguageModel = class {
       return abortedBeforeWork("waiting for opencode's MCP status and the CLI version");
     }
     const [runtimeStatus, cliVersion] = prologue.value;
+    const ptyReadOnly = useInteractive && !compactionMode && !doctor && isReadOnlyPermissionMode(this.config.permissionMode);
+    const ptyReadOnlySupported = cliSupportsRestricted(cliVersion) && cliSupportsDontAsk(cliVersion);
+    if (ptyReadOnly && !ptyReadOnlySupported) {
+      throw new Error(
+        "The read-only preset on the interactive transport needs Claude Code 2.1.263 or newer (--restricted and --permission-mode dontAsk). Update claude, or use the headless transport."
+      );
+    }
     const failoverAccounts = failoverCandidates(
       this.config.failoverAccounts,
       sourceAccount
@@ -13222,7 +13625,21 @@ var ClaudeCodeLanguageModel = class {
               allDisallowed
             };
           };
-          if (useInteractive && !compactionMode) {
+          if (useInteractive && compactionMode) {
+            const ap = spawnInteractiveProcess({
+              cwd,
+              cliPath,
+              configDir: self.config.configDir,
+              model: spawnModelId,
+              fastMode,
+              tools: [],
+              mcpConfigPaths: ['{"mcpServers":{}}'],
+              env: claudeSpawnEnv({ ignoreAnthropicApiKey: self.config.ignoreAnthropicApiKey })
+            });
+            state.proc = ap.proc;
+            state.lineEmitter = ap.lineEmitter;
+            state.activeProcess = ap;
+          } else if (useInteractive) {
             if (state.activeProcess) {
               state.proc = state.activeProcess.proc;
               state.lineEmitter = state.activeProcess.lineEmitter;
@@ -13288,6 +13705,12 @@ var ClaudeCodeLanguageModel = class {
               });
               if (stoppedBeforeWork()) return;
               const resumeSessionId = getClaudeSessionId(sk);
+              const posture = interactivePermissionPosture({
+                permissionMode: self.config.permissionMode,
+                allow,
+                supportsReadOnly: ptyReadOnlySupported
+              });
+              if (!posture) throw new Error("the interactive transport cannot hold this permission posture");
               const ap = spawnInteractiveProcess({
                 cwd,
                 cliPath,
@@ -13296,7 +13719,9 @@ var ClaudeCodeLanguageModel = class {
                 fastMode,
                 mcpConfigPaths: mcp.paths,
                 pluginDirs: skillPluginDirs,
-                permissionsAllow: allow,
+                permissionsAllow: posture.allow,
+                permissionMode: posture.permissionMode,
+                restricted: posture.restricted,
                 disallowedTools: wiring.allDisallowed,
                 proxyServer: state.proxyServer,
                 systemPromptFile,
@@ -13428,7 +13853,7 @@ var ClaudeCodeLanguageModel = class {
               state.activeProcess = ap;
             }
           }
-          if (state.activeProcess && !hasMatchedPendingResults && isTurnInFlight(state.activeProcess)) {
+          if (state.activeProcess && !hasMatchedPendingResults && !state.activeProcess.interactiveControl?.planApprovalPending?.() && isTurnInFlight(state.activeProcess)) {
             log.warn("previous turn still in flight; interrupting it", { sk });
             const idle = await interruptTurn(state.activeProcess);
             if (!idle) {
@@ -13598,7 +14023,7 @@ var ClaudeCodeLanguageModel = class {
             });
             state.controllerClosed = true;
             cleanupTurn();
-            if (!useInteractive && !compactionMode) {
+            if (!compactionMode) {
               scheduleIdleProcessEviction(
                 sk,
                 resolveIdleProcessTimeoutMs(self.config.idleProcessTimeoutMs)
@@ -13614,6 +14039,7 @@ var ClaudeCodeLanguageModel = class {
             compactionMode,
             fastMode,
             planModeQuestionActive,
+            interactive: useInteractive,
             sourceAccount,
             failoverAskActive,
             usageLimitNoteActive,
@@ -13706,6 +14132,7 @@ var ClaudeCodeLanguageModel = class {
             state.asideSinkUnregister?.();
             state.asideSinkUnregister = null;
             state.proc.off("error", procErrorHandler);
+            if (compactionMode && useInteractive) state.proc.kill();
           };
           const procErrorHandler = (err) => {
             log.error("process error", { error: err.message });
@@ -13921,10 +14348,10 @@ import {
   readFileSync as readFileSync8,
   realpathSync as realpathSync4,
   rmSync as rmSync3,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
 import { homedir as homedir9 } from "os";
-import { dirname as dirname7, join as join12, resolve as resolve5 } from "path";
+import { dirname as dirname7, join as join13, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
@@ -13932,14 +14359,14 @@ var alreadyRan = false;
 function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
-    xdg ? join12(xdg, "opencode") : null,
-    join12(homedir9(), ".cache", "opencode"),
-    join12(homedir9(), "Library", "Caches", "opencode")
+    xdg ? join13(xdg, "opencode") : null,
+    join13(homedir9(), ".cache", "opencode"),
+    join13(homedir9(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join12(homedir9(), ".config");
-  return join12(xdgConfig, "opencode", "opencode.json");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join13(homedir9(), ".config");
+  return join13(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
@@ -13966,15 +14393,15 @@ function ourLoadedDir() {
 function ourVersion(dir) {
   if (!dir) return null;
   try {
-    const pkg = JSON.parse(readFileSync8(join12(dir, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync8(join13(dir, "package.json"), "utf8"));
     return typeof pkg.version === "string" && pkg.version ? pkg.version : null;
   } catch {
     return null;
   }
 }
 function markerPath() {
-  const stateRoot = process.env.XDG_STATE_HOME ?? join12(homedir9(), ".local", "state");
-  return join12(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
+  const stateRoot = process.env.XDG_STATE_HOME ?? join13(homedir9(), ".local", "state");
+  return join13(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
 }
 function markerVersion() {
   try {
@@ -13988,7 +14415,7 @@ function writeMarker(version) {
   const file = markerPath();
   try {
     mkdirSync5(dirname7(file), { recursive: true });
-    writeFileSync6(
+    writeFileSync7(
       file,
       JSON.stringify({ version, at: (/* @__PURE__ */ new Date()).toISOString() }, null, 2) + "\n",
       "utf8"
@@ -14023,7 +14450,7 @@ function cleanupStaleUnscopedInstall() {
 }
 function cleanupOne(cacheRoot, ourDir) {
   if (!existsSync5(cacheRoot)) return;
-  const stalePath = join12(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  const stalePath = join13(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
   if (!existsSync5(stalePath)) return;
   let realStalePath = stalePath;
   try {
@@ -14031,7 +14458,7 @@ function cleanupOne(cacheRoot, ourDir) {
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
-  const pkgJsonPath = join12(stalePath, "package.json");
+  const pkgJsonPath = join13(stalePath, "package.json");
   if (!existsSync5(pkgJsonPath)) return;
   let pkg = {};
   try {
@@ -14051,13 +14478,13 @@ function cleanupOne(cacheRoot, ourDir) {
     });
     return;
   }
-  const cachePkgJson = join12(cacheRoot, "package.json");
+  const cachePkgJson = join13(cacheRoot, "package.json");
   if (!existsSync5(cachePkgJson)) return;
   try {
     const cfg = JSON.parse(readFileSync8(cachePkgJson, "utf8"));
     if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
       delete cfg.dependencies[STALE_PACKAGE_NAME];
-      writeFileSync6(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
+      writeFileSync7(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
       log.info("cleanup-stale: pruned dep from cache package.json");
     }
   } catch (err) {
@@ -14628,8 +15055,10 @@ function warnIfAnthropicApiKey(ignore) {
 function _resetPlanModeWarningForTests() {
   warnedPlanModeNoExit = false;
 }
-function warnIfPlanModeCannotExit(permissionMode) {
+function warnIfPlanModeCannotExit(permissionMode, transport) {
   if (permissionMode !== "plan") return;
+  const interactive = transport?.transport === "interactive" || transport?.transport === void 0 && transport?.interactive === true;
+  if (interactive) return;
   if (warnedPlanModeNoExit) return;
   warnedPlanModeNoExit = true;
   log.warn(
@@ -14670,7 +15099,7 @@ function createClaudeCode(settings = {}) {
   }
   warnIfAnthropicApiKey(settings.ignoreAnthropicApiKey);
   const preset = applyPermissionPreset(settings, DEFAULT_PROXY_TOOL_NAMES);
-  warnIfPlanModeCannotExit(preset ? void 0 : settings.permissionMode);
+  warnIfPlanModeCannotExit(preset ? void 0 : settings.permissionMode, settings);
   const cliPath = settings.cliPath ?? process.env.CLAUDE_CLI_PATH ?? "claude";
   const providerName = settings.providerID ?? settings.name ?? "claude-code";
   const proxyTools = preset?.proxyTools ?? settings.proxyTools ?? [...DEFAULT_PROXY_TOOL_NAMES];
@@ -14719,6 +15148,7 @@ function createClaudeCode(settings = {}) {
       turnStats: settings.turnStats === true,
       forkSessions: settings.forkSessions === true,
       resumeAfterRestart: settings.resumeAfterRestart !== false,
+      transport: settings.transport,
       interactive: settings.interactive,
       interactiveBypass: settings.interactiveBypass,
       interactiveAllowTools: settings.interactiveAllowTools,