@khalilgharbaoui/opencode-claude-code-plugin 0.62.0 → 0.63.0

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/claude-code-language-model.ts
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 
 // src/ids.ts
 import { randomInt } from "crypto";
@@ -2045,6 +2045,10 @@ function clearAccountFailoverQuestions(sessionKey2) {
     if (key.startsWith(prefix)) pendingQuestions2.delete(key);
   }
 }
+function hasAccountFailoverQuestions(sessionKey2) {
+  const prefix = `${sessionKey2}${KEY_SEPARATOR2}`;
+  return [...pendingQuestions2.keys()].some((key) => key.startsWith(prefix));
+}
 function describeReset(resetsAt) {
   return formatResetsAt(resetsAt);
 }
@@ -3164,6 +3168,10 @@ function clearSubagentDispatchQuestions(sessionKey2) {
     if (key.startsWith(prefix)) pending.delete(key);
   }
 }
+function hasPendingSubagentDispatch(sessionKey2) {
+  const prefix = `${sessionKey2}${KEY_SEPARATOR3}`;
+  return [...pending.keys()].some((key) => key.startsWith(prefix));
+}
 function isSubagentDispatchActive(input) {
   if (input.compactionMode) return false;
   if (input.childSession) return false;
@@ -5833,6 +5841,9 @@ function isPendingProxyCallChannelClosed(call) {
 function findPendingProxyCall(toolCallId) {
   return pendingByCallId.get(toolCallId);
 }
+function hasAnyPendingProxyCall() {
+  return pendingByCallId.size > 0;
+}
 function getPendingProxyCalls(sessionKey2) {
   const s = callIdsBySession.get(sessionKey2);
   if (!s || s.size === 0) return [];
@@ -6074,6 +6085,10 @@ function noteExplicitTaskModels(parentSessionId, tasks, now = Date.now()) {
   }
   return noted;
 }
+function hasUnclaimedExplicitTaskModels(now = Date.now()) {
+  pruneClaims2(now);
+  return claims2.length > 0;
+}
 function explicitTaskModelFor(sessionId) {
   return sessionModels.get(sessionId);
 }
@@ -7856,6 +7871,77 @@ async function requestSideQuestion(activeProcess, question, options) {
   });
 }
 
