@khalilgharbaoui/opencode-claude-code-plugin 0.36.4 → 0.36.5

package/README.md

@@ -59,6 +59,7 @@ Nothing in the picker? [Troubleshooting](./docs/troubleshooting/symptoms.md) is
 | **Subagents: your account, their model** | `forceModel`, `reasoningEffort` and `cacheTtl` in an agent file, inheriting the caller's account. `task_batch` runs several subagents at once. [Subagents](./docs/configuration/subagents.md) |
 | **18 models, reasoning variants, fast mode** | Haiku 4.5 through Opus 5.5, Fable and Mythos, each with a `(N×)` list-price suffix, `low` to `max` effort variants, and a fallback chain for a model this account cannot run today. [Models](./docs/models.md) |
 | **`/btw` and `/claude-code-doctor`** | Side questions on the live process, and a health report whose `bundle` form is redacted by allowlist so it is safe to paste into a public issue. [`/btw`](./docs/guides/btw.md) · [Doctor](./docs/guides/doctor.md) |
+| **Ships its own setup skill** | Ask Claude to configure it. The bundled `claude-code-plugin` skill knows every option, env var, model id and troubleshooting rule, is staged into Claude Code on every spawn, and tests keep it in step with the code. [Skills](./docs/configuration/skills.md) |
 | **Read-only preset, plan mode** | `"permissionPreset": "read-only"` holds at the CLI, the proxy and the permission layer at once. [Permissions](./docs/configuration/permissions.md) |
 
 ## How this compares
@@ -102,12 +103,12 @@ This README used to hold all of the above. Release notes and bookmarks point at
 
 ## Credits
 
