@khalilgharbaoui/opencode-claude-code-plugin 0.12.0 → 0.13.0

package/dist/index.js

@@ -393,7 +393,7 @@ var SUPPORTED_IMAGE_TYPES = /* @__PURE__ */ new Set([
   "image/webp"
 ]);
 function toImageBlock(part) {
-  const raw = part.data ?? part.url ?? part.source?.data;
+  const raw = part.image ?? part.data ?? part.url ?? part.source?.data;
   if (!raw) {
     log.warn("file part without data, skipping");
     return null;
@@ -728,6 +728,161 @@ Now continuing with the current message:
   });
 }
 
+// src/plan-mode-question.ts
+var QUESTION_TOOL_NAME = "question";
+var APPROVED_EXIT_PLAN_MODE_MESSAGE = "User has approved your plan. You can now start coding. Start with updating your todo list if applicable.";
+var REJECTED_EXIT_PLAN_MODE_PREFIX = "The user doesn't want to proceed with this tool use. The tool use was rejected. To tell you how to proceed, the user said:";
+var PLAN_MODE_APPROVAL_QUESTION = "Do you want to proceed with this plan?";
+var OPENCODE_QUESTION_RESULT_PREFIX = `User has answered your questions: "${PLAN_MODE_APPROVAL_QUESTION}"="`;
+var OPENCODE_QUESTION_RESULT_SUFFIX = `". You can now continue with the user's answers in mind.`;
+var KEY_SEPARATOR = "\0";
+function isPlanModeQuestionActive(input) {
+  if (input.compactionMode) return false;
+  if (input.configured !== true) return false;
+  return input.opencodeHasQuestion;
+}
+var pendingQuestions = /* @__PURE__ */ new Map();
+function pendingKey(sessionKey2, questionToolCallId) {
+  return `${sessionKey2}${KEY_SEPARATOR}${questionToolCallId}`;
+}
+function clearExitPlanModeQuestions(sessionKey2) {
+  const prefix = `${sessionKey2}${KEY_SEPARATOR}`;
+  for (const key of pendingQuestions.keys()) {
+    if (key.startsWith(prefix)) pendingQuestions.delete(key);
+  }
+}
+function createExitPlanModeQuestionCall(sessionKey2, exitPlanModeToolUseId, plan, questionToolCallId = `exit_plan_question_${exitPlanModeToolUseId}`) {
+  pendingQuestions.set(pendingKey(sessionKey2, questionToolCallId), exitPlanModeToolUseId);
+  return {
+    toolCallId: questionToolCallId,
+    toolName: QUESTION_TOOL_NAME,
+    input: {
+      questions: [
+        {
+          header: "Plan approval",
+          question: PLAN_MODE_APPROVAL_QUESTION,
+          options: [
+            { label: "yes", description: "" },
+            { label: "no", description: "" }
+          ],
+          multiple: false,
+          custom: true
+        }
+      ]
+    },
+    text: plan ? `
+
+${plan}
+` : "\n\n"
+  };
+}
+function buildToolResultMessage(input) {
+  return JSON.stringify({
+    type: "user",
+    message: {
+      role: "user",
+      content: [
+        input.approved ? {
+          type: "tool_result",
+          tool_use_id: input.toolUseId,
+          content: APPROVED_EXIT_PLAN_MODE_MESSAGE
+        } : {
+          type: "tool_result",
+          tool_use_id: input.toolUseId,
+          content: `${REJECTED_EXIT_PLAN_MODE_PREFIX}
+${input.feedback || "no"}`,
+          is_error: true
+        }
+      ]
+    }
+  });
+}
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function unwrapToolOutput(part) {
+  const output = part?.output ?? part?.result;
+  if (typeof output === "string") return tryParseJson(output);
+  if (!output || typeof output !== "object") return output;
+  switch (output.type) {
+    case "json":
+    case "error-json":
+      return output.value;
+    case "text":
+    case "error-text":
+      return tryParseJson(String(output.value ?? ""));
+    case "execution-denied":
+      return {
+        denied: true,
+        reason: String(output.reason ?? "question rejected")
+      };
+    case "content":
+      return Array.isArray(output.value) ? output.value.map((item) => {
+        if (item?.type === "text") return item.text;
+        return JSON.stringify(item);
+      }).join("\n") : output.value;
+    default:
+      return output;
+  }
+}
+function unwrapOpencodeQuestionResult(value) {
+  if (value.startsWith(OPENCODE_QUESTION_RESULT_PREFIX) && value.endsWith(OPENCODE_QUESTION_RESULT_SUFFIX)) {
+    return value.slice(
+      OPENCODE_QUESTION_RESULT_PREFIX.length,
+      -OPENCODE_QUESTION_RESULT_SUFFIX.length
+    );
+  }
+  return value;
+}
+function collectAnswerStrings(value) {
+  if (typeof value === "string") return [unwrapOpencodeQuestionResult(value)];
+  if (Array.isArray(value)) return value.flatMap(collectAnswerStrings);
+  if (!value || typeof value !== "object") return [];
+  const obj = value;
+  if (obj.denied === true) return [String(obj.reason ?? "question rejected")];
+  for (const key of ["answers", "answer", "selected", "selection", "value"]) {
+    if (key in obj) return collectAnswerStrings(obj[key]);
+  }
+  return [];
+}
+function classifyQuestionResult(part) {
+  const output = unwrapToolOutput(part);
+  const answers = collectAnswerStrings(output).map((answer) => answer.trim()).filter(Boolean);
+  if (answers.length === 1 && answers[0].toLowerCase() === "yes") {
+    return { approved: true, feedback: "" };
+  }
+  return {
+    approved: false,
+    feedback: answers.length > 0 ? answers.join("\n") : "no"
+  };
+}
+function consumeExitPlanModeQuestionResult(sessionKey2, prompt) {
+  for (let i = prompt.length - 1; i >= 0; i--) {
+    const msg = prompt[i];
+    if (!Array.isArray(msg.content)) continue;
+    for (const part of msg.content) {
+      if (part?.type !== "tool-result" || typeof part.toolCallId !== "string") {
+        continue;
+      }
+      const key = pendingKey(sessionKey2, part.toolCallId);
+      const exitPlanModeToolUseId = pendingQuestions.get(key);
+      if (!exitPlanModeToolUseId) continue;
+      pendingQuestions.delete(key);
+      const result = classifyQuestionResult(part);
+      return buildToolResultMessage({
+        toolUseId: exitPlanModeToolUseId,
+        approved: result.approved,
+        feedback: result.feedback
+      });
+    }
+  }
+  return null;
+}
+
 // src/mcp-bridge.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
