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

package/dist/index.js

@@ -1728,6 +1728,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);
@@ -4887,6 +4924,9 @@ function noteInteractiveProcessExit(sessionKey2, ap, code) {
   if (activeProcesses.get(sessionKey2) !== ap) return;
   cancelIdleProcessEviction(sessionKey2);
   activeProcesses.delete(sessionKey2);
+  if (getPendingProxyCalls(sessionKey2).length > 0) {
+    rejectAllPendingProxyCallsForSession(sessionKey2, new Error(CHILD_EXITED_MESSAGE));
+  }
   if (code !== 0 && code !== null) {
     claudeSessions.delete(sessionKey2);
     forgetResumePoint(sessionKey2);
@@ -6333,6 +6373,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,
@@ -8052,6 +8096,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) {
@@ -8772,6 +8819,8 @@ var ClaudeSession = class {
   trustMoves = 0;
   trustMovedAt = 0;
   turn = null;
+  /** The running turn's read state, shared with `flushTranscript`. */
+  scan = null;
   turnDenied = [];
   abandonTurn = false;
   o;
@@ -9084,67 +9133,103 @@ var ClaudeSession = class {
         this.proc.terminal.write(prompt);
       }
       await this.submitTurn();
-      let stopReason = null;
-      let stopSeenAt = 0;
-      let end = null;
-      let sawUserRecord = false;
-      let lastBeat = Date.now();
+      const scan = {
+        onRecord,
+        stopReason: null,
+        stopSeenAt: 0,
+        end: null,
+        sawUserRecord: false,
+        lastBeat: Date.now()
+      };
+      this.scan = scan;
       const deadline = Date.now() + timeout;
       while (Date.now() < deadline) {
         await delay(this.o.pollMs);
         if (this.aborted) throw new Error("aborted mid-turn");
         const fatalNow = this.fatalError();
         if (fatalNow) throw fatalNow;
-        const lines = this.readRawLines();
-        const lastComplete = lines.length - 1;
-        if (lastComplete > this.cursor) {
-          for (let i = this.cursor; i < lastComplete && !end; i++) {
-            const s = lines[i];
-            if (!s || !s.trim()) continue;
-            let rec = null;
-            try {
-              rec = JSON.parse(s);
-            } catch {
-            }
-            onRecord(s, rec);
-            if (!rec) continue;
-            if (rec.type === "assistant" && rec.message) {
-              const reason = rec.message.stop_reason;
-              if (typeof reason === "string") {
-                stopReason = TERMINAL_STOP.has(reason) ? reason : null;
-              }
-            } else if (rec.type === "user") {
-              if (sawUserRecord && isInterruptRecord(rec)) end = "interrupted";
-              sawUserRecord = true;
-            } else if ((sawUserRecord || stopReason) && isTurnDurationRecord(rec)) {
-              end = stopReason ? "stop" : "ended";
-            }
-            this.cursor = i + 1;
+        if (this.scanTranscript() || scan.end) {
+          if (scan.end) {
+            return {
+              stopReason: scan.end === "stop" ? scan.stopReason : null,
+              end: scan.end,
+              denied: this.turnDenied
+            };
           }
-          if (!end) this.cursor = lastComplete;
-          lastBeat = Date.now();
-          stopSeenAt = Date.now();
-          if (end) return { stopReason: end === "stop" ? stopReason : null, end, denied: this.turnDenied };
           continue;
         }
-        if (stopReason && Date.now() - stopSeenAt >= this.o.stopSettleMs) {
-          return { stopReason, end: "stop", denied: this.turnDenied };
+        if (scan.stopReason && Date.now() - scan.stopSeenAt >= this.o.stopSettleMs) {
+          return { stopReason: scan.stopReason, end: "stop", 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();
-        if (onHeartbeat && now - lastBeat >= this.o.heartbeatMs) {
-          lastBeat = now;
+        if (onHeartbeat && now - scan.lastBeat >= this.o.heartbeatMs) {
+          scan.lastBeat = now;
           if (now - this.lastDataAt < this.o.heartbeatMs) onHeartbeat();
         }
       }
       return { stopReason: null, end: null, denied: this.turnDenied };
     } finally {
       this.turn = null;
+      this.scan = null;
       this.abandonTurn = false;
       settle();
     }
   }
+  /**
+   * Read every complete transcript record past the cursor into the running
+   * turn. Returns whether anything new was read. The one place a record is
+   * interpreted, shared by the poll loop and `flushTranscript`.
+   */
+  scanTranscript() {
+    const scan = this.scan;
+    if (!scan || scan.end) return false;
+    const lines = this.readRawLines();
+    const lastComplete = lines.length - 1;
+    if (lastComplete <= this.cursor) return false;
+    for (let i = this.cursor; i < lastComplete && !scan.end; i++) {
+      const s = lines[i];
+      if (!s || !s.trim()) {
+        this.cursor = i + 1;
+        continue;
+      }
+      let rec = null;
+      try {
+        rec = JSON.parse(s);
+      } catch {
+      }
+      scan.onRecord(s, rec);
+      if (rec) {
+        if (rec.type === "assistant" && rec.message) {
+          const reason = rec.message.stop_reason;
+          if (typeof reason === "string") {
+            scan.stopReason = TERMINAL_STOP.has(reason) ? reason : null;
+          }
+        } else if (rec.type === "user") {
+          if (scan.sawUserRecord && isInterruptRecord(rec)) scan.end = "interrupted";
+          scan.sawUserRecord = true;
+        } else if ((scan.sawUserRecord || scan.stopReason) && isTurnDurationRecord(rec)) {
+          scan.end = scan.stopReason ? "stop" : "ended";
+        }
+      }
+      this.cursor = i + 1;
+    }
+    if (!scan.end) this.cursor = lastComplete;
+    scan.lastBeat = Date.now();
+    scan.stopSeenAt = Date.now();
+    return true;
+  }
+  /**
+   * Hand the running turn every record the TUI has already written, now
+   * rather than at the next poll. The TUI writes a reply's records before it
+   * runs the reply's tools, but a proxied tool's MCP call can reach the
+   * plugin inside one poll interval, and the step it ends must not close
+   * before the text that preceded the call was read. No-op between turns.
+   */
+  flushTranscript() {
+    this.scanTranscript();
+  }
   /**
    * 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
@@ -9309,6 +9394,7 @@ ${text}`
 }
 function interactiveExtraArgs(opts) {
   const extraArgs = [];
+  if (opts.tools) extraArgs.push("--tools", opts.tools.join(","));
   if (opts.mcpConfigPaths && opts.mcpConfigPaths.length > 0) {
     extraArgs.push(
       "--mcp-config",
@@ -9316,6 +9402,9 @@ function interactiveExtraArgs(opts) {
       "--strict-mcp-config"
     );
   }
+  if (opts.disallowedTools && opts.disallowedTools.length > 0) {
+    extraArgs.push("--disallowedTools", ...opts.disallowedTools);
+  }
   for (const dir of opts.pluginDirs ?? []) {
     extraArgs.push("--plugin-dir", dir);
   }
@@ -9415,12 +9504,30 @@ function interactiveResultFrame(opts) {
     duration_ms: 0
   });
 }
+function carriesReplyText(line) {
+  try {
+    const rec = JSON.parse(line);
+    if (rec?.type !== "assistant" || !Array.isArray(rec.message?.content)) return false;
+    return rec.message.content.some(
+      (block) => block?.type === "text" && typeof block.text === "string" && block.text.trim()
+    );
+  } catch {
+    return false;
+  }
+}
 function spawnInteractiveProcess(opts) {
   const extraArgs = interactiveExtraArgs(opts);
   const openCalls = new OpenToolCalls();
   let denials = [];
   const lineEmitter = new EventEmitter4();
   const proc = new EventEmitter4();
+  let ap;
+  let proxyClosed = false;
+  const closeProxyServer = () => {
+    if (proxyClosed || !opts.proxyServer) return;
+    proxyClosed = true;
+    void opts.proxyServer.close();
+  };
   const session = new ClaudeSession({
     ...opts.tuning,
     cwd: opts.cwd,
@@ -9450,6 +9557,7 @@ function spawnInteractiveProcess(opts) {
     onExit: (code) => {
       proc.exitCode = code;
       proc.signalCode = code === null ? "SIGTERM" : null;
+      closeProxyServer();
       log.info("interactive claude exited", { sessionId: session.sessionId, code });
       proc.emit("exit", proc.exitCode, proc.signalCode);
       proc.emit("close", proc.exitCode, proc.signalCode);
@@ -9477,7 +9585,12 @@ function spawnInteractiveProcess(opts) {
   const runTurn = async (userMsg, turnNumber) => {
     const current = () => turnNumber === writes;
     const emit2 = (line) => {
-      if (current()) lineEmitter.emit("line", line);
+      if (!current()) return;
+      if (lineEmitter.listenerCount("line") === 0) {
+        if (carriesReplyText(line)) bufferUnattendedLine(ap, line);
+        return;
+      }
+      lineEmitter.emit("line", line);
     };
     try {
       await ensureStarted();
@@ -9497,7 +9610,13 @@ function spawnInteractiveProcess(opts) {
           emit2(raw);
         },
         void 0,
-        () => emit2(heartbeatFrame(session.sessionId, openCalls.newest()))
+        // Only to a listening turn: it feeds that turn's watchdog, and the
+        // TUI redraws its spinner the whole time it waits on a proxied call.
+        () => {
+          if (lineEmitter.listenerCount("line") > 0) {
+            emit2(heartbeatFrame(session.sessionId, openCalls.newest()));
+          }
+        }
       );
       log.info("interactive turn ended", {
         end,
@@ -9570,6 +9689,7 @@ function spawnInteractiveProcess(opts) {
           });
         }
       }
+      closeProxyServer();
       const started = startPromise !== null;
       try {
         session.dispose();
@@ -9583,11 +9703,13 @@ function spawnInteractiveProcess(opts) {
       return true;
     }
   });
-  return {
+  ap = {
     proc,
     lineEmitter,
-    proxyServer: null,
+    proxyServer: opts.proxyServer ?? null,
     mcpHash: void 0,
+    unattendedLines: [],
+    unattendedDropped: 0,
     systemPromptFile: opts.systemPromptFile,
     cliPath: opts.cliPath,
     interactiveControl: {
@@ -9597,9 +9719,37 @@ function spawnInteractiveProcess(opts) {
       interrupt: (timeoutMs) => {
         cancelledThrough = writes;
         return session.interrupt(timeoutMs);
-      }
+      },
+      flushTranscript: () => session.flushTranscript()
     }
   };
+  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
@@ -11162,6 +11312,8 @@ function drainNow(state) {
   }
   if (state.drainBuffer.length === 0) return;
   if (state.controllerClosed) return;
+  state.activeProcess?.interactiveControl?.flushTranscript();
+  if (state.controllerClosed) return;
   const batch = state.drainBuffer.splice(0, state.drainBuffer.length);
   log.info("draining pending proxy calls into stream finish", {
     sessionKey: state.sessionKey,
@@ -12468,8 +12620,14 @@ 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";
+    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(
@@ -12485,7 +12643,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,
@@ -12605,7 +12762,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) {
@@ -12778,6 +12935,7 @@ 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()
     });
@@ -13015,13 +13173,159 @@ var ClaudeCodeLanguageModel = class {
               state.proxyServer = null;
             }
           }
-          if (useInteractive && !compactionMode) {
-            const mcp = self.effectiveMcpConfig(cwd, void 0, runtimeStatus);
+          const resolveProxyWiring = async () => {
+            const discovery = self.effectiveMcpConfig(
+              cwd,
+              void 0,
+              runtimeStatus
+            );
+            const mcpResolution = self.resolvedProxyMcpTools(
+              discovery.allEnabledServerNames,
+              options.tools,
+              new Set((resolvedProxy ?? []).map((def) => def.name))
+            );
+            const proxyMcpTools = mcpResolution?.defs ?? null;
+            const excludeServers = mcpResolution ? mcpResolution.coveredServers : void 0;
+            const taskProxyEnabled = resolvedProxy?.some((t) => t.name === "task") ?? false;
+            const questionProxyEnabled = resolvedProxy?.some((t) => t.name === "question") ?? false;
+            const opencodeToolsRequested = (self.config.proxyOpencodeTools?.length ?? 0) > 0;
+            log.debug("opencode tool forwarding gate", {
+              requested: self.config.proxyOpencodeTools ?? null,
+              opencodeToolsRequested
+            });
+            const liveToolInfo = taskProxyEnabled || questionProxyEnabled || opencodeToolsRequested ? await loadLiveToolInfo() : {
+              resolved: false,
+              taskDescription: void 0,
+              taskParameters: void 0,
+              questionDescription: void 0,
+              hasQuestion: false
+            };
+            let enrichedProxy = resolvedProxy;
+            let backgroundSubagentsSupported = false;
+            if (enrichedProxy && taskProxyEnabled) {
+              enrichedProxy = overlayTaskProxyDescription(
+                enrichedProxy,
+                liveToolInfo.taskDescription
+              );
+              log.info("task proxy description overlay", {
+                applied: Boolean(liveToolInfo.taskDescription),
+                liveDescriptionLength: liveToolInfo.taskDescription?.length ?? 0,
+                listsAgentTypes: Boolean(
+                  liveToolInfo.taskDescription?.includes(
+                    "Available agent types"
+                  )
+                )
+              });
+              const hostDialect = self.config.hostApi === "v2" ? "v2" : "v1";
+              backgroundSubagentsSupported = liveTaskSupportsBackground(
+                liveToolInfo.taskParameters,
+                hostDialect
+              );
+              enrichedProxy = applyBackgroundSubagentSupport(
+                enrichedProxy,
+                backgroundSubagentsSupported,
+                hostDialect
+              );
+              recordBackgroundSubagentGate({
+                supported: backgroundSubagentsSupported,
+                hostApi: hostDialect,
+                registryResolved: liveToolInfo.resolved
+              });
+              log.info("background subagent gate", {
+                supported: backgroundSubagentsSupported,
+                registryResolved: liveToolInfo.resolved,
+                hostApi: hostDialect,
+                note: backgroundSubagentsSupported ? "task accepts `background`; task_status and task_cancel are registered" : "`background` stripped from the task schema; set OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true in opencode's environment to enable it"
+              });
+            }
+            if (enrichedProxy && questionProxyEnabled) {
+              enrichedProxy = overlayQuestionProxyDescription(
+                enrichedProxy,
+                liveToolInfo.hasQuestion ? liveToolInfo.questionDescription : void 0
+              );
+              enrichedProxy = filterQuestionProxyByOpencodeSupport(
+                enrichedProxy,
+                liveToolInfo.hasQuestion
+              );
+              log.info("question proxy version gate", {
+                opencodeHasQuestion: liveToolInfo.hasQuestion,
+                kept: liveToolInfo.hasQuestion
+              });
+            }
+            const opencodeToolDefs = resolveProxyOpencodeToolDefs({
+              requested: self.config.proxyOpencodeTools,
+              items: liveToolInfo.items,
+              modelTools: self.config.hostApi === "v2" ? options.tools ?? [] : void 0,
+              allowCodeExecution: self.config.permissionPreset !== "read-only",
+              taken: new Set(
+                [...enrichedProxy ?? [], ...proxyMcpTools ?? []].map(
+                  (t) => t.name
+                )
+              )
+            });
+            if (opencodeToolDefs.length > 0) {
+              log.info("forwarding opencode tools through the proxy", {
+                tools: opencodeToolDefs.map((t) => t.name)
+              });
+            }
+            const combinedList = [
+              ...enrichedProxy ?? [],
+              ...proxyMcpTools ?? [],
+              ...opencodeToolDefs
+            ];
+            const combinedProxyTools = combinedList.length > 0 ? combinedList : null;
+            const pluginCompressEnabled = enrichedProxy?.some((t) => t.name === "compress") ?? false;
+            if (!state.proxyServer && combinedProxyTools) {
+              state.proxyServer = await self.ensureProxyServer(
+                combinedProxyTools,
+                sk,
+                pluginCompressEnabled,
+                affinity
+              );
+            }
+            const questionProxyActive = enrichedProxy?.some((t) => t.name === "question") ?? false;
+            const allDisallowed = resolveDisallowedTools({
+              proxyTools: enrichedProxy,
+              extraDisallowedTools: self.config.extraDisallowedTools,
+              disableWebSearch: self.config.webSearch === "disabled"
+            });
+            return {
+              excludeServers,
+              taskProxyEnabled,
+              backgroundSubagentsSupported,
+              questionProxyActive,
+              opencodeToolDefs,
+              pluginCompressEnabled,
+              allDisallowed
+            };
+          };
+          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;
               log.debug("reusing active interactive session", { sk });
             } else {
+              const wiring = await resolveProxyWiring();
+              const mcp = self.effectiveMcpConfig(
+                cwd,
+                state.proxyServer?.configPath(),
+                runtimeStatus,
+                wiring.excludeServers
+              );
               const allow = [
                 ...mcp.allEnabledServerNames.map((n) => `mcp__${n}__*`),
                 "mcp__opencode_proxy__*",
@@ -13035,12 +13339,27 @@ var ClaudeCodeLanguageModel = class {
               ];
               const systemPromptFile = self.config.interactiveSystemPrompt === false ? void 0 : buildAppendedSystemPrompt(
                 cwd,
-                self.config.multiStepContinuation !== false
+                self.config.multiStepContinuation !== false,
                 // Do not forward opencode's own system prompt into the
                 // interactive TUI. Live subscription-account testing
                 // showed that large forwarded payload can trigger Claude
                 // Code's third-party-app usage gate, while our static
-                // CLI/AGENTS/continuation prompt remains safe.
+                // CLI/AGENTS/continuation prompt remains safe. The
+                // plugin's own short proxy hints are part of that static
+                // prompt: without them the model narrates a subagent
+                // dispatch instead of calling the proxy (h #g74).
+                [
+                  ...wiring.taskProxyEnabled ? [SUBAGENT_DISPATCH_HINT] : [],
+                  ...wiring.backgroundSubagentsSupported ? [BACKGROUND_SUBAGENT_HINT] : [],
+                  ...wiring.questionProxyActive ? [QUESTION_PROXY_HINT] : []
+                ],
+                {
+                  compressEnabled: wiring.pluginCompressEnabled,
+                  opencodeCompressEnabled: wiring.opencodeToolDefs.some(
+                    (t) => t.name === "compress"
+                  ),
+                  compressionSummary: getCompressionSummary(sk)
+                }
               );
               if (self.config.interactiveSystemPrompt === false) {
                 log.warn(
@@ -13069,6 +13388,8 @@ var ClaudeCodeLanguageModel = class {
                 mcpConfigPaths: mcp.paths,
                 pluginDirs: skillPluginDirs,
                 permissionsAllow: allow,
+                disallowedTools: wiring.allDisallowed,
+                proxyServer: state.proxyServer,
                 systemPromptFile,
                 ignoreAnthropicApiKey: self.config.ignoreAnthropicApiKey,
                 effort: reasoningEffort,
@@ -13115,121 +13436,15 @@ var ClaudeCodeLanguageModel = class {
                 cliVersion
               });
             } else {
-              const discovery = self.effectiveMcpConfig(
-                cwd,
-                void 0,
-                runtimeStatus
-              );
-              const mcpResolution = self.resolvedProxyMcpTools(
-                discovery.allEnabledServerNames,
-                options.tools,
-                new Set((resolvedProxy ?? []).map((def) => def.name))
-              );
-              const proxyMcpTools = mcpResolution?.defs ?? null;
-              const excludeServers = mcpResolution ? mcpResolution.coveredServers : void 0;
-              const taskProxyEnabled = resolvedProxy?.some((t) => t.name === "task") ?? false;
-              const questionProxyEnabled = resolvedProxy?.some((t) => t.name === "question") ?? false;
-              const opencodeToolsRequested = (self.config.proxyOpencodeTools?.length ?? 0) > 0;
-              log.debug("opencode tool forwarding gate", {
-                requested: self.config.proxyOpencodeTools ?? null,
-                opencodeToolsRequested
-              });
-              const liveToolInfo = taskProxyEnabled || questionProxyEnabled || opencodeToolsRequested ? await loadLiveToolInfo() : {
-                resolved: false,
-                taskDescription: void 0,
-                taskParameters: void 0,
-                questionDescription: void 0,
-                hasQuestion: false
-              };
-              let enrichedProxy = resolvedProxy;
-              let backgroundSubagentsSupported = false;
-              if (enrichedProxy && taskProxyEnabled) {
-                enrichedProxy = overlayTaskProxyDescription(
-                  enrichedProxy,
-                  liveToolInfo.taskDescription
-                );
-                log.info("task proxy description overlay", {
-                  applied: Boolean(liveToolInfo.taskDescription),
-                  liveDescriptionLength: liveToolInfo.taskDescription?.length ?? 0,
-                  listsAgentTypes: Boolean(
-                    liveToolInfo.taskDescription?.includes(
-                      "Available agent types"
-                    )
-                  )
-                });
-                const hostDialect = self.config.hostApi === "v2" ? "v2" : "v1";
-                backgroundSubagentsSupported = liveTaskSupportsBackground(
-                  liveToolInfo.taskParameters,
-                  hostDialect
-                );
-                enrichedProxy = applyBackgroundSubagentSupport(
-                  enrichedProxy,
-                  backgroundSubagentsSupported,
-                  hostDialect
-                );
-                recordBackgroundSubagentGate({
-                  supported: backgroundSubagentsSupported,
-                  hostApi: hostDialect,
-                  registryResolved: liveToolInfo.resolved
-                });
-                log.info("background subagent gate", {
-                  supported: backgroundSubagentsSupported,
-                  registryResolved: liveToolInfo.resolved,
-                  hostApi: hostDialect,
-                  note: backgroundSubagentsSupported ? "task accepts `background`; task_status and task_cancel are registered" : "`background` stripped from the task schema; set OPENCODE_EXPERIMENTAL_BACKGROUND_SUBAGENTS=true in opencode's environment to enable it"
-                });
-              }
-              if (enrichedProxy && questionProxyEnabled) {
-                enrichedProxy = overlayQuestionProxyDescription(
-                  enrichedProxy,
-                  liveToolInfo.hasQuestion ? liveToolInfo.questionDescription : void 0
-                );
-                enrichedProxy = filterQuestionProxyByOpencodeSupport(
-                  enrichedProxy,
-                  liveToolInfo.hasQuestion
-                );
-                log.info("question proxy version gate", {
-                  opencodeHasQuestion: liveToolInfo.hasQuestion,
-                  kept: liveToolInfo.hasQuestion
-                });
-              }
-              const opencodeToolDefs = resolveProxyOpencodeToolDefs({
-                requested: self.config.proxyOpencodeTools,
-                items: liveToolInfo.items,
-                modelTools: self.config.hostApi === "v2" ? options.tools ?? [] : void 0,
-                allowCodeExecution: self.config.permissionPreset !== "read-only",
-                taken: new Set(
-                  [...enrichedProxy ?? [], ...proxyMcpTools ?? []].map(
-                    (t) => t.name
-                  )
-                )
-              });
-              if (opencodeToolDefs.length > 0) {
-                log.info("forwarding opencode tools through the proxy", {
-                  tools: opencodeToolDefs.map((t) => t.name)
-                });
-              }
-              const combinedList = [
-                ...enrichedProxy ?? [],
-                ...proxyMcpTools ?? [],
-                ...opencodeToolDefs
-              ];
-              const combinedProxyTools = combinedList.length > 0 ? combinedList : null;
-              const pluginCompressEnabled = enrichedProxy?.some((t) => t.name === "compress") ?? false;
-              if (!state.proxyServer && combinedProxyTools) {
-                state.proxyServer = await self.ensureProxyServer(
-                  combinedProxyTools,
-                  sk,
-                  pluginCompressEnabled,
-                  affinity
-                );
-              }
-              const questionProxyActive = enrichedProxy?.some((t) => t.name === "question") ?? false;
-              const allDisallowed = resolveDisallowedTools({
-                proxyTools: enrichedProxy,
-                extraDisallowedTools: self.config.extraDisallowedTools,
-                disableWebSearch: self.config.webSearch === "disabled"
-              });
+              const {
+                excludeServers,
+                taskProxyEnabled,
+                backgroundSubagentsSupported,
+                questionProxyActive,
+                opencodeToolDefs,
+                pluginCompressEnabled,
+                allDisallowed
+              } = await resolveProxyWiring();
               const mcp = self.effectiveMcpConfig(
                 cwd,
                 state.proxyServer?.configPath(),
@@ -13582,6 +13797,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 });
@@ -14595,6 +14811,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,