+// src/session-event-relay.ts
+var RELAY_KEY = /* @__PURE__ */ Symbol.for("@khalilgharbaoui/opencode-claude-code-plugin/session-event-relay");
+function relayState() {
+  const holder = globalThis;
+  let state = holder[RELAY_KEY];
+  if (!state) {
+    state = { members: /* @__PURE__ */ new Set(), followers: 0 };
+    holder[RELAY_KEY] = state;
+  }
+  return state;
+}
+function safely(action) {
+  try {
+    action();
+  } catch {
+  }
+}
+var ownMember;
+var ownFollowers = 0;
+var ownServed = false;
+function join10() {
+  if (!ownMember) return;
+  const state = relayState();
+  if (state.members.has(ownMember)) return;
+  state.members.add(ownMember);
+  if (state.followers > 0) safely(() => ownMember?.feedOpened());
+}
+function leave() {
+  if (!ownMember) return;
+  if (relayState().members.delete(ownMember)) safely(() => ownMember?.feedClosed());
+}
+function defineOwnRelayMember(member) {
+  ownMember = member;
+  if (ownServed) join10();
+}
+function noteRelayMemberServing() {
+  ownServed = true;
+  join10();
+}
+function relayMemberHasServed() {
+  return ownServed;
+}
+function leaveSessionEventRelay() {
+  leave();
+}
+function openRelayFollower() {
+  const state = relayState();
+  join10();
+  ownFollowers += 1;
+  state.followers += 1;
+  if (state.followers === 1) {
+    for (const member of state.members) safely(() => member.feedOpened());
+  }
+  let closed = false;
+  return () => {
+    if (closed) return;
+    closed = true;
+    ownFollowers = Math.max(0, ownFollowers - 1);
+    state.followers = Math.max(0, state.followers - 1);
+    if (state.followers === 0) {
+      for (const member of state.members) safely(() => member.feedClosed());
+    }
+    if (ownFollowers === 0 && !ownServed) leave();
+  };
+}
+function relaySessionEvent(event) {
+  const members = relayState().members;
+  if (ownMember && !members.has(ownMember)) safely(() => ownMember?.handle(event));
+  for (const member of [...members]) safely(() => member.handle(event));
+}
+
 // src/session-manager.ts
 function findActiveProcessBySessionId(sessionID) {
   let found;
@@ -8082,6 +8168,7 @@ function processBelongsToAnotherAccount(active, cliPath, configDir) {
 function setActiveProcess(key, ap) {
   cancelIdleProcessEviction(key);
   activeProcesses.set(key, ap);
+  noteRelayMemberServing();
 }
 function noteInteractiveProcessExit(sessionKey2, ap, code) {
   if (activeProcesses.get(sessionKey2) !== ap) return;
@@ -8261,6 +8348,10 @@ function setClaudeSessionId(key, sessionId) {
   capClaudeSessions();
 }
 function deleteClaudeSessionId(key) {
+  forgetClaudeSessionInMemory(key);
+  forgetResumePoint(key);
+}
+function forgetClaudeSessionInMemory(key) {
   clearExitPlanModeQuestions(key);
   clearAccountFailoverQuestions(key);
   clearSubagentDispatchQuestions(key);
@@ -8269,7 +8360,52 @@ function deleteClaudeSessionId(key) {
   claudeSessions.delete(key);
   forgetForkFingerprint(key);
   forgetServedConversation(key);
-  forgetResumePoint(key);
+}
+function keyBelongsToSession(key, sessionID, ap) {
+  return ap?.opencodeSessionID === sessionID || describeSessionKey(key).session === sessionID;
+}
+function keyHeldHere(key) {
+  return claudeSessionIsWriting(key) || hasAccountFailoverQuestions(key) || hasPendingSubagentDispatch(key);
+}
+function sessionHeldHere(sessionID) {
+  if (!sessionID || sessionID === "default") return false;
+  for (const [key, ap] of activeProcesses) {
+    if (keyBelongsToSession(key, sessionID, ap) && keyHeldHere(key)) return true;
+  }
+  for (const key of claudeSessions.keys()) {
+    if (keyBelongsToSession(key, sessionID) && keyHeldHere(key)) return true;
+  }
+  return false;
+}
+function noWorkInFlightHere() {
+  for (const ap of activeProcesses.values()) {
+    if (isTurnInFlight(ap)) return false;
+  }
+  return !hasAnyPendingProxyCall() && !hasUnclaimedExplicitTaskModels();
+}
+function holdsNoClaudeState() {
+  return activeProcesses.size === 0 && claudeSessions.size === 0 && !hasAnyPendingProxyCall();
+}
+async function releaseIdleForHandover(sessionID) {
+  if (sessionID === "default") return [];
+  const belongs = (key, ap) => sessionID === void 0 || keyBelongsToSession(key, sessionID, ap);
+  const released = [];
+  const exits = [];
+  for (const [key, ap] of [...activeProcesses]) {
+    if (!belongs(key, ap) || keyHeldHere(key)) continue;
+    exits.push(deleteActiveProcessAndWait(key));
+    released.push(key);
+  }
+  await Promise.all(exits);
+  for (const key of [...claudeSessions.keys()]) {
+    if (!belongs(key) || keyHeldHere(key)) continue;
+    forgetClaudeSessionInMemory(key);
+    if (!released.includes(key)) released.push(key);
+  }
+  if (released.length > 0) {
+    log.info("handed claude sessions to another copy of the plugin", { sessionID, released });
+  }
+  return released;
 }
 function transferClaudeSession(fromKey, toKey) {
   if (fromKey === toKey) return void 0;
@@ -8376,8 +8512,7 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcp
     settleTurn(ap);
     lineEmitter.emit("close");
   });
-  cancelIdleProcessEviction(sessionKey2);
-  activeProcesses.set(sessionKey2, ap);
+  setActiveProcess(sessionKey2, ap);
   proc.on("error", (err) => {
     log.error("claude process error", { sessionKey: sessionKey2, error: err.message });
   });
@@ -9101,6 +9236,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "agent maxTurns refused: not a positive whole number",
   "agent model override refused: unknown model",
   "agent prompt cache ttl refused: unknown value",
+  "an older plugin build failed to release its claude sessions",
   "an opencode read deny rule could not be mapped onto Claude's own Read; that path stays readable by the CLI's own file tools",
   "auto-continuation stopped",
   "auto-continuing incomplete claude result",
@@ -9247,6 +9383,7 @@ var PLUGIN_LOG_MESSAGES = /* @__PURE__ */ new Set([
   "task_batch resolving with child results missing",
   "the interactive transport has not been measured on this Claude Code version; it reads the TUI's screen and transcript, which a new release can change. If a turn hangs or a dialog is not handled, run /claude-code-doctor bundle and report it",
   "the interactive turn did not take a forwarded user message",
+  "the plugin build chosen for this turn could not take it; running it on this one",
   "this opencode process is running an older plugin build than the one on disk",
   "timed out pending proxy call",
   "turn abort listener threw",
@@ -9952,7 +10089,7 @@ function emptyMapping(enabled) {
 }
 function mapReadRules(rules, options = {}) {
   const deny = [];
-  const ask = [];
+  const ask2 = [];
   const unmapped = [];
   const shadowedAllows = [];
   const seen = /* @__PURE__ */ new Set();
@@ -9960,7 +10097,7 @@ function mapReadRules(rules, options = {}) {
   rules.forEach((rule, index) => {
     if (rule.effect === "ask") {
       if (supersededBy(index, rule.pattern, () => true)) return;
-      if (!ask.includes(rule.pattern)) ask.push(rule.pattern);
+      if (!ask2.includes(rule.pattern)) ask2.push(rule.pattern);
       return;
     }
     if (rule.effect !== "deny") return;
@@ -9981,7 +10118,7 @@ function mapReadRules(rules, options = {}) {
       if (!shadowedAllows.includes(later.pattern)) shadowedAllows.push(later.pattern);
     }
   });
-  return { deny, ask, unmapped, shadowedAllows };
+  return { deny, ask: ask2, unmapped, shadowedAllows };
 }
 function resolveReadRuleMapping(input) {
   if (input.enabled === false) return emptyMapping(false);
@@ -10115,20 +10252,20 @@ async function fetchPlanUsage(cliPath, options = {}) {
 // src/turn-history.ts
 import { mkdirSync as mkdirSync7, readFileSync as readFileSync7, renameSync as renameSync6, statSync as statSync6, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir11 } from "os";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 
 // src/turn-progress-store.ts
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync6, renameSync as renameSync5, statSync as statSync5, writeFileSync as writeFileSync6 } from "fs";
 import { homedir as homedir10 } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var MAX_TURN_PROGRESS = 64;
 var TURN_PROGRESS_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var TAG = /^[0-9a-f]{8}$/;
 var pathOverride4 = null;
 function turnProgressStorePath() {
   if (pathOverride4) return pathOverride4;
-  const stateRoot = process.env.XDG_STATE_HOME || join10(homedir10(), ".local", "state");
-  return join10(stateRoot, "opencode-claude-code-plugin", "turn-progress.json");
+  const stateRoot = process.env.XDG_STATE_HOME || join11(homedir10(), ".local", "state");
+  return join11(stateRoot, "opencode-claude-code-plugin", "turn-progress.json");
 }
 function isProgress(value) {
   const record = value;
@@ -10158,7 +10295,7 @@ function recordTurnProgress(tag, progress, now = Date.now()) {
   merged.set(tag, { ...record, out: Math.round(record.out) });
   const kept = [...merged.entries()].slice(-MAX_TURN_PROGRESS);
   try {
-    mkdirSync6(join10(file, ".."), { recursive: true, mode: 448 });
+    mkdirSync6(join11(file, ".."), { recursive: true, mode: 448 });
     const tmp = `${file}.${process.pid}.tmp`;
     writeFileSync6(tmp, JSON.stringify({ version: 1, turns: Object.fromEntries(kept) }), { mode: 384 });
     renameSync5(tmp, file);
@@ -10176,8 +10313,8 @@ var SESSION_TAG = /^[0-9a-f]{8}$/;
 var pathOverride5 = null;
 function turnHistoryStorePath() {
   if (pathOverride5) return pathOverride5;
-  const stateRoot = process.env.XDG_STATE_HOME || join11(homedir11(), ".local", "state");
-  return join11(stateRoot, "opencode-claude-code-plugin", "turn-history.json");
+  const stateRoot = process.env.XDG_STATE_HOME || join12(homedir11(), ".local", "state");
+  return join12(stateRoot, "opencode-claude-code-plugin", "turn-history.json");
 }
 function turnHistoryKey(agent, model) {
   return `${agent || "main"}/${model}`;
@@ -10361,7 +10498,7 @@ function recordTurnSample(key, sample) {
   merged.set(key, samples);
   const kept = bounded2(merged);
   try {
-    mkdirSync7(join11(file, ".."), { recursive: true, mode: 448 });
+    mkdirSync7(join12(file, ".."), { recursive: true, mode: 448 });
     const tmp = `${file}.${process.pid}.tmp`;
     writeFileSync7(tmp, JSON.stringify({ version: 1, turns: Object.fromEntries(kept) }), { mode: 384 });
     renameSync6(tmp, file);
@@ -10736,6 +10873,159 @@ import * as fs7 from "fs";
 import * as path10 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
+// src/plugin-copies.ts
+var ROUTED_TURN_LIMIT_MS = 2 * 60 * 6e4;
+var COPIES_KEY = /* @__PURE__ */ Symbol.for("@khalilgharbaoui/opencode-claude-code-plugin/copies/v1");
+function copiesState() {
+  const holder = globalThis;
+  let state = holder[COPIES_KEY];
+  if (!state) {
+    state = { copies: [], active: void 0, switching: void 0, turns: /* @__PURE__ */ new Map() };
+    holder[COPIES_KEY] = state;
+  }
+  return state;
+}
+function routedTurns(state, now) {
+  for (const [token, turn] of state.turns) {
+    if (now - turn.startedAt > ROUTED_TURN_LIMIT_MS) state.turns.delete(token);
+  }
+  return [...state.turns.values()];
+}
+function ask(question, fallback) {
+  try {
+    return question();
+  } catch {
+    return fallback;
+  }
+}
+async function releaseQuietly(copy, sessionID) {
+  try {
+    await copy.release(sessionID);
+  } catch (err) {
+    log.warn("an older plugin build failed to release its claude sessions", {
+      version: copy.version,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+function registerPluginCopy(copy) {
+  const state = copiesState();
+  if (state.copies.includes(copy)) return;
+  state.copies.push(copy);
+  state.active ??= copy;
+}
+function unregisterPluginCopy(copy) {
+  const state = copiesState();
+  const index = state.copies.indexOf(copy);
+  if (index !== -1) state.copies.splice(index, 1);
+  if (state.active === copy) state.active = void 0;
+}
+function isActivePluginCopy(copy) {
+  return copiesState().active === copy;
+}
+function processLoadedBuild(build) {
+  return copiesState().copies.some(
+    (copy) => !copy.disposed && copy.version === build.version && copy.build.entryPath === build.entryPath && copy.build.mtimeMs === build.mtimeMs && copy.build.size === build.size
+  );
+}
+function switchWhenQuiet(state, now) {
+  if (state.switching) return;
+  const newest = [...state.copies].reverse().find((copy) => !copy.disposed);
+  if (!newest || newest === state.active) return;
+  const others = state.copies.filter((copy) => copy !== newest);
+  const busy = new Set(routedTurns(state, now).map((turn) => turn.copy));
+  if (!others.every((copy) => !busy.has(copy) && ask(() => copy.quiet(), false))) return;
+  const previous = state.active;
+  state.active = newest;
+  log.info("switched to the newest plugin build", {
+    from: previous?.version,
+    to: newest.version
+  });
+  state.switching = Promise.all(others.map((copy) => releaseQuietly(copy))).then(() => {
+    state.switching = void 0;
+  });
+}
+function servingCopy(state, sessionID, own) {
+  if (sessionID) {
+    const holder = state.copies.find((copy) => ask(() => copy.holds(sessionID), false));
+    if (holder) return holder;
+  }
+  return state.active ?? own;
+}
+function followStream(source, end) {
+  const reader = source.getReader();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          end();
+          controller.close();
+          return;
+        }
+        controller.enqueue(value);
+      } catch (err) {
+        end();
+        controller.error(err);
+      }
+    },
+    async cancel(reason) {
+      end();
+      await reader.cancel(reason);
+    }
+  });
+}
+function untilTurnEnds(result, end) {
+  const stream = result?.stream;
+  if (!(stream instanceof ReadableStream)) {
+    end();
+    return result;
+  }
+  return { ...result, stream: followStream(stream, end) };
+}
+async function routeTurn(input) {
+  const state = copiesState();
+  if (state.copies.length === 0) return input.runHere();
+  const now = input.now ?? Date.now;
+  if (state.switching) await state.switching;
+  switchWhenQuiet(state, now());
+  if (state.switching) await state.switching;
+  const sessionID = input.sessionID && input.sessionID !== "default" ? input.sessionID : void 0;
+  const target = servingCopy(state, sessionID, input.own);
+  const token = {};
+  state.turns.set(token, { copy: target, sessionID, startedAt: now() });
+  let ended = false;
+  const end = () => {
+    if (ended) return;
+    ended = true;
+    state.turns.delete(token);
+  };
+  try {
+    if (sessionID) {
+      await Promise.all(
+        state.copies.filter((copy) => copy !== target).map((copy) => releaseQuietly(copy, sessionID))
+      );
+    }
+    if (target === input.own) return untilTurnEnds(await input.runHere(), end);
+    let model;
+    try {
+      model = await target.modelFor(input.turn);
+    } catch (err) {
+      log.warn("the plugin build chosen for this turn could not take it; running it on this one", {
+        version: target.version,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      const turn = state.turns.get(token);
+      if (turn) turn.copy = input.own;
+      return untilTurnEnds(await input.runHere(), end);
+    }
+    return untilTurnEnds(await input.runOn(model), end);
+  } catch (err) {
+    end();
+    throw err;
+  }
+}
+
 // src/startup-diagnostics.ts
 import { execFile as execFile3 } from "child_process";
 import * as fs6 from "fs";
@@ -11000,6 +11290,8 @@ function createStaleBuildWatch(io) {
   const warned = /* @__PURE__ */ new Set();
   let checkedAt;
   let cached2 = null;
+  let cachedOnDisk;
+  const loadedHere = (onDisk) => onDisk !== void 0 && io.loadedElsewhere?.(onDisk) === true;
   const read = () => {
     let onDisk;
     try {
@@ -11017,18 +11309,21 @@ function createStaleBuildWatch(io) {
     },
     check() {
       const now = io.now();
-      if (checkedAt !== void 0 && now - checkedAt < throttleMs) return cached2;
+      if (checkedAt !== void 0 && now - checkedAt < throttleMs) {
+        return cached2 && !loadedHere(cachedOnDisk) ? cached2 : null;
+      }
       checkedAt = now;
       const status = read();
-      cached2 = status.stale;
-      if (status.stale && status.onDisk) {
-        const identity = `${status.stale.kind}:${status.onDisk.version}:${status.onDisk.mtimeMs}:${status.onDisk.size}`;
+      cachedOnDisk = status.onDisk;
+      cached2 = status.stale && loadedHere(status.onDisk) ? null : status.stale;
+      if (cached2 && status.onDisk) {
+        const identity = `${cached2.kind}:${status.onDisk.version}:${status.onDisk.mtimeMs}:${status.onDisk.size}`;
         if (!warned.has(identity)) {
           warned.add(identity);
           warn({
-            kind: status.stale.kind,
-            loadedVersion: status.stale.loadedVersion,
-            onDiskVersion: status.stale.onDiskVersion,
+            kind: cached2.kind,
+            loadedVersion: cached2.loadedVersion,
+            onDiskVersion: cached2.onDiskVersion,
             path: io.loaded.entryPath
           });
         }
@@ -11087,7 +11382,8 @@ function staleBuildWatch() {
     watch = createStaleBuildWatch({
       loaded,
       readOnDisk: () => readOnDiskBuild(loaded.entryPath),
-      now: () => Date.now()
+      now: () => Date.now(),
+      loadedElsewhere: (onDisk) => processLoadedBuild({ entryPath: loaded.entryPath, ...onDisk })
     });
   }
   return watch;
@@ -12785,7 +13081,7 @@ import { EventEmitter as EventEmitter4 } from "events";
 import { randomUUID as randomUUID5 } from "crypto";
 import { existsSync as existsSync4, writeFileSync as writeFileSync9 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 
 // src/claude-session-bun.ts
 import * as os6 from "os";
@@ -13967,7 +14263,7 @@ ${text2}`
 }
 function stageImage(data, extension) {
   try {
-    const file = join16(pluginTmpDir(), `attachment-${randomUUID5()}.${extension}`);
+    const file = join17(pluginTmpDir(), `attachment-${randomUUID5()}.${extension}`);
     writeFileSync9(file, data, { mode: 384, flag: "wx" });
     return file;
   } catch (err) {
@@ -14451,15 +14747,15 @@ function spawnInteractiveProcess(opts) {
 // src/spawn-record-store.ts
 import { mkdirSync as mkdirSync9, readFileSync as readFileSync11, renameSync as renameSync7, statSync as statSync10, writeFileSync as writeFileSync10 } from "fs";
 import { homedir as homedir14 } from "os";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 var MAX_SPAWN_RECORDS = 256;
 var SPAWN_RECORD_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
 var pathOverride6 = null;
 var lastWritten = /* @__PURE__ */ new Map();
 function spawnRecordStorePath() {
   if (pathOverride6) return pathOverride6;
-  const stateRoot = process.env.XDG_STATE_HOME || join17(homedir14(), ".local", "state");
-  return join17(stateRoot, "opencode-claude-code-plugin", "session-spawns.json");
+  const stateRoot = process.env.XDG_STATE_HOME || join18(homedir14(), ".local", "state");
+  return join18(stateRoot, "opencode-claude-code-plugin", "session-spawns.json");
 }
 function isRecord5(value) {
   const record = value;
@@ -14511,7 +14807,7 @@ ${record.agent ?? ""}`;
   const cutoff = now - SPAWN_RECORD_MAX_AGE_MS;
   const kept = [...merged.entries()].filter(([, entry]) => entry.at >= cutoff).sort((a, b) => a[1].at - b[1].at).slice(-MAX_SPAWN_RECORDS);
   try {
-    mkdirSync9(join17(file, ".."), { recursive: true, mode: 448 });
+    mkdirSync9(join18(file, ".."), { recursive: true, mode: 448 });
     const tmp = `${file}.${process.pid}.tmp`;
     writeFileSync10(tmp, JSON.stringify({ version: 1, sessions: Object.fromEntries(kept) }), {
       mode: 384
@@ -14589,7 +14885,7 @@ function dedupe2(dirs) {
 import { readFileSync as readFileSync12, writeFileSync as writeFileSync11 } from "fs";
 import { homedir as homedir15 } from "os";
 import { randomUUID as randomUUID7 } from "crypto";
-import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join18 } from "path";
+import { basename as basename2, dirname as dirname6, isAbsolute as isAbsolute3, join as join19 } from "path";
 function readPromptFileIfPresent(path15) {
   try {
     const content = readFileSync12(path15, "utf8").trim();
@@ -14601,7 +14897,7 @@ function readPromptFileIfPresent(path15) {
 function nearestWorkspaceAgentsPrompt(cwd) {
   let dir = cwd;
   while (true) {
-    const content = readPromptFileIfPresent(join18(dir, "AGENTS.md"));
+    const content = readPromptFileIfPresent(join19(dir, "AGENTS.md"));
     if (content) return content;
     const parent = dirname6(dir);
     if (parent === dir) return void 0;
@@ -14753,8 +15049,8 @@ ${options.compressionSummary.trim()}`
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
   }
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join18(homedir15(), ".config");
-  const globalAgents = readPromptFileIfPresent(join18(configRoot, "opencode", "AGENTS.md"));
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join19(homedir15(), ".config");
+  const globalAgents = readPromptFileIfPresent(join19(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   const forwarded = extraSystemContent.join("\n\n");
   const pushGlobal = !!globalAgents && !forwarded.includes(globalAgents);
@@ -14770,7 +15066,7 @@ ${options.compressionSummary.trim()}`
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path15 = join18(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
+  const path15 = join19(pluginTmpDir(), `opencode-cc-sys-${randomUUID7()}.md`);
   try {
     writeFileSync11(path15, content, { encoding: "utf8", mode: 384 });
     return path15;
@@ -18614,7 +18910,7 @@ 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 transcriptPath2 = (id, dir) => join19(dir ?? configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
+      const transcriptPath2 = (id, dir) => join20(dir ?? configDir, "projects", encodeCwd(cwd), `${id}.jsonl`);
       const resumePoint = findResumePoint({
         sessionKey: sk,
         prompt: options.prompt,
@@ -20289,7 +20585,7 @@ import {
   writeFileSync as writeFileSync12
 } from "fs";
 import { homedir as homedir16 } from "os";
-import { dirname as dirname7, join as join20, resolve as resolve6 } from "path";
+import { dirname as dirname7, join as join21, resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
@@ -20297,14 +20593,14 @@ var alreadyRan = false;
 function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
-    xdg ? join20(xdg, "opencode") : null,
-    join20(homedir16(), ".cache", "opencode"),
-    join20(homedir16(), "Library", "Caches", "opencode")
+    xdg ? join21(xdg, "opencode") : null,
+    join21(homedir16(), ".cache", "opencode"),
+    join21(homedir16(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join20(homedir16(), ".config");
-  return join20(xdgConfig, "opencode", "opencode.json");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join21(homedir16(), ".config");
+  return join21(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
@@ -20331,15 +20627,15 @@ function ourLoadedDir() {
 function ourVersion(dir) {
   if (!dir) return null;
   try {
-    const pkg = JSON.parse(readFileSync14(join20(dir, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync14(join21(dir, "package.json"), "utf8"));
     return typeof pkg.version === "string" && pkg.version ? pkg.version : null;
   } catch {
     return null;
   }
 }
 function markerPath() {
-  const stateRoot = process.env.XDG_STATE_HOME ?? join20(homedir16(), ".local", "state");
-  return join20(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
+  const stateRoot = process.env.XDG_STATE_HOME ?? join21(homedir16(), ".local", "state");
+  return join21(stateRoot, "opencode-claude-code-plugin", "cleanup-stale.json");
 }
 function markerVersion() {
   try {
@@ -20388,7 +20684,7 @@ function cleanupStaleUnscopedInstall() {
 }
 function cleanupOne(cacheRoot, ourDir) {
   if (!existsSync5(cacheRoot)) return;
-  const stalePath = join20(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  const stalePath = join21(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
   if (!existsSync5(stalePath)) return;
   let realStalePath = stalePath;
   try {
@@ -20396,7 +20692,7 @@ function cleanupOne(cacheRoot, ourDir) {
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
-  const pkgJsonPath = join20(stalePath, "package.json");
+  const pkgJsonPath = join21(stalePath, "package.json");
   if (!existsSync5(pkgJsonPath)) return;
   let pkg = {};
   try {
@@ -20416,7 +20712,7 @@ function cleanupOne(cacheRoot, ourDir) {
     });
     return;
   }
-  const cachePkgJson = join20(cacheRoot, "package.json");
+  const cachePkgJson = join21(cacheRoot, "package.json");
   if (!existsSync5(cachePkgJson)) return;
   try {
     const cfg = JSON.parse(readFileSync14(cachePkgJson, "utf8"));
@@ -20822,22 +21118,125 @@ function stoppedSessionIdV2(event) {
   const id = event.data?.sessionID;
   return typeof id === "string" && id.length > 0 ? id : void 0;
 }
+function handleSessionEventHere(event) {
+  noteSessionRunEvent(event);
+  const deleted = deletedSessionIdV2(event);
+  if (deleted) {
+    const released = deleteActiveProcessesForSession(deleted);
+    if (released.length > 0) {
+      log.info("released claude state for deleted session", { sessionID: deleted, released });
+    }
+    return;
+  }
+  const stopped = stoppedSessionIdV2(event);
+  if (stopped) releaseParkedProxyCallsForSession(stopped);
+}
+var ownCopy;
+var liveSetups = 0;
+var plannedByDirectory = /* @__PURE__ */ new Map();
+var forwardedProviders = /* @__PURE__ */ new Map();
+var MAX_FORWARDED_PROVIDERS = 32;
+function plannedSettings(directory, providerID) {
+  const here = plannedByDirectory.get(directory)?.get(providerID);
+  if (here) return here;
+  for (const planned of plannedByDirectory.values()) {
+    const found = planned.get(providerID);
+    if (found) return found;
+  }
+  return void 0;
+}
+function pluginCopyFor(deps) {
+  if (ownCopy) return ownCopy;
+  const loaded = staleBuildWatch().loaded;
+  ownCopy = {
+    id: randomUUID8(),
+    version: loaded.version,
+    build: { entryPath: loaded.entryPath, mtimeMs: loaded.mtimeMs, size: loaded.size },
+    disposed: false,
+    holds: (sessionID) => sessionHeldHere(sessionID),
+    quiet: () => noWorkInFlightHere(),
+    release: (sessionID) => releaseIdleForHandover(sessionID),
+    async modelFor(turn) {
+      const planned = plannedSettings(turn.directory, turn.providerID);
+      if (!planned) throw new Error(`no provider ${turn.providerID} is planned in this build`);
+      const cacheKey = JSON.stringify([turn.directory ?? null, turn.providerID, turn.sdkOptions]);
+      let provider = forwardedProviders.get(cacheKey);
+      if (!provider) {
+        const settings = await resolveSdkSettings(turn.providerID, planned, turn.sdkOptions);
+        provider = deps.createProvider(settings);
+        forwardedProviders.set(cacheKey, provider);
+        while (forwardedProviders.size > MAX_FORWARDED_PROVIDERS) {
+          const oldest = forwardedProviders.keys().next().value;
+          if (oldest === void 0) break;
+          forwardedProviders.delete(oldest);
+        }
+      }
+      return provider.languageModel(turn.modelId);
+    }
+  };
+  return ownCopy;
+}
+function retireWhenSpent() {
+  const copy = ownCopy;
+  if (!copy?.disposed || isActivePluginCopy(copy) || !holdsNoClaudeState()) return;
+  unregisterPluginCopy(copy);
+  leaveSessionEventRelay();
+  log.info("a disposed plugin build left the process", { version: copy.version });
+}
+function routedModel(model, copy, turn) {
+  const sessionOf = (options) => resolveSessionAffinity(
+    options.headers,
+    options.providerOptions,
+    turn.providerID
+  );
+  return {
+    specificationVersion: model.specificationVersion,
+    provider: model.provider,
+    modelId: model.modelId,
+    supportedUrls: model.supportedUrls,
+    doStream: (options) => routeTurn({
+      own: copy,
+      turn,
+      sessionID: sessionOf(options),
+      runHere: () => model.doStream(options),
+      runOn: (other) => other.doStream(options)
+    }),
+    doGenerate: (options) => routeTurn({
+      own: copy,
+      turn,
+      sessionID: sessionOf(options),
+      runHere: () => model.doGenerate(options),
+      runOn: (other) => other.doGenerate(options)
+    })
+  };
+}
+function routedProvider(provider, copy, base) {
+  const languageModel = (modelId) => routedModel(provider.languageModel(modelId), copy, { ...base, modelId });
+  return Object.assign((modelId) => languageModel(modelId), provider, {
+    languageModel
+  });
+}
+var closeOwnFeed;
+defineOwnRelayMember({
+  handle: (event) => {
+    handleSessionEventHere(event);
+    retireWhenSpent();
+  },
+  feedOpened: () => {
+    closeOwnFeed ??= openSessionRunEventFeed();
+  },
+  feedClosed: () => {
+    const close = closeOwnFeed;
+    closeOwnFeed = void 0;
+    close?.();
+  }
+});
 async function followSessionEvents(subscribe, signal) {
-  const closeFeed = openSessionRunEventFeed();
+  const closeFollower = openRelayFollower();
   try {
     for await (const event of subscribe({ signal })) {
       if (signal.aborted) break;
-      noteSessionRunEvent(event);
-      const deleted = deletedSessionIdV2(event);
-      if (deleted) {
-        const released = deleteActiveProcessesForSession(deleted);
-        if (released.length > 0) {
-          log.info("released claude state for deleted session", { sessionID: deleted, released });
-        }
-        continue;
-      }
-      const stopped = stoppedSessionIdV2(event);
-      if (stopped) releaseParkedProxyCallsForSession(stopped);
+      relaySessionEvent(event);
     }
   } catch (err) {
     if (!signal.aborted) {
@@ -20847,7 +21246,7 @@ async function followSessionEvents(subscribe, signal) {
       );
     }
   } finally {
-    closeFeed();
+    closeFollower();
   }
 }
 var noticeEmitters = /* @__PURE__ */ new Set();
@@ -20935,6 +21334,11 @@ function createV2Setup(deps) {
       }
     }
     const planned = /* @__PURE__ */ new Map();
+    const copy = pluginCopyFor(deps);
+    copy.disposed = false;
+    registerPluginCopy(copy);
+    liveSetups += 1;
+    plannedByDirectory.set(directory, planned);
     registrations.push(
       await ctx.provider.transform((editor) => {
         const seed = editor.get(BASE_PROVIDER_ID);
@@ -20978,7 +21382,11 @@ function createV2Setup(deps) {
         const providerID = event.model.providerID;
         if (!isClaudeCodeProviderId(providerID)) return;
         const settings = await resolveSdkSettings(providerID, planned.get(providerID), event.options);
-        event.sdk = deps.createProvider(settings);
+        event.sdk = routedProvider(deps.createProvider(settings), copy, {
+          directory,
+          providerID,
+          sdkOptions: event.options
+        });
         log.debug("v2 sdk created", { providerID, cliPath: settings.cliPath });
       })
     );
@@ -21045,6 +21453,11 @@ function createV2Setup(deps) {
     });
     return async () => {
       events.abort();
+      liveSetups = Math.max(0, liveSetups - 1);
+      if (liveSetups === 0) {
+        copy.disposed = true;
+        if (!relayMemberHasServed()) unregisterPluginCopy(copy);
+      }
       for (const registration of registrations.splice(0)) {
         await registration.dispose().catch(() => void 0);
       }