@khalilgharbaoui/opencode-claude-code-plugin 0.42.2 → 0.43.0

package/dist/index.js

@@ -1327,7 +1327,7 @@ function formatUsageLimitNote(input) {
   const what = [
     `the Claude account "${account}" is out of usage`,
     window ? ` in ${window}` : "",
-    resets ? `, which resets at ${resets}` : "",
+    resets ? `, which resets at ${resets}` : input.resetsText ? `, which resets ${input.resetsText}` : "",
     "."
   ].join("");
   const advice = others ? `Pick a model from ${others} and resend your message, or wait for the window to reset.` : "Wait for the window to reset, or enable extra usage on the account.";
@@ -1341,6 +1341,13 @@ function isAccountLimitError(input) {
   if (typeof text !== "string" || text.length === 0) return false;
   return ACCOUNT_LIMIT_PATTERNS.some((pattern) => pattern.test(text));
 }
+function limitFactsFromText(text) {
+  const facts = {};
+  if (/\bsession limit\b/i.test(text)) facts.window = "five_hour";
+  const reset = /\bresets\s+([^·\n]{1,60}?)\s*$/im.exec(text);
+  if (reset) facts.resetsText = reset[1].trim();
+  return facts;
+}
 var lastAccountLimits = /* @__PURE__ */ new Map();
 function rememberAccountLimit(account, facts) {
   const name = normalizeAccountName(account || DEFAULT_ACCOUNT);
@@ -1423,7 +1430,6 @@ async function resolveFailoverSpawn(input) {
 }
 function isAccountFailoverQuestionActive(input) {
   if (input.compactionMode) return false;
-  if (input.interactive) return false;
   if (input.childSession) return false;
   if (input.configured !== "ask") return false;
   if (input.candidates.length === 0) return false;
@@ -1723,6 +1729,10 @@ function cliSupportsDontAsk(v) {
   if (!v) return false;
   return gte(v, { major: 2, minor: 1, patch: 263 });
 }
+function cliSupportsInteractiveBypass(v) {
+  if (!v) return false;
+  return gte(v, { major: 2, minor: 1, patch: 263 });
+}
 var INTERACTIVE_MEASURED_CLI = "2.1.288";
 var INTERACTIVE_MEASURED = { major: 2, minor: 1, patch: 288 };
 function isUnmeasuredInteractiveCli(v) {
@@ -4559,18 +4569,36 @@ function summarizePermissionPreset(provider, options, defaultProxyTools = DEFAUL
   };
 }
 function interactivePermissionPosture(input) {
-  if (!isReadOnlyPermissionMode(input.permissionMode)) {
-    return { permissionMode: input.permissionMode, restricted: false, allow: input.allow };
+  if (isReadOnlyPermissionMode(input.permissionMode)) {
+    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())
+      ),
+      bypass: false,
+      disallowed: []
+    };
   }
-  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())
-    )
+  const unchanged = {
+    permissionMode: input.permissionMode === "bypassPermissions" ? void 0 : input.permissionMode,
+    restricted: false,
+    allow: input.allow,
+    bypass: false,
+    disallowed: []
   };