-This plugin absorbs work from its forks directly, cherry-picked with the original authorship preserved or reimplemented with the author named in the commit. The people behind the features you are using, and what each built, are on the [Credits](./docs/credits.md) page; `git log --author` on this repo shows the preserved authorship.
+Made and maintained by [Khalil Gharbaoui (@khalilgharbaoui)](https://github.com/khalilgharbaoui). This plugin absorbs work from its forks directly, cherry-picked with the original authorship preserved or reimplemented with the author named in the commit. The people behind the features you are using, and what each built, are on the [Credits](./docs/credits.md) page; `git log --author` on this repo shows the preserved authorship.
 
-Free and MIT-licensed. If the plugin saves you time, you can buy its maintainer a coffee:
+Free and MIT-licensed. If the plugin saves you time, you can buy [its maintainer](https://github.com/khalilgharbaoui) a coffee:
 
 <a href="https://www.buymeacoffee.com/khalilgharbaoui"><img src="site/public/buy-me-a-coffee.png" alt="Buy me a coffee" width="214" height="60"></a>
 
 ## License
 
-MIT. See [LICENSE](./LICENSE). The first version was written by Émilien ([@unixfox](https://github.com/unixfox)); everything since by Khalil Gharbaoui and the people in [Credits](./docs/credits.md).
+MIT. See [LICENSE](./LICENSE). The first version was written by Émilien ([@unixfox](https://github.com/unixfox)); everything since by [Khalil Gharbaoui](https://github.com/khalilgharbaoui) and the people in [Credits](./docs/credits.md).

package/dist/index.js

@@ -808,6 +808,13 @@ function formatSilentTurnNote(hadReasoning) {
   const what = hadReasoning ? "Claude Code finished the turn after thinking but never wrote an answer" : "Claude Code finished the turn without writing anything or calling a tool";
   return `
 ${SILENT_TURN_MARKER} ${what}, so there is no reply above. Nothing failed and nothing is pending: send the message again, or rephrase it.
+`;
+}
+var UNATTENDED_REPLAY_MARKER = "\u258C **between turns:**";
+function formatUnattendedReplayNote(dropped) {
+  const lost = dropped > 0 ? ` ${dropped} earlier line${dropped === 1 ? "" : "s"} were dropped.` : "";
+  return `${UNATTENDED_REPLAY_MARKER} The Claude Code CLI wrote this after the previous turn had already finished, so it is not an answer to the message above.${lost}
+
 `;
 }
 var UNRECOGNIZED_MODEL_STDERR_MARKER = "[claude-code:unrecognized_model]";
@@ -7286,7 +7293,8 @@ var PLUGIN_NOTE_MARKERS = [
   SILENT_TURN_MARKER,
   FAILOVER_MARKER,
   ACCOUNT_BLOCK_MARKER,
-  MODEL_FALLBACK_MARKER
+  MODEL_FALLBACK_MARKER,
+  UNATTENDED_REPLAY_MARKER
 ];
 function isPluginNote(part) {
   if (!part || part.type !== "text" || typeof part.text !== "string") return false;
@@ -9688,6 +9696,8 @@ function createTurnState(init) {
     toolCallMap: /* @__PURE__ */ new Map(),
     skipResultForIds: /* @__PURE__ */ new Set(),
     toolCallsById: /* @__PURE__ */ new Map(),
+    toolCallEmittedIds: /* @__PURE__ */ new Set(),
+    toolCallAnsweredIds: /* @__PURE__ */ new Set(),
     resultMeta: {},
     lastCallUsage: void 0,
     resultFailure: void 0,
@@ -9704,6 +9714,23 @@ function createTurnState(init) {
   };
   return state;
 }
+function cliToolCallInputJson(state, id) {
+  for (const entry of state.toolCallMap.values()) {
+    if (entry.id === id) return entry.inputJson || "{}";
+  }
+  return "{}";
+}
+function emitCliToolCall(state, id, name, inputJson, executed) {
+  if (state.toolCallEmittedIds.has(id)) return;
+  state.toolCallEmittedIds.add(id);
+  state.controller.enqueue({
+    type: "tool-call",
+    toolCallId: id,
+    toolName: name,
+    input: inputJson,
+    providerExecuted: executed
+  });
+}
 
 // src/turn-abort.ts
 function watchTurnAbort(signal) {
@@ -10113,9 +10140,46 @@ function deliverPendingCompletions(state, force = false) {
   armStartWatchdog(state);
   return true;
 }
+var CLI_RESULT_DEFERRED_OUTPUT = "Claude Code ran this tool itself and kept its output in its own context. This step ended on a tool call opencode has to run, so the output was not available to show here.";
+function closeDeferredCliToolResults(state) {
+  const answer = (id, name, stage) => {
+    emitCliToolCall(state, id, name, cliToolCallInputJson(state, id), true);
+    state.controller.enqueue({
+      type: "tool-result",
+      toolCallId: id,
+      toolName: name,
+      result: {
+        output: CLI_RESULT_DEFERRED_OUTPUT,
+        title: name,
+        metadata: {}
+      },
+      providerExecuted: true
+    });
+    state.toolCallsById.delete(id);
+    state.toolCallAnsweredIds.add(id);
+    log.info("closing a CLI-executed tool call whose result this step cannot wait for", {
+      sessionKey: state.sessionKey,
+      toolUseId: id,
+      name,
+      stage
+    });
+  };
+  for (const [id, toolCall] of [...state.toolCallsById]) {
+    if (state.skipResultForIds.has(id)) continue;
+    answer(id, toolCall.name, "registered");
+  }
+  for (const entry of state.toolCallMap.values()) {
+    if (!entry.started || !entry.mappedName) continue;
+    if (state.skipResultForIds.has(entry.id)) continue;
+    if (state.toolCallAnsweredIds.has(entry.id)) continue;
+    if (state.toolCallEmittedIds.has(entry.id)) continue;
+    answer(entry.id, entry.mappedName, "open-block");
+  }
+}
 function finishWithToolCalls(state, calls) {
   if (state.controllerClosed) return;
   if (calls.length === 0) return;
+  closeDeferredCliToolResults(state);
   const enqueueToolCall = (toolCallId, toolName, input) => {
     state.controller.enqueue({
       type: "tool-input-start",
@@ -10321,6 +10385,26 @@ var KNOWN_DELTA_TYPES = /* @__PURE__ */ new Set([
   "signature_delta"
 ]);
 var PROXY_RESULT_BOUNDARY_GRACE_MS = 250;
+function adoptOpenCliToolCall(state, ctx, id) {
+  for (const entry of state.toolCallMap.values()) {
+    if (entry.id !== id || !entry.started || !entry.mappedName) continue;
+    let parsedInput = {};
+    try {
+      parsedInput = JSON.parse(entry.inputJson || "{}");
+    } catch {
+    }
+    const { input: mappedInput, executed } = mapTool(entry.name, parsedInput, {
+      webSearch: ctx.config.webSearch,
+      sessionId: getClaudeSessionId(state.sessionKey),
+      toolUseId: entry.id
+    });
+    const registration = { id: entry.id, name: entry.mappedName, input: parsedInput };
+    state.toolCallsById.set(entry.id, registration);
+    emitCliToolCall(state, entry.id, entry.mappedName, JSON.stringify(mappedInput), executed);
+    return registration;
+  }
+  return void 0;
+}
 function createLineHandler(state, ctx) {
   return (line) => {
     if (!line.trim()) return;
@@ -10449,6 +10533,7 @@ function createLineHandler(state, ctx) {
             );
             if (!skip) {
               entry.started = true;
+              entry.mappedName = mappedName;
               state.controller.enqueue({
                 type: "tool-input-start",
                 id: block2.id,
@@ -10606,20 +10691,14 @@ ${plan}
               sessionId: getClaudeSessionId(state.sessionKey),
               toolUseId: tc.id
             });
-            if (!skip) {
+            if (!skip && !state.toolCallAnsweredIds.has(tc.id)) {
               state.toolCallsById.set(tc.id, {
                 id: tc.id,
                 name: mappedName,
                 input: parsedInput
               });
               if (!executed) state.skipResultForIds.add(tc.id);
-              state.controller.enqueue({
-                type: "tool-call",
-                toolCallId: tc.id,
-                toolName: mappedName,
-                input: JSON.stringify(mappedInput),
-                providerExecuted: executed
-              });
+              emitCliToolCall(state, tc.id, mappedName, JSON.stringify(mappedInput), executed);
             }
             log.info("tool call complete", {
               name: tc.name,
@@ -10805,13 +10884,7 @@ ${plan}
                   toolName: mappedName,
                   providerExecuted: executed
                 });
-                state.controller.enqueue({
-                  type: "tool-call",
-                  toolCallId: block2.id,
-                  toolName: mappedName,
-                  input: JSON.stringify(mappedInput),
-                  providerExecuted: executed
-                });
+                emitCliToolCall(state, block2.id, mappedName, JSON.stringify(mappedInput), executed);
               }
               log.info("tool_use from assistant message", {
                 name: block2.name,
@@ -10877,7 +10950,7 @@ ${plan}
                 noteToolActivity(state);
               }
             }
-            const toolCall = state.toolCallsById.get(block2.tool_use_id);
+            const toolCall = state.toolCallsById.get(block2.tool_use_id) ?? adoptOpenCliToolCall(state, ctx, block2.tool_use_id);
             if (toolCall) {
               const isError = block2.is_error === true;
               state.controller.enqueue({
@@ -10899,6 +10972,7 @@ ${plan}
                 isError
               });
               state.toolCallsById.delete(block2.tool_use_id);
+              state.toolCallAnsweredIds.add(block2.tool_use_id);
             }
           }
         }
@@ -12561,16 +12635,12 @@ var ClaudeCodeLanguageModel = class {
               });
               let partialText = false;
               {
-                if (unattended.dropped > 0) {
-                  const id = state.startTextBlock();
-                  controller.enqueue({
-                    type: "text-delta",
-                    id,
-                    delta: `> _${unattended.dropped} lines of output emitted between turns were dropped._
-
-`
-                  });
-                }
+                const replayId = state.startTextBlock();
+                controller.enqueue({
+                  type: "text-delta",
+                  id: replayId,
+                  delta: formatUnattendedReplayNote(unattended.dropped)
+                });
                 for (const line of unattended.lines) {
                   try {
                     const outer = JSON.parse(line);