@khalilgharbaoui/opencode-claude-code-plugin 0.4.18 → 0.4.20

package/dist/index.js

@@ -198,7 +198,12 @@ var OPENCODE_HANDLED_TOOLS = /* @__PURE__ */ new Set([
 var CLAUDE_INTERNAL_TOOLS = /* @__PURE__ */ new Set([
   "ToolSearch",
   "Agent",
-  "AskFollowupQuestion"
+  "AskFollowupQuestion",
+  "TaskCreate",
+  "TaskUpdate",
+  "TaskList",
+  "TaskGet",
+  "TaskStop"
 ]);
 function mapTool(name, input, opts) {
   if (CLAUDE_INTERNAL_TOOLS.has(name)) {
@@ -340,7 +345,74 @@ function getToolResultText(part) {
       return JSON.stringify(value);
   }
 }
-function compactConversationHistory(prompt) {
+var MAX_HISTORY_CHARS = 18e4;
+var MAX_TOOL_RESULT_CHARS = 1e4;
+var MAX_TOOL_INPUT_CHARS = 2e3;
+function clipWithMarker(text, max) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max)}
+\u2026[truncated ${text.length - max} chars]`;
+}
+function renderToolInput(input) {
+  let raw;
+  try {
+    raw = typeof input === "string" ? input : JSON.stringify(input);
+  } catch {
+    raw = String(input);
+  }
+  return clipWithMarker(raw, MAX_TOOL_INPUT_CHARS);
+}
+function renderMessageContentForCompaction(msg) {
+  const lines = [];
+  let toolResultCount = 0;
+  if (typeof msg.content === "string") {
+    return { text: msg.content, toolResultCount: 0 };
+  }
+  if (!Array.isArray(msg.content)) {
+    return { text: "", toolResultCount: 0 };
+  }
+  for (const part of msg.content) {
+    if (!part) continue;
+    switch (part.type) {
+      case "text":
+        if (part.text) lines.push(part.text);
+        break;
+      case "tool-call":
+        lines.push(
+          `[tool_use:${part.toolName ?? "unknown"}(${renderToolInput(part.input)})]`
+        );
+        break;
+      case "tool-result":
+        toolResultCount++;
+        lines.push(
+          `[tool_result:${part.toolName ?? part.toolCallId ?? "unknown"}]
+${clipWithMarker(
+            getToolResultText(part),
+            MAX_TOOL_RESULT_CHARS
+          )}`
+        );
+        break;
+      case "image":
+        lines.push(
+          `[image: ${part.mediaType ?? part.mimeType ?? "unknown"}]`
+        );
+        break;
+      case "file":
+        lines.push(
+          `[file: ${part.mediaType ?? part.mimeType ?? "unknown"}]`
+        );
+        break;
+      case "reasoning":
+        break;
+    }
+  }
+  return { text: lines.join("\n"), toolResultCount };
+}
+function compactConversationHistory(prompt, opts = {}) {
+  const mode = opts.mode ?? "fresh-session";
+  if (mode === "compaction") {
+    return buildCompactionHistory(prompt);
+  }
   const conversationMessages = prompt.filter(
     (m) => m.role === "user" || m.role === "assistant"
   );
@@ -382,9 +454,59 @@ function compactConversationHistory(prompt) {
   }
   return historyParts.join("\n\n");
 }
-function getClaudeUserMessage(prompt, includeHistoryContext = false, reasoningEffort) {
+function buildCompactionHistory(prompt) {
+  const entries = [];
+  let total = 0;
+  let totalToolResults = 0;
+  let droppedOldest = 0;
+  const end = prompt.length > 0 && prompt[prompt.length - 1].role === "user" ? prompt.length - 1 : prompt.length;
+  for (let i = end - 1; i >= 0; i--) {
+    const msg = prompt[i];
+    const roleLabel = msg.role === "user" ? "User" : msg.role === "assistant" ? "Assistant" : msg.role === "tool" ? "Tool" : msg.role;
+    const { text, toolResultCount } = renderMessageContentForCompaction(msg);
+    if (!text.trim()) continue;
+    const entry = `${roleLabel}: ${text}`;
+    if (total + entry.length > MAX_HISTORY_CHARS) {
+      droppedOldest = i + 1;
+      break;
+    }
+    entries.push(entry);
+    total += entry.length + 2;
+    totalToolResults += toolResultCount;
+  }
+  if (entries.length === 0) return null;
+  entries.reverse();
+  log.info("built compaction history", {
+    entries: entries.length,
+    chars: total,
+    toolResults: totalToolResults,
+    droppedOldestBefore: droppedOldest
+  });
+  return entries.join("\n\n");
+}
+function getClaudeUserMessage(prompt, includeHistoryContext = false, reasoningEffort, opts = {}) {
+  const compactionMode = opts.compactionMode === true;
   const content = [];
-  if (includeHistoryContext) {
+  if (compactionMode) {
+    const transcript = compactConversationHistory(prompt, {
+      mode: "compaction"
+    });
+    if (transcript) {
+      log.info("including compaction transcript", {
+        historyLength: transcript.length
+      });
+      content.push({
+        type: "text",
+        text: `<conversation_transcript>
+${transcript}
+</conversation_transcript>
+
+The complete prior conversation appears above. The synthesis instructions follow below.
+
+`
+      });
+    }
+  } else if (includeHistoryContext) {
     const historyContext = compactConversationHistory(prompt);
     if (historyContext) {
       log.info("including conversation history context", {
@@ -467,17 +589,19 @@ Now continuing with the current message:
       }
     });
   }
-  const keyword = reasoningKeyword(reasoningEffort);
-  if (keyword) {
-    const lastTextPart = [...content].reverse().find((p) => p.type === "text");
-    if (lastTextPart) {
-      lastTextPart.text = lastTextPart.text ? `${lastTextPart.text}
+  if (!compactionMode) {
+    const keyword = reasoningKeyword(reasoningEffort);
+    if (keyword) {
+      const lastTextPart = [...content].reverse().find((p) => p.type === "text");
+      if (lastTextPart) {
+        lastTextPart.text = lastTextPart.text ? `${lastTextPart.text}
 
 (${keyword})` : `(${keyword})`;
-    } else {
-      content.push({ type: "text", text: `(${keyword})` });
+      } else {
+        content.push({ type: "text", text: `(${keyword})` });
+      }
+      log.debug("injected reasoning keyword", { effort: reasoningEffort, keyword });
     }
-    log.debug("injected reasoning keyword", { effort: reasoningEffort, keyword });
   }
   return JSON.stringify({
     type: "user",
@@ -922,9 +1046,87 @@ import { spawn } from "child_process";
 import { createInterface } from "readline";
 import { EventEmitter } from "events";
 import { unlink } from "fs/promises";
+
+// src/cli-version.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var cache = /* @__PURE__ */ new Map();
+function detectCliVersion(cliPath) {
+  const cached = cache.get(cliPath);
+  if (cached) return cached;
+  const promise = (async () => {
+    try {
+      const { stdout } = await execFileAsync(cliPath, ["--version"], {
+        timeout: 5e3
+      });
+      const match = /(\d+)\.(\d+)\.(\d+)/.exec(stdout.trim());
+      if (!match) {
+        log.warn("claude --version output unparseable", { stdout: stdout.trim() });
+        return null;
+      }
+      const v = {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        raw: stdout.trim()
+      };
+      log.info("detected claude cli version", { cliPath, version: v.raw });
+      if (!cliSupportsThinkingDisplay(v)) {
+        log.notice(
+          "claude cli < 2.1.142 detected; Opus 4.7 thinking summaries unavailable. Run `npm i -g @anthropic-ai/claude-code` to upgrade.",
+          { version: v.raw }
+        );
+      }
+      return v;
+    } catch (err) {
+      log.warn("failed to detect claude cli version", {
+        cliPath,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return null;
+    }
+  })();
+  cache.set(cliPath, promise);
+  return promise;
+}
+function gte(v, target) {
+  if (v.major !== target.major) return v.major > target.major;
+  if (v.minor !== target.minor) return v.minor > target.minor;
+  return v.patch >= target.patch;
+}
+function cliSupportsThinkingDisplay(v) {
+  if (!v) return false;
+  return gte(v, { major: 2, minor: 1, patch: 142 });
+}
+function cliSupportsThinking(v) {
+  if (!v) return false;
+  return gte(v, { major: 2, minor: 0, patch: 0 });
+}
+
+// src/session-manager.ts
 var activeProcesses = /* @__PURE__ */ new Map();
 var claudeSessions = /* @__PURE__ */ new Map();
 var MAX_ACTIVE_PROCESSES = 16;
+function envFlagEnabled(value) {
+  if (value === void 0) return false;
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) return false;
+  return !["0", "false", "no", "off"].includes(normalized);
+}
+function isClaudeThinkingDisabled() {
+  return envFlagEnabled(process.env.CLAUDE_CODE_DISABLE_THINKING) || envFlagEnabled(process.env.CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING);
+}
+function claudeSpawnEnv() {
+  const env = {
+    ...process.env,
+    TERM: "xterm-256color"
+  };
+  if (!isClaudeThinkingDisabled() && process.env.CLAUDE_CODE_SHOW_THINKING_SUMMARIES === void 0) {
+    env.CLAUDE_CODE_SHOW_THINKING_SUMMARIES = "1";
+  }
+  return env;
+}
 function touch(key) {
   const existing = activeProcesses.get(key);
   if (existing) {
@@ -968,7 +1170,7 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
   const proc = spawn(cliPath, cliArgs, {
     cwd,
     stdio: ["pipe", "pipe", "pipe"],
-    env: { ...process.env, TERM: "xterm-256color" },
+    env: claudeSpawnEnv(),
     shell: process.platform === "win32"
   });
   const lineEmitter = new EventEmitter();
@@ -1029,7 +1231,10 @@ function buildCliArgs(opts) {
     mcpConfig,
     strictMcpConfig,
     disallowedTools,
-    appendSystemPromptFile
+    appendSystemPromptFile,
+    thinking,
+    thinkingDisplay,
+    cliVersion
   } = opts;
   const args = [
     "--print",
@@ -1065,6 +1270,12 @@ function buildCliArgs(opts) {
   if (disallowedTools && disallowedTools.length > 0) {
     args.push("--disallowedTools", ...disallowedTools);
   }
+  if (thinking && cliSupportsThinking(cliVersion ?? null)) {
+    args.push("--thinking", thinking);
+  }
+  if (thinkingDisplay && cliSupportsThinkingDisplay(cliVersion ?? null)) {
+    args.push("--thinking-display", thinkingDisplay);
+  }
   if (appendSystemPromptFile) {
     args.push("--append-system-prompt-file", appendSystemPromptFile);
   }
@@ -1316,8 +1527,8 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
       });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      const isTimeout = errorMessage.includes("timed out after") && errorMessage.includes("waiting for opencode to resolve");
-      const logFn = isTimeout ? log.notice : log.warn;
+      const isExpectedCleanup = errorMessage.includes("timed out after") && errorMessage.includes("waiting for opencode to resolve") || errorMessage.includes("rejecting as orphaned") || errorMessage.includes("was orphaned by a new user turn");
+      const logFn = isExpectedCleanup ? log.notice : log.warn;
       logFn("proxy-mcp error handling request", {
         error: errorMessage
       });
@@ -1549,7 +1760,7 @@ function rejectPendingProxyCallById(toolCallId, error) {
   indexRemove(pending.sessionKey, toolCallId);
   clearTimeout(pending.timer);
   pending.reject(error);
-  log.warn("rejected pending proxy call", {
+  log.notice("rejected pending proxy call", {
     sessionKey: pending.sessionKey,
     toolCallId: pending.toolCallId,
     toolName: pending.toolName,
@@ -1574,6 +1785,20 @@ import { unlink as unlink2 } from "fs/promises";
 import { homedir as homedir3, tmpdir as tmpdir2 } from "os";
 import { randomUUID as randomUUID2 } from "crypto";
 import { dirname as dirname3, join as join5 } from "path";
+var DEFAULT_COMPACTION_MODEL = "claude-haiku-4-5";
+function resolveCompactionModel(configured) {
+  const env = process.env.CLAUDE_CODE_COMPACTION_MODEL?.trim();
+  if (env) return env;
+  const trimmed = configured?.trim();
+  if (trimmed) return trimmed;
+  return DEFAULT_COMPACTION_MODEL;
+}
+var KNOWN_DELTA_TYPES = /* @__PURE__ */ new Set([
+  "thinking_delta",
+  "text_delta",
+  "input_json_delta",
+  "signature_delta"
+]);
 function hasNewUserContent(prompt) {
   for (let i = prompt.length - 1; i >= 0; i--) {
     const msg = prompt[i];
@@ -2015,6 +2240,32 @@ var ClaudeCodeLanguageModel = class {
     ];
     return valid.includes(effort) ? effort : void 0;
   }
+  getOpencodeAgent(providerOptions) {
+    if (!providerOptions) return void 0;
+    const ownKey = this.config.provider;
+    const bag = providerOptions[ownKey] ?? providerOptions["claude-code"];
+    const agent = bag?.opencodeAgent;
+    return typeof agent === "string" ? agent : void 0;
+  }
+  isCompactionCall(options) {
+    return this.getOpencodeAgent(options.providerOptions) === "compaction";
+  }
+  /**
+   * Pick the model used to handle /compact. Precedence:
+   *   1. `CLAUDE_CODE_COMPACTION_MODEL` env var (per-process override)
+   *   2. `compactionModel` provider setting (opencode.json / .jsonc)
+   *   3. Built-in default (claude-haiku-4-5)
+   */
+  resolveCompactionModel() {
+    return resolveCompactionModel(this.config.compactionModel);
+  }
+  thinkingCliOptions() {
+    if (isClaudeThinkingDisabled()) return {};
+    return {
+      thinking: "enabled",
+      thinkingDisplay: process.env.CLAUDE_CODE_SHOW_THINKING_SUMMARIES === void 0 ? "summarized" : void 0
+    };
+  }
   latestUserText(prompt) {
     for (let i = prompt.length - 1; i >= 0; i--) {
       const msg = prompt[i];
@@ -2138,10 +2389,19 @@ var ClaudeCodeLanguageModel = class {
     const scope = this.requestScope(options);
     const affinity = this.sessionAffinity(options);
     const sk = sessionKey(cwd, `${this.modelId}::${scope}::${affinity}`);
+    const compactionMode = this.isCompactionCall(options);
     if (scope === "tools" && (this.resolvedProxyTools() || this.config.proxyOpencodeMcpTools !== false && this.config.bridgeOpencodeMcp !== false)) {
       return this.doGenerateViaStream(options);
     }
+    if (compactionMode) {
+      return this.doGenerateViaStream(options);
+    }
     if (scope === "no-tools") {
+      log.info("doGenerate no-tools title stub", {
+        compactionMode,
+        opencodeAgent: this.getOpencodeAgent(options.providerOptions),
+        providerOptionsKeys: options.providerOptions ? Object.keys(options.providerOptions) : []
+      });
       const text = this.synthesizeTitle(options.prompt);
       return {
         content: [{ type: "text", text }],
@@ -2193,7 +2453,10 @@ var ClaudeCodeLanguageModel = class {
       includeHistoryContext,
       reasoningEffort
     );
-    const runtimeStatus = await getRuntimeMcpStatus();
+    const [runtimeStatus, cliVersion] = await Promise.all([
+      getRuntimeMcpStatus(),
+      detectCliVersion(this.config.cliPath)
+    ]);
     const systemPromptFile = buildAppendedSystemPrompt(
       cwd,
       this.config.multiStepContinuation !== false
@@ -2207,7 +2470,9 @@ var ClaudeCodeLanguageModel = class {
       mcpConfig: this.effectiveMcpConfig(cwd, void 0, runtimeStatus).paths,
       strictMcpConfig: this.config.strictMcpConfig,
       disallowedTools: this.config.webSearch === "disabled" ? ["WebSearch"] : void 0,
-      appendSystemPromptFile: systemPromptFile
+      appendSystemPromptFile: systemPromptFile,
+      ...this.thinkingCliOptions(),
+      cliVersion
     });
     log.info("doGenerate starting", {
       cwd,
@@ -2220,7 +2485,7 @@ var ClaudeCodeLanguageModel = class {
     const proc = spawn2(this.config.cliPath, cliArgs, {
       cwd,
       stdio: ["pipe", "pipe", "pipe"],
-      env: { ...process.env, TERM: "xterm-256color" },
+      env: claudeSpawnEnv(),
       shell: process.platform === "win32"
     });
     if (systemPromptFile) {
@@ -2435,11 +2700,18 @@ ${plan}
     const skipPermissions = this.config.skipPermissions !== false;
     const scope = this.requestScope(options);
     const affinity = this.sessionAffinity(options);
-    const sk = sessionKey(cwd, `${this.modelId}::${scope}::${affinity}`);
+    const compactionMode = this.isCompactionCall(options);
+    const effectiveModelId = compactionMode ? this.resolveCompactionModel() : this.modelId;
+    const sk = compactionMode ? sessionKey(cwd, `${effectiveModelId}::compaction::${affinity}`) : sessionKey(cwd, `${this.modelId}::${scope}::${affinity}`);
     const toUsage = this.toUsage.bind(this);
     const toFinishReason = this.toFinishReason.bind(this);
     const handleControlRequest = this.handleControlRequest.bind(this);
-    if (scope === "no-tools") {
+    if (scope === "no-tools" && !compactionMode) {
+      log.info("doStream no-tools title stub", {
+        compactionMode,
+        opencodeAgent: this.getOpencodeAgent(options.providerOptions),
+        providerOptionsKeys: options.providerOptions ? Object.keys(options.providerOptions) : []
+      });
       const text = this.synthesizeTitle(options.prompt);
       const textId = generateId();
       const stream2 = new ReadableStream({
@@ -2501,11 +2773,12 @@ ${plan}
     const userMsg = getClaudeUserMessage(
       options.prompt,
       includeHistoryContext,
-      reasoningEffort
+      reasoningEffort,
+      { compactionMode }
     );
-    const resolvedProxy = this.resolvedProxyTools();
+    const resolvedProxy = compactionMode ? null : this.resolvedProxyTools();
     const self = this;
-    const previousPendingProxyCalls = getPendingProxyCalls(sk);
+    const previousPendingProxyCalls = compactionMode ? [] : getPendingProxyCalls(sk);
     const previousPendingProxyMatches = previousPendingProxyCalls.map((call) => ({
       call,
       result: this.extractPendingProxyResult(options.prompt, call.toolCallId)
@@ -2513,23 +2786,34 @@ ${plan}
     const hasMatchedPendingResults = previousPendingProxyMatches.some(
       (m) => m.result !== null
     );
-    const runtimeStatus = await getRuntimeMcpStatus();
+    const [runtimeStatus, cliVersion] = await Promise.all([
+      compactionMode ? Promise.resolve(void 0) : getRuntimeMcpStatus(),
+      detectCliVersion(this.config.cliPath)
+    ]);
     log.info("doStream starting", {
       cwd,
-      model: this.modelId,
+      model: effectiveModelId,
       textLength: userMsg.length,
       includeHistoryContext,
       hasActiveProcess,
       reasoningEffort,
-      proxyTools: resolvedProxy?.map((t) => t.name) ?? null
+      proxyTools: resolvedProxy?.map((t) => t.name) ?? null,
+      compactionMode,
+      scope,
+      opencodeAgent: this.getOpencodeAgent(options.providerOptions),
+      providerOptionsKeys: options.providerOptions ? Object.keys(options.providerOptions) : []
     });
     const stream = new ReadableStream({
       start(controller) {
+        if (compactionMode) {
+          deleteActiveProcess(sk);
+          deleteClaudeSessionId(sk);
+        }
         let activeProcess = getActiveProcess(sk);
         let proc;
         let lineEmitter;
         let proxyServer = activeProcess?.proxyServer ?? null;
-        if (activeProcess && self.config.hotReloadMcp !== false && self.config.bridgeOpencodeMcp !== false) {
+        if (!compactionMode && activeProcess && self.config.hotReloadMcp !== false && self.config.bridgeOpencodeMcp !== false) {
           const probe = self.effectiveMcpConfig(cwd, void 0, runtimeStatus);
           const previousHash = activeProcess.mcpHash ?? null;
           if (previousHash !== probe.bridgedHash) {
@@ -2544,44 +2828,64 @@ ${plan}
           }
         }
         const setup = async () => {
-          const discovery = self.effectiveMcpConfig(
-            cwd,
-            void 0,
-            runtimeStatus
-          );
-          const proxyMcpTools = await self.resolvedProxyMcpTools(
-            discovery.allEnabledServerNames
-          );
-          const excludeServers = proxyMcpTools ? new Set(discovery.allEnabledServerNames) : void 0;
-          const combinedProxyTools = resolvedProxy || proxyMcpTools ? [...resolvedProxy ?? [], ...proxyMcpTools ?? []] : null;
-          if (!proxyServer && combinedProxyTools) {
-            proxyServer = await self.ensureProxyServer(combinedProxyTools, sk);
+          let cliArgs;
+          let spawnSystemPromptFile;
+          let spawnProxyServer = null;
+          let spawnMcpHash = null;
+          if (compactionMode) {
+            cliArgs = buildCliArgs({
+              sessionKey: sk,
+              skipPermissions,
+              includeSessionId: false,
+              model: effectiveModelId,
+              permissionMode: self.config.permissionMode,
+              cliVersion
+            });
+          } else {
+            const discovery = self.effectiveMcpConfig(
+              cwd,
+              void 0,
+              runtimeStatus
+            );
+            const proxyMcpTools = await self.resolvedProxyMcpTools(
+              discovery.allEnabledServerNames
+            );
+            const excludeServers = proxyMcpTools ? new Set(discovery.allEnabledServerNames) : void 0;
+            const combinedProxyTools = resolvedProxy || proxyMcpTools ? [...resolvedProxy ?? [], ...proxyMcpTools ?? []] : null;
+            if (!proxyServer && combinedProxyTools) {
+              proxyServer = await self.ensureProxyServer(combinedProxyTools, sk);
+            }
+            const proxyDisallowed = resolvedProxy ? disallowedToolFlags(resolvedProxy) : [];
+            const extraDisallowed = [];
+            if (self.config.webSearch === "disabled") extraDisallowed.push("WebSearch");
+            const allDisallowed = [...proxyDisallowed, ...extraDisallowed];
+            const mcp = self.effectiveMcpConfig(
+              cwd,
+              proxyServer?.configPath(),
+              runtimeStatus,
+              excludeServers
+            );
+            const systemPromptFile = activeProcess ? void 0 : buildAppendedSystemPrompt(
+              cwd,
+              self.config.multiStepContinuation !== false
+            );
+            cliArgs = buildCliArgs({
+              sessionKey: sk,
+              skipPermissions,
+              model: self.modelId,
+              permissionMode: self.config.permissionMode,
+              mcpConfig: mcp.paths,
+              strictMcpConfig: self.config.strictMcpConfig,
+              disallowedTools: allDisallowed.length > 0 ? allDisallowed : void 0,
+              appendSystemPromptFile: systemPromptFile,
+              ...self.thinkingCliOptions(),
+              cliVersion
+            });
+            spawnSystemPromptFile = systemPromptFile;
+            spawnProxyServer = proxyServer;
+            spawnMcpHash = mcp.bridgedHash;
           }
-          const proxyDisallowed = resolvedProxy ? disallowedToolFlags(resolvedProxy) : [];
-          const extraDisallowed = [];
-          if (self.config.webSearch === "disabled") extraDisallowed.push("WebSearch");
-          const allDisallowed = [...proxyDisallowed, ...extraDisallowed];
-          const mcp = self.effectiveMcpConfig(
-            cwd,
-            proxyServer?.configPath(),
-            runtimeStatus,
-            excludeServers
-          );
-          const systemPromptFile = activeProcess ? void 0 : buildAppendedSystemPrompt(
-            cwd,
-            self.config.multiStepContinuation !== false
-          );
-          const cliArgs = buildCliArgs({
-            sessionKey: sk,
-            skipPermissions,
-            model: self.modelId,
-            permissionMode: self.config.permissionMode,
-            mcpConfig: mcp.paths,
-            strictMcpConfig: self.config.strictMcpConfig,
-            disallowedTools: allDisallowed.length > 0 ? allDisallowed : void 0,
-            appendSystemPromptFile: systemPromptFile
-          });
-          if (activeProcess) {
+          if (activeProcess && !compactionMode) {
             proc = activeProcess.proc;
             lineEmitter = activeProcess.lineEmitter;
             log.debug("reusing active process", { sk });
@@ -2591,9 +2895,9 @@ ${plan}
               cliArgs,
               cwd,
               sk,
-              proxyServer,
-              mcp.bridgedHash,
-              systemPromptFile
+              spawnProxyServer,
+              spawnMcpHash,
+              spawnSystemPromptFile
             );
             proc = ap.proc;
             lineEmitter = ap.lineEmitter;
@@ -2619,6 +2923,7 @@ ${plan}
           };
           const reasoningIds = /* @__PURE__ */ new Map();
           const reasoningStarted = /* @__PURE__ */ new Map();
+          let hadThinkingTextFromStream = false;
           let turnCompleted = false;
           let controllerClosed = false;
           let pendingProxyUnsubscribe = null;
@@ -2765,11 +3070,6 @@ ${plan}
                   noteReasoning();
                   const reasoningId = generateId();
                   reasoningIds.set(idx, reasoningId);
-                  controller.enqueue({
-                    type: "reasoning-start",
-                    id: reasoningId
-                  });
-                  reasoningStarted.set(idx, true);
                 }
                 if (block.type === "text") {
                   textBlockIndices.add(idx);
@@ -2819,8 +3119,16 @@ ${plan}
                 const idx = msg.index;
                 if (delta.type === "thinking_delta" && delta.thinking) {
                   noteReasoning();
+                  hadThinkingTextFromStream = true;
                   const reasoningId = reasoningIds.get(idx);
                   if (reasoningId) {
+                    if (!reasoningStarted.get(idx)) {
+                      controller.enqueue({
+                        type: "reasoning-start",
+                        id: reasoningId
+                      });
+                      reasoningStarted.set(idx, true);
+                    }
                     controller.enqueue({
                       type: "reasoning-delta",
                       id: reasoningId,
@@ -2849,6 +3157,13 @@ ${plan}
                     });
                   }
                 }
+                if (!KNOWN_DELTA_TYPES.has(delta.type)) {
+                  log.debug("unrecognized content_block_delta type", {
+                    type: delta.type,
+                    idx,
+                    keys: Object.keys(delta)
+                  });
+                }
               }
               if (msg.type === "content_block_stop" && msg.index !== void 0) {
                 const idx = msg.index;
@@ -2946,6 +3261,42 @@ ${plan}
               if (msg.type === "assistant" && msg.message && typeof msg.message.stop_reason === "string") {
                 lastStopReason = msg.message.stop_reason;
               }
+              if (msg.type === "assistant" && msg.message?.content && gotPartialEvents) {
+                const thinkingBlocks = msg.message.content.filter(
+                  (b) => b.type === "thinking"
+                );
+                if (thinkingBlocks.length > 0) {
+                  log.info("assistant message thinking blocks", {
+                    count: thinkingBlocks.length,
+                    hasText: thinkingBlocks.some(
+                      (b) => typeof b.thinking === "string" && b.thinking.length > 0
+                    ),
+                    hadStreamThinking: hadThinkingTextFromStream
+                  });
+                  if (!hadThinkingTextFromStream) {
+                    for (const block of thinkingBlocks) {
+                      if (block.thinking && block.thinking.length > 0) {
+                        noteReasoning();
+                        hadThinkingTextFromStream = true;
+                        const thinkingId = generateId();
+                        controller.enqueue({
+                          type: "reasoning-start",
+                          id: thinkingId
+                        });
+                        controller.enqueue({
+                          type: "reasoning-delta",
+                          id: thinkingId,
+                          delta: block.thinking
+                        });
+                        controller.enqueue({
+                          type: "reasoning-end",
+                          id: thinkingId
+                        });
+                      }
+                    }
+                  }
+                }
+              }
               if (msg.type === "assistant" && msg.message?.content && !gotPartialEvents) {
                 const hasText = msg.message.content.some(
                   (b) => b.type === "text" && b.text
@@ -3234,7 +3585,10 @@ ${plan}
                   finishReason: toFinishReason("stop"),
                   usage: toUsage(msg.usage),
                   providerMetadata: {
-                    "claude-code": resultMeta,
+                    "claude-code": {
+                      ...resultMeta,
+                      ...compactionMode ? { compactionModel: effectiveModelId } : {}
+                    },
                     ...typeof msg.usage?.cache_creation_input_tokens === "number" ? {
                       anthropic: {
                         cacheCreationInputTokens: msg.usage.cache_creation_input_tokens
@@ -3275,7 +3629,10 @@ ${plan}
               finishReason: toFinishReason("stop"),
               usage: toUsage(),
               providerMetadata: {
-                "claude-code": resultMeta
+                "claude-code": {
+                  ...resultMeta,
+                  ...compactionMode ? { compactionModel: effectiveModelId } : {}
+                }
               }
             });
             try {
@@ -3384,7 +3741,7 @@ ${plan}
                 });
                 resolvePendingProxyCallById(call.toolCallId, result);
               } else {
-                log.warn(
+                log.notice(
                   "pending proxy call had no matching tool-result; rejecting as orphan",
                   {
                     sessionKey: sk,
@@ -3875,7 +4232,8 @@ function createClaudeCode(settings = {}) {
       hotReloadMcp: settings.hotReloadMcp ?? true,
       proxyOpencodeMcpTools: settings.proxyOpencodeMcpTools ?? true,
       multiStepContinuation: settings.multiStepContinuation ?? true,
-      autoContinueIncompleteTurns: settings.autoContinueIncompleteTurns ?? "smart"
+      autoContinueIncompleteTurns: settings.autoContinueIncompleteTurns ?? "smart",
+      compactionModel: settings.compactionModel
     });
   };
   const provider = function(modelId) {
@@ -4069,6 +4427,27 @@ var server = async (input) => {
     provider: {
       id: PROVIDER_ID2,
       models: async (provider) => defaultModelsForProvider(provider.models)
+    },
+    // Inject opencode's agent name into providerOptions so the language
+    // model can distinguish /compact (and title) calls from normal turns.
+    // Without this, every no-tools call looks like a title request and
+    // gets short-circuited to a synthetic stub.
+    "chat.params": async (input2, output) => {
+      const providerID = input2.model?.providerID ?? input2.provider?.info?.id;
+      log.debug("chat.params hook fired", {
+        agent: input2.agent,
+        providerID,
+        sessionID: input2.sessionID
+      });
+      if (typeof providerID !== "string") return;
+      if (providerID !== PROVIDER_ID2 && !providerID.startsWith(`${PROVIDER_ID2}-`)) return;
+      if (!input2.agent) return;
+      output.options ??= {};
+      output.options.opencodeAgent = input2.agent;
+      log.debug("chat.params tagged providerOptions", {
+        agent: input2.agent,
+        providerID
+      });
     }
   };
 };