oh-my-opencode 2.4.4 → 2.4.5

package/dist/index.js

@@ -6061,6 +6061,10 @@ function createAnthropicAutoCompactHook(ctx, options) {
     event: eventHandler
   };
 }
+// src/hooks/preemptive-compaction/index.ts
+import { existsSync as existsSync15, readdirSync as readdirSync5 } from "fs";
+import { join as join19 } from "path";
+
 // src/hooks/preemptive-compaction/constants.ts
 var DEFAULT_THRESHOLD = 0.85;
 var MIN_TOKENS_FOR_COMPACTION = 50000;
@@ -6072,6 +6076,19 @@ var CLAUDE_DEFAULT_CONTEXT_LIMIT = 200000;
 function isSupportedModel(modelID) {
   return CLAUDE_MODEL_PATTERN.test(modelID);
 }
+function getMessageDir4(sessionID) {
+  if (!existsSync15(MESSAGE_STORAGE))
+    return null;
+  const directPath = join19(MESSAGE_STORAGE, sessionID);
+  if (existsSync15(directPath))
+    return directPath;
+  for (const dir of readdirSync5(MESSAGE_STORAGE)) {
+    const sessionPath = join19(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync15(sessionPath))
+      return sessionPath;
+  }
+  return null;
+}
 function createState() {
   return {
     lastCompactionTime: new Map,
@@ -6211,6 +6228,19 @@ function createPreemptiveCompactionHook(ctx, options) {
         if (assistants.length === 0)
           return;
         const lastAssistant = assistants[assistants.length - 1];
+        if (!lastAssistant.providerID || !lastAssistant.modelID) {
+          const messageDir = getMessageDir4(sessionID);
+          const storedMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
+          if (storedMessage?.model?.providerID && storedMessage?.model?.modelID) {
+            lastAssistant.providerID = storedMessage.model.providerID;
+            lastAssistant.modelID = storedMessage.model.modelID;
+            log("[preemptive-compaction] using stored message model info", {
+              sessionID,
+              providerID: lastAssistant.providerID,
+              modelID: lastAssistant.modelID
+            });
+          }
+        }
         await checkAndTriggerCompaction(sessionID, lastAssistant);
       } catch {}
     }
@@ -6534,8 +6564,8 @@ function createThinkModeHook() {
 }
 // src/hooks/claude-code-hooks/config.ts
 import { homedir as homedir6 } from "os";
-import { join as join19 } from "path";
-import { existsSync as existsSync15 } from "fs";
+import { join as join20 } from "path";
+import { existsSync as existsSync16 } from "fs";
 function normalizeHookMatcher(raw) {
   return {
     matcher: raw.matcher ?? raw.pattern ?? "*",
@@ -6560,11 +6590,11 @@ function normalizeHooksConfig(raw) {
 function getClaudeSettingsPaths(customPath) {
   const home = homedir6();
   const paths = [
-    join19(home, ".claude", "settings.json"),
-    join19(process.cwd(), ".claude", "settings.json"),
-    join19(process.cwd(), ".claude", "settings.local.json")
+    join20(home, ".claude", "settings.json"),
+    join20(process.cwd(), ".claude", "settings.json"),
+    join20(process.cwd(), ".claude", "settings.local.json")
   ];
-  if (customPath && existsSync15(customPath)) {
+  if (customPath && existsSync16(customPath)) {
     paths.unshift(customPath);
   }
   return paths;
@@ -6588,7 +6618,7 @@ async function loadClaudeHooksConfig(customSettingsPath) {
   const paths = getClaudeSettingsPaths(customSettingsPath);
   let mergedConfig = {};
   for (const settingsPath of paths) {
-    if (existsSync15(settingsPath)) {
+    if (existsSync16(settingsPath)) {
       try {
         const content = await Bun.file(settingsPath).text();
         const settings = JSON.parse(content);
@@ -6605,15 +6635,15 @@ async function loadClaudeHooksConfig(customSettingsPath) {
 }
 
 // src/hooks/claude-code-hooks/config-loader.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join20 } from "path";
-var USER_CONFIG_PATH = join20(homedir7(), ".config", "opencode", "opencode-cc-plugin.json");
+import { join as join21 } from "path";
+var USER_CONFIG_PATH = join21(homedir7(), ".config", "opencode", "opencode-cc-plugin.json");
 function getProjectConfigPath() {
-  return join20(process.cwd(), ".opencode", "opencode-cc-plugin.json");
+  return join21(process.cwd(), ".opencode", "opencode-cc-plugin.json");
 }
 async function loadConfigFromPath(path4) {
-  if (!existsSync16(path4)) {
+  if (!existsSync17(path4)) {
     return null;
   }
   try {
@@ -6792,16 +6822,16 @@ async function executePreToolUseHooks(ctx, config, extendedConfig) {
 }
 
 // src/hooks/claude-code-hooks/transcript.ts
-import { join as join21 } from "path";
-import { mkdirSync as mkdirSync6, appendFileSync as appendFileSync5, existsSync as existsSync17, writeFileSync as writeFileSync6, unlinkSync as unlinkSync5 } from "fs";
+import { join as join22 } from "path";
+import { mkdirSync as mkdirSync6, appendFileSync as appendFileSync5, existsSync as existsSync18, writeFileSync as writeFileSync6, unlinkSync as unlinkSync5 } from "fs";
 import { homedir as homedir8, tmpdir as tmpdir5 } from "os";
 import { randomUUID } from "crypto";
-var TRANSCRIPT_DIR = join21(homedir8(), ".claude", "transcripts");
+var TRANSCRIPT_DIR = join22(homedir8(), ".claude", "transcripts");
 function getTranscriptPath(sessionId) {
-  return join21(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
+  return join22(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
 }
 function ensureTranscriptDir() {
-  if (!existsSync17(TRANSCRIPT_DIR)) {
+  if (!existsSync18(TRANSCRIPT_DIR)) {
     mkdirSync6(TRANSCRIPT_DIR, { recursive: true });
   }
 }
@@ -6888,7 +6918,7 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
       }
     };
     entries.push(JSON.stringify(currentEntry));
-    const tempPath = join21(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+    const tempPath = join22(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
     writeFileSync6(tempPath, entries.join(`
 `) + `
 `);
@@ -6908,7 +6938,7 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
           ]
         }
       };
-      const tempPath = join21(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+      const tempPath = join22(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
       writeFileSync6(tempPath, JSON.stringify(currentEntry) + `
 `);
       return tempPath;
@@ -7120,11 +7150,11 @@ ${USER_PROMPT_SUBMIT_TAG_CLOSE}`);
 }
 
 // src/hooks/claude-code-hooks/todo.ts
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 import { homedir as homedir9 } from "os";
-var TODO_DIR = join22(homedir9(), ".claude", "todos");
+var TODO_DIR = join23(homedir9(), ".claude", "todos");
 function getTodoPath(sessionId) {
-  return join22(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
+  return join23(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
 }
 
 // src/hooks/claude-code-hooks/stop.ts
@@ -7462,17 +7492,17 @@ import { relative as relative3, resolve as resolve4 } from "path";
 
 // src/hooks/rules-injector/finder.ts
 import {
-  existsSync as existsSync18,
-  readdirSync as readdirSync5,
+  existsSync as existsSync19,
+  readdirSync as readdirSync6,
   realpathSync,
   statSync as statSync2
 } from "fs";
-import { dirname as dirname4, join as join24, relative } from "path";
+import { dirname as dirname4, join as join25, relative } from "path";
 
 // src/hooks/rules-injector/constants.ts
-import { join as join23 } from "path";
-var OPENCODE_STORAGE6 = join23(xdgData2 ?? "", "opencode", "storage");
-var RULES_INJECTOR_STORAGE = join23(OPENCODE_STORAGE6, "rules-injector");
+import { join as join24 } from "path";
+var OPENCODE_STORAGE6 = join24(xdgData2 ?? "", "opencode", "storage");
+var RULES_INJECTOR_STORAGE = join24(OPENCODE_STORAGE6, "rules-injector");
 var PROJECT_MARKERS = [
   ".git",
   "pyproject.toml",
@@ -7499,8 +7529,8 @@ function findProjectRoot(startPath) {
   }
   while (true) {
     for (const marker of PROJECT_MARKERS) {
-      const markerPath = join24(current, marker);
-      if (existsSync18(markerPath)) {
+      const markerPath = join25(current, marker);
+      if (existsSync19(markerPath)) {
         return current;
       }
     }
@@ -7512,12 +7542,12 @@ function findProjectRoot(startPath) {
   }
 }
 function findRuleFilesRecursive(dir, results) {
-  if (!existsSync18(dir))
+  if (!existsSync19(dir))
     return;
   try {
-    const entries = readdirSync5(dir, { withFileTypes: true });
+    const entries = readdirSync6(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join24(dir, entry.name);
+      const fullPath = join25(dir, entry.name);
       if (entry.isDirectory()) {
         findRuleFilesRecursive(fullPath, results);
       } else if (entry.isFile()) {
@@ -7543,7 +7573,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
   let distance = 0;
   while (true) {
     for (const [parent, subdir] of PROJECT_RULE_SUBDIRS) {
-      const ruleDir = join24(currentDir, parent, subdir);
+      const ruleDir = join25(currentDir, parent, subdir);
       const files = [];
       findRuleFilesRecursive(ruleDir, files);
       for (const filePath of files) {
@@ -7567,7 +7597,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
     currentDir = parentDir;
     distance++;
   }
-  const userRuleDir = join24(homeDir, USER_RULE_DIR);
+  const userRuleDir = join25(homeDir, USER_RULE_DIR);
   const userFiles = [];
   findRuleFilesRecursive(userRuleDir, userFiles);
   for (const filePath of userFiles) {
@@ -7756,19 +7786,19 @@ function mergeGlobs(existing, newValue) {
 
 // src/hooks/rules-injector/storage.ts
 import {
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync7,
   readFileSync as readFileSync9,
   writeFileSync as writeFileSync7,
   unlinkSync as unlinkSync6
 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 function getStoragePath3(sessionID) {
-  return join25(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
+  return join26(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedRules(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (!existsSync19(filePath))
+  if (!existsSync20(filePath))
     return { contentHashes: new Set, realPaths: new Set };
   try {
     const content = readFileSync9(filePath, "utf-8");
@@ -7782,7 +7812,7 @@ function loadInjectedRules(sessionID) {
   }
 }
 function saveInjectedRules(sessionID, data) {
-  if (!existsSync19(RULES_INJECTOR_STORAGE)) {
+  if (!existsSync20(RULES_INJECTOR_STORAGE)) {
     mkdirSync7(RULES_INJECTOR_STORAGE, { recursive: true });
   }
   const storageData = {
@@ -7795,7 +7825,7 @@ function saveInjectedRules(sessionID, data) {
 }
 function clearInjectedRules(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (existsSync19(filePath)) {
+  if (existsSync20(filePath)) {
     unlinkSync6(filePath);
   }
 }
@@ -8365,18 +8395,18 @@ async function showLocalDevToast(ctx, version, isSisyphusEnabled) {
 }
 // src/hooks/agent-usage-reminder/storage.ts
 import {
-  existsSync as existsSync22,
+  existsSync as existsSync23,
   mkdirSync as mkdirSync8,
   readFileSync as readFileSync13,
   writeFileSync as writeFileSync10,
   unlinkSync as unlinkSync7
 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 
 // src/hooks/agent-usage-reminder/constants.ts
-import { join as join29 } from "path";
-var OPENCODE_STORAGE7 = join29(xdgData2 ?? "", "opencode", "storage");
-var AGENT_USAGE_REMINDER_STORAGE = join29(OPENCODE_STORAGE7, "agent-usage-reminder");
+import { join as join30 } from "path";
+var OPENCODE_STORAGE7 = join30(xdgData2 ?? "", "opencode", "storage");
+var AGENT_USAGE_REMINDER_STORAGE = join30(OPENCODE_STORAGE7, "agent-usage-reminder");
 var TARGET_TOOLS = new Set([
   "grep",
   "safe_grep",
@@ -8421,11 +8451,11 @@ ALWAYS prefer: Multiple parallel background_task calls > Direct tool calls
 
 // src/hooks/agent-usage-reminder/storage.ts
 function getStoragePath4(sessionID) {
-  return join30(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
+  return join31(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
 }
 function loadAgentUsageState(sessionID) {
   const filePath = getStoragePath4(sessionID);
-  if (!existsSync22(filePath))
+  if (!existsSync23(filePath))
     return null;
   try {
     const content = readFileSync13(filePath, "utf-8");
@@ -8435,7 +8465,7 @@ function loadAgentUsageState(sessionID) {
   }
 }
 function saveAgentUsageState(state2) {
-  if (!existsSync22(AGENT_USAGE_REMINDER_STORAGE)) {
+  if (!existsSync23(AGENT_USAGE_REMINDER_STORAGE)) {
     mkdirSync8(AGENT_USAGE_REMINDER_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath4(state2.sessionID);
@@ -8443,7 +8473,7 @@ function saveAgentUsageState(state2) {
 }
 function clearAgentUsageState(sessionID) {
   const filePath = getStoragePath4(sessionID);
-  if (existsSync22(filePath)) {
+  if (existsSync23(filePath)) {
     unlinkSync7(filePath);
   }
 }
@@ -8670,18 +8700,18 @@ function createNonInteractiveEnvHook(_ctx) {
 }
 // src/hooks/interactive-bash-session/storage.ts
 import {
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   mkdirSync as mkdirSync9,
   readFileSync as readFileSync14,
   writeFileSync as writeFileSync11,
   unlinkSync as unlinkSync8
 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 
 // src/hooks/interactive-bash-session/constants.ts
-import { join as join31 } from "path";
-var OPENCODE_STORAGE8 = join31(xdgData2 ?? "", "opencode", "storage");
-var INTERACTIVE_BASH_SESSION_STORAGE = join31(OPENCODE_STORAGE8, "interactive-bash-session");
+import { join as join32 } from "path";
+var OPENCODE_STORAGE8 = join32(xdgData2 ?? "", "opencode", "storage");
+var INTERACTIVE_BASH_SESSION_STORAGE = join32(OPENCODE_STORAGE8, "interactive-bash-session");
 var OMO_SESSION_PREFIX = "omo-";
 function buildSessionReminderMessage(sessions) {
   if (sessions.length === 0)
@@ -8693,11 +8723,11 @@ function buildSessionReminderMessage(sessions) {
 
 // src/hooks/interactive-bash-session/storage.ts
 function getStoragePath5(sessionID) {
-  return join32(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
+  return join33(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
 }
 function loadInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath5(sessionID);
-  if (!existsSync23(filePath))
+  if (!existsSync24(filePath))
     return null;
   try {
     const content = readFileSync14(filePath, "utf-8");
@@ -8712,7 +8742,7 @@ function loadInteractiveBashSessionState(sessionID) {
   }
 }
 function saveInteractiveBashSessionState(state2) {
-  if (!existsSync23(INTERACTIVE_BASH_SESSION_STORAGE)) {
+  if (!existsSync24(INTERACTIVE_BASH_SESSION_STORAGE)) {
     mkdirSync9(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath5(state2.sessionID);
@@ -8725,7 +8755,7 @@ function saveInteractiveBashSessionState(state2) {
 }
 function clearInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath5(sessionID);
-  if (existsSync23(filePath)) {
+  if (existsSync24(filePath)) {
     unlinkSync8(filePath);
   }
 }
@@ -10669,19 +10699,19 @@ async function createGoogleAntigravityAuthPlugin({
   };
 }
 // src/features/claude-code-command-loader/loader.ts
-import { existsSync as existsSync24, readdirSync as readdirSync6, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync25, readdirSync as readdirSync7, readFileSync as readFileSync15 } from "fs";
 import { homedir as homedir12 } from "os";
-import { join as join33, basename } from "path";
+import { join as join34, basename } from "path";
 function loadCommandsFromDir(commandsDir, scope) {
-  if (!existsSync24(commandsDir)) {
+  if (!existsSync25(commandsDir)) {
     return [];
   }
-  const entries = readdirSync6(commandsDir, { withFileTypes: true });
+  const entries = readdirSync7(commandsDir, { withFileTypes: true });
   const commands = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join33(commandsDir, entry.name);
+    const commandPath = join34(commandsDir, entry.name);
     const commandName = basename(entry.name, ".md");
     try {
       const content = readFileSync15(commandPath, "utf-8");
@@ -10724,44 +10754,44 @@ function commandsToRecord(commands) {
   return result;
 }
 function loadUserCommands() {
-  const userCommandsDir = join33(homedir12(), ".claude", "commands");
+  const userCommandsDir = join34(homedir12(), ".claude", "commands");
   const commands = loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands);
 }
 function loadProjectCommands() {
-  const projectCommandsDir = join33(process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join34(process.cwd(), ".claude", "commands");
   const commands = loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands);
 }
 function loadOpencodeGlobalCommands() {
-  const opencodeCommandsDir = join33(homedir12(), ".config", "opencode", "command");
+  const opencodeCommandsDir = join34(homedir12(), ".config", "opencode", "command");
   const commands = loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands);
 }
 function loadOpencodeProjectCommands() {
-  const opencodeProjectDir = join33(process.cwd(), ".opencode", "command");
+  const opencodeProjectDir = join34(process.cwd(), ".opencode", "command");
   const commands = loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands);
 }
 // src/features/claude-code-skill-loader/loader.ts
-import { existsSync as existsSync25, readdirSync as readdirSync7, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync26, readdirSync as readdirSync8, readFileSync as readFileSync16 } from "fs";
 import { homedir as homedir13 } from "os";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 function loadSkillsFromDir(skillsDir, scope) {
-  if (!existsSync25(skillsDir)) {
+  if (!existsSync26(skillsDir)) {
     return [];
   }
-  const entries = readdirSync7(skillsDir, { withFileTypes: true });
+  const entries = readdirSync8(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
-    const skillPath = join34(skillsDir, entry.name);
+    const skillPath = join35(skillsDir, entry.name);
     if (!entry.isDirectory() && !entry.isSymbolicLink())
       continue;
     const resolvedPath = resolveSymlink(skillPath);
-    const skillMdPath = join34(resolvedPath, "SKILL.md");
-    if (!existsSync25(skillMdPath))
+    const skillMdPath = join35(resolvedPath, "SKILL.md");
+    if (!existsSync26(skillMdPath))
       continue;
     try {
       const content = readFileSync16(skillMdPath, "utf-8");
@@ -10798,7 +10828,7 @@ $ARGUMENTS
   return skills;
 }
 function loadUserSkillsAsCommands() {
-  const userSkillsDir = join34(homedir13(), ".claude", "skills");
+  const userSkillsDir = join35(homedir13(), ".claude", "skills");
   const skills = loadSkillsFromDir(userSkillsDir, "user");
   return skills.reduce((acc, skill) => {
     acc[skill.name] = skill.definition;
@@ -10806,7 +10836,7 @@ function loadUserSkillsAsCommands() {
   }, {});
 }
 function loadProjectSkillsAsCommands() {
-  const projectSkillsDir = join34(process.cwd(), ".claude", "skills");
+  const projectSkillsDir = join35(process.cwd(), ".claude", "skills");
   const skills = loadSkillsFromDir(projectSkillsDir, "project");
   return skills.reduce((acc, skill) => {
     acc[skill.name] = skill.definition;
@@ -10814,9 +10844,9 @@ function loadProjectSkillsAsCommands() {
   }, {});
 }
 // src/features/claude-code-agent-loader/loader.ts
-import { existsSync as existsSync26, readdirSync as readdirSync8, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync27, readdirSync as readdirSync9, readFileSync as readFileSync17 } from "fs";
 import { homedir as homedir14 } from "os";
-import { join as join35, basename as basename2 } from "path";
+import { join as join36, basename as basename2 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
     return;
@@ -10830,15 +10860,15 @@ function parseToolsConfig(toolsStr) {
   return result;
 }
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync26(agentsDir)) {
+  if (!existsSync27(agentsDir)) {
     return [];
   }
-  const entries = readdirSync8(agentsDir, { withFileTypes: true });
+  const entries = readdirSync9(agentsDir, { withFileTypes: true });
   const agents = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const agentPath = join35(agentsDir, entry.name);
+    const agentPath = join36(agentsDir, entry.name);
     const agentName = basename2(entry.name, ".md");
     try {
       const content = readFileSync17(agentPath, "utf-8");
@@ -10868,7 +10898,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   return agents;
 }
 function loadUserAgents() {
-  const userAgentsDir = join35(homedir14(), ".claude", "agents");
+  const userAgentsDir = join36(homedir14(), ".claude", "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user");
   const result = {};
   for (const agent of agents) {
@@ -10877,7 +10907,7 @@ function loadUserAgents() {
   return result;
 }
 function loadProjectAgents() {
-  const projectAgentsDir = join35(process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join36(process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project");
   const result = {};
   for (const agent of agents) {
@@ -10886,9 +10916,9 @@ function loadProjectAgents() {
   return result;
 }
 // src/features/claude-code-mcp-loader/loader.ts
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import { homedir as homedir15 } from "os";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 
 // src/features/claude-code-mcp-loader/env-expander.ts
 function expandEnvVars(value) {
@@ -10957,13 +10987,13 @@ function getMcpConfigPaths() {
   const home = homedir15();
   const cwd = process.cwd();
   return [
-    { path: join36(home, ".claude", ".mcp.json"), scope: "user" },
-    { path: join36(cwd, ".mcp.json"), scope: "project" },
-    { path: join36(cwd, ".claude", ".mcp.json"), scope: "local" }
+    { path: join37(home, ".claude", ".mcp.json"), scope: "user" },
+    { path: join37(cwd, ".mcp.json"), scope: "project" },
+    { path: join37(cwd, ".claude", ".mcp.json"), scope: "local" }
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync27(filePath)) {
+  if (!existsSync28(filePath)) {
     return null;
   }
   try {
@@ -11298,11 +11328,11 @@ var EXT_TO_LANG = {
   ".gql": "graphql"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync28, readFileSync as readFileSync18 } from "fs";
-import { join as join37 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync18 } from "fs";
+import { join as join38 } from "path";
 import { homedir as homedir16 } from "os";
 function loadJsonFile(path7) {
-  if (!existsSync28(path7))
+  if (!existsSync29(path7))
     return null;
   try {
     return JSON.parse(readFileSync18(path7, "utf-8"));
@@ -11313,9 +11343,9 @@ function loadJsonFile(path7) {
 function getConfigPaths2() {
   const cwd = process.cwd();
   return {
-    project: join37(cwd, ".opencode", "oh-my-opencode.json"),
-    user: join37(homedir16(), ".config", "opencode", "oh-my-opencode.json"),
-    opencode: join37(homedir16(), ".config", "opencode", "opencode.json")
+    project: join38(cwd, ".opencode", "oh-my-opencode.json"),
+    user: join38(homedir16(), ".config", "opencode", "oh-my-opencode.json"),
+    opencode: join38(homedir16(), ".config", "opencode", "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -11411,21 +11441,21 @@ function isServerInstalled(command) {
   const pathSeparator = isWindows2 ? ";" : ":";
   const paths = pathEnv.split(pathSeparator);
   for (const p of paths) {
-    if (existsSync28(join37(p, cmd)) || existsSync28(join37(p, cmd + ext))) {
+    if (existsSync29(join38(p, cmd)) || existsSync29(join38(p, cmd + ext))) {
       return true;
     }
   }
   const cwd = process.cwd();
   const additionalPaths = [
-    join37(cwd, "node_modules", ".bin", cmd),
-    join37(cwd, "node_modules", ".bin", cmd + ext),
-    join37(homedir16(), ".config", "opencode", "bin", cmd),
-    join37(homedir16(), ".config", "opencode", "bin", cmd + ext),
-    join37(homedir16(), ".config", "opencode", "node_modules", ".bin", cmd),
-    join37(homedir16(), ".config", "opencode", "node_modules", ".bin", cmd + ext)
+    join38(cwd, "node_modules", ".bin", cmd),
+    join38(cwd, "node_modules", ".bin", cmd + ext),
+    join38(homedir16(), ".config", "opencode", "bin", cmd),
+    join38(homedir16(), ".config", "opencode", "bin", cmd + ext),
+    join38(homedir16(), ".config", "opencode", "node_modules", ".bin", cmd),
+    join38(homedir16(), ".config", "opencode", "node_modules", ".bin", cmd + ext)
   ];
   for (const p of additionalPaths) {
-    if (existsSync28(p)) {
+    if (existsSync29(p)) {
       return true;
     }
   }
@@ -12020,16 +12050,16 @@ ${msg}`);
 }
 // src/tools/lsp/utils.ts
 import { extname as extname2, resolve as resolve6 } from "path";
-import { existsSync as existsSync29, readFileSync as readFileSync20, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync20, writeFileSync as writeFileSync12 } from "fs";
 function findWorkspaceRoot(filePath) {
   let dir = resolve6(filePath);
-  if (!existsSync29(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  if (!existsSync30(dir) || !__require("fs").statSync(dir).isDirectory()) {
     dir = __require("path").dirname(dir);
   }
   const markers = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
   while (dir !== "/") {
     for (const marker of markers) {
-      if (existsSync29(__require("path").join(dir, marker))) {
+      if (existsSync30(__require("path").join(dir, marker))) {
         return dir;
       }
     }
@@ -24954,13 +24984,13 @@ var lsp_code_action_resolve = tool({
 });
 // src/tools/ast-grep/constants.ts
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname6, join as join39 } from "path";
-import { existsSync as existsSync31, statSync as statSync4 } from "fs";
+import { dirname as dirname6, join as join40 } from "path";
+import { existsSync as existsSync32, statSync as statSync4 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 var {spawn: spawn5 } = globalThis.Bun;
-import { existsSync as existsSync30, mkdirSync as mkdirSync10, chmodSync as chmodSync2, unlinkSync as unlinkSync9 } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync10, chmodSync as chmodSync2, unlinkSync as unlinkSync9 } from "fs";
+import { join as join39 } from "path";
 import { homedir as homedir17 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
@@ -24986,19 +25016,19 @@ var PLATFORM_MAP2 = {
 function getCacheDir3() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join38(homedir17(), "AppData", "Local");
-    return join38(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join39(homedir17(), "AppData", "Local");
+    return join39(base2, "oh-my-opencode", "bin");
   }
   const xdgCache2 = process.env.XDG_CACHE_HOME;
-  const base = xdgCache2 || join38(homedir17(), ".cache");
-  return join38(base, "oh-my-opencode", "bin");
+  const base = xdgCache2 || join39(homedir17(), ".cache");
+  return join39(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath2() {
-  const binaryPath = join38(getCacheDir3(), getBinaryName3());
-  return existsSync30(binaryPath) ? binaryPath : null;
+  const binaryPath = join39(getCacheDir3(), getBinaryName3());
+  return existsSync31(binaryPath) ? binaryPath : null;
 }
 async function extractZip2(archivePath, destDir) {
   const proc = process.platform === "win32" ? spawn5([
@@ -25024,8 +25054,8 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
-  const binaryPath = join38(cacheDir, binaryName);
-  if (existsSync30(binaryPath)) {
+  const binaryPath = join39(cacheDir, binaryName);
+  if (existsSync31(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os5 } = platformInfo;
@@ -25033,21 +25063,21 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   const downloadUrl = `https://github.com/${REPO2}/releases/download/${version2}/${assetName}`;
   console.log(`[oh-my-opencode] Downloading ast-grep binary...`);
   try {
-    if (!existsSync30(cacheDir)) {
+    if (!existsSync31(cacheDir)) {
       mkdirSync10(cacheDir, { recursive: true });
     }
     const response2 = await fetch(downloadUrl, { redirect: "follow" });
     if (!response2.ok) {
       throw new Error(`HTTP ${response2.status}: ${response2.statusText}`);
     }
-    const archivePath = join38(cacheDir, assetName);
+    const archivePath = join39(cacheDir, assetName);
     const arrayBuffer = await response2.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip2(archivePath, cacheDir);
-    if (existsSync30(archivePath)) {
+    if (existsSync31(archivePath)) {
       unlinkSync9(archivePath);
     }
-    if (process.platform !== "win32" && existsSync30(binaryPath)) {
+    if (process.platform !== "win32" && existsSync31(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -25098,8 +25128,8 @@ function findSgCliPathSync() {
     const require2 = createRequire4(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDir = dirname6(cliPkgPath);
-    const sgPath = join39(cliDir, binaryName);
-    if (existsSync31(sgPath) && isValidBinary(sgPath)) {
+    const sgPath = join40(cliDir, binaryName);
+    if (existsSync32(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -25110,8 +25140,8 @@ function findSgCliPathSync() {
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
       const pkgDir = dirname6(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join39(pkgDir, astGrepName);
-      if (existsSync31(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join40(pkgDir, astGrepName);
+      if (existsSync32(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -25119,7 +25149,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path7 of homebrewPaths) {
-      if (existsSync31(path7) && isValidBinary(path7)) {
+      if (existsSync32(path7) && isValidBinary(path7)) {
         return path7;
       }
     }
@@ -25175,11 +25205,11 @@ var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn6 } = globalThis.Bun;
-import { existsSync as existsSync32 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync32(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync33(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -25187,7 +25217,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync32(syncPath)) {
+    if (syncPath && existsSync33(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -25221,7 +25251,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync32(cliPath) && cliPath !== "sg") {
+  if (!existsSync33(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -25485,24 +25515,24 @@ var ast_grep_replace = tool({
 var {spawn: spawn7 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
-import { existsSync as existsSync34 } from "fs";
-import { join as join41, dirname as dirname7 } from "path";
+import { existsSync as existsSync35 } from "fs";
+import { join as join42, dirname as dirname7 } from "path";
 import { spawnSync } from "child_process";
 
 // src/tools/grep/downloader.ts
-import { existsSync as existsSync33, mkdirSync as mkdirSync11, chmodSync as chmodSync3, unlinkSync as unlinkSync10, readdirSync as readdirSync9 } from "fs";
-import { join as join40 } from "path";
+import { existsSync as existsSync34, mkdirSync as mkdirSync11, chmodSync as chmodSync3, unlinkSync as unlinkSync10, readdirSync as readdirSync10 } from "fs";
+import { join as join41 } from "path";
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join40(homeDir, ".cache", "oh-my-opencode", "bin");
+  return join41(homeDir, ".cache", "oh-my-opencode", "bin");
 }
 function getRgPath() {
   const isWindows2 = process.platform === "win32";
-  return join40(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
+  return join41(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
 }
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
-  return existsSync33(rgPath) ? rgPath : null;
+  return existsSync34(rgPath) ? rgPath : null;
 }
 
 // src/tools/grep/constants.ts
@@ -25525,13 +25555,13 @@ function getOpenCodeBundledRg() {
   const isWindows2 = process.platform === "win32";
   const rgName = isWindows2 ? "rg.exe" : "rg";
   const candidates = [
-    join41(execDir, rgName),
-    join41(execDir, "bin", rgName),
-    join41(execDir, "..", "bin", rgName),
-    join41(execDir, "..", "libexec", rgName)
+    join42(execDir, rgName),
+    join42(execDir, "bin", rgName),
+    join42(execDir, "..", "bin", rgName),
+    join42(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync34(candidate)) {
+    if (existsSync35(candidate)) {
       return candidate;
     }
   }
@@ -25934,19 +25964,19 @@ var glob = tool({
   }
 });
 // src/tools/slashcommand/tools.ts
-import { existsSync as existsSync35, readdirSync as readdirSync10, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync36, readdirSync as readdirSync11, readFileSync as readFileSync21 } from "fs";
 import { homedir as homedir18 } from "os";
-import { join as join42, basename as basename3, dirname as dirname8 } from "path";
+import { join as join43, basename as basename3, dirname as dirname8 } from "path";
 function discoverCommandsFromDir(commandsDir, scope) {
-  if (!existsSync35(commandsDir)) {
+  if (!existsSync36(commandsDir)) {
     return [];
   }
-  const entries = readdirSync10(commandsDir, { withFileTypes: true });
+  const entries = readdirSync11(commandsDir, { withFileTypes: true });
   const commands = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join42(commandsDir, entry.name);
+    const commandPath = join43(commandsDir, entry.name);
     const commandName = basename3(entry.name, ".md");
     try {
       const content = readFileSync21(commandPath, "utf-8");
@@ -25974,10 +26004,10 @@ function discoverCommandsFromDir(commandsDir, scope) {
   return commands;
 }
 function discoverCommandsSync() {
-  const userCommandsDir = join42(homedir18(), ".claude", "commands");
-  const projectCommandsDir = join42(process.cwd(), ".claude", "commands");
-  const opencodeGlobalDir = join42(homedir18(), ".config", "opencode", "command");
-  const opencodeProjectDir = join42(process.cwd(), ".opencode", "command");
+  const userCommandsDir = join43(homedir18(), ".claude", "commands");
+  const projectCommandsDir = join43(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join43(homedir18(), ".config", "opencode", "command");
+  const opencodeProjectDir = join43(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project");
@@ -26100,246 +26130,6 @@ Provide a command name to execute.`;
 Try a different command name.`;
   }
 });
-// src/tools/skill/types.ts
-var SkillFrontmatterSchema = exports_external.object({
-  name: exports_external.string().regex(/^[a-z0-9-]+$/, "Name must be lowercase alphanumeric with hyphens only").min(1, "Name cannot be empty"),
-  description: exports_external.string().min(20, "Description must be at least 20 characters for discoverability"),
-  license: exports_external.string().optional(),
-  "allowed-tools": exports_external.array(exports_external.string()).optional(),
-  metadata: exports_external.record(exports_external.string(), exports_external.string()).optional()
-});
-// src/tools/skill/tools.ts
-import { existsSync as existsSync36, readdirSync as readdirSync11, readFileSync as readFileSync22 } from "fs";
-import { homedir as homedir19 } from "os";
-import { join as join43, basename as basename4 } from "path";
-function parseSkillFrontmatter(data) {
-  return {
-    name: typeof data.name === "string" ? data.name : "",
-    description: typeof data.description === "string" ? data.description : "",
-    license: typeof data.license === "string" ? data.license : undefined,
-    "allowed-tools": Array.isArray(data["allowed-tools"]) ? data["allowed-tools"] : undefined,
-    metadata: typeof data.metadata === "object" && data.metadata !== null ? data.metadata : undefined
-  };
-}
-function discoverSkillsFromDir(skillsDir, scope) {
-  if (!existsSync36(skillsDir)) {
-    return [];
-  }
-  const entries = readdirSync11(skillsDir, { withFileTypes: true });
-  const skills = [];
-  for (const entry of entries) {
-    if (entry.name.startsWith("."))
-      continue;
-    const skillPath = join43(skillsDir, entry.name);
-    if (entry.isDirectory() || entry.isSymbolicLink()) {
-      const resolvedPath = resolveSymlink(skillPath);
-      const skillMdPath = join43(resolvedPath, "SKILL.md");
-      if (!existsSync36(skillMdPath))
-        continue;
-      try {
-        const content = readFileSync22(skillMdPath, "utf-8");
-        const { data } = parseFrontmatter(content);
-        skills.push({
-          name: data.name || entry.name,
-          description: data.description || "",
-          scope
-        });
-      } catch {
-        continue;
-      }
-    }
-  }
-  return skills;
-}
-function discoverSkillsSync() {
-  const userSkillsDir = join43(homedir19(), ".claude", "skills");
-  const projectSkillsDir = join43(process.cwd(), ".claude", "skills");
-  const userSkills = discoverSkillsFromDir(userSkillsDir, "user");
-  const projectSkills = discoverSkillsFromDir(projectSkillsDir, "project");
-  return [...projectSkills, ...userSkills];
-}
-var availableSkills = discoverSkillsSync();
-var skillListForDescription = availableSkills.map((s) => `- ${s.name}: ${s.description} (${s.scope})`).join(`
-`);
-async function parseSkillMd(skillPath) {
-  const resolvedPath = resolveSymlink(skillPath);
-  const skillMdPath = join43(resolvedPath, "SKILL.md");
-  if (!existsSync36(skillMdPath)) {
-    return null;
-  }
-  try {
-    let content = readFileSync22(skillMdPath, "utf-8");
-    content = await resolveCommandsInText(content);
-    const { data, body } = parseFrontmatter(content);
-    const frontmatter2 = parseSkillFrontmatter(data);
-    const metadata = {
-      name: frontmatter2.name || basename4(skillPath),
-      description: frontmatter2.description,
-      license: frontmatter2.license,
-      allowedTools: frontmatter2["allowed-tools"],
-      metadata: frontmatter2.metadata
-    };
-    const referencesDir = join43(resolvedPath, "references");
-    const scriptsDir = join43(resolvedPath, "scripts");
-    const assetsDir = join43(resolvedPath, "assets");
-    const references = existsSync36(referencesDir) ? readdirSync11(referencesDir).filter((f) => !f.startsWith(".")) : [];
-    const scripts = existsSync36(scriptsDir) ? readdirSync11(scriptsDir).filter((f) => !f.startsWith(".") && !f.startsWith("__")) : [];
-    const assets = existsSync36(assetsDir) ? readdirSync11(assetsDir).filter((f) => !f.startsWith(".")) : [];
-    return {
-      name: metadata.name,
-      path: resolvedPath,
-      basePath: resolvedPath,
-      metadata,
-      content: body,
-      references,
-      scripts,
-      assets
-    };
-  } catch {
-    return null;
-  }
-}
-async function discoverSkillsFromDirAsync(skillsDir) {
-  if (!existsSync36(skillsDir)) {
-    return [];
-  }
-  const entries = readdirSync11(skillsDir, { withFileTypes: true });
-  const skills = [];
-  for (const entry of entries) {
-    if (entry.name.startsWith("."))
-      continue;
-    const skillPath = join43(skillsDir, entry.name);
-    if (entry.isDirectory() || entry.isSymbolicLink()) {
-      const skillInfo = await parseSkillMd(skillPath);
-      if (skillInfo) {
-        skills.push(skillInfo);
-      }
-    }
-  }
-  return skills;
-}
-async function discoverSkills() {
-  const userSkillsDir = join43(homedir19(), ".claude", "skills");
-  const projectSkillsDir = join43(process.cwd(), ".claude", "skills");
-  const userSkills = await discoverSkillsFromDirAsync(userSkillsDir);
-  const projectSkills = await discoverSkillsFromDirAsync(projectSkillsDir);
-  return [...projectSkills, ...userSkills];
-}
-function findMatchingSkills(skills, query) {
-  const queryLower = query.toLowerCase();
-  const queryTerms = queryLower.split(/\s+/).filter(Boolean);
-  return skills.map((skill) => {
-    let score = 0;
-    const nameLower = skill.metadata.name.toLowerCase();
-    const descLower = skill.metadata.description.toLowerCase();
-    if (nameLower === queryLower)
-      score += 100;
-    if (nameLower.includes(queryLower))
-      score += 50;
-    for (const term of queryTerms) {
-      if (nameLower.includes(term))
-        score += 20;
-      if (descLower.includes(term))
-        score += 10;
-    }
-    return { skill, score };
-  }).filter(({ score }) => score > 0).sort((a, b) => b.score - a.score).map(({ skill }) => skill);
-}
-async function loadSkillWithReferences(skill, includeRefs) {
-  const referencesLoaded = [];
-  if (includeRefs && skill.references.length > 0) {
-    for (const ref of skill.references) {
-      const refPath = join43(skill.path, "references", ref);
-      try {
-        let content = readFileSync22(refPath, "utf-8");
-        content = await resolveCommandsInText(content);
-        referencesLoaded.push({ path: ref, content });
-      } catch {}
-    }
-  }
-  return {
-    name: skill.name,
-    metadata: skill.metadata,
-    basePath: skill.basePath,
-    body: skill.content,
-    referencesLoaded
-  };
-}
-function formatSkillList(skills) {
-  if (skills.length === 0) {
-    return "No skills found in ~/.claude/skills/";
-  }
-  const lines = [`# Available Skills
-`];
-  for (const skill of skills) {
-    lines.push(`- **${skill.metadata.name}**: ${skill.metadata.description || "(no description)"}`);
-  }
-  lines.push(`
-**Total**: ${skills.length} skills`);
-  return lines.join(`
-`);
-}
-function formatLoadedSkills(loadedSkills) {
-  if (loadedSkills.length === 0) {
-    return "No skills loaded.";
-  }
-  const skill = loadedSkills[0];
-  const sections = [];
-  sections.push(`Base directory for this skill: ${skill.basePath}/`);
-  sections.push("");
-  sections.push(skill.body.trim());
-  if (skill.referencesLoaded.length > 0) {
-    sections.push(`
----
-### Loaded References
-`);
-    for (const ref of skill.referencesLoaded) {
-      sections.push(`#### ${ref.path}
-`);
-      sections.push("```");
-      sections.push(ref.content.trim());
-      sections.push("```\n");
-    }
-  }
-  sections.push(`
----
-**Launched skill**: ${skill.metadata.name}`);
-  return sections.join(`
-`);
-}
-var skill = tool({
-  description: `Execute a skill within the main conversation.
-
-When you invoke a skill, the skill's prompt will expand and provide detailed instructions on how to complete the task.
-
-Available Skills:
-${skillListForDescription}`,
-  args: {
-    skill: tool.schema.string().describe("The skill name or search query to find and load. Can be exact skill name (e.g., 'python-programmer') or keywords (e.g., 'python', 'plan').")
-  },
-  async execute(args) {
-    const skills = await discoverSkills();
-    if (!args.skill) {
-      return formatSkillList(skills) + `
-
-Provide a skill name to load.`;
-    }
-    const matchingSkills = findMatchingSkills(skills, args.skill);
-    if (matchingSkills.length === 0) {
-      return `No skills found matching "${args.skill}".
-
-` + formatSkillList(skills) + `
-
-Try a different skill name.`;
-    }
-    const loadedSkills = [];
-    for (const skillInfo of matchingSkills.slice(0, 3)) {
-      const loaded = await loadSkillWithReferences(skillInfo, true);
-      loadedSkills.push(loaded);
-    }
-    return formatLoadedSkills(loadedSkills);
-  }
-});
 // src/tools/interactive-bash/constants.ts
 var DEFAULT_TIMEOUT_MS4 = 60000;
 var BLOCKED_TMUX_SUBCOMMANDS = [
@@ -27011,13 +26801,12 @@ var builtinTools = {
   ast_grep_replace,
   grep,
   glob,
-  slashcommand,
-  skill
+  slashcommand
 };
 // src/features/background-agent/manager.ts
 import { existsSync as existsSync37, readdirSync as readdirSync12 } from "fs";
 import { join as join44 } from "path";
-function getMessageDir4(sessionID) {
+function getMessageDir5(sessionID) {
   if (!existsSync37(MESSAGE_STORAGE))
     return null;
   const directPath = join44(MESSAGE_STORAGE, sessionID);
@@ -27261,7 +27050,7 @@ class BackgroundManager {
     log("[background-agent] Sending notification to parent session:", { parentSessionID: task.parentSessionID });
     setTimeout(async () => {
       try {
-        const messageDir = getMessageDir4(task.parentSessionID);
+        const messageDir = getMessageDir5(task.parentSessionID);
         const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
         await this.client.session.prompt({
           path: { id: task.parentSessionID },

package/dist/tools/index.d.ts

@@ -318,13 +318,4 @@ export declare const builtinTools: {
             command: string;
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
     };
-    skill: {
-        description: string;
-        args: {
-            skill: import("zod").ZodString;
-        };
-        execute(args: {
-            skill: string;
-        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-    };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "2.4.4",
+  "version": "2.4.5",
   "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/tools/skill/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./types";
-export { skill } from "./tools";

package/dist/tools/skill/tools.d.ts

@@ -1,10 +0,0 @@
-import { z } from "zod/v4";
-export declare const skill: {
-    description: string;
-    args: {
-        skill: z.ZodString;
-    };
-    execute(args: {
-        skill: string;
-    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-};

package/dist/tools/skill/types.d.ts

@@ -1,41 +0,0 @@
-import { z } from "zod/v4";
-export type SkillScope = "user" | "project";
-/**
- * Zod schema for skill frontmatter validation
- * Following Anthropic Agent Skills Specification v1.0
- */
-export declare const SkillFrontmatterSchema: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodString;
-    license: z.ZodOptional<z.ZodString>;
-    "allowed-tools": z.ZodOptional<z.ZodArray<z.ZodString>>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-}, z.core.$strip>;
-export type SkillFrontmatter = z.infer<typeof SkillFrontmatterSchema>;
-export interface SkillMetadata {
-    name: string;
-    description: string;
-    license?: string;
-    allowedTools?: string[];
-    metadata?: Record<string, string>;
-}
-export interface SkillInfo {
-    name: string;
-    path: string;
-    basePath: string;
-    metadata: SkillMetadata;
-    content: string;
-    references: string[];
-    scripts: string[];
-    assets: string[];
-}
-export interface LoadedSkill {
-    name: string;
-    metadata: SkillMetadata;
-    basePath: string;
-    body: string;
-    referencesLoaded: Array<{
-        path: string;
-        content: string;
-    }>;
-}