@khalilgharbaoui/opencode-claude-code-plugin 0.41.0 → 0.42.1

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 });
@@ -3779,12 +3783,16 @@ async function fetchSessionParentId(sessionID) {
     return void 0;
   }
 }
-async function fetchSessionRunState(sessionID) {
+async function fetchSessionRunState(sessionID, directory) {
   if (!sessionID || sessionID === "default") return "unknown";
   const status = opencodeClient?.session?.status;
   if (!status) return "unknown";
   try {
-    const res = await status.call(opencodeClient.session);
+    const dir = directory ?? await fetchSessionDirectory(sessionID);
+    const res = await status.call(
+      opencodeClient.session,
+      dir ? { query: { directory: dir } } : void 0
+    );
     const data = res.data;
     if (!data || typeof data !== "object") return "unknown";
     const entry = data[sessionID];
@@ -3804,8 +3812,10 @@ async function settleSessionRunState(sessionID, options = {}) {
   const windowMs = options.windowMs ?? 1500;
   const started = Date.now();
   let last = "unknown";
+  let directory = options.directory;
   for (; ; ) {
-    const state = await fetchSessionRunState(sessionID);
+    directory ??= await fetchSessionDirectory(sessionID);
+    const state = await fetchSessionRunState(sessionID, directory ?? "");
     if (state === "busy") return "busy";
     if (state !== "unknown") last = state;
     if (Date.now() - started >= windowMs) return last;
@@ -4533,6 +4543,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;
 }
@@ -4612,7 +4636,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)) {
@@ -5762,6 +5804,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",
@@ -8181,6 +8225,38 @@ Now continuing with the current message:
     }
   });
 }
+function getTrailingUserMessages(prompt, opts = {}) {
+  prompt = stripAccountFailoverParts(prompt);
+  if (opts.stripContextReminders) prompt = stripContextReminders(prompt).prompt;
+  let assistantIndex = -1;
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    if (prompt[i].role === "assistant") {
+      assistantIndex = i;
+      break;
+    }
+  }
+  const messages = [];
+  for (let i = assistantIndex + 1; i < prompt.length; i++) {
+    const msg = prompt[i];
+    if (msg.role !== "user") continue;
+    if (parseSideQuestionContent(msg.content) !== null) continue;
+    const blocks = [];
+    if (typeof msg.content === "string") {
+      if (msg.content.trim()) blocks.push({ type: "text", text: msg.content });
+    } else if (Array.isArray(msg.content)) {
+      for (const part of msg.content) {
+        if (part.type === "text") {
+          if (part.text && part.text.trim()) blocks.push({ type: "text", text: part.text });
+        } else if (part.type === "file" || part.type === "image") {
+          const block = toImageBlock(part);
+          if (block) blocks.push(block);
+        }
+      }
+    }
+    if (blocks.length > 0) messages.push(blocks);
+  }
+  return { assistantIndex, messages };
+}
 
 // src/skill-bridge.ts
 import * as crypto3 from "crypto";
@@ -8554,8 +8630,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";
@@ -8635,6 +8713,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.
@@ -8665,6 +8754,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);
@@ -8756,7 +8852,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;
@@ -8770,6 +8866,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");
@@ -8804,6 +8905,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;
@@ -8822,6 +8927,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 = {}) {
@@ -8829,7 +8943,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;
@@ -8872,12 +8988,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);
@@ -8946,6 +9066,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;
@@ -9001,6 +9124,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";
@@ -9139,8 +9269,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) {
@@ -9174,6 +9306,9 @@ var ClaudeSession = class {
       this.turn = null;
       this.scan = null;
       this.abandonTurn = false;
+      this.planApprovalToolUseId = null;
+      this.planDialog = null;
+      this.answeredPlans.clear();
       settle();
     }
   }
@@ -9199,6 +9334,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) {
@@ -9230,6 +9373,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
@@ -9358,7 +9569,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);
@@ -9370,16 +9588,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++;
@@ -9390,11 +9614,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",
@@ -9552,6 +9826,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) => {
@@ -9582,7 +9857,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;
@@ -9655,12 +9930,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--;
     });
   };
@@ -9669,7 +9994,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() {
@@ -9720,7 +10056,9 @@ function spawnInteractiveProcess(opts) {
         cancelledThrough = writes;
         return session.interrupt(timeoutMs);
       },
-      flushTranscript: () => session.flushTranscript()
+      flushTranscript: () => session.flushTranscript(),
+      planApprovalPending: () => session.pendingPlanApproval !== null,
+      askAside
     }
   };
   return ap;
@@ -9753,10 +10091,10 @@ async function selectTransport(requested, cliPath, available = hasInteractiveTra
 }
 
 // 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();
@@ -9768,7 +10106,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;
@@ -9877,8 +10215,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);
@@ -9889,9 +10227,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) });
@@ -10506,7 +10844,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");
@@ -11305,6 +11642,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);
@@ -11901,6 +12256,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);
@@ -12181,6 +12540,7 @@ async function isProxyCallStillServed(callId) {
   return await fetchSessionRunState(session) === "busy";
 }
 setProxyDeadlineGuard(({ callId }) => isProxyCallStillServed(callId));