@@ -1341,6 +1496,7 @@ function setClaudeSessionId(key, sessionId) {
   claudeSessions.set(key, sessionId);
 }
 function deleteClaudeSessionId(key) {
+  clearExitPlanModeQuestions(key);
   const claudeSessionId = claudeSessions.get(key);
   if (claudeSessionId) clearLedger(claudeSessionId);
   claudeSessions.delete(key);
@@ -2056,6 +2212,31 @@ function spawnInteractiveProcess(opts) {
   };
 }
 
+// src/compression-store.ts
+var MAX_COMPRESSION_ENTRIES = 32;
+var compressions = /* @__PURE__ */ new Map();
+function storeCompressionSummary(sessionKey2, summary) {
+  compressions.set(sessionKey2, { summary, restartPending: true });
+  while (compressions.size > MAX_COMPRESSION_ENTRIES) {
+    const oldest = compressions.keys().next();
+    if (oldest.done) break;
+    compressions.delete(oldest.value);
+    log.info("compression store evicted oldest entry", { sessionKey: oldest.value });
+  }
+}
+function getCompressionSummary(sessionKey2) {
+  return compressions.get(sessionKey2)?.summary;
+}
+function consumeCompressionRestart(sessionKey2) {
+  const state = compressions.get(sessionKey2);
+  if (!state?.restartPending) return false;
+  state.restartPending = false;
+  return true;
+}
+function clearCompression(sessionKey2) {
+  compressions.delete(sessionKey2);
+}
+
 // src/proxy-mcp.ts
 import { createServer } from "http";
 import * as fs4 from "fs";
