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

package/README.md

@@ -366,7 +366,8 @@ model: claude-code-work/claude-opus-5@work
 | `compactionModel` | string | `"claude-haiku-4-5"` | Model used when opencode invokes `/compact`. Override per-process via the `CLAUDE_CODE_COMPACTION_MODEL` env var (env wins over config). See [Compaction](#compaction). |
 | `ignoreAnthropicApiKey` | boolean | `false` | Strip `ANTHROPIC_API_KEY` / `ANTHROPIC_AUTH_TOKEN` from every spawned `claude` process so it authenticates with your logged-in subscription instead of pay-as-you-go API billing. The plugin warns once at startup whenever an API key is detected, regardless of this setting. See [Billing](#billing). |
 | `idleProcessTimeoutMs` | number | – | Kill a retained headless Claude worker after this many idle milliseconds following a completed turn. The timer starts when a turn finishes, a new turn cancels it, a worker that is mid-turn when it fires is left alone and re-timed, and the session id is preserved for `--resume`. Values above Node's maximum timer delay (`2147483647`) are ignored. Omit or set `0` to retain workers until LRU eviction (16 processes). Interactive transport is excluded. Contributed by [@bernardofortes](https://github.com/bernardofortes). |
-| `bridgeOpencodeSkills` | boolean | `false` | Expose your opencode skills to Claude's native `Skill` tool. Off by default because every bridged skill is also in the system prompt opencode forwards, so a large set is paid for twice per turn; the bundled configuration skill is staged either way. See [Skill bridge](#skill-bridge). Written by [@broskees](https://github.com/broskees). |
+| `bridgeOpencodeSkills` | boolean | `false` | Expose your opencode skills to Claude's native `Skill` tool, from every root opencode itself reads. Off by default because every bridged skill is also in the system prompt opencode forwards, so a large set is paid for twice per turn; the bundled configuration skill is staged either way. See [Skill bridge](#skill-bridge). Written by [@broskees](https://github.com/broskees). |
+| `bridgeSkipNativeSkills` | boolean | `true` | Leave a skill unbridged when the Claude session already loads it from `$CLAUDE_CONFIG_DIR/skills`, the project's `.claude/skills`, or an installed plugin, so one skill does not reach the model twice. Matched by resolved path, by identical `SKILL.md`, or by name. `false` bridges everything and reinstates the duplicates. See [Skills Claude already has](#skills-claude-already-has). |
 | `logging` | object | all defaults | The plugin's own logger, four independent fields: `file` (boolean, default `false`), `dir` (string, default `~/.local/share/opencode-claude-code/`), `mode` (`"silent"` \| `"debug"`, default `"silent"`) and `level` (`"debug"` \| `"info"` \| `"notice"` \| `"warn"` \| `"error"`, default `"info"`). Goes under `provider.claude-code.options` like every other row here. See [Logging](#logging). |
 | `turnStats` | boolean | `false` | Append a one-line cost / duration / cache footer to each finished turn. See [Per-turn stats](#per-turn-stats). |
 | `interactive` | boolean | `false` | **Experimental.** Drive the interactive `claude` TUI (subscription billing) instead of headless `--print`. Requires opencode running under Bun with PTY support; silently falls back to headless otherwise. The tool proxy, `permissionMode` and `/btw` are all unavailable on it, so read [What it does not support](#what-it-does-not-support) before enabling. Env: `CLAUDE_CODE_INTERACTIVE_TRANSPORT=1`. |
@@ -778,6 +779,7 @@ Four Claude Code stream events used to reach nothing but a debug log:
 
 - **A rate-limit rejection.** When the CLI reports `status: "rejected"` (or a rejected extra-usage state), the turn now carries a `▌ **rate limit:**` line naming the window, the reason extra usage is unavailable, when it resets, and the four things that can be done about it. Warned once per identity per process. See [Billing](#billing-change-june-15-2026-agent-sdk-credit).
 - **A context compaction Claude Code did on its own.** A `▌ **context compacted:**` note says so, with the before and after token counts, so an answer that suddenly forgets the start of the conversation has a visible cause.
+- **A conversation Claude Code cleared.** Sending `/clear` as a message, or a plan-mode exit that clears context, makes Claude Code start a fresh conversation while opencode still shows the old messages. A `▌ **claude code reset:**` note says so. The plugin deliberately does not replay the earlier messages, since that would undo the clear. Start a new opencode session if you want the two to match.
 - **A `result` whose subtype is not `success`** (`error_max_turns`, `error_during_execution`, …). The subtype is named in the transcript and the turn finishes as an error instead of an ordinary reply.
 - **A CLI-executed tool that failed.** Its result is forwarded with the AI SDK's error flag, so opencode renders the row as failed rather than as a success whose output happens to be an error message.
 
@@ -799,7 +801,7 @@ No separate skill installation or copying is needed. It ships with each package
 
 ## Skill bridge
 
-opencode and Claude Code use the same on-disk skill format, a `<name>/SKILL.md` whose frontmatter carries `name` and `description`, but they read from different directories. opencode looks in `.opencode/skills/` and `~/.config/opencode/skills/`; the Claude CLI looks in `~/.claude/skills/` and its own plugins. So opencode advertises your skills in the system prompt it forwards, the model calls `Skill("browser-automation")`, and Claude answers `Unknown skill`.
+opencode and Claude Code use the same on-disk skill format, a `<name>/SKILL.md` whose frontmatter carries `name` and `description`, but they read from overlapping, not identical, directories. opencode looks in `.opencode/skills/`, `~/.config/opencode/skills/`, `~/.agents/skills/` and more; the Claude CLI looks in `~/.claude/skills/`, the project's `.claude/skills/` and its own plugins. Where they differ, opencode advertises a skill in the system prompt it forwards, the model calls `Skill("browser-automation")`, and Claude answers `Unknown skill`. Where they overlap, the same skill reaches one session twice.
 
 By default the plugin discovers your opencode skills, stages a throwaway Claude Code plugin directory that links them, and passes it as `claude --plugin-dir`. They register natively, prefixed with the plugin name:
 
@@ -810,9 +812,33 @@ opencode-skills:rtk
 
 Claude can invoke them with the Skill tool or as `/opencode-skills:<name>`. `--plugin-dir` is scoped to the spawned session, so nothing is written into your `~/.claude`.
 
-Discovery order, first match wins: `.opencode/skills/` walking up from the working directory, then `~/.opencode/skills/`, then `$OPENCODE_CONFIG_DIR/skills/`, then `~/.config/opencode/skills/`. A project skill shadows a global one of the same name. If the skill set is unchanged the staged directory is reused between spawns.
+Discovery covers every root opencode itself reads, first match wins:
 
-The bridge is **off by default**: every bridged skill's name and description is also in the system prompt opencode already forwards, so a large skill set is paid for twice on every turn. Set `bridgeOpencodeSkills: true` when the model tries `Skill("<name>")` for a skill opencode advertises and gets `Unknown skill`; the bundled configuration skill is staged either way. When on, the bridge applies to the headless, interactive and direct `doGenerate` spawns alike, never to compaction, and it is skipped on a Claude CLI without `--plugin-dir` (the plugin probes `claude --help` and logs a notice).
+1. Walking up from the working directory: `.opencode/skills/`, `.claude/skills/`, `.agents/skills/` at each level.
+2. `~/.opencode/skills/`.
+3. `$OPENCODE_CONFIG_DIR/skills/` and `.../skill/`.
+4. `~/.config/opencode/skills/` and `.../skill/` (or `$XDG_CONFIG_HOME`).
+5. `~/.claude/skills/` and `~/.agents/skills/`.
+
+A project skill shadows a global one of the same name, and an opencode-managed copy shadows an external one. Step 5 is opencode's own "external" scan and honours its `OPENCODE_DISABLE_EXTERNAL_SKILLS` and `OPENCODE_DISABLE_CLAUDE_CODE_SKILLS` variables. A skill is known by the `name:` its `SKILL.md` frontmatter declares, falling back to the directory name, which is what opencode advertises. If the skill set is unchanged the staged directory is reused between spawns.
+
+### Skills Claude already has
+
+Those roots overlap Claude Code's own, which reads `$CLAUDE_CONFIG_DIR/skills/` (`~/.claude/skills/` by default), the project's `.claude/skills/`, and the `skills/` folder of every installed plugin. Without care one skill reaches a single session twice, costing prompt tokens on every turn and leaving it ambiguous which copy answers.
+
+So `bridgeSkipNativeSkills` (**on by default**) leaves a skill unbridged when Claude already loads it. A skill counts as already loaded when:
+
+- it is literally the same directory, symlinks resolved;
+- its `SKILL.md` is byte-identical to a native one, wherever that one lives (this is the case for a skill installed as a Claude plugin *and* symlinked into `~/.agents/skills`);
+- a **different** skill of the same name is registered under user or project scope. Plugin skills are namespaced `<plugin>:<name>` and so never take a bridged name, only duplicate its content.
+
+Only that last case changes which copy answers `Skill("<name>")`, so it is logged at WARN naming both paths; the others are logged at INFO. Set `bridgeSkipNativeSkills: false` to bridge everything regardless and get the duplicates back.
+
+One limitation worth knowing: the plugin scan reads `installed_plugins.json` and does not check whether that plugin is actually enabled, so a skill from a disabled plugin can be treated as native. If a skill disappears, grep `plugin.log` for `skills claude code already loads`: one line names both paths and the reason.
+
+### Enabling it
+
+The bridge itself is **off by default**: every bridged skill's name and description is also in the system prompt opencode already forwards, so a large skill set is paid for twice on every turn. Set `bridgeOpencodeSkills: true` when the model tries `Skill("<name>")` for a skill opencode advertises and gets `Unknown skill`; the bundled configuration skill is staged either way. When on, the bridge applies to the headless, interactive and direct `doGenerate` spawns alike, never to compaction, and it is skipped on a Claude CLI without `--plugin-dir` (the plugin probes `claude --help` and logs a notice).
 
 This bridge was written by [@broskees](https://github.com/broskees) (Joseph Roberts) on his fork and absorbed here with credit; see [Credits](#credits).
 

package/dist/index.d.ts

@@ -407,6 +407,8 @@ interface ClaudeCodeConfig {
     idleProcessTimeoutMs?: number;
     /** Stage opencode skills as a `--plugin-dir` so Claude's Skill tool can run them. */
     bridgeOpencodeSkills?: boolean;
+    /** Leave out the skills the Claude session already loads natively. Default true. */
+    bridgeSkipNativeSkills?: boolean;
     /** Append a one-line cost / duration / cache footer to each finished turn. */
     turnStats?: boolean;
     logging?: LoggingConfig;
@@ -662,17 +664,41 @@ interface ClaudeCodeProviderSettings {
      */
     idleProcessTimeoutMs?: number;
     /**
-     * Expose your opencode skills (`.opencode/skills`, `~/.config/opencode/skills`)
-     * to Claude Code's native Skill tool by staging them as a session-scoped
-     * `--plugin-dir`, so a `Skill("<name>")` call for a skill opencode advertises
-     * does not fail with `Unknown skill`. Off by default: every bridged skill
-     * is also listed in the system prompt opencode forwards, so a large skill
-     * set costs prompt tokens twice per turn. When on it applies to the
-     * headless, interactive and direct `doGenerate` spawns alike; compaction
-     * never loads it, and the bundled configuration skill is staged either way.
-     * No-op on CLIs without `--plugin-dir`.
+     * Expose your opencode skills to Claude Code's native Skill tool by staging
+     * them as a session-scoped `--plugin-dir`, so a `Skill("<name>")` call for a
+     * skill opencode advertises does not fail with `Unknown skill`. Covers every
+     * root opencode itself reads: project `.opencode/`, `.claude/` and `.agents/`
+     * walking up from the workspace, the opencode config dirs, and the global
+     * `~/.claude/skills` and `~/.agents/skills` (those last two behind the same
+     * `OPENCODE_DISABLE_EXTERNAL_SKILLS` / `OPENCODE_DISABLE_CLAUDE_CODE_SKILLS`
+     * switches opencode honours).
+     *
+     * Off by default: every bridged skill is also listed in the system prompt
+     * opencode forwards, so a large skill set costs prompt tokens twice per turn.
+     * When on it applies to the headless, interactive and direct `doGenerate`
+     * spawns alike; compaction never loads it, and the bundled configuration
+     * skill is staged either way. No-op on CLIs without `--plugin-dir`.
      */
     bridgeOpencodeSkills?: boolean;
+    /**
+     * Leave a skill unbridged when the Claude Code session already loads it:
+     * from `<CLAUDE_CONFIG_DIR>/skills` (`~/.claude/skills` by default), from the
+     * project's own `.claude/skills`, or from an installed plugin's `skills/`.
+     * On by default, because those roots overlap opencode's and the duplicate
+     * costs prompt tokens on every turn for nothing.
+     *
+     * A skill is treated as already loaded when it is literally the same
+     * directory (symlinks resolved), when its SKILL.md is byte-identical to a
+     * native one, or when a *different* skill of the same name is registered
+     * under user or project scope. That last case is the only one that changes
+     * behaviour, because `Skill("<name>")` then answers from Claude's copy
+     * rather than opencode's, so it is logged at WARN naming both paths. Plugin
+     * skills are namespaced `<plugin>:<name>` and so only ever match by content.
+     *
+     * Set `false` to bridge everything regardless, which restores the pre-0.25
+     * behaviour of advertising a shared skill twice.
+     */
+    bridgeSkipNativeSkills?: boolean;
     /**
      * Append one compact line to the end of every finished (non-compaction,
      * non-error) turn with what that turn cost: dollars, wall duration, how many
@@ -810,6 +836,8 @@ interface ClaudeStreamMessage {
      * `accountBlockKind`; schema confirmed on Claude Code 2.1.280.
      */
     error?: string;
+    /** On a `conversation_reset`: the conversation Claude Code started. */
+    new_conversation_id?: string;
     message?: {
         role?: string;
         model?: string;
@@ -993,6 +1021,13 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
      * spawn block resolves anything: `userMsg` is built well ahead of it.
      */
     private stripContextRemindersEnabled;
+    /**
+     * 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.
+     */
+    private skillBridgeSpawn;
     /** Share one lazy registry request within a turn without making it stale. */
     private createLiveToolInfoLoader;
     /**

package/dist/index.js

@@ -553,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;
@@ -878,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",
@@ -4721,6 +4746,7 @@ 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,
@@ -5572,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();
@@ -5588,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) {
@@ -5612,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);
 }
@@ -5632,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) => {
@@ -5679,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");
@@ -5714,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) {
@@ -6960,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;
@@ -7478,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,
@@ -8208,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,
@@ -8364,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,
@@ -8938,6 +9160,18 @@ ${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") {
@@ -9930,7 +10164,7 @@ ${plan}
 import {
   existsSync as existsSync4,
   readFileSync as readFileSync6,
-  realpathSync,
+  realpathSync as realpathSync2,
   rmSync as rmSync3,
   writeFileSync as writeFileSync5
 } from "fs";
@@ -9969,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;
   }
@@ -9997,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;
@@ -10556,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,