@khalilgharbaoui/opencode-claude-code-plugin 0.19.0 → 0.21.0

package/dist/index.js

@@ -475,9 +475,6 @@ import { randomUUID as randomUUID3 } from "crypto";
 import { EventEmitter as EventEmitter3 } from "events";
 import { unlink } from "fs/promises";
 
-// src/proxy-broker.ts
-import { EventEmitter as EventEmitter2 } from "events";
-
 // src/proxy-mcp.ts
 import { createServer } from "http";
 import * as fs2 from "fs";
@@ -511,7 +508,7 @@ function pluginTmpDir() {
 }
 
 // src/proxy-mcp.ts
-var SSE_KEEPALIVE_MS = 15e3;
+var PROXY_KEEPALIVE_MS = 15e3;
 function acceptsEventStream(acceptHeader) {
   return typeof acceptHeader === "string" && acceptHeader.toLowerCase().includes("text/event-stream");
 }
@@ -523,11 +520,11 @@ var PROTOCOL_VERSION = "2024-11-05";
 var SERVER_NAME = "opencode_proxy";
 var PROXY_TOOL_PREFIX = `mcp__${SERVER_NAME}__`;
 var PROXY_DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
+var PROXY_NO_DEADLINE_MS = 0;
 var PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS = {
-  task: 60 * 60 * 1e3,
-  // 60 min
-  task_batch: 60 * 60 * 1e3,
-  // 60 min, same reasoning: it IS task calls
+  task: PROXY_NO_DEADLINE_MS,
+  task_batch: PROXY_NO_DEADLINE_MS,
+  // same reasoning: it IS task calls
   question: 30 * 60 * 1e3
   // 30 min
 };