@@ -2123,6 +2304,7 @@ var TASK_PROXY_NOTE = "This is the ONLY tool that dispatches opencode subagents
 var AGENT_TYPES_HEADING = "Available agent types";
 var AGENT_BLURB_LIMIT = 140;
 var QUESTION_PROXY_NOTE = "This routes structured questions through opencode's native `question` tool, which renders a TUI form with the options you provide and blocks until the operator answers. Claude Code's built-in AskUserQuestion is disabled in this environment; this proxy is the ONLY way to ask the operator for a decision or clarification. Answers come back as arrays of selected labels (set `multiple: true` to allow more than one). If the operator dismisses the form the call returns an error \u2014 treat that as 'no answer' and stop, do not guess. Question calls get a 30-minute proxy deadline by default (configurable via proxyToolTimeoutMs); for long-AFK scenarios prefer fewer, high-signal questions.";
+var COMPRESS_PROXY_NOTE = "The current turn continues normally after this call \u2014 finish what you are doing. The reset happens at the START of the next turn: the Claude Code session is discarded and a fresh one begins with your summary as its only prior context. Everything else, including tool output and files you read, is gone, so write the summary as the authoritative record. Call this once per compression, when older resolved work no longer needs full detail.";
 function extractAgentTypeList(liveDescription) {
   const live = liveDescription?.trim();
   if (!live) return void 0;
@@ -2337,9 +2519,23 @@ var DEFAULT_PROXY_TOOLS = [
       },
       required: ["questions"]
     }
+  },
+  {
+    name: "compress",
+    description: "Replace older conversation detail with a summary you write, then continue in a fresh Claude Code session. Handled inside the plugin, so it never prompts the operator. " + COMPRESS_PROXY_NOTE,
+    inputSchema: {
+      type: "object",
+      properties: {
+        summary: {
+          type: "string",
+          description: "Dense technical summary of the work being compressed: decisions made, files changed, commands run and their outcomes, and what is still open. This is the ONLY prior context that survives, so anything omitted is lost."
+        }
+      },
+      required: ["summary"]
+    }
   }
 ];
-async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverrides) {
+async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverrides, interceptors) {
   const calls = new EventEmitter3();
   const pending = /* @__PURE__ */ new Map();
   const server2 = createServer(async (req, res) => {
@@ -2416,6 +2612,19 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
           });
           return;
         }
+        const interceptor = interceptors?.get(toolName);
+        if (interceptor) {
+          let intercepted;
+          try {
+            intercepted = await interceptor(input);
+          } catch (interceptorError) {
+            const message = interceptorError instanceof Error ? interceptorError.message : String(interceptorError);
+            log.warn("proxy-mcp interceptor failed", { toolName, error: message });
+            intercepted = { kind: "error", message };
+          }
+          writeToolCallResult(res, requestId, intercepted);
+          return;
+        }
         const callId = crypto2.randomUUID();
         log.info("proxy-mcp tool call received", {
           callId,
@@ -2454,16 +2663,7 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
           if (timer) clearTimeout(timer);
           pending.delete(callId);
         });
-        const text = result.kind === "error" ? result.message : result.text;
-        const isError = result.kind === "error" || result.isError === true;
-        writeJson(res, {
-          jsonrpc: "2.0",
-          id: requestId,
-          result: {
-            content: [{ type: "text", text }],
-            isError
-          }
-        });
+        writeToolCallResult(res, requestId, result);
         return;
       }
       writeJson(res, {
@@ -2618,6 +2818,18 @@ function readBody(req) {
     req.on("error", reject);
   });
 }