+var FORWARD_SETTLE_MS = 250;
 var CHILD_EXIT_STATUS_GRACE_MS = 250;
 var ClaudeCodeLanguageModel = class {
   specificationVersion = "v3";
@@ -12625,9 +12985,6 @@ var ClaudeCodeLanguageModel = class {
     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";
-    if (useInteractive && !compactionMode && !doctor && (this.config.permissionPreset === "read-only" || this.config.permissionMode === "plan")) {
-      throw new Error("Interactive Claude transport cannot enforce the read-only preset or plan mode. Use the headless transport for this permission posture.");
-    }
     const interactiveBypassRequested = this.config.interactiveBypass ?? flagOn(process.env.CLAUDE_CODE_INTERACTIVE_BYPASS);
     const modelFallbackArmed = attempt?.armed === true && !compactionMode && !useInteractive;
     const sourceAccount = normalizeAccountName(
@@ -12912,7 +13269,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);
@@ -12939,7 +13296,8 @@ var ClaudeCodeLanguageModel = class {
       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,
@@ -12975,6 +13333,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
@@ -13096,7 +13461,7 @@ var ClaudeCodeLanguageModel = class {
                   });
                   return;
                 }
-                log.info("abort between proxy tool boundaries; releasing pending calls", { sk, reason });
+                log.info("abort between proxy tool boundaries; releasing pending calls", { sk, reason, session: stopped });
                 void interruptTurn(stoppedProcess).then((idle) => {
                   log.info("interrupt sent for aborted turn", { sk, idle });
                 });
@@ -13379,6 +13744,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,
@@ -13387,7 +13758,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,
@@ -13519,7 +13892,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) {
@@ -13689,7 +14062,7 @@ var ClaudeCodeLanguageModel = class {
             });
             state.controllerClosed = true;
             cleanupTurn();
-            if (!useInteractive && !compactionMode) {
+            if (!compactionMode) {
               scheduleIdleProcessEviction(
                 sk,
                 resolveIdleProcessTimeoutMs(self.config.idleProcessTimeoutMs)
@@ -13705,6 +14078,7 @@ var ClaudeCodeLanguageModel = class {
             compactionMode,
             fastMode,
             planModeQuestionActive,
+            interactive: useInteractive,
             sourceAccount,
             failoverAskActive,
             usageLimitNoteActive,
@@ -13918,6 +14292,34 @@ var ClaudeCodeLanguageModel = class {
           state.proc.on("error", procErrorHandler);
           if (hasMatchedPendingResults) {
             state.cliAskedForWork = true;
+            const forwardTrailingUserMessages = () => {
+              if (compactionMode || !state.activeProcess) return 0;
+              if (state.activeProcess.interactiveControl) return 0;
+              const trailing = getTrailingUserMessages(effectivePrompt, {
+                stripContextReminders: self.stripContextRemindersEnabled()
+              });
+              const sent = state.activeProcess.forwardedUserMessages?.assistantIndex === trailing.assistantIndex ? state.activeProcess.forwardedUserMessages.count : 0;
+              const fresh = trailing.messages.slice(sent);
+              if (fresh.length === 0) return 0;
+              state.activeProcess.forwardedUserMessages = {
+                assistantIndex: trailing.assistantIndex,
+                count: trailing.messages.length
+              };
+              for (const content of fresh) {
+                state.proc.stdin?.write(
+                  JSON.stringify({ type: "user", message: { role: "user", content } }) + "\n"
+                );
+              }
+              log.info("forwarded user messages that arrived beside tool results", {
+                sessionKey: sk,
+                messages: fresh.length
+              });
+              return fresh.length;
+            };
+            if (!state.unattendedTurnEnded && forwardTrailingUserMessages() > 0) {
+              await new Promise((resolve6) => setTimeout(resolve6, FORWARD_SETTLE_MS));
+              if (state.controllerClosed) return;
+            }
             for (const { call, result } of previousPendingProxyMatches) {
               if (result) {
                 const channelClosed = isPendingProxyCallChannelClosed(call);
@@ -13947,7 +14349,10 @@ var ClaudeCodeLanguageModel = class {
                 );
               }
             }
-            if (state.unattendedTurnEnded) deliverPendingCompletions(state);
+            if (state.unattendedTurnEnded) {
+              deliverPendingCompletions(state);
+              forwardTrailingUserMessages();
+            }
             const unemitted = getPendingProxyCalls(sk).filter(
               (call) => !call.emitted
             );
@@ -13976,7 +14381,10 @@ var ClaudeCodeLanguageModel = class {
             }
           }
           state.cliAskedForWork = true;
-          if (state.activeProcess) noteTurnStarted(state.activeProcess);
+          if (state.activeProcess) {
+            noteTurnStarted(state.activeProcess);
+            state.activeProcess.forwardedUserMessages = void 0;
+          }
           state.proc.stdin?.write(userMsg + "\n");
           log.debug("sent user message", { textLength: userMsg.length });
           armStartWatchdog(state);
@@ -14013,10 +14421,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";
@@ -14024,14 +14432,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();
@@ -14058,15 +14466,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 {
@@ -14080,7 +14488,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"
@@ -14115,7 +14523,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 {
@@ -14123,7 +14531,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 {
@@ -14143,13 +14551,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) {
@@ -14720,8 +15128,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(
@@ -14762,7 +15172,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];