@@ -537,7 +534,7 @@ function resolveProxyCallTimeoutMs(toolName, input, overrides) {
   let ms = PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS[key] ?? PROXY_DEFAULT_TIMEOUT_MS;
   if (overrides) {
     const ov = lookupCaseInsensitive(overrides, key);
-    if (typeof ov === "number" && ov > 0) ms = ov;
+    if (isDeadlineOverride(ov)) ms = ov;
   }
   if (key === "bash") {
     const requested = input?.timeout;
@@ -545,6 +542,9 @@ function resolveProxyCallTimeoutMs(toolName, input, overrides) {
   }
   return Math.min(ms, MAX_PROXY_TIMEOUT_MS);
 }
+function isDeadlineOverride(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
 function lookupCaseInsensitive(map, key) {
   if (Object.prototype.hasOwnProperty.call(map, key)) return map[key];
   for (const k of Object.keys(map)) {
@@ -554,14 +554,20 @@ function lookupCaseInsensitive(map, key) {
 }
 function resolveProxyClientCeilingMs(overrides) {
   let ms = PROXY_DEFAULT_TIMEOUT_MS;
-  for (const v of Object.values(PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS)) {
-    if (v > ms) ms = v;
-  }
-  if (overrides) {
-    for (const v of Object.values(overrides)) {
-      if (typeof v === "number" && v > ms) ms = v;
+  const consider = (deadlineMs) => {
+    if (deadlineMs === PROXY_NO_DEADLINE_MS) return true;
+    if (deadlineMs > ms) ms = deadlineMs;
+    return false;
+  };
+  for (const [toolName, defaultMs] of Object.entries(PROXY_PER_TOOL_DEFAULT_TIMEOUT_MS)) {
+    const override = overrides ? lookupCaseInsensitive(overrides, toolName) : void 0;
+    if (consider(isDeadlineOverride(override) ? override : defaultMs)) {
+      return MAX_PROXY_TIMEOUT_MS;
     }
   }
+  for (const value of Object.values(overrides ?? {})) {
+    if (isDeadlineOverride(value) && consider(value)) return MAX_PROXY_TIMEOUT_MS;
+  }
   return Math.min(ms, MAX_PROXY_TIMEOUT_MS);
 }
 function buildProxyTimeoutError(toolName, ms) {
@@ -574,9 +580,9 @@ function buildProxyTimeoutError(toolName, ms) {
   }
   return new Error(base);
 }
-var TASK_PROXY_NOTE = "This and task_batch are the ONLY tools that dispatch opencode subagents (including user @-mentions). Claude Code's built-in TaskCreate/TaskUpdate manage a local todo list and cannot dispatch subagents. Do not search config files to verify a subagent type exists: invalid types fail fast with a clear error. Foreground calls block until the subagent finishes; set `background` to request opencode's background execution mode. For two or more independent subagents in one response use task_batch, not several task calls: those run one after another. Task calls get a 60-minute proxy deadline by default (configurable via proxyToolTimeoutMs).";
+var TASK_PROXY_NOTE = "This and task_batch are the ONLY tools that dispatch opencode subagents (including user @-mentions). Claude Code's built-in TaskCreate/TaskUpdate manage a local todo list and cannot dispatch subagents. Do not search config files to verify a subagent type exists: invalid types fail fast with a clear error. Foreground calls block until the subagent finishes; set `background` to request opencode's background execution mode. For two or more independent subagents in one response use task_batch, not several task calls: those run one after another. Task calls have no proxy deadline by default: the call waits for the subagent to finish (a positive proxyToolTimeoutMs override adds a deadline).";
 var TASK_BATCH_TOOL_NAME = "task_batch";
-var TASK_BATCH_PROXY_NOTE = "Use this instead of several task calls in one response: Claude Code runs MCP tool calls one at a time, so separate task calls run serially even when emitted together, while one task_batch call fans them out as parallel opencode task calls. Each task takes the same fields as the task tool. Results come back in task order, each labelled. Same 60-minute proxy deadline as task (configurable via proxyToolTimeoutMs).";
+var TASK_BATCH_PROXY_NOTE = "Use this instead of several task calls in one response: Claude Code runs MCP tool calls one at a time, so separate task calls run serially even when emitted together, while one task_batch call fans them out as parallel opencode task calls. Each task takes the same fields as the task tool. Results come back in task order, each labelled. Like task it has no proxy deadline by default (a positive proxyToolTimeoutMs override adds one).";
 var TASK_INPUT_REQUIRED = ["description", "prompt", "subagent_type"];
 function taskBatchInputError(input) {
   const tasks = input?.tasks;
@@ -874,9 +880,10 @@ var DEFAULT_PROXY_TOOLS = [
     }
   }
 ];
-async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverrides, interceptors) {
+async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverrides, interceptors, options = {}) {
   const calls = new EventEmitter();
   const pending = /* @__PURE__ */ new Map();
+  const keepaliveMs = options.keepaliveMs ?? PROXY_KEEPALIVE_MS;
   const authToken = crypto.randomBytes(32).toString("hex");
   const expectedAuth = Buffer.from(`Bearer ${authToken}`);
   let boundAuthority = "";
@@ -925,7 +932,7 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
     }
     let requestId = null;
     let requestMethod = null;
-    let sse = null;
+    let reply = null;
     try {
       const body = await readBody(req);
       const request = JSON.parse(body);
@@ -1020,11 +1027,9 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
           sse: acceptsEventStream(req.headers.accept)
         });
         const channel = { closed: false };
-        if (acceptsEventStream(req.headers.accept)) {
-          sse = openEventStream(res);
-        }
+        reply = acceptsEventStream(req.headers.accept) ? openEventStream(res, keepaliveMs) : openJsonStream(res, keepaliveMs);
         res.once("close", () => {
-          sse?.stop();
+          reply?.stop();
           if (res.writableFinished) return;
           channel.closed = true;
           log.notice("proxy-mcp client closed a tool call before its result", {
@@ -1049,16 +1054,18 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
               input,
               timeoutOverrides
             );
-            timer = setTimeout(() => {
-              if (!pending.has(callId)) return;
-              pending.delete(callId);
-              log.notice("proxy-mcp tool call timed out", {
-                callId,
-                toolName,
-                deadlineMs
-              });
-              reject2(buildProxyTimeoutError(toolName, deadlineMs));
-            }, deadlineMs);
+            if (deadlineMs > PROXY_NO_DEADLINE_MS) {
+              timer = setTimeout(() => {
+                if (!pending.has(callId)) return;
+                pending.delete(callId);
+                log.notice("proxy-mcp tool call timed out", {
+                  callId,
+                  toolName,
+                  deadlineMs
+                });
+                reject2(buildProxyTimeoutError(toolName, deadlineMs));
+              }, deadlineMs);
+            }
             calls.emit("call", entry);
           }
         ).finally(() => {
@@ -1072,7 +1079,7 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
           });
           return;
         }
-        writeToolCallResult(res, requestId, result, sse);
+        writeToolCallResult(res, requestId, result, reply);
         return;
       }
       writeJson(res, {
@@ -1092,7 +1099,7 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
             res,
             requestId,
             { kind: "error", message: errorMessage },
-            sse
+            reply
           );
         } catch {
           try {
@@ -1174,6 +1181,9 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS, timeoutOverride
       configFilePath = outPath;
       return outPath;
     },
+    pendingCallIds() {
+      return [...pending.keys()];
+    },
     async close() {
       for (const entry of pending.values()) {
         entry.reject(new Error(SERVER_CLOSED_MESSAGE));
@@ -1238,6 +1248,61 @@ function resolveDisallowedTools(options) {
   if (options.disableWebSearch) push("WebSearch");
   return out;
 }
+function resolveProxyOpencodeToolDefs(options) {
+  const requested = options.requested ?? [];
+  if (requested.length === 0) return [];
+  const items = options.items;
+  if (!items) {
+    log.warn(
+      "proxyOpencodeTools is set but opencode's tool registry did not answer; forwarding nothing this spawn",
+      { requested: requested.map(String) }
+    );
+    return [];
+  }
+  const byLowerId = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = item.id.toLowerCase();
+    if (!byLowerId.has(key)) byLowerId.set(key, item);
+  }
+  const taken = options.taken ?? /* @__PURE__ */ new Set();
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const unknown = [];
+  const collided = [];
+  for (const raw of requested) {
+    const name = String(raw).trim();
+    if (!name) continue;
+    const item = byLowerId.get(name.toLowerCase());
+    if (!item) {
+      unknown.push(name);
+      continue;
+    }
+    if (taken.has(item.id)) {
+      collided.push(item.id);
+      continue;
+    }
+    if (seen.has(item.id)) continue;
+    seen.add(item.id);
+    out.push({
+      name: item.id,
+      description: typeof item.description === "string" ? item.description : "",
+      inputSchema: item.parameters && typeof item.parameters === "object" ? item.parameters : { type: "object", properties: {} }
+    });
+  }
+  if (unknown.length > 0) {
+    log.warn("ignoring unknown proxyOpencodeTools entries", {
+      unknown,
+      known: [...byLowerId.values()].map((item) => item.id).join(", ")
+    });
+  }
+  if (collided.length > 0) {
+    log.warn(
+      "proxyOpencodeTools entry dropped: a proxy tool already holds that name, and it keeps it",
+      { collided }
+    );
+  }
+  return out;
+}
 function readBody(req) {
   return new Promise((resolve5, reject) => {
     const chunks = [];
@@ -1246,7 +1311,7 @@ function readBody(req) {
     req.on("error", reject);
   });
 }
-function writeToolCallResult(res, requestId, result, sse = null) {
+function writeToolCallResult(res, requestId, result, reply = null) {
   const text = result.kind === "error" ? result.message : result.text;
   const isError = result.kind === "error" || result.isError === true;
   const envelope = {
@@ -1257,26 +1322,20 @@ function writeToolCallResult(res, requestId, result, sse = null) {
       isError
     }
   };
-  if (sse) {
-    sse.finish(envelope);
+  if (reply) {
+    reply.finish(envelope);
     return;
   }
   writeJson(res, envelope);
 }
-function openEventStream(res) {
-  res.statusCode = 200;
-  res.setHeader("Content-Type", "text/event-stream");
-  res.setHeader("Cache-Control", "no-cache, no-transform");
-  res.setHeader("Connection", "keep-alive");
-  res.flushHeaders();
-  res.write(": open\n\n");
+function startKeepalive(res, keepaliveMs, ping) {
   let timer = setInterval(() => {
     if (res.writableEnded || res.destroyed) {
       stop();
       return;
     }
-    res.write(": keepalive\n\n");
-  }, SSE_KEEPALIVE_MS);
+    res.write(ping);
+  }, keepaliveMs);
   timer.unref?.();
   const stop = () => {
     if (timer) {
@@ -1284,6 +1343,16 @@ function openEventStream(res) {
       timer = null;
     }
   };
+  return stop;
+}
+function openEventStream(res, keepaliveMs) {
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache, no-transform");
+  res.setHeader("Connection", "keep-alive");
+  res.flushHeaders();
+  res.write(": open\n\n");
+  const stop = startKeepalive(res, keepaliveMs, ": keepalive\n\n");
   return {
     stop,
     finish(envelope) {
@@ -1296,6 +1365,21 @@ data: ${JSON.stringify(envelope)}
     }
   };
 }
+function openJsonStream(res, keepaliveMs) {
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "application/json");
+  res.setHeader("Cache-Control", "no-cache, no-transform");
+  res.flushHeaders();
+  const stop = startKeepalive(res, keepaliveMs, " ");
+  return {
+    stop,
+    finish(envelope) {
+      stop();
+      if (res.writableEnded || res.destroyed) return;
+      res.end(JSON.stringify(envelope));
+    }
+  };
+}
 function writeJson(res, body) {
   if (res.destroyed || res.writableEnded) return;
   const payload = JSON.stringify(body);
@@ -1306,6 +1390,12 @@ function writeJson(res, body) {
 }
 
 // src/proxy-broker.ts
+import { EventEmitter as EventEmitter2 } from "events";
+var PROXY_STALL_WARNING_MS = 5 * 6e4;
+function clearPendingTimers(pending) {
+  if (pending.timer) clearTimeout(pending.timer);
+  if (pending.stallTimer) clearInterval(pending.stallTimer);
+}
 var pendingByCallId = /* @__PURE__ */ new Map();
 var callIdsBySession = /* @__PURE__ */ new Map();
 var emitter = new EventEmitter2();
@@ -1331,10 +1421,10 @@ function onPendingProxyCall(sessionKey2, handler) {
   emitter.on(name, handler);
   return () => emitter.off(name, handler);
 }
-function queuePendingProxyCall(sessionKey2, call, timeoutOverrides) {
+function queuePendingProxyCall(sessionKey2, call, timeoutOverrides, stallWarningMs = PROXY_STALL_WARNING_MS) {
   const previous = pendingByCallId.get(call.id);
   if (previous) {
-    clearTimeout(previous.timer);
+    clearPendingTimers(previous);
     previous.reject(
       new Error(`Replaced pending proxy call ${call.id} with a fresh one`)
     );
@@ -1346,11 +1436,12 @@ function queuePendingProxyCall(sessionKey2, call, timeoutOverrides) {
     call.input,
     timeoutOverrides
   );
-  const timer = setTimeout(() => {
+  const timer = deadlineMs > PROXY_NO_DEADLINE_MS ? setTimeout(() => {
     const current = pendingByCallId.get(call.id);
     if (!current) return;
     pendingByCallId.delete(call.id);
     indexRemove(current.sessionKey, call.id);
+    clearPendingTimers(current);
     current.reject(buildProxyTimeoutError(call.toolName, deadlineMs));
     log.notice("timed out pending proxy call", {
       sessionKey: current.sessionKey,
@@ -1358,7 +1449,21 @@ function queuePendingProxyCall(sessionKey2, call, timeoutOverrides) {
       toolName: call.toolName,
       deadlineMs
     });
-  }, deadlineMs);
+  }, deadlineMs) : null;
+  const stallTimer = deadlineMs === PROXY_NO_DEADLINE_MS && stallWarningMs > 0 ? setInterval(() => {
+    const current = pendingByCallId.get(call.id);
+    if (!current) return;
+    log.warn("proxy call still waiting, no deadline", {
+      sessionKey: current.sessionKey,
+      toolCallId: current.toolCallId,
+      toolName: current.toolName,
+      waitedMs: Date.now() - current.createdAt,
+      emitted: current.emitted === true,
+      channelClosed: current.channel?.closed === true,
+      note: "nothing will time this out; it ends when opencode returns a result, you abort, you send another message, or the claude process goes"
+    });
+  }, stallWarningMs) : null;
+  stallTimer?.unref?.();
   const pending = {
     sessionKey: sessionKey2,
     toolCallId: call.id,
@@ -1368,6 +1473,7 @@ function queuePendingProxyCall(sessionKey2, call, timeoutOverrides) {
     createdAt: Date.now(),
     deadlineMs,
     timer,
+    stallTimer,
     resolve: call.resolve,
     reject: call.reject
   };
@@ -1418,7 +1524,7 @@ function resolvePendingProxyCallById(toolCallId, result) {
   if (!pending) return false;
   pendingByCallId.delete(toolCallId);
   indexRemove(pending.sessionKey, toolCallId);
-  clearTimeout(pending.timer);
+  clearPendingTimers(pending);
   pending.resolve(result);
   log.info("resolved pending proxy call", {
     sessionKey: pending.sessionKey,
@@ -1432,7 +1538,7 @@ function rejectPendingProxyCallById(toolCallId, error) {
   if (!pending) return false;
   pendingByCallId.delete(toolCallId);
   indexRemove(pending.sessionKey, toolCallId);
-  clearTimeout(pending.timer);
+  clearPendingTimers(pending);
   pending.reject(error);
   log.notice("rejected pending proxy call", {
     sessionKey: pending.sessionKey,
@@ -1864,9 +1970,14 @@ var activeProcesses = /* @__PURE__ */ new Map();
 var claudeSessions = /* @__PURE__ */ new Map();
 var idleEvictionTimers = /* @__PURE__ */ new Map();
 var MAX_IDLE_TIMEOUT_MS = 2147483647;
+var DEFAULT_IDLE_PROCESS_TIMEOUT_MS = 0;
+function resolveIdleProcessTimeoutMs(configured) {
+  return configured === void 0 ? DEFAULT_IDLE_PROCESS_TIMEOUT_MS : configured;
+}
 var MAX_ACTIVE_PROCESSES = 16;
 var PROCESS_EXIT_TIMEOUT_MS = 1500;
 var PROCESS_FORCE_EXIT_TIMEOUT_MS = 500;
+var CHILD_EXITED_MESSAGE = "Claude CLI subprocess closed before pending tool calls were resolved";
 function envFlagEnabled(value) {
   if (value === void 0) return false;
   const normalized = value.trim().toLowerCase();
@@ -2016,6 +2127,11 @@ function scheduleIdleProcessEviction(key, timeoutMs) {
   const timer = setTimeout(() => {
     idleEvictionTimers.delete(key);
     if (activeProcesses.get(key) !== scheduledProcess) return;
+    if (isTurnInFlight(scheduledProcess)) {
+      log.info("idle timer found a turn in flight; re-arming", { sessionKey: key, timeoutMs });
+      scheduleIdleProcessEviction(key, timeoutMs);
+      return;
+    }
     log.info("evicting idle claude process", { sessionKey: key, timeoutMs });
     deleteActiveProcess(key);
   }, timeoutMs);
@@ -2027,9 +2143,44 @@ function detachActiveProcess(key) {
   const ap = activeProcesses.get(key);
   if (!ap) return void 0;
   activeProcesses.delete(key);
-  void ap.proxyServer?.close();
+  if (ap.proxyServer) {
+    void ap.proxyServer.close();
+    rejectAllPendingProxyCallsForSession(key, new Error(SERVER_CLOSED_MESSAGE));
+  }
   return ap;
 }
+function deleteActiveProcessesForSession(sessionID) {
+  if (!sessionID || sessionID === "default") return [];
+  const released = [];
+  for (const [key, ap] of [...activeProcesses]) {
+    const owned = ap.opencodeSessionID === sessionID || describeSessionKey(key).session === sessionID;
+    if (!owned) continue;
+    log.info("releasing claude process for deleted session", { sessionKey: key, sessionID });
+    void deleteActiveProcessAndWait(key);
+    released.push(key);
+  }
+  for (const key of [...claudeSessions.keys()]) {
+    if (describeSessionKey(key).session !== sessionID) continue;
+    deleteClaudeSessionId(key);
+    clearCompression(key);
+    if (!released.includes(key)) released.push(key);
+  }
+  return released;
+}
+function killAllActiveProcesses() {
+  const keys = [...activeProcesses.keys()];
+  for (const key of keys) deleteActiveProcess(key);
+  return keys;
+}
+var processExitCleanupWired = false;
+function ensureProcessExitCleanup() {
+  if (processExitCleanupWired) return false;
+  processExitCleanupWired = true;
+  process.once("exit", () => {
+    killAllActiveProcesses();
+  });
+  return true;
+}
 function deleteActiveProcess(key) {
   const ap = detachActiveProcess(key);
   ap?.proc.kill();
@@ -2178,6 +2329,12 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
     if (ownsSessionKey) {
       cancelIdleProcessEviction(sessionKey2);
       activeProcesses.delete(sessionKey2);
+      if (getPendingProxyCalls(sessionKey2).length > 0) {
+        rejectAllPendingProxyCallsForSession(
+          sessionKey2,
+          new Error(CHILD_EXITED_MESSAGE)
+        );
+      }
     }
     if (ownsSessionKey && code !== 0 && code !== null) {
       log.info("process exited with error, clearing session", {
@@ -2218,6 +2375,7 @@ function appendResumeIfNeeded(sessionKey2, cliArgs) {
 function respawnActiveProcess(sessionKey2, cliPath, cliArgs, cwd, ignoreAnthropicApiKey) {
   const old = activeProcesses.get(sessionKey2);
   if (!old) return void 0;
+  const turnWasInFlight = isTurnInFlight(old);
   activeProcesses.delete(sessionKey2);
   old.proc.removeAllListeners("exit");
   try {
@@ -2237,6 +2395,7 @@ function respawnActiveProcess(sessionKey2, cliPath, cliArgs, cwd, ignoreAnthropi
   );
   replacement.pendingProxyCompletions = old.pendingProxyCompletions;
   delete old.pendingProxyCompletions;
+  if (turnWasInFlight) noteTurnStarted(replacement);
   return replacement;
 }
 function buildCliArgs(opts) {
@@ -3532,10 +3691,9 @@ function formatDoctorReport(report) {
     lines.push("| tool | call id | age | deadline |");
     lines.push("|---|---|---|---|");
     for (const call of report.pendingCalls) {
+      const deadline = call.deadlineMs > 0 ? formatAge(call.deadlineMs) : "none";
       lines.push(
-        `| ${call.toolName} | \`${call.toolCallId}\` | ${formatAge(call.ageMs)} | ${formatAge(
-          call.deadlineMs
-        )} |`
+        `| ${call.toolName} | \`${call.toolCallId}\` | ${formatAge(call.ageMs)} | ${deadline} |`
       );
     }
   }
@@ -3758,6 +3916,35 @@ function filterSideQuestionHistory(prompt) {
     (message) => message.role === "assistant" ? { ...message, content: stripPluginNotes(message.content) } : message
   );
 }
+var DCP_REMINDER_BLOCK = /<dcp-system-reminder\b[^>]*>[\s\S]*?<\/dcp-system-reminder>/gi;
+function stripContextReminderBlocks(text) {
+  if (!text.includes("<dcp-system-reminder")) return text;
+  return text.replace(DCP_REMINDER_BLOCK, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function shouldStripContextReminders(options) {
+  if (options.enabled !== true) return false;
+  const namesCompress = (list2) => (list2 ?? []).some((name) => String(name).trim().toLowerCase() === "compress");
+  return !namesCompress(options.proxyTools) && !namesCompress(options.proxyOpencodeTools);
+}
+function stripContextReminders(prompt) {
+  let removed = 0;
+  const countIn = (text) => (text.match(DCP_REMINDER_BLOCK) ?? []).length;
+  const out = prompt.map((message) => {
+    if (message.role !== "user" && message.role !== "assistant") return message;
+    if (!Array.isArray(message.content)) return message;
+    let touched = false;
+    const parts = message.content.map((part) => {
+      if (!part || part.type !== "text" || typeof part.text !== "string") return part;
+      const hits = countIn(part.text);
+      if (hits === 0) return part;
+      removed += hits;
+      touched = true;
+      return { ...part, text: stripContextReminderBlocks(part.text) };
+    });
+    return touched ? { ...message, content: parts } : message;
+  });
+  return removed > 0 ? { prompt: out, removed } : { prompt, removed: 0 };
+}
 var SUPPORTED_IMAGE_TYPES = /* @__PURE__ */ new Set([
   "image/jpeg",
   "image/png",
@@ -3957,6 +4144,15 @@ function getClaudeUserMessage(prompt, includeHistoryContext = false, opts = {})
   const compactionMode = opts.compactionMode === true;
   const cliToolCallIds = opts.cliToolCallIds;
   const content = [];
+  if (opts.stripContextReminders) {
+    const stripped = stripContextReminders(prompt);
+    if (stripped.removed > 0) {
+      log.info("stripped unsatisfiable context reminders", {
+        blocks: stripped.removed
+      });
+      prompt = stripped.prompt;
+    }
+  }
   const pushToolResult = (part) => {
     const id = part.toolCallId;
     const text = getToolResultText(part);
@@ -5059,7 +5255,7 @@ ${text}`
   }
   return parts.join("\n\n");
 }
-function spawnInteractiveProcess(opts) {
+function interactiveExtraArgs(opts) {
   const extraArgs = [];
   if (opts.mcpConfigPaths && opts.mcpConfigPaths.length > 0) {
     extraArgs.push(
@@ -5068,6 +5264,9 @@ function spawnInteractiveProcess(opts) {
       "--strict-mcp-config"
     );
   }
+  for (const dir of opts.pluginDirs ?? []) {
+    extraArgs.push("--plugin-dir", dir);
+  }
   const flagSettings = {};
   if (opts.permissionsAllow && opts.permissionsAllow.length > 0) {
     flagSettings.permissions = { allow: opts.permissionsAllow };
@@ -5088,6 +5287,10 @@ function spawnInteractiveProcess(opts) {
   if (opts.systemPromptFile) {
     extraArgs.push("--append-system-prompt-file", opts.systemPromptFile);
   }
+  return extraArgs;
+}
+function spawnInteractiveProcess(opts) {
+  const extraArgs = interactiveExtraArgs(opts);
   const session = new ClaudeSession({
     cwd: opts.cwd,
     cliPath: opts.cliPath,
@@ -5503,6 +5706,14 @@ You are running via the Claude Code CLI (not a direct API call). This affects co
 - 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.`;
+var CLAUDE_CLI_OPENCODE_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\`. Use that exact full name. It runs opencode's own \`compress\` tool, which is what a "MAX CONTEXT LIMIT REACHED" reminder is asking you to do.
+- It compresses opencode's stored conversation, NOT this Claude Code session. Your current session keeps the context it already has, so do not assume earlier detail is gone after the call.
+- 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) {
@@ -5529,7 +5740,7 @@ ${options.compressionSummary.trim()}`
     );
   }
   parts.push(
-    options.compressEnabled ? CLAUDE_CLI_COMPRESS_NOTE : CLAUDE_CLI_CONTEXT_NOTE
+    options.compressEnabled ? CLAUDE_CLI_COMPRESS_NOTE : options.opencodeCompressEnabled ? CLAUDE_CLI_OPENCODE_COMPRESS_NOTE : CLAUDE_CLI_CONTEXT_NOTE
   );
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
@@ -5776,9 +5987,22 @@ var ClaudeCodeLanguageModel = class {
       resolved: items !== void 0,
       taskDescription: items?.find((item) => item.id === "task")?.description,
       questionDescription: question?.description,
-      hasQuestion: !!question
+      hasQuestion: !!question,
+      items
     };
   }
+  /**
+   * Whether dcp-style context reminders should be stripped from this turn's
+   * messages. Config-only and synchronous, so it can be answered before the
+   * spawn block resolves anything: `userMsg` is built well ahead of it.
+   */
+  stripContextRemindersEnabled() {
+    return shouldStripContextReminders({
+      enabled: this.config.stripContextReminders,
+      proxyTools: this.config.proxyTools,
+      proxyOpencodeTools: this.config.proxyOpencodeTools
+    });
+  }
   /** Share one lazy registry request within a turn without making it stale. */
   createLiveToolInfoLoader() {
     let pending;
@@ -5814,10 +6038,10 @@ var ClaudeCodeLanguageModel = class {
    * 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) {
+  async ensureProxyServer(tools, sessionKeyForCalls, interceptCompress) {
     const timeoutOverrides = this.config.proxyToolTimeoutMs;
     const interceptors = /* @__PURE__ */ new Map();
-    if (tools.some((t) => t.name === "compress")) {
+    if (interceptCompress && tools.some((t) => t.name === "compress")) {
       interceptors.set("compress", (input) => {
         const summary = typeof input.summary === "string" ? input.summary.trim() : "";
         if (!summary) {
@@ -6258,7 +6482,8 @@ var ClaudeCodeLanguageModel = class {
     // at all: every tool result reaching it belongs to opencode and must be
     // rendered as text rather than an orphaned `tool_result` (issue #29).
     getClaudeUserMessage(options.prompt, includeHistoryContext, {
-      cliToolCallIds: /* @__PURE__ */ new Set()
+      cliToolCallIds: /* @__PURE__ */ new Set(),
+      stripContextReminders: this.stripContextRemindersEnabled()
     });
     const [runtimeStatus, cliVersion, planModeQuestionActive] = await Promise.all([
       getRuntimeMcpStatus(),
@@ -6274,6 +6499,11 @@ var ClaudeCodeLanguageModel = class {
       { compressEnabled: false, compressionSummary: getCompressionSummary(sk) }
     );
     const { model: spawnModelId, fast: fastMode } = parseModelId(effectiveModelId);
+    const skillPluginDirs = await resolveSkillPluginDirs({
+      cwd,
+      cliPath: this.config.cliPath,
+      enabled: this.config.bridgeOpencodeSkills === true
+    });
     const cliArgs = buildCliArgs({
       sessionKey: sk,
       skipPermissions: this.config.skipPermissions !== false,
@@ -6284,6 +6514,7 @@ var ClaudeCodeLanguageModel = class {
       strictMcpConfig: this.config.strictMcpConfig,
       disallowedTools: this.config.webSearch === "disabled" ? ["WebSearch"] : void 0,
       appendSystemPromptFile: systemPromptFile,
+      pluginDirs: skillPluginDirs,
       ...this.thinkingCliOptions(),
       fastMode,
       cliVersion
@@ -6771,7 +7002,8 @@ ${plan}
     const previousPendingProxyCalls = compactionMode ? [] : getPendingProxyCalls(sk);
     const userMsg = exitPlanModeQuestionResult ?? getClaudeUserMessage(options.prompt, includeHistoryContext, {
       compactionMode,
-      cliToolCallIds: new Set(previousPendingProxyCalls.map((c) => c.toolCallId))
+      cliToolCallIds: new Set(previousPendingProxyCalls.map((c) => c.toolCallId)),
+      stripContextReminders: this.stripContextRemindersEnabled()
     });
     const resolvedProxy = compactionMode ? null : this.resolvedProxyTools();
     const loadLiveToolInfo = this.createLiveToolInfoLoader();
@@ -6883,6 +7115,11 @@ ${plan}
                   "interactiveBypass ignored: Claude Code prompts for bypassPermissions confirmation in the interactive TUI"
                 );
               }
+              const skillPluginDirs = await resolveSkillPluginDirs({
+                cwd,
+                cliPath,
+                enabled: self.config.bridgeOpencodeSkills === true
+              });
               const ap = spawnInteractiveProcess({
                 cwd,
                 cliPath,
@@ -6890,6 +7127,7 @@ ${plan}
                 model: spawnModelId,
                 fastMode,
                 mcpConfigPaths: mcp.paths,
+                pluginDirs: skillPluginDirs,
                 permissionsAllow: allow,
                 systemPromptFile,
                 ignoreAnthropicApiKey: self.config.ignoreAnthropicApiKey,
@@ -6933,7 +7171,12 @@ ${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 loadLiveToolInfo() : {
+              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,
                 questionDescription: void 0,
@@ -6969,13 +7212,33 @@ ${plan}
                   kept: liveToolInfo.hasQuestion
                 });
               }
+              const opencodeToolDefs = resolveProxyOpencodeToolDefs({
+                requested: self.config.proxyOpencodeTools,
+                items: liveToolInfo.items,
+                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 ?? []
+                ...proxyMcpTools ?? [],
+                ...opencodeToolDefs
               ];
               const combinedProxyTools = combinedList.length > 0 ? combinedList : null;
+              const pluginCompressEnabled = enrichedProxy?.some((t) => t.name === "compress") ?? false;
               if (!proxyServer && combinedProxyTools) {
-                proxyServer = await self.ensureProxyServer(combinedProxyTools, sk);
+                proxyServer = await self.ensureProxyServer(
+                  combinedProxyTools,
+                  sk,
+                  pluginCompressEnabled
+                );
               }
               const questionProxyActive = enrichedProxy?.some((t) => t.name === "question") ?? false;
               const allDisallowed = resolveDisallowedTools({
@@ -6998,7 +7261,10 @@ ${plan}
                   ...questionProxyActive ? [QUESTION_PROXY_HINT] : []
                 ],
                 {
-                  compressEnabled: enrichedProxy?.some((t) => t.name === "compress") ?? false,
+                  compressEnabled: pluginCompressEnabled,
+                  opencodeCompressEnabled: opencodeToolDefs.some(
+                    (t) => t.name === "compress"
+                  ),
                   compressionSummary: getCompressionSummary(sk)
                 }
               );
@@ -7221,6 +7487,7 @@ ${plan}
             if (entries.length === 0) return false;
             endTextBlock();
             watchdogMessage = makeLateProxyResultMessage(entries);
+            if (activeProcess) noteTurnStarted(activeProcess);
             proc.stdin.write(watchdogMessage + "\n");
             for (const { call } of entries) pending.delete(call.toolCallId);
             log.warn("delivering proxy results after interrupted continuation", {
@@ -7482,7 +7749,10 @@ ${plan}
             controllerClosed = true;
             cleanupTurn();
             if (!useInteractive && !compactionMode) {
-              scheduleIdleProcessEviction(sk, self.config.idleProcessTimeoutMs);
+              scheduleIdleProcessEviction(
+                sk,
+                resolveIdleProcessTimeoutMs(self.config.idleProcessTimeoutMs)
+              );
             }
             try {
               controller.close();
@@ -8277,7 +8547,7 @@ ${plan}
                       if (outer.session_id) setClaudeSessionId(sk, outer.session_id);
                       if (msg.is_error && msg.result) text = msg.result;
                     }
-                    if (text) controller.enqueue({ type: "text-delta", id: startTextBlock(), delta: text });
+                    if (text) controller.enqueue({ type: "text-delta", id: currentTextId ?? startTextBlock(), delta: text });
                   } catch {
                   }
                 }
@@ -8334,9 +8604,25 @@ ${plan}
           });
           proc.on("error", procErrorHandler);
           if (options.abortSignal) {
+            const releaseAbandonedProxyCalls = (reason) => {
+              if (drainBuffer.length === 0 && getPendingProxyCalls(sk).length === 0) return;
+              rejectAllPendingProxyCallsForSession(sk, new Error(reason));
+              drainBuffer.length = 0;
+            };
             options.abortSignal.addEventListener("abort", () => {
               autoContinueState.aborted = true;
-              if (turnCompleted || controllerClosed) return;
+              if (turnCompleted || controllerClosed) {
+                if (activeProcess && activeProcess.lineEmitter.listenerCount("line") === 0 && getPendingProxyCalls(sk).length > 0) {
+                  log.info("abort between proxy tool boundaries; releasing pending calls", { sk });
+                  void interruptTurn(activeProcess).then((idle) => {
+                    log.info("interrupt sent for aborted turn", { sk, idle });
+                  });
+                  releaseAbandonedProxyCalls(
+                    "Provider stream was aborted while opencode was running its proxy tool calls"
+                  );
+                }
+                return;
+              }
               if (activeProcess) {
                 void interruptTurn(activeProcess).then((idle) => {
                   log.info("interrupt sent for aborted turn", { sk, idle });
@@ -8347,15 +8633,9 @@ ${plan}
                   "abort signal received before content, closing stream immediately",
                   { cwd }
                 );
-                if (drainBuffer.length > 0 || getPendingProxyCalls(sk).length > 0) {
-                  rejectAllPendingProxyCallsForSession(
-                    sk,
-                    new Error(
-                      "Provider stream was aborted before pending proxy calls were emitted"
-                    )
-                  );
-                  drainBuffer.length = 0;
-                }
+                releaseAbandonedProxyCalls(
+                  "Provider stream was aborted before pending proxy calls were emitted"
+                );
                 controllerClosed = true;
                 cleanupTurn();
                 try {
@@ -8368,6 +8648,9 @@ ${plan}
                 "abort signal received mid-turn, starting grace period",
                 { cwd }
               );
+              releaseAbandonedProxyCalls(
+                "Provider stream was aborted while proxy tool calls were pending"
+              );
               startResultFallback(5e3);
             });
           }
@@ -8805,6 +9088,8 @@ function createClaudeCode(settings = {}) {
       controlRequestToolBehaviors: settings.controlRequestToolBehaviors,
       controlRequestDenyMessage: settings.controlRequestDenyMessage,
       proxyTools,
+      proxyOpencodeTools: settings.proxyOpencodeTools,
+      stripContextReminders: settings.stripContextReminders === true,
       extraDisallowedTools: settings.extraDisallowedTools,
       proxyToolTimeoutMs: settings.proxyToolTimeoutMs,
       planModeQuestion: settings.planModeQuestion ?? false,
@@ -9007,8 +9292,16 @@ async function buildAgentRegistry(config) {
     defaultSubagentModel: getDefaultSubagentModel()
   });
 }
+function extractDeletedSessionId(event) {
+  const payload = event?.payload ?? event;
+  if (!payload || payload.type !== "session.deleted") return void 0;
+  const properties = payload.properties;
+  const id = properties?.info?.id;
+  return typeof id === "string" && id.length > 0 ? id : void 0;
+}
 var server = async (input) => {
   cleanupStaleUnscopedInstall();
+  ensureProcessExitCleanup();
   const opencodeVersion = pickOpencodeVersion(input);
   if (input && typeof input === "object" && "client" in input) {
     setOpencodeClient(input.client);
@@ -9043,10 +9336,21 @@ var server = async (input) => {
         opencodeVersion
       );
     },
-    // No `event` hook: MCP config drift is detected at turn start by the
-    // hot-reload check in `claude-code-language-model.ts`, which respawns
-    // claude safely between turns. Eviction on `global.disposed` would kill
-    // an in-flight stream and abort the user's current turn.
+    // Only `session.deleted` is acted on. MCP config drift is still detected
+    // at turn start by the hot-reload check in `claude-code-language-model.ts`,
+    // which respawns claude safely between turns, and eviction on
+    // `global.disposed` would kill an in-flight stream and abort the user's
+    // current turn. A deleted session has no turn left to abort, and its
+    // `claude` child would otherwise linger until the idle timer or LRU
+    // pressure took it, with its session id kept for a resume that never comes.
+    event: async ({ event }) => {
+      const sessionID = extractDeletedSessionId(event);
+      if (!sessionID) return;
+      const released = deleteActiveProcessesForSession(sessionID);
+      if (released.length > 0) {
+        log.info("released claude state for deleted session", { sessionID, released });
+      }
+    },
     provider: {
       id: PROVIDER_ID2,
       models: async (provider) => defaultModelsForProvider(provider.models)
@@ -9101,6 +9405,7 @@ export {
   createClaudeCode,
   index_default as default,
   defaultModels,
+  extractDeletedSessionId,
   getAgentRegistry,
   getDefaultSubagentModel,
   registerDoctorCommand,