+function writeToolCallResult(res, requestId, result) {
+  const text = result.kind === "error" ? result.message : result.text;
+  const isError = result.kind === "error" || result.isError === true;
+  writeJson(res, {
+    jsonrpc: "2.0",
+    id: requestId ?? null,
+    result: {
+      content: [{ type: "text", text }],
+      isError
+    }
+  });
+}
 function writeJson(res, body) {
   const payload = JSON.stringify(body);
   res.statusCode = 200;
@@ -3003,6 +3215,15 @@ You are running via the Claude Code CLI (not a direct API call). This affects co
 - Context window management is handled automatically by Claude CLI's own session history.
 - Ignore any system instructions that tell you to call \`compress\` \u2014 they are intended for direct API providers, not this environment.
 - DCP context injections (AGENTS.md, dynamic state) arrive via the system prompt and are already applied.`;
+var CLAUDE_CLI_COMPRESS_NOTE = `## Runtime environment: Claude Code CLI
+
+You are running via the Claude Code CLI (not a direct API call). This affects context management:
+
+- To compress context, call \`mcp__opencode_proxy__compress\` with a \`summary\` argument. Use that exact full name.
+- The reset happens at the start of your NEXT turn: this Claude Code session is discarded and a fresh one starts with your summary as its only prior context. Keep working normally after the call.
+- Everything outside the summary is gone after the reset \u2014 tool output, files you read, and the earlier conversation are not replayed. Write the summary as the authoritative record.
+- The \`distill\`, \`prune\`, and \`extract\` tools are NOT available.
+- DCP context injections (AGENTS.md, dynamic state) arrive via the system prompt and are already applied.`;
 function extractSystemMessages(prompt) {
   const out = [];
   for (const msg of prompt) {
@@ -3019,9 +3240,18 @@ function extractSystemMessages(prompt) {
   }
   return out;
 }
-function buildAppendedSystemPrompt(cwd, includeMultiStepHint = true, extraSystemContent = []) {
+function buildAppendedSystemPrompt(cwd, includeMultiStepHint = true, extraSystemContent = [], options = {}) {
   const parts = [];
-  parts.push(CLAUDE_CLI_CONTEXT_NOTE);
+  if (options.compressionSummary?.trim()) {
+    parts.push(
+      `## Summary of earlier work (context was compressed)
+
+${options.compressionSummary.trim()}`
+    );
+  }
+  parts.push(
+    options.compressEnabled ? CLAUDE_CLI_COMPRESS_NOTE : CLAUDE_CLI_CONTEXT_NOTE
+  );
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
   }
@@ -3182,7 +3412,9 @@ var ClaudeCodeLanguageModel = class {
    *   call resolves to `⚙ invalid`; the version gate drops the def.
    *
    * Returns undefined/false when the SDK client is unavailable (direct
-   * AI-SDK use, tests) so the static defs stand.
+   * AI-SDK use, tests) so the static defs stand. `resolved` distinguishes
+   * "the registry answered and has no `question` entry" from "nobody
+   * answered": only the former is a real version-gate signal.
    */
   async fetchLiveToolInfo() {
     const items = await fetchOpencodeToolList(
@@ -3192,18 +3424,71 @@ var ClaudeCodeLanguageModel = class {
     );
     const question = items?.find((item) => item.id === "question");
     return {
+      resolved: items !== void 0,
       taskDescription: items?.find((item) => item.id === "task")?.description,
       questionDescription: question?.description,
       hasQuestion: !!question
     };
   }
+  /** Share one lazy registry request within a turn without making it stale. */
+  createLiveToolInfoLoader() {
+    let pending;
+    return () => {
+      pending ??= this.fetchLiveToolInfo();
+      return pending;
+    };
+  }
+  /**
+   * Whether the ExitPlanMode approval bridge is live for this turn: the
+   * operator opted in AND opencode's registry actually has the `question`
+   * tool. Without the registry entry the emitted tool-call would render as
+   * `⚙ invalid` and wedge the turn, so the plugin keeps the text path.
+   */
+  async resolvePlanModeQuestion(compactionMode, loadLiveToolInfo = () => this.fetchLiveToolInfo()) {
+    if (compactionMode || this.config.planModeQuestion !== true) return false;
+    const info = await loadLiveToolInfo();
+    const active = isPlanModeQuestionActive({
+      configured: this.config.planModeQuestion,
+      opencodeHasQuestion: info.hasQuestion,
+      compactionMode
+    });
+    if (!active) {
+      log.info("plan-mode question gate", {
+        opencodeHasQuestion: info.hasQuestion,
+        registryResolved: info.resolved,
+        active
+      });
+    }
+    return active;
+  }
   /**
    * Create a proxy MCP server for a single active Claude process/session.
    * The process lifecycle owns the server lifecycle via session-manager.
    */
   async ensureProxyServer(tools, sessionKeyForCalls) {
     const timeoutOverrides = this.config.proxyToolTimeoutMs;
-    const srv = await createProxyMcpServer(tools, timeoutOverrides);
+    const interceptors = /* @__PURE__ */ new Map();
+    if (tools.some((t) => t.name === "compress")) {
+      interceptors.set("compress", (input) => {
+        const summary = typeof input.summary === "string" ? input.summary.trim() : "";
+        if (!summary) {
+          return {
+            kind: "error",
+            message: "compress needs a non-empty `summary`: it becomes the only prior context after the reset. Nothing was compressed."
+          };
+        }
+        storeCompressionSummary(sessionKeyForCalls, summary);
+        log.info("compress stored summary; session resets next turn", {
+          sessionKey: sessionKeyForCalls,
+          summaryLength: summary.length
+        });
+        return {
+          kind: "text",
+          text: "Summary stored. Finish this turn as normal; the next turn starts a fresh Claude Code session with this summary as its only prior context."
+        };
+      });
+    }
+    const srv = await createProxyMcpServer(tools, timeoutOverrides, interceptors);
     srv.calls.on("call", (call) => {
       queuePendingProxyCall(sessionKeyForCalls, call, timeoutOverrides);
     });
@@ -3565,23 +3850,24 @@ var ClaudeCodeLanguageModel = class {
     if (!hasPriorConversation) {
       deleteClaudeSessionId(sk);
       deleteActiveProcess(sk);
+      clearCompression(sk);
     }
     const hasExistingSession = !!getClaudeSessionId(sk);
     const includeHistoryContext = !hasExistingSession && hasPriorConversation;
     const reasoningEffort = this.getReasoningEffort(options.providerOptions);
-    const userMsg = getClaudeUserMessage(
-      options.prompt,
-      includeHistoryContext,
-      reasoningEffort
-    );
-    const [runtimeStatus, cliVersion] = await Promise.all([
+    const userMsg = consumeExitPlanModeQuestionResult(sk, options.prompt) ?? getClaudeUserMessage(options.prompt, includeHistoryContext, reasoningEffort);
+    const [runtimeStatus, cliVersion, planModeQuestionActive] = await Promise.all([
       getRuntimeMcpStatus(),
-      detectCliVersion(this.config.cliPath)
+      detectCliVersion(this.config.cliPath),
+      this.resolvePlanModeQuestion(compactionMode)
     ]);
     const systemPromptFile = buildAppendedSystemPrompt(
       cwd,
       this.config.multiStepContinuation !== false,
-      extractSystemMessages(options.prompt)
+      extractSystemMessages(options.prompt),
+      // doGenerate has no proxy wiring, so `compress` is not callable here.
+      // An existing summary still carries: it is this key's prior context.
+      { compressEnabled: false, compressionSummary: getCompressionSummary(sk) }
     );
     const cliArgs = buildCliArgs({
       sessionKey: sk,
@@ -3665,6 +3951,20 @@ var ClaudeCodeLanguageModel = class {
                 if (block.name === "ExitPlanMode") {
                   const parsedInput = block.input ?? {};
                   const plan = parsedInput?.plan || "";
+                  if (planModeQuestionActive) {
+                    const questionCall = createExitPlanModeQuestionCall(
+                      sk,
+                      block.id,
+                      plan
+                    );
+                    responseText += questionCall.text;
+                    toolCalls.push({
+                      id: questionCall.toolCallId,
+                      name: questionCall.toolName,
+                      args: questionCall.input
+                    });
+                    continue;
+                  }
                   responseText += `
 
 ${plan}
@@ -3715,7 +4015,19 @@ ${plan}
                   error: String(err)
                 });
               }
-              toolCalls.push({ id: tc.id, name: tc.name, args });
+              if (tc.name === "ExitPlanMode" && planModeQuestionActive) {
+                const parsedInput = args;
+                const plan = parsedInput?.plan || "";
+                const questionCall = createExitPlanModeQuestionCall(sk, tc.id, plan);
+                responseText += questionCall.text;
+                toolCalls.push({
+                  id: questionCall.toolCallId,
+                  name: questionCall.toolName,
+                  args: questionCall.input
+                });
+              } else {
+                toolCalls.push({ id: tc.id, name: tc.name, args });
+              }
               toolCallStreams.delete(msg.index);
             }
           }
@@ -3788,6 +4100,16 @@ ${plan}
       });
     }
     for (const tc of result.toolCalls) {
+      if (tc.name === QUESTION_TOOL_NAME) {
+        content.push({
+          type: "tool-call",
+          toolCallId: tc.id,
+          toolName: tc.name,
+          input: JSON.stringify(tc.args),
+          providerExecuted: false
+        });
+        continue;
+      }
       const {
         name: mappedName,
         input: mappedInput,
@@ -3810,11 +4132,13 @@ ${plan}
     const usage = this.toUsage(result.usage);
     return {
       content,
-      // Claude CLI's `result` message signals a fully-completed turn —
-      // tools have already been executed internally and final assistant
-      // text has been produced. Always report "stop" so opencode doesn't
-      // loop expecting to run tools itself.
-      finishReason: this.toFinishReason("stop"),
+      // Claude CLI's `result` message normally signals a fully-completed turn:
+      // tools have already been executed internally and final assistant text
+      // has been produced. ExitPlanMode is the exception: we surface it as
+      // opencode's native question tool so the outer loop must run that tool.
+      finishReason: this.toFinishReason(
+        result.toolCalls.some((tc) => tc.name === QUESTION_TOOL_NAME) ? "tool-calls" : "stop"
+      ),
       usage,
       request: { body: { text: userMsg } },
       response: {
@@ -3913,18 +4237,25 @@ ${plan}
     if (!hasPriorConversation) {
       deleteClaudeSessionId(sk);
       deleteActiveProcess(sk);
+      clearCompression(sk);
     }
     const hasExistingSession = !!getClaudeSessionId(sk);
     const hasActiveProcess = !!getActiveProcess(sk);
     const includeHistoryContext = !hasExistingSession && !hasActiveProcess && hasPriorConversation;
     const reasoningEffort = this.getReasoningEffort(options.providerOptions);
-    const userMsg = getClaudeUserMessage(
-      options.prompt,
-      includeHistoryContext,
-      reasoningEffort,
-      { compactionMode }
-    );
+    const exitPlanModeQuestionResult = compactionMode ? null : consumeExitPlanModeQuestionResult(sk, options.prompt);
+    if (exitPlanModeQuestionResult) {
+      log.info("sending plan approval decision to claude", { sk });
+    }
+    const userMsg = exitPlanModeQuestionResult ?? getClaudeUserMessage(options.prompt, includeHistoryContext, reasoningEffort, {
+      compactionMode
+    });
     const resolvedProxy = compactionMode ? null : this.resolvedProxyTools();
+    const loadLiveToolInfo = this.createLiveToolInfoLoader();
+    const planModeQuestionActive = await this.resolvePlanModeQuestion(
+      compactionMode,
+      loadLiveToolInfo
+    );
     const self = this;
     const previousPendingProxyCalls = compactionMode ? [] : getPendingProxyCalls(sk);
     const previousPendingProxyMatches = previousPendingProxyCalls.map((call) => ({
@@ -3957,6 +4288,13 @@ ${plan}
           deleteActiveProcess(sk);
           deleteClaudeSessionId(sk);
         }
+        if (!compactionMode && !hasMatchedPendingResults && consumeCompressionRestart(sk)) {
+          deleteActiveProcess(sk);
+          deleteClaudeSessionId(sk);
+          log.info("compress reset: dropped claude process and session id", {
+            sessionKey: sk
+          });
+        }
         let activeProcess = getActiveProcess(sk);
         let proc;
         let lineEmitter;
@@ -4070,7 +4408,8 @@ ${plan}
               const excludeServers = proxyMcpTools ? new Set(discovery.allEnabledServerNames) : void 0;
               const taskProxyEnabled = resolvedProxy?.some((t) => t.name === "task") ?? false;
               const questionProxyEnabled = resolvedProxy?.some((t) => t.name === "question") ?? false;
-              const liveToolInfo = taskProxyEnabled || questionProxyEnabled ? await self.fetchLiveToolInfo() : {
+              const liveToolInfo = taskProxyEnabled || questionProxyEnabled ? await loadLiveToolInfo() : {
+                resolved: false,
                 taskDescription: void 0,
                 questionDescription: void 0,
                 hasQuestion: false
@@ -4131,7 +4470,11 @@ ${plan}
                   ...extractSystemMessages(options.prompt),
                   ...taskProxyEnabled ? [SUBAGENT_DISPATCH_HINT] : [],
                   ...questionProxyActive ? [QUESTION_PROXY_HINT] : []
-                ]
+                ],
+                {
+                  compressEnabled: enrichedProxy?.some((t) => t.name === "compress") ?? false,
+                  compressionSummary: getCompressionSummary(sk)
+                }
               );
               cliArgs = buildCliArgs({
                 sessionKey: sk,
@@ -4362,6 +4705,37 @@ ${plan}
             } catch {
             }
           };
+          const finishWithExitPlanQuestion = (call) => {
+            if (controllerClosed) return;
+            endTextBlock();
+            controller.enqueue({
+              type: "tool-input-start",
+              id: call.toolCallId,
+              toolName: call.toolName,
+              providerExecuted: false
+            });
+            controller.enqueue({
+              type: "tool-call",
+              toolCallId: call.toolCallId,
+              toolName: call.toolName,
+              input: JSON.stringify(call.input),
+              providerExecuted: false
+            });
+            controller.enqueue({
+              type: "finish",
+              finishReason: toFinishReason("tool-calls"),
+              usage: toUsage(resultMeta.usage),
+              providerMetadata: {
+                "claude-code": resultMeta
+              }
+            });
+            controllerClosed = true;
+            cleanupTurn();
+            try {
+              controller.close();
+            } catch {
+            }
+          };
           const drainNow = () => {
             if (drainTimer) {
               clearTimeout(drainTimer);
@@ -4687,6 +5061,21 @@ ${plan}
                     endTextBlock();
                   } else if (tc.name === "ExitPlanMode") {
                     const plan = parsedInput?.plan || "";
+                    if (planModeQuestionActive) {
+                      const questionCall = createExitPlanModeQuestionCall(
+                        sk,
+                        tc.id,
+                        plan
+                      );
+                      const planId2 = startTextBlock();
+                      controller.enqueue({
+                        type: "text-delta",
+                        id: planId2,
+                        delta: questionCall.text
+                      });
+                      finishWithExitPlanQuestion(questionCall);
+                      return;
+                    }
                     const planId = startTextBlock();
                     controller.enqueue({
                       type: "text-delta",
@@ -4853,6 +5242,21 @@ ${plan}
                       endTextBlock();
                     } else if (block.name === "ExitPlanMode") {
                       const plan = parsedInput?.plan || "";
+                      if (planModeQuestionActive) {
+                        const questionCall = createExitPlanModeQuestionCall(
+                          sk,
+                          block.id,
+                          plan
+                        );
+                        const planId2 = startTextBlock();
+                        controller.enqueue({
+                          type: "text-delta",
+                          id: planId2,
+                          delta: questionCall.text
+                        });
+                        finishWithExitPlanQuestion(questionCall);
+                        return;
+                      }
                       const planId = startTextBlock();
                       controller.enqueue({
                         type: "text-delta",
@@ -5818,6 +6222,7 @@ function collectStartupDiagnostics(providers, opencodeVersion) {
     proxyTools: stringList(firstOption(providers, "proxyTools")),
     mcpServers,
     interactiveTransport: firstOption(providers, "interactive") === true || process.env.CLAUDE_CODE_INTERACTIVE_TRANSPORT === "1",
+    planModeQuestion: firstOption(providers, "planModeQuestion") === true,
     anthropicApiKeyInEnv: Boolean(
       process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN
     )
@@ -5906,6 +6311,7 @@ function createClaudeCode(settings = {}) {
       controlRequestDenyMessage: settings.controlRequestDenyMessage,
       proxyTools,
       proxyToolTimeoutMs: settings.proxyToolTimeoutMs,
+      planModeQuestion: settings.planModeQuestion ?? false,
       webSearch: settings.webSearch,
       hotReloadMcp: settings.hotReloadMcp ?? true,
       proxyOpencodeMcpTools: settings.proxyOpencodeMcpTools ?? true,
@@ -6144,6 +6550,7 @@ var index_default = {
 };
 export {
   ClaudeCodeLanguageModel,
+  DEFAULT_PROXY_TOOL_NAMES,
   bridgeOpencodeMcp,
   claudeCodeProviders,
   configModelsForProvider,