+  if (input.permissionMode === "plan" || !input.supportsBypass) return unchanged;
+  const perTool = Object.entries(input.controlRequestToolBehaviors ?? {});
+  const named = (behavior) => perTool.filter(([, value]) => value === behavior).map(([tool]) => tool);
+  if (input.skipPermissions !== false || input.permissionMode === "bypassPermissions") {
+    return { ...unchanged, bypass: true };
+  }
+  if ((input.controlRequestBehavior ?? "allow") === "allow") {
+    return { ...unchanged, bypass: true, disallowed: named("deny") };
+  }
+  return { ...unchanged, permissionMode: "dontAsk", allow: named("allow") };
 }
 function isReadOnlyPermissionMode(mode) {
   return mode === READ_ONLY_PERMISSION_MODE;
@@ -5825,7 +5853,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "interactive transport denied a permission prompt",
   "interactive transport dropped non-text content blocks",
   "interactive turn failed",
-  "interactiveBypass ignored: Claude Code prompts for bypassPermissions confirmation in the interactive TUI",
+  "interactiveBypass is ignored: skipPermissions governs the interactive transport too",
   "malformed data URI, skipping file part",
   "no active process to respawn (start watchdog); ending turn",
   "no proxyTools entry was recognised; nothing will be proxied this turn",
@@ -5862,6 +5890,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "stale scratch directory sweep failed",
   "task_batch resolving with child results missing",
   "the interactive transport has not been measured on this Claude Code version; it reads the TUI's screen and transcript, which a new release can change. If a turn hangs or a dialog is not handled, run /claude-code-doctor bundle and report it",
+  "the interactive turn did not take a forwarded user message",
   "this opencode process is running an older plugin build than the one on disk",
   "timed out pending proxy call",
   "turn abort listener threw",
@@ -7541,6 +7570,20 @@ function parseModelId(modelId) {
   if (!Object.hasOwn(defaultModels, base)) return { model: modelId, fast: false };
   return { model: base.slice(0, -FAST_SUFFIX.length) + account, fast: true };
 }
+var WEB_SEARCH_USD = 0.01;
+function apiCallCostUsd(model, usage) {
+  if (typeof model !== "string" || !usage || typeof usage !== "object") return null;
+  const base = model.replace(/@.*$/, "").replace(/\[1m\]$/i, "").replace(/-\d{8}$/, "");
+  const entry = (usage.speed === "fast" ? defaultModels[`${base}${FAST_SUFFIX}`] : void 0) ?? defaultModels[base];
+  if (!entry) return null;
+  const cost = entry.cost;
+  const count = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+  const split = usage.cache_creation;
+  const write1h = split ? count(split.ephemeral_1h_input_tokens) : 0;
+  const write5m = split ? count(split.ephemeral_5m_input_tokens) : count(usage.cache_creation_input_tokens);
+  const perMillion = count(usage.input_tokens) * cost.input + count(usage.output_tokens) * cost.output + count(usage.cache_read_input_tokens) * cost.cache.read + write5m * cost.cache.write + write1h * cost.input * 2;
+  return perMillion / 1e6 + count(usage.server_tool_use?.web_search_requests) * WEB_SEARCH_USD;
+}
 
 // src/agent-models.ts
 var AGENT_DIR_NAMES = ["agents", "agent"];
@@ -8860,6 +8903,7 @@ function isApiCallRecord(rec) {
 }
 var TurnUsageAccumulator = class {
   calls = /* @__PURE__ */ new Map();
+  models = /* @__PURE__ */ new Map();
   lastKey = null;
   /** Feed every transcript record of the turn, in file order. */
   add(rec) {
@@ -8867,8 +8911,24 @@ var TurnUsageAccumulator = class {
     const id = rec.message.id;
     const key = typeof id === "string" && id.length > 0 ? id : `uuid:${rec.uuid ?? this.calls.size}`;
     this.calls.set(key, rec.message.usage);
+    this.models.set(key, rec.message.model);
     this.lastKey = key;
   }
+  /**
+   * The turn's list-price cost over its distinct calls, the headless
+   * `result`'s `total_cost_usd` (h #g208). Null when no call was made or any
+   * call's model is one the catalog cannot price, never a partial sum.
+   */
+  get costUsd() {
+    if (this.calls.size === 0) return null;
+    let total = 0;
+    for (const [key, usage] of this.calls) {
+      const cost = apiCallCostUsd(this.models.get(key), usage);
+      if (cost === null) return null;
+      total += cost;
+    }
+    return total;
+  }
   /** Distinct API calls seen, for diagnostics. */
   get callCount() {
     return this.calls.size;
@@ -8999,6 +9059,9 @@ var ClaudeSession = class {
    *  (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;
+  /** `queue-operation` enqueue records read, which is how `queueInput` knows
+   *  the TUI took a message into the running turn. */
+  enqueued = 0;
   /** This turn's `ExitPlanMode` calls already answered. */
   answeredPlans = /* @__PURE__ */ new Set();
   abandonTurn = false;
@@ -9057,7 +9120,9 @@ var ClaudeSession = class {
       // 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
+      planDialogWaitMs: opts.planDialogWaitMs ?? 3e4,
+      // 100 times the longest silence measured while Claude works (h #g207).
+      idleEndMs: opts.idleEndMs ?? 2e4
     };
   }
   /** The CLI arguments this session spawns with. */
@@ -9335,7 +9400,8 @@ var ClaudeSession = class {
         end: null,
         sawUserRecord: false,
         lastBeat: Date.now(),
-        awaitingOwnPrompt: this.forkPending ? normalizedPrompt(prompt) : null
+        awaitingOwnPrompt: this.forkPending ? normalizedPrompt(prompt) : null,
+        sawReply: false
       };
       this.forkPending = false;
       this.scan = scan;
@@ -9358,6 +9424,9 @@ var ClaudeSession = class {
         if (scan.stopReason && Date.now() - scan.stopSeenAt >= this.o.stopSettleMs) {
           return { stopReason: scan.stopReason, end: "stop", denied: this.turnDenied };
         }
+        if (scan.sawReply && !this.planApprovalToolUseId && Date.now() - this.lastDataAt >= this.o.idleEndMs && Date.now() - scan.stopSeenAt >= this.o.idleEndMs) {
+          return { stopReason: null, end: "ended", denied: this.turnDenied };
+        }
         if (this.exited) throw new Error(this.failureMessage("claude exited mid-turn", true));
         if (this.abandonTurn) return { stopReason: null, end: "interrupted", denied: this.turnDenied };
         const now = Date.now();
@@ -9407,9 +9476,11 @@ var ClaudeSession = class {
         scan.awaitingOwnPrompt = null;
       }
       if (rec) this.notePlanApproval(rec);
+      if (rec?.type === "queue-operation" && rec.operation === "enqueue") this.enqueued++;
       scan.onRecord(s, rec);
       if (rec) {
         if (rec.type === "assistant" && rec.message) {
+          scan.sawReply = true;
           const reason = rec.message.stop_reason;
           if (typeof reason === "string") {
             scan.stopReason = TERMINAL_STOP.has(reason) ? reason : null;
@@ -9498,6 +9569,29 @@ var ClaudeSession = class {
     this.write("\r");
     return true;
   }
+  /**
+   * Type a message into the running turn's own input queue, not as a turn of
+   * its own (h #g206). Measured on 2.1.288: text pasted and submitted while a
+   * tool call runs is recorded as `queue-operation` enqueue and remove plus a
+   * `queued_command` attachment, answered in the same turn, which still ends
+   * once. Resolves true once the enqueue is in the transcript; false with no
+   * turn running, or with a plan approval dialog up, which would take the
+   * keys as its answer.
+   */
+  async queueInput(text, timeoutMs = 3e3) {
+    if (!this.turn || !this.proc || this.exited || this.pendingPlanApproval) return false;
+    const before = this.enqueued;
+    this.write(this.o.bracketedPaste ? "\x1B[200~" + text + "\x1B[201~" : text);
+    await delay(this.o.submitMinMs);
+    this.write("\r");
+    const deadline = Date.now() + timeoutMs;
+    while (this.enqueued === before) {
+      if (!this.turn || this.exited || Date.now() >= deadline) return false;
+      await delay(this.o.pollMs);
+      this.scanTranscript();
+    }
+    return true;
+  }
   /** Wait until the PTY has been quiet for `permissionQuietMs`, at most 3 s. */
   async waitForQuiet() {
     const until = Date.now() + 3e3;
@@ -9585,11 +9679,29 @@ var ClaudeSession = class {
   async tailTurn(prompt, onLine, perTurnTimeoutMs, onHeartbeat) {
     const timeout = perTurnTimeoutMs ?? this.o.turnTimeoutMs;
     const usage = new TurnUsageAccumulator();
+    const startedAt = Date.now();
+    let reportedDurationMs = null;
+    let apiError = null;
     const { stopReason, end, denied } = await this.runTurnLoop(
       prompt,
       (raw, rec) => {
         onLine(raw);
         if (rec) usage.add(rec);
+        if (rec?.type === "assistant") {
+          if (rec.isApiErrorMessage === true) {
+            const text = (Array.isArray(rec.message?.content) ? rec.message.content : []).filter((block) => block?.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n");
+            apiError = {
+              text,
+              ...typeof rec.apiErrorStatus === "number" ? { status: rec.apiErrorStatus } : {},
+              ...typeof rec.error === "string" ? { kind: rec.error } : {}
+            };
+          } else if (rec.message?.model !== "<synthetic>") {
+            apiError = null;
+          }
+        }
+        if (isTurnDurationRecord(rec) && typeof rec.durationMs === "number") {
+          reportedDurationMs = rec.durationMs;
+        }
       },
       timeout,
       onHeartbeat
@@ -9607,6 +9719,9 @@ var ClaudeSession = class {
       usage: usage.turnTotal,
       lastCallUsage: usage.lastCall,
       callCount: usage.callCount,
+      costUsd: usage.costUsd,
+      durationMs: reportedDurationMs ?? Date.now() - startedAt,
+      apiError,
       denied
     };
   }
@@ -9754,13 +9869,19 @@ function interactiveExtraArgs(opts) {
   if (opts.fastMode) {
     flagSettings.fastMode = true;
   }
+  if (opts.bypass) {
+    flagSettings.skipDangerousModePermissionPrompt = true;
+    extraArgs.push("--dangerously-skip-permissions");
+  }
   if (Object.keys(flagSettings).length > 0) {
     extraArgs.push("--settings", JSON.stringify(flagSettings));
   }
   if (opts.permissionMode === "bypassPermissions") {
-    log.warn(
-      "interactive permissionMode bypassPermissions ignored: Claude Code prompts for confirmation in the TUI"
-    );
+    if (!opts.bypass) {
+      log.warn(
+        "interactive permissionMode bypassPermissions ignored: Claude Code prompts for confirmation in the TUI"
+      );
+    }
   } else if (opts.permissionMode) {
     extraArgs.push("--permission-mode", opts.permissionMode);
   }
@@ -9812,6 +9933,7 @@ function heartbeatFrame(sessionId, openCall, now = Date.now()) {
 }
 function interactiveResultFrame(opts) {
   const completed = opts.end === "stop" && !!opts.stopReason;
+  const apiError = completed && opts.apiError ? opts.apiError : null;
   let result;
   let terminalReason = "completed";
   if (!completed) {
@@ -9829,20 +9951,35 @@ function interactiveResultFrame(opts) {
   return JSON.stringify({
     type: "result",
     subtype: completed ? "success" : "error_during_execution",
-    is_error: !completed,
+    is_error: !completed || apiError !== null,
     stop_reason: completed ? opts.stopReason : null,
     terminal_reason: terminalReason,
-    result,
+    result: apiError ? apiError.text : result,
+    ...apiError?.status !== void 0 ? { api_error_status: apiError.status } : {},
     session_id: opts.sessionId,
     usage: opts.usage ?? {},
     // The TUI has no `can_use_tool` channel, so a permission dialog is the
     // only way it asks; each one the session denied is reported in the
     // headless field's place, names and ids only (h #g109).
     permission_denials: opts.denials ?? [],
-    total_cost_usd: null,
-    duration_ms: 0
+    total_cost_usd: opts.costUsd ?? null,
+    duration_ms: opts.durationMs ?? 0
   });
 }
+function interactiveSpawnEnv2(env) {
+  if (env.CLAUDE_CODE_MCP_AUTO_BACKGROUND_MS !== void 0) return env;
+  return { ...env, CLAUDE_CODE_MCP_AUTO_BACKGROUND_MS: "0" };
+}
+function streamFrameFromRecord(raw) {
+  if (!raw.includes('"isApiErrorMessage":true')) return raw;
+  try {
+    const rec = JSON.parse(raw);
+    if (rec?.isApiErrorMessage !== true || rec.is_api_error_message !== void 0) return raw;
+    return JSON.stringify({ ...rec, is_api_error_message: true });
+  } catch {
+    return raw;
+  }
+}
 function carriesReplyText(line) {
   try {
     const rec = JSON.parse(line);
@@ -9880,6 +10017,7 @@ function spawnInteractiveProcess(opts) {
     ignoreAnthropicApiKey: opts.ignoreAnthropicApiKey,
     effort: opts.effort ? cliEffortLevel(opts.effort) : void 0,
     resumeSessionId: opts.resumeSessionId,
+    ...opts.forkOf ? { forkOf: opts.forkOf } : {},
     env: opts.env,
     spawnPty: opts.spawnPty,
     onScreen: (event) => {
@@ -9911,6 +10049,7 @@ function spawnInteractiveProcess(opts) {
     effort: opts.effort,
     sessionId: session.sessionId,
     resumed: !!opts.resumeSessionId,
+    forkedFrom: opts.forkOf ?? null,
     jsonlPath: session.jsonlPath
   });
   let startPromise = null;
@@ -9940,14 +10079,14 @@ function spawnInteractiveProcess(opts) {
       }
       openCalls.clear();
       denials = [];
-      const { stopReason, end, usage, lastCallUsage, callCount, denied } = await session.tailTurn(
+      const { stopReason, end, usage, lastCallUsage, callCount, costUsd, durationMs, apiError, denied } = await session.tailTurn(
         userMsg,
         (raw) => {
           try {
             openCalls.add(JSON.parse(raw));
           } catch {
           }
-          emit2(raw);
+          emit2(streamFrameFromRecord(raw));
         },
         void 0,
         // Only to a listening turn: it feeds that turn's watchdog, and the
@@ -9978,7 +10117,10 @@ function spawnInteractiveProcess(opts) {
           end,
           stopReason,
           usage,
-          denials
+          denials,
+          costUsd,
+          durationMs,
+          apiError
         })
       );
     } catch (err) {
@@ -10022,7 +10164,9 @@ function spawnInteractiveProcess(opts) {
       configDir: opts.configDir,
       model: opts.model,
       settingSources: opts.settingSources === void 0 ? null : opts.settingSources,
-      extraArgs: interactiveExtraArgs({ ...opts, permissionsAllow: [], permissionMode: "dontAsk" }),
+      // Tool-free whatever the main spawn's posture: `dontAsk` with nothing
+      // allowed, and never the skip flag, which would win over it (h #g210).
+      extraArgs: interactiveExtraArgs({ ...opts, permissionsAllow: [], permissionMode: "dontAsk", bypass: false }),
       ignoreAnthropicApiKey: opts.ignoreAnthropicApiKey,
       effort: opts.effort ? cliEffortLevel(opts.effort) : void 0,
       env: opts.env,
@@ -10123,6 +10267,13 @@ function spawnInteractiveProcess(opts) {
       },
       flushTranscript: () => session.flushTranscript(),
       planApprovalPending: () => session.pendingPlanApproval !== null,
+      // Text only: an image in a mid-call message is dropped with the
+      // decoder's own warning rather than staged for a turn that is not ours.
+      queueInput: async (content) => {
+        const text = decodeUserEnvelope(JSON.stringify({ type: "user", message: { role: "user", content } })).trim();
+        if (!text) return false;
+        return session.queueInput(text);
+      },
       askAside
     }
   };
@@ -11120,6 +11271,7 @@ function createTurnState(init) {
     lastCallUsage: void 0,
     resultFailure: void 0,
     accountLimitHit: null,
+    apiErrorTextShown: null,
     usageLimitNote: false,
     accountBlock: null,
     modelRefusal: null,
@@ -12211,11 +12363,21 @@ ${plan}
           state.hasReceivedContent = true;
         }
         const apiErrorReply = msg.is_api_error_message === true;
-        const limitErrorReply = apiErrorReply && ctx.usageLimitNoteActive && !state.accountBlock && (msg.error === "rate_limit" || isAccountLimitError({
+        const limitFromReply = apiErrorReply && !state.accountBlock && (msg.error === "rate_limit" || isAccountLimitError({
           resultText: msg.message.content.filter((b) => b.type === "text" && b.text).map((b) => String(b.text)).join("\n")
         }));
-        if (limitErrorReply) {
+        const limitErrorReply = limitFromReply && ctx.usageLimitNoteActive;
+        if (limitFromReply) {
           state.accountLimitHit ??= recallAccountLimit(ctx.sourceAccount);
+          const said = limitFactsFromText(
+            msg.message.content.filter((b) => b.type === "text" && b.text).map((b) => String(b.text)).join("\n")
+          );
+          const known = state.accountLimitHit;
+          state.accountLimitHit = {
+            ...known,
+            window: known.window ?? said.window,
+            ...known.resetsAt === void 0 && said.resetsText ? { resetsText: said.resetsText } : {}
+          };
         }
         if (hasText && !hasToolUse) {
           startResultFallback(state);
@@ -12226,6 +12388,7 @@ ${plan}
         for (const block2 of msg.message.content) {
           if (block2.type === "text" && block2.text) {
             if (limitErrorReply) continue;
+            if (apiErrorReply) state.apiErrorTextShown = block2.text;
             resetLastVisibleTextBlock(state);
             const blockId = state.startTextBlock();
             state.controller.enqueue({
@@ -12450,7 +12613,8 @@ ${plan}
         state.usageLimitNote = ctx.usageLimitNoteActive && !!state.accountLimitHit && // An expired login or a billing hold writes its own note just below
         // and says what to run; two notes about one failure is one too many.
         !state.accountBlock && msg.is_error === true;
-        if (!state.currentTextId && msg.is_error && !state.usageLimitNote && typeof msg.result === "string" && msg.result.trim().length > 0) {
+        if (!state.currentTextId && msg.is_error && // Already on screen from the reply frame, word for word.
+        !(typeof msg.result === "string" && state.apiErrorTextShown !== null && msg.result.trim() === state.apiErrorTextShown.trim()) && !state.usageLimitNote && typeof msg.result === "string" && msg.result.trim().length > 0) {
           const errId = state.startTextBlock();
           state.controller.enqueue({
             type: "text-delta",
@@ -13025,12 +13189,12 @@ var ClaudeCodeLanguageModel = class {
     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 modelFallbackArmed = attempt?.armed === true && !compactionMode;
     const sourceAccount = normalizeAccountName(
       this.config.account ?? DEFAULT_ACCOUNT
     );
     const baseCliPath = this.config.baseCliPath ?? this.config.cliPath;
-    let failover = useInteractive || compactionMode ? { cliPath: this.config.cliPath, modelId: effectiveModelId, failedOver: false } : await resolveFailoverSpawn({
+    let failover = compactionMode ? { cliPath: this.config.cliPath, modelId: effectiveModelId, failedOver: false } : await resolveFailoverSpawn({
       account: sourceAccount,
       baseCliPath,
       cliPath: this.config.cliPath,
@@ -13183,7 +13347,7 @@ var ClaudeCodeLanguageModel = class {
       deleteActiveProcess(sk);
       clearCompression(sk);
     }
-    const failoverAnswer = compactionMode || useInteractive || mode === "generate" ? null : consumeAccountFailoverAnswer(sk, options.prompt, {
+    const failoverAnswer = compactionMode || mode === "generate" ? null : consumeAccountFailoverAnswer(sk, options.prompt, {
       sourceAccount,
       candidates: failoverCandidates(this.config.failoverAccounts, sourceAccount)
     });
@@ -13246,7 +13410,7 @@ var ClaudeCodeLanguageModel = class {
       });
     }
     const processForAccount = getActiveProcess(sk);
-    if (!compactionMode && !useInteractive && processForAccount?.cliPath && processForAccount.cliPath !== cliPath) {
+    if (!compactionMode && processForAccount?.cliPath && processForAccount.cliPath !== cliPath) {
       log.notice("claude process belongs to another account; starting fresh", {
         sessionKey: sk,
         was: processForAccount.cliPath,
@@ -13263,7 +13427,7 @@ var ClaudeCodeLanguageModel = class {
       includeHistoryContext = true;
     }
     let forkFromClaudeSessionId;
-    if (this.config.forkSessions === true && includeHistoryContext && !compactionMode && !useInteractive && failoverAnswer?.kind !== "switch") {
+    if (this.config.forkSessions === true && includeHistoryContext && !compactionMode && failoverAnswer?.kind !== "switch") {
       const parent = findForkParent({
         sessionKey: sk,
         prompt: options.prompt,
@@ -13319,7 +13483,7 @@ var ClaudeCodeLanguageModel = class {
         });
       }
     }
-    if (this.config.forkSessions === true && !compactionMode && !useInteractive) {
+    if (this.config.forkSessions === true && !compactionMode) {
       recordForkFingerprint(sk, options.prompt, cliPath);
     }
     const { model: spawnModelId, fast: fastMode } = parseModelId(failover.modelId);
@@ -13375,6 +13539,7 @@ var ClaudeCodeLanguageModel = class {
     if (useInteractive) reportUnmeasuredInteractiveCli(cliVersion);
     const ptyReadOnly = useInteractive && !compactionMode && !doctor && isReadOnlyPermissionMode(this.config.permissionMode);
     const ptyReadOnlySupported = cliSupportsRestricted(cliVersion) && cliSupportsDontAsk(cliVersion);
+    const ptyBypassSupported = cliSupportsInteractiveBypass(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."
@@ -13384,14 +13549,13 @@ var ClaudeCodeLanguageModel = class {
       this.config.failoverAccounts,
       sourceAccount
     );
-    const failoverAskActive = failoverAccounts.length > 0 && this.config.accountFailover === "ask" && !compactionMode && !useInteractive && // A `doGenerate` caller takes the override and reports the plain
+    const failoverAskActive = failoverAccounts.length > 0 && this.config.accountFailover === "ask" && !compactionMode && // A `doGenerate` caller takes the override and reports the plain
     // rate-limit error, never the form. See `TurnMode`.
     mode !== "generate" && isAccountFailoverQuestionActive({
       configured: this.config.accountFailover,
       candidates: failoverAccounts,
       opencodeHasQuestion: (await loadLiveToolInfo()).hasQuestion,
       compactionMode,
-      interactive: !!useInteractive,
       // A subagent follows its parent's account for free, because the
       // override is account-scoped. Asking it would put a form in a session
       // the operator is usually not even looking at.
@@ -13773,7 +13937,7 @@ var ClaudeCodeLanguageModel = class {
               }
               if (interactiveBypassRequested) {
                 log.warn(
-                  "interactiveBypass ignored: Claude Code prompts for bypassPermissions confirmation in the interactive TUI"
+                  "interactiveBypass is ignored: skipPermissions governs the interactive transport too"
                 );
               }
               const skillPluginDirs = await resolveSkillPluginDirs({
@@ -13787,13 +13951,19 @@ var ClaudeCodeLanguageModel = class {
               const posture = interactivePermissionPosture({
                 permissionMode: self.config.permissionMode,
                 allow,
-                supportsReadOnly: ptyReadOnlySupported
+                supportsReadOnly: ptyReadOnlySupported,
+                skipPermissions: self.config.skipPermissions,
+                controlRequestBehavior: self.config.controlRequestBehavior,
+                controlRequestToolBehaviors: self.config.controlRequestToolBehaviors,
+                supportsBypass: ptyBypassSupported
               });
               if (!posture) throw new Error("the interactive transport cannot hold this permission posture");
               const ap = spawnInteractiveProcess({
                 cwd,
                 cliPath,
-                configDir: self.config.configDir,
+                // On an account switch, the other account's directory: the
+                // TUI writes its transcript there (h #g209).
+                configDir: self.skillBridgeSpawn(failover).configDir,
                 model: spawnModelId,
                 fastMode,
                 mcpConfigPaths: mcp.paths,
@@ -13801,19 +13971,26 @@ var ClaudeCodeLanguageModel = class {
                 permissionsAllow: posture.allow,
                 permissionMode: posture.permissionMode,
                 restricted: posture.restricted,
-                disallowedTools: wiring.allDisallowed,
+                bypass: posture.bypass,
+                disallowedTools: [...wiring.allDisallowed, ...posture.disallowed],
                 proxyServer: state.proxyServer,
                 systemPromptFile,
                 ignoreAnthropicApiKey: self.config.ignoreAnthropicApiKey,
                 effort: reasoningEffort,
                 resumeSessionId,
+                // A fork of a conversation already served (`forkSessions`):
+                // the TUI branches it instead of the history being replayed.
+                ...forkFromClaudeSessionId && !resumeSessionId ? { forkOf: forkFromClaudeSessionId } : {},
                 // The headless spawn's env, so hygiene, effort and the
-                // agent's prompt cache TTL reach both transports alike.
-                env: claudeSpawnEnv({
-                  ignoreAnthropicApiKey: self.config.ignoreAnthropicApiKey,
-                  effort: reasoningEffort,
-                  promptCacheTtl
-                })
+                // agent's prompt cache TTL reach both transports alike, plus
+                // what keeps a proxied call in the foreground (h #g210).
+                env: interactiveSpawnEnv2(
+                  claudeSpawnEnv({
+                    ignoreAnthropicApiKey: self.config.ignoreAnthropicApiKey,
+                    effort: reasoningEffort,
+                    promptCacheTtl
+                  })
+                )
               });
               ap.proc.once(
                 "exit",
@@ -13821,6 +13998,7 @@ var ClaudeCodeLanguageModel = class {
               );
               ap.mcpHash = mcp.bridgedHash;
               ap.mcpServers = mcp.allEnabledServerNames;
+              ap.cliPath = cliPath;
               setActiveProcess(sk, ap);
               state.proc = ap.proc;
               state.lineEmitter = ap.lineEmitter;
@@ -13828,6 +14006,7 @@ var ClaudeCodeLanguageModel = class {
               log.info("spawned interactive claude session", {
                 sk,
                 resumed: !!resumeSessionId,
+                forked: !!forkFromClaudeSessionId && !resumeSessionId,
                 cliPath,
                 configDir: self.config.configDir,
                 model: effectiveModelId
@@ -14042,7 +14221,8 @@ var ClaudeCodeLanguageModel = class {
                   sourceAccount,
                   candidates: failoverAccounts,
                   resetsAt: state.accountLimitHit?.resetsAt,
-                  window: state.accountLimitHit?.window
+                  window: state.accountLimitHit?.window,
+                  resetsText: state.accountLimitHit?.resetsText
                 })
               });
               state.endTextBlock();
@@ -14332,9 +14512,10 @@ var ClaudeCodeLanguageModel = class {
           state.proc.on("error", procErrorHandler);
           if (hasMatchedPendingResults) {
             state.cliAskedForWork = true;
-            const forwardTrailingUserMessages = () => {
+            const forwardTrailingUserMessages = async () => {
               if (compactionMode || !state.activeProcess) return 0;
-              if (state.activeProcess.interactiveControl) return 0;
+              const control = state.activeProcess.interactiveControl;
+              if (control && (!control.queueInput || !control.turnRunning())) return 0;
               const trailing = getTrailingUserMessages(effectivePrompt, {
                 stripContextReminders: self.stripContextRemindersEnabled()
               });
@@ -14345,6 +14526,21 @@ var ClaudeCodeLanguageModel = class {
                 assistantIndex: trailing.assistantIndex,
                 count: trailing.messages.length
               };
+              if (control) {
+                let queued = 0;
+                for (const content of fresh) if (await control.queueInput(content)) queued++;
+                if (queued < fresh.length) {
+                  log.warn("the interactive turn did not take a forwarded user message", {
+                    sessionKey: sk,
+                    messages: fresh.length - queued
+                  });
+                }
+                log.info("forwarded user messages into the interactive turn's input queue", {
+                  sessionKey: sk,
+                  messages: queued
+                });
+                return queued;
+              }
               for (const content of fresh) {
                 state.proc.stdin?.write(
                   JSON.stringify({ type: "user", message: { role: "user", content } }) + "\n"
@@ -14356,7 +14552,7 @@ var ClaudeCodeLanguageModel = class {
               });
               return fresh.length;
             };
-            if (!state.unattendedTurnEnded && forwardTrailingUserMessages() > 0) {
+            if (!state.unattendedTurnEnded && await forwardTrailingUserMessages() > 0) {
               await new Promise((resolve6) => setTimeout(resolve6, FORWARD_SETTLE_MS));
               if (state.controllerClosed) return;
             }
@@ -14391,7 +14587,7 @@ var ClaudeCodeLanguageModel = class {
             }
             if (state.unattendedTurnEnded) {
               deliverPendingCompletions(state);
-              forwardTrailingUserMessages();
+              await forwardTrailingUserMessages();
             }
             const unemitted = getPendingProxyCalls(sk).filter(
               (call) => !call.emitted