@khalilgharbaoui/opencode-claude-code-plugin 0.26.2 → 0.27.0

package/dist/index.js

@@ -514,6 +514,9 @@ function translateStreamForHost(stream, dialect = "v1") {
   );
 }
 
+// src/account-failover.ts
+import { homedir as homedir2 } from "os";
+
 // src/accounts.ts
 import { chmod, lstat, mkdir, readlink, symlink, writeFile } from "fs/promises";
 import path from "path";
@@ -550,6 +553,10 @@ function accountConfigDir(account) {
   if (!normalized || normalized === DEFAULT_ACCOUNT) return void 0;
   return `~/.claude-${normalized}`;
 }
+function accountConfigDirPath(account) {
+  const dir = accountConfigDir(account);
+  return dir ? expandHome(dir) : void 0;
+}
 function expandHome(value) {
   const home = process.env.HOME ?? process.env.USERPROFILE;
   if (value === "~") return home ?? value;
@@ -875,6 +882,27 @@ function reportCompactBoundary(msg) {
   });
   return formatCompactBoundaryNote(boundary);
 }
+var CONVERSATION_RESET_MARKER = "\u258C **claude code reset:**";
+function parseConversationReset(msg) {
+  if (msg.type !== "conversation_reset") return null;
+  const newConversationId = str(msg.new_conversation_id);
+  if (!newConversationId) return null;
+  return { newConversationId, previousSessionId: str(msg.session_id) };
+}
+function formatConversationResetNote() {
+  return `
+${CONVERSATION_RESET_MARKER} Claude Code cleared its conversation, so from here on Claude does not see the earlier messages this chat still shows. Start a new opencode session for a clean slate, or restate what matters.
+`;
+}
+function reportConversationReset(msg) {
+  const reset = parseConversationReset(msg);
+  if (!reset) return null;
+  log.notice("claude code reset its conversation", {
+    newConversationId: reset.newConversationId,
+    previousSessionId: reset.previousSessionId ?? null
+  });
+  return formatConversationResetNote();
+}
 var RESULT_ERROR_MARKER = "\u258C **claude code error:**";
 var RESULT_SUBTYPES = {
   error_max_turns: "it hit its internal turn limit before finishing",
@@ -1082,6 +1110,35 @@ var ACCOUNT_LIMIT_PATTERNS = [
   /third-party apps now draw from your extra usage/i,
   /you[’'`]?ve hit your individual spend limit/i
 ];
+var ACCOUNT_BLOCK_MARKER = "\u258C **claude account:**";
+var ACCOUNT_BLOCKS = {
+  authentication_failed: { what: "is not logged in (its login expired or was revoked)", login: true },
+  oauth_org_not_allowed: { what: "belongs to an organization that does not allow this login", login: false },
+  account_on_hold: { what: "is on hold", login: false },
+  verification_required: { what: "needs to be verified at claude.ai", login: false },
+  billing_error: { what: "has a billing problem", login: false }
+};
+function accountBlockKind(msg) {
+  if (msg.type !== "assistant" || typeof msg.error !== "string") return null;
+  return Object.prototype.hasOwnProperty.call(ACCOUNT_BLOCKS, msg.error) ? msg.error : null;
+}
+function describeAccountBlock(kind) {
+  return ACCOUNT_BLOCKS[kind].what;
+}
+function loginCommandFor(configDir, home = homedir2()) {
+  if (!configDir) return "claude auth login";
+  const shown = configDir === home || configDir.startsWith(`${home}/`) ? `~${configDir.slice(home.length)}` : configDir;
+  return `CLAUDE_CONFIG_DIR=${shown} claude auth login`;
+}
+function formatAccountBlockNote(input) {
+  const block = ACCOUNT_BLOCKS[input.kind];
+  const account = normalizeAccountName(input.account || DEFAULT_ACCOUNT);
+  const fix = block.login ? `Log in again with \`${loginCommandFor(input.configDir)}\`, then resend your message.` : "Check the account at claude.ai, then resend your message.";
+  const then = input.offeringSwitch ? " Or pick another account below." : "";
+  return `
+${ACCOUNT_BLOCK_MARKER} the Claude account "${account}" ${block.what}. ${fix}${then}
+`;
+}
 function isAccountLimitError(input) {
   if (input.rateLimit && isRateLimitRejected(input.rateLimit)) return true;
   const text = input.resultText;
@@ -1187,7 +1244,7 @@ function createAccountFailoverQuestionCall(sessionKey2, input, toolCallId = `${A
   const candidates = input.candidates.map((c) => normalizeAccountName(c));
   const resets = describeReset(input.resetsAt);
   const until = resets ?? "opencode restarts";
-  const question = [
+  const question = input.reason ? `The Claude account "${source}" ${input.reason}. Continue this task on another configured account? Leaving this unanswered waits, at no cost.` : [
     `The Claude account "${source}" is out of usage`,
     input.window ? ` in ${input.window}` : "",
     resets ? `, which resets at ${resets}` : "",
@@ -4689,11 +4746,13 @@ var PLUGIN_NOTE_MARKERS = [
   ...LEGACY_INLINE_ASIDE_MARKERS,
   TURN_STATS_MARKER,
   COMPACT_BOUNDARY_MARKER,
+  CONVERSATION_RESET_MARKER,
   RATE_LIMIT_MARKER,
   RESULT_ERROR_MARKER,
   DOCTOR_MARKER,
   STREAM_TIMEOUT_MARKER,
-  FAILOVER_MARKER
+  FAILOVER_MARKER,
+  ACCOUNT_BLOCK_MARKER
 ];
 function isPluginNote(part) {
   if (!part || part.type !== "text" || typeof part.text !== "string") return false;
@@ -5539,13 +5598,48 @@ function dirExists2(p) {
     return false;
   }
 }
-function fileExists2(p) {
+function realPath(p) {
   try {
-    return fs5.statSync(p).isFile();
+    return fs5.realpathSync(p);
   } catch {
-    return false;
+    return path7.resolve(p);
   }
 }
+function envEnabled(name) {
+  const value = process.env[name];
+  if (value === void 0) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized !== "" && normalized !== "0" && normalized !== "false";
+}
+var SAFE_SKILL_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var FRONTMATTER_BLOCK = /^---\r?\n([\s\S]*?)\r?\n---/;
+var FRONTMATTER_NAME = /^name:[ \t]*(.+?)[ \t]*$/m;
+function declaredSkillName(source) {
+  const block = FRONTMATTER_BLOCK.exec(source);
+  if (!block) return null;
+  const line = FRONTMATTER_NAME.exec(block[1]);
+  if (!line) return null;
+  const name = line[1].trim().replace(/^["']|["']$/g, "").trim();
+  return SAFE_SKILL_NAME.test(name) ? name : null;
+}
+function readSkill(root, entry) {
+  const dir = path7.join(root, entry);
+  let source;
+  try {
+    source = fs5.readFileSync(path7.join(dir, "SKILL.md"), "utf8");
+  } catch {
+    return null;
+  }
+  return {
+    name: declaredSkillName(source) ?? entry,
+    dir,
+    realDir: realPath(dir),
+    contentHash: crypto3.createHash("sha256").update(source).digest("hex")
+  };
+}
+function sameSkill(a, b) {
+  return a.realDir === b.realDir || a.contentHash === b.contentHash;
+}
 function skillRoots(cwd) {
   const roots = [];
   const seen = /* @__PURE__ */ new Set();
@@ -5555,19 +5649,36 @@ function skillRoots(cwd) {
     seen.add(abs);
     if (dirExists2(abs)) roots.push(abs);
   };
+  const home = os3.homedir();
+  const homeDir = home ? path7.resolve(home) : null;
   let current = path7.resolve(cwd);
   while (true) {
     push(path7.join(current, ".opencode", "skills"));
+    if (current !== homeDir) {
+      push(path7.join(current, ".claude", "skills"));
+      push(path7.join(current, ".agents", "skills"));
+    }
     const parent = path7.dirname(current);
     if (parent === current) break;
     current = parent;
   }
-  const home = os3.homedir();
-  if (home) push(path7.join(home, ".opencode", "skills"));
+  if (homeDir) push(path7.join(homeDir, ".opencode", "skills"));
   const envDir = process.env.OPENCODE_CONFIG_DIR;
-  if (envDir) push(path7.join(envDir, "skills"));
-  const xdg = process.env.XDG_CONFIG_HOME ?? (home ? path7.join(home, ".config") : null);
-  if (xdg) push(path7.join(xdg, "opencode", "skills"));
+  if (envDir) {
+    push(path7.join(envDir, "skills"));
+    push(path7.join(envDir, "skill"));
+  }
+  const xdg = process.env.XDG_CONFIG_HOME ?? (homeDir ? path7.join(homeDir, ".config") : null);
+  if (xdg) {
+    push(path7.join(xdg, "opencode", "skills"));
+    push(path7.join(xdg, "opencode", "skill"));
+  }
+  if (homeDir && !envEnabled("OPENCODE_DISABLE_EXTERNAL_SKILLS")) {
+    if (!envEnabled("OPENCODE_DISABLE_CLAUDE_CODE_SKILLS")) {
+      push(path7.join(homeDir, ".claude", "skills"));
+    }
+    push(path7.join(homeDir, ".agents", "skills"));
+  }
   return roots;
 }
 function collectSkills(root, claimed, found) {
@@ -5579,19 +5690,28 @@ function collectSkills(root, claimed, found) {
   }
   for (const entry of entries) {
     if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const name = entry.name;
-    if (name.startsWith(".")) continue;
-    if (claimed.has(name)) continue;
-    const dir = path7.join(root, name);
-    if (!fileExists2(path7.join(dir, "SKILL.md"))) continue;
-    claimed.add(name);
-    found.push({ name, dir });
+    if (entry.name.startsWith(".")) continue;
+    const skill = readSkill(root, entry.name);
+    if (!skill) continue;
+    const winner = claimed.get(skill.name);
+    if (winner) {
+      if (!sameSkill(winner, skill)) {
+        log.warn("two different skills share a name; bridging the one the nearest root claimed", {
+          name: skill.name,
+          bridged: winner.dir,
+          ignored: skill.dir
+        });
+      }
+      continue;
+    }
+    claimed.set(skill.name, skill);
+    found.push(skill);
   }
 }
 var byName = (a, b) => a.name.localeCompare(b.name);
 function discoverOpencodeSkills(cwd) {
   const found = [];
-  const claimed = /* @__PURE__ */ new Set();
+  const claimed = /* @__PURE__ */ new Map();
   for (const root of skillRoots(cwd)) collectSkills(root, claimed, found);
   return found.sort(byName);
 }
@@ -5599,17 +5719,105 @@ function discoverBundledSkills() {
   const root = bundledSkillsDir();
   if (!root) return [];
   const found = [];
-  collectSkills(root, /* @__PURE__ */ new Set(), found);
+  collectSkills(root, /* @__PURE__ */ new Map(), found);
   return found.sort(byName);
 }
-function registerBundledSkillPath(config) {
-  const dir = bundledSkillsDir();
-  if (!dir) return false;
-  config.skills ??= {};
-  const paths = config.skills.paths ??= [];
-  if (paths.some((p) => path7.resolve(p) === dir)) return false;
-  paths.push(dir);
-  return true;
+function claudeConfigDir(configDir) {
+  const explicit = configDir ?? process.env.CLAUDE_CONFIG_DIR;
+  if (explicit) return path7.resolve(expandHome(explicit));
+  const home = os3.homedir();
+  return home ? path7.resolve(home, ".claude") : null;
+}
+function installedPluginSkillRoots(configDir, cwd) {
+  if (!configDir) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(
+      fs5.readFileSync(path7.join(configDir, "plugins", "installed_plugins.json"), "utf8")
+    );
+  } catch {
+    return [];
+  }
+  const plugins = parsed?.plugins;
+  if (!plugins || typeof plugins !== "object") return [];
+  const workspace = path7.resolve(cwd);
+  const roots = [];
+  for (const installs of Object.values(plugins)) {
+    if (!Array.isArray(installs)) continue;
+    for (const install of installs) {
+      const entry = install;
+      if (typeof entry?.installPath !== "string" || !entry.installPath) continue;
+      if (entry.scope !== "user" && !coversWorkspace(entry.projectPath, workspace)) continue;
+      roots.push(path7.join(entry.installPath, "skills"));
+    }
+  }
+  return roots;
+}
+function coversWorkspace(projectPath, workspace) {
+  if (typeof projectPath !== "string" || !projectPath) return false;
+  const root = path7.resolve(projectPath);
+  if (root === workspace) return true;
+  const rel = path7.relative(root, workspace);
+  return rel !== "" && !rel.startsWith("..") && !path7.isAbsolute(rel);
+}
+function discoverNativeClaudeSkills(opts) {
+  const found = [];
+  const scanned = /* @__PURE__ */ new Set();
+  const scan = (root, scope) => {
+    const abs = path7.resolve(root);
+    if (scanned.has(abs)) return;
+    scanned.add(abs);
+    let entries;
+    try {
+      entries = fs5.readdirSync(abs, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+      if (entry.name.startsWith(".")) continue;
+      const skill = readSkill(abs, entry.name);
+      if (skill) found.push({ ...skill, scope });
+    }
+  };
+  const configDir = claudeConfigDir(opts.configDir);
+  if (configDir) scan(path7.join(configDir, "skills"), "user");
+  const home = os3.homedir();
+  const homeDir = home ? path7.resolve(home) : null;
+  let current = path7.resolve(opts.cwd);
+  while (true) {
+    if (current !== homeDir) scan(path7.join(current, ".claude", "skills"), "project");
+    const parent = path7.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  for (const root of installedPluginSkillRoots(configDir, opts.cwd)) scan(root, "plugin");
+  return found;
+}
+function dropNativelyLoadedSkills(skills, native) {
+  if (native.length === 0) return { bridged: skills, skipped: [] };
+  const bridged = [];
+  const skipped = [];
+  for (const skill of skills) {
+    const sameCopy = native.find((n) => n.realDir === skill.realDir);
+    const sameContent = sameCopy ?? native.find((n) => n.contentHash === skill.contentHash);
+    const nameTaken = sameContent ?? native.find((n) => n.scope !== "plugin" && n.name === skill.name);
+    if (!nameTaken) {
+      bridged.push(skill);
+      continue;
+    }
+    const reason = sameCopy ? "same-copy" : sameContent ? "same-content" : "name-taken";
+    skipped.push({ skill, native: nameTaken, reason });
+    if (reason === "name-taken") {
+      log.warn("claude already registers a different skill under this name; not bridging ours", {
+        name: skill.name,
+        claudeLoads: nameTaken.dir,
+        notBridged: skill.dir,
+        scope: nameTaken.scope
+      });
+    }
+  }
+  return { bridged, skipped };
 }
 function readBundledSkillInfos() {
   return discoverBundledSkills().flatMap((skill) => {
@@ -5646,6 +5854,13 @@ function linkSkill(source, target) {
     fs5.cpSync(source, target, { recursive: true, dereference: true });
   }
 }
+function fileExists2(p) {
+  try {
+    return fs5.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
 function buildSkillPluginDir(skills) {
   if (skills.length === 0) return null;
   const fingerprint = skills.map((s) => `${s.name}\0${s.dir}`).join("\n");
@@ -5681,11 +5896,36 @@ function buildSkillPluginDir(skills) {
   }
   return root;
 }
+function registerBundledSkillPath(config) {
+  const dir = bundledSkillsDir();
+  if (!dir) return false;
+  config.skills ??= {};
+  const paths = config.skills.paths ??= [];
+  if (paths.some((p) => path7.resolve(p) === dir)) return false;
+  paths.push(dir);
+  return true;
+}
 async function resolveSkillPluginDirs(opts) {
   const user = opts.enabled ? discoverOpencodeSkills(opts.cwd) : [];
   const claimed = new Set(user.map((s) => s.name));
   const bundled = discoverBundledSkills().filter((s) => !claimed.has(s.name));
-  const skills = [...user, ...bundled].sort(byName);
+  let skills = [...user, ...bundled].sort(byName);
+  if (opts.skipNative !== false && skills.length > 0) {
+    const native = discoverNativeClaudeSkills({ cwd: opts.cwd, configDir: opts.configDir });
+    const { bridged, skipped } = dropNativelyLoadedSkills(skills, native);
+    if (skipped.length > 0) {
+      log.info("skills claude code already loads; left unbridged", {
+        count: skipped.length,
+        skipped: skipped.map((s) => ({
+          name: s.skill.name,
+          reason: s.reason,
+          opencode: s.skill.dir,
+          claude: s.native.dir
+        }))
+      });
+    }
+    skills = bridged;
+  }
   if (skills.length === 0) return [];
   const supported = await detectCliSupportsFlag(opts.cliPath, "--plugin-dir");
   if (!supported) {
@@ -6289,7 +6529,7 @@ function spawnInteractiveProcess(opts) {
 // src/claude-code-language-model.ts
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
 import { unlink as unlink3 } from "fs/promises";
-import { homedir as homedir5, tmpdir as tmpdir2 } from "os";
+import { homedir as homedir6, tmpdir as tmpdir2 } from "os";
 import { randomUUID as randomUUID5 } from "crypto";
 import { dirname as dirname5, join as join8 } from "path";
 async function isProxyCallStillServed(callId) {
@@ -6653,7 +6893,7 @@ ${options.compressionSummary.trim()}`
   for (const s of extraSystemContent) {
     if (s.trim()) parts.push(s.trim());
   }
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join8(homedir5(), ".config");
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join8(homedir6(), ".config");
   const globalAgents = readPromptFileIfPresent(join8(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   const forwarded = extraSystemContent.join("\n\n");
@@ -6927,6 +7167,18 @@ var ClaudeCodeLanguageModel = class {
       proxyOpencodeTools: this.config.proxyOpencodeTools
     });
   }
+  /**
+   * Arguments the skill bridge needs beyond `cwd` / `cliPath`: which
+   * `CLAUDE_CONFIG_DIR` this spawn reads its native skills from, and whether
+   * to drop the ones it already loads. A failover moves the spawn to another
+   * account, and therefore to that account's config dir.
+   */
+  skillBridgeSpawn(failover) {
+    return {
+      configDir: failover.failedOver && failover.target ? accountConfigDirPath(failover.target) : this.config.configDir,
+      skipNative: this.config.bridgeSkipNativeSkills !== false
+    };
+  }
   /** Share one lazy registry request within a turn without making it stale. */
   createLiveToolInfoLoader() {
     let pending;
@@ -7445,7 +7697,8 @@ var ClaudeCodeLanguageModel = class {
     const skillPluginDirs = await resolveSkillPluginDirs({
       cwd,
       cliPath,
-      enabled: this.config.bridgeOpencodeSkills === true
+      enabled: this.config.bridgeOpencodeSkills === true,
+      ...this.skillBridgeSpawn(failover)
     });
     const cliArgs = buildCliArgs({
       sessionKey: sk,
@@ -8175,7 +8428,8 @@ ${plan}
               const skillPluginDirs = await resolveSkillPluginDirs({
                 cwd,
                 cliPath,
-                enabled: self.config.bridgeOpencodeSkills === true
+                enabled: self.config.bridgeOpencodeSkills === true,
+                ...self.skillBridgeSpawn(failover)
               });
               const ap = spawnInteractiveProcess({
                 cwd,
@@ -8331,7 +8585,8 @@ ${plan}
               const skillPluginDirs = await resolveSkillPluginDirs({
                 cwd,
                 cliPath,
-                enabled: self.config.bridgeOpencodeSkills === true
+                enabled: self.config.bridgeOpencodeSkills === true,
+                ...self.skillBridgeSpawn(failover)
               });
               cliArgs = buildCliArgs({
                 sessionKey: sk,
@@ -8591,6 +8846,7 @@ ${plan}
           let resultMeta = {};
           let resultFailure;
           let accountLimitHit = null;
+          let accountBlock = null;
           const drainBuffer = [];
           let drainTimer = null;
           const DRAIN_QUIET_MS = 100;
@@ -8752,20 +9008,21 @@ ${plan}
               });
             }
             activeProcess?.pendingProxyCompletions?.clear();
-            if (accountLimitHit && failoverAskActive && msg.is_error === true) {
+            if ((accountLimitHit || accountBlock) && failoverAskActive && msg.is_error === true) {
               const call = createAccountFailoverQuestionCall(sk, {
                 sourceAccount,
                 candidates: failoverAccounts,
-                resetsAt: accountLimitHit.resetsAt,
-                window: accountLimitHit.window
+                resetsAt: accountLimitHit?.resetsAt,
+                window: accountLimitHit?.window,
+                reason: accountLimitHit || !accountBlock ? void 0 : describeAccountBlock(accountBlock)
               });
               log.warn(
-                `Claude account "${sourceAccount}" is out of usage; asking which account to continue on.`,
+                `Claude account "${sourceAccount}" ${accountLimitHit || !accountBlock ? "is out of usage" : `cannot serve (${accountBlock})`}; asking which account to continue on.`,
                 {
                   sessionKey: sk,
                   candidates: failoverAccounts,
                   toolCallId: call.toolCallId,
-                  resetsAt: accountLimitHit.resetsAt ?? null
+                  resetsAt: accountLimitHit?.resetsAt ?? null
                 }
               );
               finishWithQuestionCall(call);
@@ -8903,6 +9160,20 @@ ${plan}
                   endTextBlock();
                 }
               }
+              if (msg.type === "conversation_reset") {
+                const note = reportConversationReset(msg);
+                if (note) {
+                  toolCallMap.clear();
+                  reasoningIds.clear();
+                  reasoningStarted.clear();
+                  textBlockIndices.clear();
+                  controller.enqueue({ type: "text-delta", id: startTextBlock(), delta: note });
+                  endTextBlock();
+                }
+                return;
+              }
+              const block = accountBlockKind(msg);
+              if (block) accountBlock = block;
               if (msg.type === "rate_limit_event") {
                 const info = parseRateLimitEvent(msg);
                 if (info && isRateLimitRejected(info)) {
@@ -8919,58 +9190,58 @@ ${plan}
                 return;
               }
               if (msg.type === "content_block_start" && msg.content_block && msg.index !== void 0) {
-                const block = msg.content_block;
+                const block2 = msg.content_block;
                 const idx = msg.index;
-                if (block.type === "thinking") {
+                if (block2.type === "thinking") {
                   noteReasoning();
                   const reasoningId = generateId();
                   reasoningIds.set(idx, reasoningId);
                 }
-                if (block.type === "text") {
+                if (block2.type === "text") {
                   textBlockIndices.add(idx);
                   resetLastVisibleTextBlock();
-                  if (block.text) {
+                  if (block2.text) {
                     if (!currentTextId) startTextBlock();
                     controller.enqueue({
                       type: "text-delta",
                       id: currentTextId,
-                      delta: block.text
+                      delta: block2.text
                     });
-                    noteVisibleText(block.text);
+                    noteVisibleText(block2.text);
                     hasReceivedContent = true;
                   }
                 }
-                if (block.type === "tool_use" && block.id && block.name) {
+                if (block2.type === "tool_use" && block2.id && block2.name) {
                   noteToolActivity();
                   const entry = {
-                    id: block.id,
-                    name: block.name,
+                    id: block2.id,
+                    name: block2.name,
                     inputJson: "",
                     started: false
                   };
                   toolCallMap.set(idx, entry);
-                  if (block.name !== "AskUserQuestion" && block.name !== "ask_user_question" && block.name !== "ExitPlanMode" && !block.name.startsWith(PROXY_TOOL_PREFIX)) {
+                  if (block2.name !== "AskUserQuestion" && block2.name !== "ask_user_question" && block2.name !== "ExitPlanMode" && !block2.name.startsWith(PROXY_TOOL_PREFIX)) {
                     const { name: mappedName, skip, executed } = mapTool(
-                      block.name,
+                      block2.name,
                       void 0,
                       {
                         webSearch: self.config.webSearch,
                         sessionId: getClaudeSessionId(sk),
-                        toolUseId: block.id
+                        toolUseId: block2.id
                       }
                     );
                     if (!skip) {
                       entry.started = true;
                       controller.enqueue({
                         type: "tool-input-start",
-                        id: block.id,
+                        id: block2.id,
                         toolName: mappedName,
                         providerExecuted: executed
                       });
                       log.info("tool started", {
-                        name: block.name,
+                        name: block2.name,
                         mappedName,
-                        id: block.id
+                        id: block2.id
                       });
                     }
                   }
@@ -9161,8 +9432,8 @@ ${plan}
                     hadStreamThinking: hadThinkingTextFromStream
                   });
                   if (!hadThinkingTextFromStream) {
-                    for (const block of thinkingBlocks) {
-                      if (block.thinking && block.thinking.length > 0) {
+                    for (const block2 of thinkingBlocks) {
+                      if (block2.thinking && block2.thinking.length > 0) {
                         noteReasoning();
                         hadThinkingTextFromStream = true;
                         const thinkingId = generateId();
@@ -9173,7 +9444,7 @@ ${plan}
                         controller.enqueue({
                           type: "reasoning-delta",
                           id: thinkingId,
-                          delta: block.thinking
+                          delta: block2.thinking
                         });
                         controller.enqueue({
                           type: "reasoning-end",
@@ -9200,20 +9471,20 @@ ${plan}
                 if (hasToolUse) {
                   clearFallbackTimer();
                 }
-                for (const block of msg.message.content) {
-                  if (block.type === "text" && block.text) {
+                for (const block2 of msg.message.content) {
+                  if (block2.type === "text" && block2.text) {
                     resetLastVisibleTextBlock();
                     const blockId = startTextBlock();
                     controller.enqueue({
                       type: "text-delta",
                       id: blockId,
-                      delta: block.text
+                      delta: block2.text
                     });
                     endTextBlock();
-                    noteVisibleText(block.text);
+                    noteVisibleText(block2.text);
                     hasReceivedContent = true;
                   }
-                  if (block.type === "thinking" && block.thinking) {
+                  if (block2.type === "thinking" && block2.thinking) {
                     noteReasoning();
                     const thinkingId = generateId();
                     controller.enqueue({
@@ -9223,17 +9494,17 @@ ${plan}
                     controller.enqueue({
                       type: "reasoning-delta",
                       id: thinkingId,
-                      delta: block.thinking
+                      delta: block2.thinking
                     });
                     controller.enqueue({
                       type: "reasoning-end",
                       id: thinkingId
                     });
                   }
-                  if (block.type === "tool_use" && block.id && block.name) {
+                  if (block2.type === "tool_use" && block2.id && block2.name) {
                     noteToolActivity();
-                    const parsedInput = block.input ?? {};
-                    if (isAskUserQuestionTool(block.name)) {
+                    const parsedInput = block2.input ?? {};
+                    if (isAskUserQuestionTool(block2.name)) {
                       const askId = startTextBlock();
                       controller.enqueue({
                         type: "text-delta",
@@ -9241,12 +9512,12 @@ ${plan}
                         delta: formatAskUserQuestion(parsedInput)
                       });
                       endTextBlock();
-                    } else if (block.name === "ExitPlanMode") {
+                    } else if (block2.name === "ExitPlanMode") {
                       const plan = parsedInput?.plan || "";
                       if (planModeQuestionActive) {
                         const questionCall = createExitPlanModeQuestionCall(
                           sk,
-                          block.id,
+                          block2.id,
                           plan
                         );
                         const planId2 = startTextBlock();
@@ -9271,8 +9542,8 @@ ${plan}
 `
                       });
                       endTextBlock();
-                    } else if (isWebSearchTool(block.name) && isWebSearchHandledByCli(self.config.webSearch)) {
-                      toolCallsById.delete(block.id);
+                    } else if (isWebSearchTool(block2.name) && isWebSearchHandledByCli(self.config.webSearch)) {
+                      toolCallsById.delete(block2.id);
                       const query = typeof parsedInput?.query === "string" ? parsedInput.query : JSON.stringify(parsedInput);
                       const searchId = startTextBlock();
                       controller.enqueue({
@@ -9283,11 +9554,11 @@ ${plan}
 `
                       });
                       endTextBlock();
-                    } else if (block.name.startsWith(PROXY_TOOL_PREFIX)) {
+                    } else if (block2.name.startsWith(PROXY_TOOL_PREFIX)) {
                       noteProxyActivity();
                       log.debug("ignoring proxy tool_use from assistant message", {
-                        name: block.name,
-                        id: block.id
+                        name: block2.name,
+                        id: block2.id
                       });
                     } else {
                       const {
@@ -9295,61 +9566,61 @@ ${plan}
                         input: mappedInput,
                         executed,
                         skip
-                      } = mapTool(block.name, parsedInput, {
+                      } = mapTool(block2.name, parsedInput, {
                         webSearch: self.config.webSearch,
                         sessionId: getClaudeSessionId(sk),
-                        toolUseId: block.id
+                        toolUseId: block2.id
                       });
                       if (!skip) {
-                        toolCallsById.set(block.id, {
-                          id: block.id,
-                          name: block.name,
+                        toolCallsById.set(block2.id, {
+                          id: block2.id,
+                          name: block2.name,
                           input: parsedInput
                         });
-                        if (!executed) skipResultForIds.add(block.id);
+                        if (!executed) skipResultForIds.add(block2.id);
                         controller.enqueue({
                           type: "tool-input-start",
-                          id: block.id,
+                          id: block2.id,
                           toolName: mappedName,
                           providerExecuted: executed
                         });
                         controller.enqueue({
                           type: "tool-call",
-                          toolCallId: block.id,
+                          toolCallId: block2.id,
                           toolName: mappedName,
                           input: JSON.stringify(mappedInput),
                           providerExecuted: executed
                         });
                       }
                       log.info("tool_use from assistant message", {
-                        name: block.name,
+                        name: block2.name,
                         mappedName,
-                        id: block.id,
+                        id: block2.id,
                         executed
                       });
                     }
                   }
-                  if (block.type === "tool_result") {
+                  if (block2.type === "tool_result") {
                     log.debug("tool_result", {
-                      toolUseId: block.tool_use_id
+                      toolUseId: block2.tool_use_id
                     });
                   }
                 }
               }
               if (msg.type === "user" && msg.message?.content) {
-                for (const block of msg.message.content) {
-                  if (block.type === "tool_result" && block.tool_use_id) {
-                    if (skipResultForIds.has(block.tool_use_id)) {
+                for (const block2 of msg.message.content) {
+                  if (block2.type === "tool_result" && block2.tool_use_id) {
+                    if (skipResultForIds.has(block2.tool_use_id)) {
                       log.debug("skipping tool-result (opencode runs it)", {
-                        toolUseId: block.tool_use_id
+                        toolUseId: block2.tool_use_id
                       });
                       continue;
                     }
                     let resultText = "";
-                    if (typeof block.content === "string") {
-                      resultText = block.content;
-                    } else if (Array.isArray(block.content)) {
-                      resultText = block.content.filter(
+                    if (typeof block2.content === "string") {
+                      resultText = block2.content;
+                    } else if (Array.isArray(block2.content)) {
+                      resultText = block2.content.filter(
                         (c) => c.type === "text" && typeof c.text === "string"
                       ).map((c) => c.text).join("\n");
                     }
@@ -9357,11 +9628,11 @@ ${plan}
                     if (claudeSessionId) {
                       const list2 = applyTaskCreateToolResult(
                         claudeSessionId,
-                        block.tool_use_id,
+                        block2.tool_use_id,
                         resultText
                       );
                       if (list2) {
-                        const synthId = `todowrite_${block.tool_use_id}`;
+                        const synthId = `todowrite_${block2.tool_use_id}`;
                         controller.enqueue({
                           type: "tool-input-start",
                           id: synthId,
@@ -9385,12 +9656,12 @@ ${plan}
                         noteToolActivity();
                       }
                     }
-                    const toolCall = toolCallsById.get(block.tool_use_id);
+                    const toolCall = toolCallsById.get(block2.tool_use_id);
                     if (toolCall) {
-                      const isError = block.is_error === true;
+                      const isError = block2.is_error === true;
                       controller.enqueue({
                         type: "tool-result",
-                        toolCallId: block.tool_use_id,
+                        toolCallId: block2.tool_use_id,
                         toolName: toolCall.name,
                         result: {
                           output: resultText,
@@ -9402,11 +9673,11 @@ ${plan}
                       });
                       noteToolActivity();
                       log.info("tool result emitted", {
-                        toolUseId: block.tool_use_id,
+                        toolUseId: block2.tool_use_id,
                         name: toolCall.name,
                         isError
                       });
-                      toolCallsById.delete(block.tool_use_id);
+                      toolCallsById.delete(block2.tool_use_id);
                     }
                   }
                 }
@@ -9432,6 +9703,26 @@ ${plan}
                 })) {
                   accountLimitHit = {};
                 }
+                if (accountBlock && msg.is_error) {
+                  resultFailure ??= accountBlock;
+                  const offeringSwitch = failoverAskActive;
+                  controller.enqueue({
+                    type: "text-delta",
+                    id: startTextBlock(),
+                    delta: formatAccountBlockNote({
+                      kind: accountBlock,
+                      account: sourceAccount,
+                      configDir: self.config.configDir,
+                      offeringSwitch
+                    })
+                  });
+                  endTextBlock();
+                  log.warn(`Claude account "${sourceAccount}" cannot serve requests`, {
+                    sessionKey: sk,
+                    kind: accountBlock,
+                    offeringSwitch
+                  });
+                }
                 const failure = describeResultFailure(msg);
                 if (failure) {
                   resultFailure = msg.subtype;
@@ -9873,11 +10164,11 @@ ${plan}
 import {
   existsSync as existsSync4,
   readFileSync as readFileSync6,
-  realpathSync,
+  realpathSync as realpathSync2,
   rmSync as rmSync3,
   writeFileSync as writeFileSync5
 } from "fs";
-import { homedir as homedir6 } from "os";
+import { homedir as homedir7 } from "os";
 import { join as join9, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
@@ -9887,12 +10178,12 @@ function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
     xdg ? join9(xdg, "opencode") : null,
-    join9(homedir6(), ".cache", "opencode"),
-    join9(homedir6(), "Library", "Caches", "opencode")
+    join9(homedir7(), ".cache", "opencode"),
+    join9(homedir7(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join9(homedir6(), ".config");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join9(homedir7(), ".config");
   return join9(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {
@@ -9912,7 +10203,7 @@ function userIntendsToUseUnscoped() {
 function ourLoadedDir() {
   try {
     const filePath = fileURLToPath3(import.meta.url);
-    return realpathSync(resolve4(filePath, "..", ".."));
+    return realpathSync2(resolve4(filePath, "..", ".."));
   } catch {
     return null;
   }
@@ -9940,7 +10231,7 @@ function cleanupOne(cacheRoot, ourDir) {
   if (!existsSync4(stalePath)) return;
   let realStalePath = stalePath;
   try {
-    realStalePath = realpathSync(stalePath);
+    realStalePath = realpathSync2(stalePath);
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
@@ -10499,6 +10790,7 @@ function createClaudeCode(settings = {}) {
       ignoreAnthropicApiKey: settings.ignoreAnthropicApiKey,
       idleProcessTimeoutMs: settings.idleProcessTimeoutMs,
       bridgeOpencodeSkills: settings.bridgeOpencodeSkills === true,
+      bridgeSkipNativeSkills: settings.bridgeSkipNativeSkills !== false,
       turnStats: settings.turnStats === true,
       interactive: settings.interactive,
       interactiveBypass: settings.interactiveBypass,