@khalilgharbaoui/opencode-claude-code-plugin 0.45.0 → 0.46.0

package/dist/index.d.ts

@@ -433,6 +433,8 @@ interface ClaudeCodeConfig {
     forkSessions?: boolean;
     /** Resume a conversation's Claude session after opencode restarts. Default true. */
     resumeAfterRestart?: boolean;
+    /** Carry a conversation's Claude session over when its model or effort changes. Default true. */
+    resumeAcrossModelChanges?: boolean;
     logging?: LoggingConfig;
 }
 interface LoggingConfig {
@@ -829,6 +831,31 @@ interface ClaudeCodeProviderSettings {
      * before. `false` never reads or writes the file.
      */
     resumeAfterRestart?: boolean;
+    /**
+     * Carry a conversation's Claude session over when the operator changes its
+     * model or its reasoning effort mid-conversation, instead of replaying the
+     * whole thread as text into a fresh one. Default `true`.
+     *
+     * Both the model and the effort level are in the session key, so changing
+     * either lands the same opencode conversation on a key nothing has ever
+     * answered. That was the other half of issue #91: at least 18 replays in
+     * one ~15-hour session. Neither is a reason to start a new Claude
+     * conversation, because both are spawn-time choices (`--model`,
+     * `CLAUDE_CODE_EFFORT_LEVEL`) that the CLI applies to a transcript it
+     * resumes, measured on 2.1.288.
+     *
+     * It takes the Claude session off the sibling key rather than sharing it, so
+     * one conversation is owned by exactly one key, and it is refused on every
+     * term `resumeAfterRestart` is refused on (another account, a transcript
+     * that is gone, a conversation that has changed) plus two of its own: a
+     * sibling whose transcript may still be written to, and anything that is not
+     * the same cwd, request scope, opencode session, agent and prompt-cache TTL.
+     * A compaction turn and an account-failover switch never take one.
+     *
+     * It reads the record `resumeAfterRestart` writes, so `resumeAfterRestart:
+     * false` turns this off too.
+     */
+    resumeAcrossModelChanges?: boolean;
     /**
      * Routing for Claude's built-in `WebSearch` tool.
      *

package/dist/index.js

@@ -916,6 +916,10 @@ function formatResultFailureNote(message) {
 ${RESULT_ERROR_MARKER} ${message}
 `;
 }
+function formatCompactionFailure(cause, detail) {
+  const said = detail?.trim();
+  return `Claude Code could not compact this conversation (${cause}), so no summary was produced.` + (said ? ` The CLI said: ${said}` : "");
+}
 var STREAM_TIMEOUT_MARKER = "\u258C **stream timeout:**";
 function formatStreamTimeoutNote(silenceMs) {
   const seconds = Math.max(1, Math.round(silenceMs / 1e3));
@@ -4250,7 +4254,8 @@ function messageDigest(msg) {
   }
   return hash.digest("hex").slice(0, 32);
 }
-function conversationDigests(prompt) {
+var ASSISTANT_TURN_DIGEST = "assistant-turn";
+function conversationDigests(prompt, opts) {
   const out = [];
   for (const msg of prompt) {
     if (msg.role !== "user" && msg.role !== "assistant" && msg.role !== "tool") {
@@ -4258,7 +4263,7 @@ function conversationDigests(prompt) {
     }
     out.push({
       role: msg.role,
-      digest: messageDigest(msg)
+      digest: opts?.assistantContent === false && msg.role === "assistant" ? ASSISTANT_TURN_DIGEST : messageDigest(msg)
     });
   }
   return out;
@@ -4285,7 +4290,24 @@ function forkSiblingSignature(sessionKey2) {
   blanked[3] = "*";
   return blanked.join("::");
 }
-function splitForkHistory(prompt) {
+function modelSiblingSignature(sessionKey2) {
+  const parts = sessionKey2.split("::");
+  if (parts.length < 5) return null;
+  if (parts[2] === "compaction") return null;
+  const withoutEffort = parts[parts.length - 1].startsWith("effort=") ? parts.slice(0, -1) : parts;
+  if (withoutEffort.length < 5) return null;
+  const blanked = [...withoutEffort];
+  blanked[1] = "*";
+  return blanked.join("::");
+}
+function moveForkFingerprint(fromKey, toKey) {
+  const record = fingerprints.get(fromKey);
+  if (!record) return;
+  fingerprints.delete(fromKey);
+  fingerprints.delete(toKey);
+  fingerprints.set(toKey, { ...record, seq: ++fingerprintSeq });
+}
+function splitForkHistory(prompt, opts) {
   const messages = prompt;
   let lastAssistant = -1;
   for (let i = messages.length - 1; i >= 0; i--) {
@@ -4304,7 +4326,7 @@ function splitForkHistory(prompt) {
     }
   }
   return {
-    history: conversationDigests(messages.slice(0, lastAssistant + 1)),
+    history: conversationDigests(messages.slice(0, lastAssistant + 1), opts),
     forkable: true
   };
 }
@@ -4343,8 +4365,8 @@ function findForkParent(opts) {
   }
   return best;
 }
-function continuesRecordedConversation(recorded, prompt) {
-  const { history, forkable } = splitForkHistory(prompt);
+function continuesRecordedConversation(recorded, prompt, opts) {
+  const { history, forkable } = splitForkHistory(prompt, opts);
   if (!forkable || recorded.length === 0 || recorded.length > history.length) return false;
   return isPrefix(recorded, history) && tailIsReplyOnly(history, recorded.length);
 }
@@ -4381,7 +4403,7 @@ function isDigest(value) {
 }
 function isRecord2(value) {
   const record = value;
-  return !!record && typeof record.claudeSessionId === "string" && typeof record.cliPath === "string" && typeof record.updatedAt === "number" && Array.isArray(record.chain) && record.chain.every(isDigest);
+  return !!record && typeof record.claudeSessionId === "string" && typeof record.cliPath === "string" && typeof record.updatedAt === "number" && Array.isArray(record.chain) && record.chain.every(isDigest) && (record.shape === void 0 || Array.isArray(record.shape) && record.shape.every(isDigest));
 }
 function load() {
   if (records) return records;
@@ -4430,13 +4452,14 @@ function save(update) {
 function recordResumePoint(sessionKey2, claudeSessionId, prompt, cliPath) {
   const chain = conversationDigests(prompt);
   if (chain.length === 0) return;
+  const shape2 = conversationDigests(prompt, { assistantContent: false });
   const current = load().get(sessionKey2);
-  if (current && current.claudeSessionId === claudeSessionId && current.cliPath === cliPath && current.chain.length === chain.length && current.chain.every((entry, i) => entry.digest === chain[i].digest)) {
+  if (current && current.claudeSessionId === claudeSessionId && current.cliPath === cliPath && current.shape !== void 0 && current.chain.length === chain.length && current.chain.every((entry, i) => entry.digest === chain[i].digest)) {
     return;
   }
   save((merged) => {
     merged.delete(sessionKey2);
-    merged.set(sessionKey2, { claudeSessionId, cliPath, chain, updatedAt: Date.now() });
+    merged.set(sessionKey2, { claudeSessionId, cliPath, chain, shape: shape2, updatedAt: Date.now() });
   });
 }
 function forgetResumePoint(sessionKey2) {
@@ -4445,25 +4468,84 @@ function forgetResumePoint(sessionKey2) {
     merged.delete(sessionKey2);
   });
 }
+function moveResumePoint(fromKey, toKey) {
+  const record = load().get(fromKey);
+  if (!record) return;
+  save((merged) => {
+    merged.delete(fromKey);
+    if (merged.has(toKey)) return;
+    merged.set(toKey, { ...record, updatedAt: Date.now() });
+  });
+}
 function findResumePoint(opts) {
   const record = load().get(opts.sessionKey);
-  if (!record) return void 0;
+  if (!record) {
+    opts.onRefused?.("no-session-recorded");
+    return void 0;
+  }
   const refuse = (reason) => {
     log.info("not resuming the claude session from before the restart", {
       sessionKey: opts.sessionKey,
       reason
     });
+    opts.onRefused?.(reason);
     return void 0;
   };
-  if (record.cliPath !== opts.cliPath) return refuse("another claude binary");
+  if (record.cliPath !== opts.cliPath) return refuse("another-claude-binary");
   if (!continuesRecordedConversation(record.chain, opts.prompt)) {
-    return refuse("the conversation changed");
+    return refuse("conversation-changed");
   }
   if (!existsSync2(opts.transcriptPath(record.claudeSessionId))) {
-    return refuse("the transcript is gone");
+    return refuse("transcript-gone");
   }
   return { claudeSessionId: record.claudeSessionId, matched: record.chain.length };
 }
+function findSiblingResumePoint(opts) {
+  const signature = modelSiblingSignature(opts.sessionKey);
+  if (!signature) {
+    opts.onRefused?.("no-sibling-possible");
+    return void 0;
+  }
+  let best;
+  let bestUpdatedAt = -1;
+  let refusal;
+  for (const [key, record] of load()) {
+    if (key === opts.sessionKey) continue;
+    if (modelSiblingSignature(key) !== signature) continue;
+    if (record.cliPath !== opts.cliPath) {
+      refusal = "sibling-another-claude-binary";
+      continue;
+    }
+    if (!record.shape || !continuesRecordedConversation(record.shape, opts.prompt, {
+      assistantContent: false
+    })) {
+      refusal = "sibling-conversation-changed";
+      continue;
+    }
+    if (opts.isBusy(key)) {
+      refusal = "sibling-still-writing";
+      continue;
+    }
+    if (!existsSync2(opts.transcriptPath(record.claudeSessionId))) {
+      refusal = "sibling-transcript-gone";
+      continue;
+    }
+    if (record.updatedAt >= bestUpdatedAt) {
+      bestUpdatedAt = record.updatedAt;
+      best = {
+        claudeSessionId: record.claudeSessionId,
+        siblingKey: key,
+        matched: record.chain.length
+      };
+    }
+  }
+  if (!best) {
+    opts.onRefused?.(
+      refusal ?? "no-sibling-recorded"
+    );
+  }
+  return best;
+}
 
 // src/permission-presets.ts
 var READ_ONLY_DISALLOWED_CLI_TOOLS = [
@@ -5164,6 +5246,23 @@ function deleteClaudeSessionId(key) {
   forgetForkFingerprint(key);
   forgetResumePoint(key);
 }
+function transferClaudeSession(fromKey, toKey) {
+  if (fromKey === toKey) return void 0;
+  const claudeSessionId = claudeSessions.get(fromKey);
+  if (!claudeSessionId) return void 0;
+  if (claudeSessions.has(toKey)) return void 0;
+  claudeSessions.delete(fromKey);
+  setClaudeSessionId(toKey, claudeSessionId);
+  moveResumePoint(fromKey, toKey);
+  moveForkFingerprint(fromKey, toKey);
+  clearExitPlanModeQuestions(fromKey);
+  clearAccountFailoverQuestions(fromKey);
+  log.notice("carrying the claude conversation over to the new session key", {
+    fromKey,
+    toKey
+  });
+  return claudeSessionId;
+}
 function effortSessionKey(baseKey, effort) {
   return effort ? `${baseKey}::effort=${effort}` : baseKey;
 }
@@ -5186,8 +5285,14 @@ function invalidateOtherEffortSessions(baseKey, effort) {
       );
     }
   }
+  const currentKey = effortSessionKey(baseKey, effort);
   for (const key of staleKeys) {
     deleteActiveProcess(key);
+    if (transferClaudeSession(key, currentKey)) {
+      clearCompression(key);
+      clearBackgroundTasks(key);
+      continue;
+    }
     deleteClaudeSessionId(key);
     clearCompression(key);
     clearBackgroundTasks(key);
@@ -5270,12 +5375,11 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
       }
     }
     if (ownsSessionKey && code !== 0 && code !== null) {
-      log.info("process exited with error, clearing session", {
+      log.info("process exited with error; keeping the claude session to resume", {
         code,
-        sessionKey: sessionKey2
+        sessionKey: sessionKey2,
+        resumable: claudeSessions.has(sessionKey2)
       });
-      claudeSessions.delete(sessionKey2);
-      forgetResumePoint(sessionKey2);
     }
   });
   proc.stderr?.on("data", (data) => {
@@ -5788,6 +5892,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "btw: a turn is running but no claude process appeared for it",
   "btw: early aside failed; the message will ask again",
   "cannot interrupt this transport; waiting for the turn to end",
+  "carrying the claude conversation over to the new session key",
   "claude --version output unparseable",
   "claude account is out of usage; the turn ends with a note",
   "claude already registers a different skill under this name; not bridging ours",
@@ -5795,6 +5900,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "claude cli does not support --plugin-dir; opencode skills will not be bridged. Run `npm i -g @anthropic-ai/claude-code` to upgrade.",
   "claude code compacted its own context",
   "claude code reset its conversation",
+  "claude could not compact the conversation; no summary was stored",
   "claude finished the turn without a reply",
   "claude kept missing the probe deadline; keeping the conservative answer for this process",
   "claude process belongs to another account; starting fresh",
@@ -5810,6 +5916,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "cleanup-stale: could not record the sweep marker",
   "cleanup-stale: error processing cache root",
   "cleanup-stale: rmSync failed",
+  "continuing this conversation's claude session under the new model or effort instead of replaying it",
   "delivering proxy results after interrupted continuation",
   "draining proxy calls queued between turns",
   "empty user content; sending sentinel to satisfy CLI",
@@ -5881,6 +5988,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "rejected pending proxy call",
   "remote URL images are not supported by Claude CLI, skipping",
   "replaying stdout the child emitted between turns",
+  "replaying the conversation as text: no claude session was available to continue",
   "result fallback timer fired \u2014 closing stream without result event",
   "resuming the claude session from before the restart instead of replaying it",
   "shared Claude capability already exists; leaving untouched",
@@ -5936,6 +6044,7 @@ var BUNDLE_DATA_ALLOWLIST = {
   inFlight: "flag",
   anthropicApiKeyInEnv: "flag",
   includeHistoryContext: "flag",
+  resumable: "flag",
   interactive: "flag",
   interactiveTransport: "flag",
   isError: "flag",
@@ -5957,6 +6066,8 @@ var BUNDLE_DATA_ALLOWLIST = {
   dropped: "count",
   exitCode: "count",
   historyLength: "count",
+  matchedMessages: "count",
+  messages: "count",
   inputTokens: "count",
   lastTextLength: "count",
   lines: "count",
@@ -6058,6 +6169,12 @@ var BUNDLE_DATA_ALLOWLIST = {
   sessionId: "id",
   sessionID: "id",
   sessionKey: "id",
+  // The two ends of a conversation carried from one session key to another
+  // (h #g215), and the fork lookup's parent. All three are session keys.
+  fromKey: "id",
+  toKey: "id",
+  siblingKey: "id",
+  parentKey: "id",
   toolCallId: "id",
   toolCallIds: "id",
   toolUseId: "id",
@@ -8276,7 +8393,7 @@ The complete prior conversation appears above. The synthesis instructions follow
       content.push({
         type: "text",
         text: `<conversation_history>
-The following is a summary of our conversation so far (from a previous session that couldn't be resumed):
+The following is a summary of our conversation so far, replayed as text because no Claude session was available to continue it:
 
 ${historyContext}
 
@@ -11326,6 +11443,7 @@ function createTurnState(init) {
     accountLimitHit: null,
     apiErrorTextShown: null,
     usageLimitNote: false,
+    compactionFailureText: null,
     accountBlock: null,
     modelRefusal: null,
     drainBuffer: [],
@@ -12420,6 +12538,7 @@ ${plan}
           resultText: msg.message.content.filter((b) => b.type === "text" && b.text).map((b) => String(b.text)).join("\n")
         }));
         const limitErrorReply = limitFromReply && ctx.usageLimitNoteActive;
+        const compactionApiError = ctx.compactionMode && (apiErrorReply || typeof msg.error === "string");
         if (limitFromReply) {
           state.accountLimitHit ??= recallAccountLimit(ctx.sourceAccount);
           const said = limitFactsFromText(
@@ -12441,6 +12560,10 @@ ${plan}
         for (const block2 of msg.message.content) {
           if (block2.type === "text" && block2.text) {
             if (limitErrorReply) continue;
+            if (compactionApiError) {
+              state.compactionFailureText ??= block2.text;
+              continue;
+            }
             if (apiErrorReply) state.apiErrorTextShown = block2.text;
             resetLastVisibleTextBlock(state);
             const blockId = state.startTextBlock();
@@ -12666,7 +12789,14 @@ ${plan}
         state.usageLimitNote = ctx.usageLimitNoteActive && !!state.accountLimitHit && // An expired login or a billing hold writes its own note just below
         // and says what to run; two notes about one failure is one too many.
         !state.accountBlock && msg.is_error === true;
-        if (!state.currentTextId && msg.is_error && // Already on screen from the reply frame, word for word.
+        const compactionFailure = ctx.compactionMode && (msg.is_error === true || typeof msg.subtype === "string" && msg.subtype !== "success");
+        if (compactionFailure) {
+          if (typeof msg.result === "string" && msg.result.trim()) {
+            state.compactionFailureText ??= msg.result.trim();
+          }
+          state.resultFailure ??= state.accountBlock ?? (state.accountLimitHit ? "usage_limit" : void 0) ?? (typeof msg.subtype === "string" && msg.subtype !== "success" ? msg.subtype : "error");
+        }
+        if (!state.currentTextId && msg.is_error && !compactionFailure && // Already on screen from the reply frame, word for word.
         !(typeof msg.result === "string" && state.apiErrorTextShown !== null && msg.result.trim() === state.apiErrorTextShown.trim()) && !state.usageLimitNote && typeof msg.result === "string" && msg.result.trim().length > 0) {
           const errId = state.startTextBlock();
           state.controller.enqueue({
@@ -12681,21 +12811,23 @@ ${plan}
         if (state.accountBlock && msg.is_error) {
           state.resultFailure ??= state.accountBlock;
           const offeringSwitch = ctx.failoverAskActive;
-          state.controller.enqueue({
-            type: "text-delta",
-            id: state.startTextBlock(),
-            delta: formatAccountBlockNote({
-              kind: state.accountBlock,
-              account: ctx.sourceAccount,
-              configDir: ctx.config.configDir,
-              offeringSwitch,
-              // Read only when the form is not taking the turn, which is the
-              // default: moving the work by hand is then the operator's only
-              // route and nothing else on screen says it exists (h #g194).
-              candidates: ctx.failoverAccounts
-            })
-          });
-          state.endTextBlock();
+          if (!compactionFailure) {
+            state.controller.enqueue({
+              type: "text-delta",
+              id: state.startTextBlock(),
+              delta: formatAccountBlockNote({
+                kind: state.accountBlock,
+                account: ctx.sourceAccount,
+                configDir: ctx.config.configDir,
+                offeringSwitch,
+                // Read only when the form is not taking the turn, which is the
+                // default: moving the work by hand is then the operator's only
+                // route and nothing else on screen says it exists (h #g194).
+                candidates: ctx.failoverAccounts
+              })
+            });
+            state.endTextBlock();
+          }
           log.warn(`Claude account "${ctx.sourceAccount}" cannot serve requests`, {
             sessionKey: state.sessionKey,
             kind: state.accountBlock,
@@ -12705,11 +12837,14 @@ ${plan}
         const failure = describeResultFailure(msg);
         if (failure) {
           state.resultFailure = msg.subtype;
-          state.controller.enqueue({
-            type: "text-delta",
-            id: state.startTextBlock(),
-            delta: formatResultFailureNote(failure)
-          });
+          if (!compactionFailure) {
+            state.controller.enqueue({
+              type: "text-delta",
+              id: state.startTextBlock(),
+              delta: formatResultFailureNote(failure)
+            });
+          }
+          if (compactionFailure) state.compactionFailureText ??= failure;
           log.warn(failure, { sessionKey: state.sessionKey, subtype: msg.subtype });
         }
         const turnStats = extractTurnStats(msg);
@@ -13519,13 +13654,18 @@ var ClaudeCodeLanguageModel = class {
         }
       }
     }
+    let replayReason = "no-session-for-key";
     if (this.config.resumeAfterRestart !== false && includeHistoryContext && !compactionMode && !forkFromClaudeSessionId && failoverAnswer?.kind !== "switch") {
       const configDir = resolveConfigDir(this.config.configDir);
+      const transcriptPath = (id) => join12(configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
       const resumePoint = findResumePoint({
         sessionKey: sk,
         prompt: options.prompt,
         cliPath,
-        transcriptPath: (id) => join12(configDir, "projects", encodeCwd(cwd), `${id}.jsonl`)
+        transcriptPath,
+        onRefused: (reason) => {
+          replayReason = reason;
+        }
       });
       if (resumePoint) {
         setClaudeSessionId(sk, resumePoint.claudeSessionId);
@@ -13534,8 +13674,47 @@ var ClaudeCodeLanguageModel = class {
           sessionKey: sk,
           matchedMessages: resumePoint.matched
         });
+      } else if (this.config.resumeAcrossModelChanges !== false) {
+        const sibling = findSiblingResumePoint({
+          sessionKey: sk,
+          prompt: options.prompt,
+          cliPath,
+          transcriptPath,
+          // `claudeSessionIsWriting`, not `getActiveProcess`: this walks every
+          // sibling key, and that one refreshes LRU order and cancels idle
+          // timers on everything it touches (the same reason the fork lookup
+          // above uses it).
+          isBusy: claudeSessionIsWriting,
+          onRefused: (reason) => {
+            replayReason = reason;
+          }
+        });
+        if (sibling) {
+          deleteActiveProcess(sibling.siblingKey);
+          const carried = transferClaudeSession(sibling.siblingKey, sk);
+          if (carried) {
+            includeHistoryContext = false;
+            log.notice(
+              "continuing this conversation's claude session under the new model or effort instead of replaying it",
+              {
+                sessionKey: sk,
+                siblingKey: sibling.siblingKey,
+                matchedMessages: sibling.matched
+              }
+            );
+          } else {
+            replayReason = "sibling-carry-over-failed";
+          }
+        }
       }
     }
+    if (includeHistoryContext && !compactionMode) {
+      log.notice("replaying the conversation as text: no claude session was available to continue", {
+        sessionKey: sk,
+        reason: replayReason,
+        messages: options.prompt.length
+      });
+    }
     if (this.config.forkSessions === true && !compactionMode) {
       recordForkFingerprint(sk, options.prompt, cliPath);
     }
@@ -14288,6 +14467,7 @@ var ClaudeCodeLanguageModel = class {
                 })
               });
               state.endTextBlock();
+              state.resultFailure ??= "usage_limit";
             }
             if (runAutoContinue(state, msg)) return;
             for (const [idx, reasoningId] of state.reasoningIds) {
@@ -14321,6 +14501,18 @@ var ClaudeCodeLanguageModel = class {
               });
               state.endTextBlock();
             }
+            if (compactionMode && state.resultFailure) {
+              log.warn("claude could not compact the conversation; no summary was stored", {
+                sessionKey: sk,
+                cause: state.resultFailure
+              });
+              controller.enqueue({
+                type: "error",
+                error: new Error(
+                  formatCompactionFailure(state.resultFailure, state.compactionFailureText)
+                )
+              });
+            }
             const usage = toUsage2(lastCallContextUsage(state.lastCallUsage, msg.usage));
             controller.enqueue({
               type: "finish",
@@ -15519,6 +15711,7 @@ function createClaudeCode(settings = {}) {
       turnStats: settings.turnStats === true,
       forkSessions: settings.forkSessions === true,
       resumeAfterRestart: settings.resumeAfterRestart !== false,
+      resumeAcrossModelChanges: settings.resumeAcrossModelChanges !== false,
       transport: settings.transport,
       interactive: settings.interactive,
       interactiveBypass: settings.interactiveBypass,