oh-my-opencode 2.12.3 → 2.13.0

package/dist/index.js

@@ -7925,12 +7925,12 @@ var require_dist = __commonJS((exports, module) => {
       throw new Error(`Unknown format "${name}"`);
     return f;
   };
-  function addFormats(ajv, list, fs10, exportName) {
+  function addFormats(ajv, list, fs11, exportName) {
     var _a;
     var _b;
     (_a = (_b = ajv.opts.code).formats) !== null && _a !== undefined || (_b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`);
     for (const f of list)
-      ajv.addFormat(f, fs10[f]);
+      ajv.addFormat(f, fs11[f]);
   }
   module.exports = exports = formatsPlugin;
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -7941,7 +7941,7 @@ var require_dist = __commonJS((exports, module) => {
 var require_windows = __commonJS((exports, module) => {
   module.exports = isexe;
   isexe.sync = sync;
-  var fs10 = __require("fs");
+  var fs11 = __require("fs");
   function checkPathExt(path7, options) {
     var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
     if (!pathext) {
@@ -7966,12 +7966,12 @@ var require_windows = __commonJS((exports, module) => {
     return checkPathExt(path7, options);
   }
   function isexe(path7, options, cb) {
-    fs10.stat(path7, function(er, stat2) {
+    fs11.stat(path7, function(er, stat2) {
       cb(er, er ? false : checkStat(stat2, path7, options));
     });
   }
   function sync(path7, options) {
-    return checkStat(fs10.statSync(path7), path7, options);
+    return checkStat(fs11.statSync(path7), path7, options);
   }
 });
 
@@ -7979,14 +7979,14 @@ var require_windows = __commonJS((exports, module) => {
 var require_mode = __commonJS((exports, module) => {
   module.exports = isexe;
   isexe.sync = sync;
-  var fs10 = __require("fs");
+  var fs11 = __require("fs");
   function isexe(path7, options, cb) {
-    fs10.stat(path7, function(er, stat2) {
+    fs11.stat(path7, function(er, stat2) {
       cb(er, er ? false : checkStat(stat2, options));
     });
   }
   function sync(path7, options) {
-    return checkStat(fs10.statSync(path7), options);
+    return checkStat(fs11.statSync(path7), options);
   }
   function checkStat(stat2, options) {
     return stat2.isFile() && checkMode(stat2, options);
@@ -8008,7 +8008,7 @@ var require_mode = __commonJS((exports, module) => {
 
 // node_modules/isexe/index.js
 var require_isexe = __commonJS((exports, module) => {
-  var fs10 = __require("fs");
+  var fs11 = __require("fs");
   var core3;
   if (process.platform === "win32" || global.TESTING_WINDOWS) {
     core3 = require_windows();
@@ -8247,16 +8247,16 @@ var require_shebang_command = __commonJS((exports, module) => {
 
 // node_modules/cross-spawn/lib/util/readShebang.js
 var require_readShebang = __commonJS((exports, module) => {
-  var fs10 = __require("fs");
+  var fs11 = __require("fs");
   var shebangCommand = require_shebang_command();
   function readShebang(command) {
     const size = 150;
     const buffer = Buffer.alloc(size);
     let fd;
     try {
-      fd = fs10.openSync(command, "r");
-      fs10.readSync(fd, buffer, 0, size, 0);
-      fs10.closeSync(fd);
+      fd = fs11.openSync(command, "r");
+      fs11.readSync(fd, buffer, 0, size, 0);
+      fs11.closeSync(fd);
     } catch (e) {}
     return shebangCommand(buffer.toString());
   }
@@ -15544,6 +15544,7 @@ function isHookDisabled(config, hookType) {
 }
 // src/shared/file-utils.ts
 import { lstatSync, readlinkSync } from "fs";
+import { promises as fs4 } from "fs";
 import { resolve as resolve3 } from "path";
 function isMarkdownFile(entry) {
   return !entry.name.startsWith(".") && entry.name.endsWith(".md") && entry.isFile();
@@ -15559,20 +15560,32 @@ function resolveSymlink(filePath) {
     return filePath;
   }
 }
+async function resolveSymlinkAsync(filePath) {
+  try {
+    const stats = await fs4.lstat(filePath);
+    if (stats.isSymbolicLink()) {
+      const linkTarget = await fs4.readlink(filePath);
+      return resolve3(filePath, "..", linkTarget);
+    }
+    return filePath;
+  } catch {
+    return filePath;
+  }
+}
 // src/shared/config-path.ts
 import * as path3 from "path";
 import * as os3 from "os";
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 function getUserConfigDir() {
   if (process.platform === "win32") {
     const crossPlatformDir = path3.join(os3.homedir(), ".config");
     const crossPlatformConfigPath = path3.join(crossPlatformDir, "opencode", "oh-my-opencode.json");
     const appdataDir = process.env.APPDATA || path3.join(os3.homedir(), "AppData", "Roaming");
     const appdataConfigPath = path3.join(appdataDir, "opencode", "oh-my-opencode.json");
-    if (fs4.existsSync(crossPlatformConfigPath)) {
+    if (fs5.existsSync(crossPlatformConfigPath)) {
       return crossPlatformDir;
     }
-    if (fs4.existsSync(appdataConfigPath)) {
+    if (fs5.existsSync(appdataConfigPath)) {
       return appdataDir;
     }
     return crossPlatformDir;
@@ -16469,7 +16482,7 @@ function detectConfigFile(basePath) {
   return { format: "none", path: jsonPath };
 }
 // src/shared/migration.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 var AGENT_NAME_MAP = {
   omo: "Sisyphus",
   OmO: "Sisyphus",
@@ -16535,7 +16548,7 @@ function migrateConfigFile(configPath, rawConfig) {
   }
   if (needsWrite) {
     try {
-      fs5.writeFileSync(configPath, JSON.stringify(rawConfig, null, 2) + `
+      fs6.writeFileSync(configPath, JSON.stringify(rawConfig, null, 2) + `
 `, "utf-8");
       log(`Migrated config file: ${configPath}`);
     } catch (err) {
@@ -17522,96 +17535,186 @@ setInterval(() => {
 // src/hooks/keyword-detector/constants.ts
 var CODE_BLOCK_PATTERN2 = /```[\s\S]*?```/g;
 var INLINE_CODE_PATTERN2 = /`[^`]+`/g;
-var KEYWORD_DETECTORS = [
-  {
-    pattern: /(ultrawork|ulw)/i,
-    message: `<ultrawork-mode>
+var ULTRAWORK_PLANNER_SECTION = `## CRITICAL: YOU ARE A PLANNER, NOT AN IMPLEMENTER
+
+**IDENTITY CONSTRAINT (NON-NEGOTIABLE):**
+You ARE the planner. You ARE NOT an implementer. You DO NOT write code. You DO NOT execute tasks.
+
+**TOOL RESTRICTIONS (SYSTEM-ENFORCED):**
+| Tool | Allowed | Blocked |
+|------|---------|---------|
+| Write/Edit | \`.sisyphus/**/*.md\` ONLY | Everything else |
+| Read | All files | - |
+| Bash | Research commands only | Implementation commands |
+| sisyphus_task | explore, librarian | - |
+
+**IF YOU TRY TO WRITE/EDIT OUTSIDE \`.sisyphus/\`:**
+- System will BLOCK your action
+- You will receive an error
+- DO NOT retry - you are not supposed to implement
+
+**YOUR ONLY WRITABLE PATHS:**
+- \`.sisyphus/plans/*.md\` - Final work plans
+- \`.sisyphus/drafts/*.md\` - Working drafts during interview
+
+**WHEN USER ASKS YOU TO IMPLEMENT:**
+REFUSE. Say: "I'm a planner. I create work plans, not implementations. Run \`/start-work\` after I finish planning."
+
+---
+
+## CONTEXT GATHERING (MANDATORY BEFORE PLANNING)
+
+You ARE the planner. Your job: create bulletproof work plans.
+**Before drafting ANY plan, gather context via explore/librarian agents.**
+
+### Research Protocol
+1. **Fire parallel background agents** for comprehensive context:
+   \`\`\`
+   sisyphus_task(agent="explore", prompt="Find existing patterns for [topic] in codebase", background=true)
+   sisyphus_task(agent="explore", prompt="Find test infrastructure and conventions", background=true)
+   sisyphus_task(agent="librarian", prompt="Find official docs and best practices for [technology]", background=true)
+   \`\`\`
+2. **Wait for results** before planning - rushed plans fail
+3. **Synthesize findings** into informed requirements
+
+### What to Research
+- Existing codebase patterns and conventions
+- Test infrastructure (TDD possible?)
+- External library APIs and constraints
+- Similar implementations in OSS (via librarian)
+
+**NEVER plan blind. Context first, plan second.**`;
+function isPlannerAgent(agentName) {
+  if (!agentName)
+    return false;
+  const lowerName = agentName.toLowerCase();
+  return lowerName.includes("prometheus") || lowerName.includes("planner") || lowerName === "plan";
+}
+function getUltraworkMessage(agentName) {
+  const isPlanner = isPlannerAgent(agentName);
+  if (isPlanner) {
+    return `<ultrawork-mode>
+
+**MANDATORY**: You MUST say "ULTRAWORK MODE ENABLED!" to the user as your first response when this mode activates. This is non-negotiable.
+
+${ULTRAWORK_PLANNER_SECTION}
 
-## TODO IS YOUR LIFELINE (NON-NEGOTIABLE)
+</ultrawork-mode>
 
-**USE TodoWrite OBSESSIVELY. This is the #1 most important tool.**
+---
 
-### TODO Rules
-1. **BEFORE any action**: Create TODOs FIRST. Break down into atomic, granular steps.
-2. **Be excessively detailed**: 10 small TODOs > 3 vague TODOs. Err on the side of too many.
-3. **Real-time updates**: Mark \`in_progress\` before starting, \`completed\` IMMEDIATELY after. NEVER batch.
-4. **One at a time**: Only ONE TODO should be \`in_progress\` at any moment.
-5. **Sub-tasks**: Complex TODO? Break it into sub-TODOs. Keep granularity high.
-6. **Questions too**: User asks a question? TODO: "Answer with evidence: [question]"
+`;
+  }
+  return `<ultrawork-mode>
 
-### Example TODO Granularity
-BAD: "Implement user auth"
-GOOD:
-- "Read existing auth patterns in codebase"
-- "Create auth schema types"  
-- "Implement login endpoint"
-- "Implement token validation middleware"
-- "Add auth tests - login success case"
-- "Add auth tests - login failure case"
-- "Verify LSP diagnostics clean"
+**MANDATORY**: You MUST say "ULTRAWORK MODE ENABLED!" to the user as your first response when this mode activates. This is non-negotiable.
 
-**YOUR WORK IS INVISIBLE WITHOUT TODOs. USE THEM.**
+[CODE RED] Maximum precision required. Ultrathink before acting.
 
-## TDD WORKFLOW (MANDATORY when tests exist)
+YOU MUST LEVERAGE ALL AVAILABLE AGENTS TO THEIR FULLEST POTENTIAL.
+TELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.
 
-Check for test infrastructure FIRST. If exists, follow strictly:
+## AGENT UTILIZATION PRINCIPLES (by capability, not by name)
+- **Codebase Exploration**: Spawn exploration agents using BACKGROUND TASKS for file patterns, internal implementations, project structure
+- **Documentation & References**: Use librarian-type agents via BACKGROUND TASKS for API references, examples, external library docs
+- **Planning & Strategy**: NEVER plan yourself - ALWAYS spawn a dedicated planning agent for work breakdown
+- **High-IQ Reasoning**: Leverage specialized agents for architecture decisions, code review, strategic planning
+- **Frontend/UI Tasks**: Delegate to UI-specialized agents for design and implementation
 
-1. **RED**: Write failing test FIRST \u2192 \`bun test\` must FAIL
-2. **GREEN**: Write MINIMAL code to pass \u2192 \`bun test\` must PASS
-3. **REFACTOR**: Clean up, tests stay green \u2192 \`bun test\` still PASS
-4. **REPEAT**: Next test case, loop until complete
+## EXECUTION RULES
+- **TODO**: Track EVERY step. Mark complete IMMEDIATELY after each.
+- **PARALLEL**: Fire independent agent calls simultaneously via background_task - NEVER wait sequentially.
+- **BACKGROUND FIRST**: Use background_task for exploration/research agents (10+ concurrent if needed).
+- **VERIFY**: Re-read request after completion. Check ALL requirements met before reporting done.
+- **DELEGATE**: Don't do everything yourself - orchestrate specialized agents for their strengths.
 
-**NEVER write implementation before test. NEVER delete failing tests.**
+## WORKFLOW
+1. Analyze the request and identify required capabilities
+2. Spawn exploration/librarian agents via background_task in PARALLEL (10+ if needed)
+3. Always Use Plan agent with gathered context to create detailed work breakdown
+4. Execute with continuous verification against original requirements
 
-## AGENT DEPLOYMENT
+## VERIFICATION GUARANTEE (NON-NEGOTIABLE)
 
-Fire available agents in PARALLEL via background tasks. Use explore/librarian agents liberally (multiple concurrent if needed).
+**NOTHING is "done" without PROOF it works.**
 
-## EVIDENCE-BASED ANSWERS
+### Pre-Implementation: Define Success Criteria
 
-- Every claim: code snippet + file path + line number
-- No "I think..." - find and SHOW actual code
-- Local search fails? \u2192 librarian for external sources
-- **NEVER acceptable**: "I couldn't find it"
+BEFORE writing ANY code, you MUST define:
 
-## ZERO TOLERANCE FOR SHORTCUTS (RIGOROUS & HONEST EXECUTION)
+| Criteria Type | Description | Example |
+|---------------|-------------|---------|
+| **Functional** | What specific behavior must work | "Button click triggers API call" |
+| **Observable** | What can be measured/seen | "Console shows 'success', no errors" |
+| **Pass/Fail** | Binary, no ambiguity | "Returns 200 OK" not "should work" |
 
-**CORE PRINCIPLE**: Execute user's ORIGINAL INTENT with maximum rigor. No shortcuts. No compromises. No matter how large the task.
+Write these criteria explicitly. Share with user if scope is non-trivial.
 
-### ABSOLUTE PROHIBITIONS
-| Violation | Why It's Forbidden |
-|-----------|-------------------|
-| **Mocking/Stubbing** | Never use mocks, stubs, or fake implementations unless explicitly requested. Real implementation only. |
-| **Scope Reduction** | Never make "demo", "skeleton", "simplified", "basic", "minimal" versions. Deliver FULL implementation. |
-| **Partial Completion** | Never stop at 60-80% saying "you can extend this...", "as an exercise...", "you can add...". Finish 100%. |
-| **Lazy Placeholders** | Never use "// TODO", "...", "etc.", "and so on" in actual code. Complete everything. |
-| **Assumed Shortcuts** | Never skip requirements deemed "optional" or "can be added later". All requirements are mandatory. |
-| **Test Deletion** | Never delete or skip failing tests. Fix the code, not the tests. |
-| **Evidence-Free Claims** | Never say "I think...", "probably...", "should work...". Show actual code/output. |
+### Test Plan Template (MANDATORY for non-trivial tasks)
+
+\`\`\`
+## Test Plan
+### Objective: [What we're verifying]
+### Prerequisites: [Setup needed]
+### Test Cases:
+1. [Test Name]: [Input] \u2192 [Expected Output] \u2192 [How to verify]
+2. ...
+### Success Criteria: ALL test cases pass
+### How to Execute: [Exact commands/steps]
+\`\`\`
 
-### RIGOROUS EXECUTION MANDATE
-1. **Parse Original Intent**: What did the user ACTUALLY want? Not what's convenient. The REAL, COMPLETE request.
-2. **No Task Too Large**: If the task requires 100 files, modify 100 files. If it needs 1000 lines, write 1000 lines. Size is irrelevant.
-3. **Honest Assessment**: If you cannot complete something, say so BEFORE starting. Don't fake completion.
-4. **Evidence-Based Verification**: Every claim backed by code snippets, file paths, line numbers, and actual outputs.
-5. **Complete Verification**: Re-read original request after completion. Check EVERY requirement was met.
+### Execution & Evidence Requirements
 
-### FAILURE RECOVERY
-If you realize you've taken shortcuts:
-1. STOP immediately
-2. Identify what you skipped/faked
-3. Create TODOs for ALL remaining work
-4. Execute to TRUE completion - not "good enough"
+| Phase | Action | Required Evidence |
+|-------|--------|-------------------|
+| **Build** | Run build command | Exit code 0, no errors |
+| **Test** | Execute test suite | All tests pass (screenshot/output) |
+| **Manual Verify** | Test the actual feature | Demonstrate it works (describe what you observed) |
+| **Regression** | Ensure nothing broke | Existing tests still pass |
+
+**WITHOUT evidence = NOT verified = NOT done.**
+
+### TDD Workflow (when test infrastructure exists)
+
+1. **SPEC**: Define what "working" means (success criteria above)
+2. **RED**: Write failing test \u2192 Run it \u2192 Confirm it FAILS
+3. **GREEN**: Write minimal code \u2192 Run test \u2192 Confirm it PASSES
+4. **REFACTOR**: Clean up \u2192 Tests MUST stay green
+5. **VERIFY**: Run full test suite, confirm no regressions
+6. **EVIDENCE**: Report what you ran and what output you saw
+
+### Verification Anti-Patterns (BLOCKING)
+
+| Violation | Why It Fails |
+|-----------|--------------|
+| "It should work now" | No evidence. Run it. |
+| "I added the tests" | Did they pass? Show output. |
+| "Fixed the bug" | How do you know? What did you test? |
+| "Implementation complete" | Did you verify against success criteria? |
+| Skipping test execution | Tests exist to be RUN, not just written |
 
-**THE USER ASKED FOR X. DELIVER EXACTLY X. COMPLETELY. HONESTLY. NO MATTER THE SIZE.**
+**CLAIM NOTHING WITHOUT PROOF. EXECUTE. VERIFY. SHOW EVIDENCE.**
 
-## SUCCESS = All TODOs Done + All Requirements Met + Evidence Provided
+## ZERO TOLERANCE FAILURES
+- **NO Scope Reduction**: Never make "demo", "skeleton", "simplified", "basic" versions - deliver FULL implementation
+- **NO MockUp Work**: When user asked you to do "port A", you must "port A", fully, 100%. No Extra feature, No reduced feature, no mock data, fully working 100% port.
+- **NO Partial Completion**: Never stop at 60-80% saying "you can extend this..." - finish 100%
+- **NO Assumed Shortcuts**: Never skip requirements you deem "optional" or "can be added later"
+- **NO Premature Stopping**: Never declare done until ALL TODOs are completed and verified
+- **NO TEST DELETION**: Never delete or skip failing tests to make the build pass. Fix the code, not the tests.
+
+THE USER ASKED FOR X. DELIVER EXACTLY X. NOT A SUBSET. NOT A DEMO. NOT A STARTING POINT.
 
 </ultrawork-mode>
 
 ---
 
-`
+`;
+}
+var KEYWORD_DETECTORS = [
+  {
+    pattern: /(ultrawork|ulw)/i,
+    message: getUltraworkMessage
   },
   {
     pattern: /\b(search|find|locate|lookup|look\s*up|explore|discover|scan|grep|query|browse|detect|trace|seek|track|pinpoint|hunt)\b|where\s+is|show\s+me|list\s+all|\uAC80\uC0C9|\uCC3E\uC544|\uD0D0\uC0C9|\uC870\uD68C|\uC2A4\uCE94|\uC11C\uCE58|\uB4A4\uC838|\uCC3E\uAE30|\uC5B4\uB514|\uCD94\uC801|\uD0D0\uC9C0|\uCC3E\uC544\uBD10|\uCC3E\uC544\uB0B4|\uBCF4\uC5EC\uC918|\uBAA9\uB85D|\u691C\u7D22|\u63A2\u3057\u3066|\u898B\u3064\u3051\u3066|\u30B5\u30FC\u30C1|\u63A2\u7D22|\u30B9\u30AD\u30E3\u30F3|\u3069\u3053|\u767A\u898B|\u635C\u7D22|\u898B\u3064\u3051\u51FA\u3059|\u4E00\u89A7|\u641C\u7D22|\u67E5\u627E|\u5BFB\u627E|\u67E5\u8BE2|\u68C0\u7D22|\u5B9A\u4F4D|\u626B\u63CF|\u53D1\u73B0|\u5728\u54EA\u91CC|\u627E\u51FA\u6765|\u5217\u51FA|t\u00ECm ki\u1EBFm|tra c\u1EE9u|\u0111\u1ECBnh v\u1ECB|qu\u00E9t|ph\u00E1t hi\u1EC7n|truy t\u00ECm|t\u00ECm ra|\u1EDF \u0111\u00E2u|li\u1EC7t k\u00EA/i,
@@ -17643,13 +17746,16 @@ SYNTHESIZE findings before proceeding.`
 function removeCodeBlocks2(text) {
   return text.replace(CODE_BLOCK_PATTERN2, "").replace(INLINE_CODE_PATTERN2, "");
 }
-function detectKeywordsWithType(text) {
+function resolveMessage(message, agentName) {
+  return typeof message === "function" ? message(agentName) : message;
+}
+function detectKeywordsWithType(text, agentName) {
   const textWithoutCode = removeCodeBlocks2(text);
   const types3 = ["ultrawork", "search", "analyze"];
   return KEYWORD_DETECTORS.map(({ pattern, message }, index) => ({
     matches: pattern.test(textWithoutCode),
     type: types3[index],
-    message
+    message: resolveMessage(message, agentName)
   })).filter((result) => result.matches).map(({ type: type2, message }) => ({ type: type2, message }));
 }
 function extractPromptText2(parts) {
@@ -17661,13 +17767,14 @@ function createKeywordDetectorHook(ctx) {
   return {
     "chat.message": async (input, output) => {
       const promptText = extractPromptText2(output.parts);
-      const detectedKeywords = detectKeywordsWithType(removeCodeBlocks2(promptText));
+      const detectedKeywords = detectKeywordsWithType(removeCodeBlocks2(promptText), input.agent);
       if (detectedKeywords.length === 0) {
         return;
       }
       const hasUltrawork = detectedKeywords.some((k) => k.type === "ultrawork");
       if (hasUltrawork) {
         log(`[keyword-detector] Ultrawork mode activated`, { sessionID: input.sessionID });
+        output.message.variant = "max";
         ctx.client.tui.showToast({
           body: {
             title: "Ultrawork Mode Activated",
@@ -17759,7 +17866,7 @@ function createClaudeCodeHooksHook(ctx, config = {}) {
           log("chat.message injection skipped - interrupted during hooks", { sessionID: input.sessionID });
           return;
         }
-        const detectedKeywords = detectKeywordsWithType(removeCodeBlocks2(prompt));
+        const detectedKeywords = detectKeywordsWithType(removeCodeBlocks2(prompt), input.agent);
         const keywordMessages = detectedKeywords.map((k) => k.message);
         if (keywordMessages.length > 0) {
           log("[claude-code-hooks] Detected keywords", {
@@ -18490,14 +18597,14 @@ function createBackgroundNotificationHook(manager) {
   };
 }
 // src/hooks/auto-update-checker/checker.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import * as path5 from "path";
 import { fileURLToPath } from "url";
 
 // src/hooks/auto-update-checker/constants.ts
 import * as path4 from "path";
 import * as os4 from "os";
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 var PACKAGE_NAME = "oh-my-opencode";
 var NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
 var NPM_FETCH_TIMEOUT = 5000;
@@ -18516,7 +18623,7 @@ function getUserConfigDir2() {
     const appdataDir = process.env.APPDATA ?? path4.join(os4.homedir(), "AppData", "Roaming");
     const crossPlatformConfig = path4.join(crossPlatformDir, "opencode", "opencode.json");
     const crossPlatformConfigJsonc = path4.join(crossPlatformDir, "opencode", "opencode.jsonc");
-    if (fs6.existsSync(crossPlatformConfig) || fs6.existsSync(crossPlatformConfigJsonc)) {
+    if (fs7.existsSync(crossPlatformConfig) || fs7.existsSync(crossPlatformConfigJsonc)) {
       return crossPlatformDir;
     }
     return appdataDir;
@@ -18564,9 +18671,9 @@ function getConfigPaths(directory) {
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!fs7.existsSync(configPath))
+      if (!fs8.existsSync(configPath))
         continue;
-      const content = fs7.readFileSync(configPath, "utf-8");
+      const content = fs8.readFileSync(configPath, "utf-8");
       const config = JSON.parse(stripJsonComments(content));
       const plugins = config.plugin ?? [];
       for (const entry of plugins) {
@@ -18586,13 +18693,13 @@ function getLocalDevPath(directory) {
 }
 function findPackageJsonUp(startPath) {
   try {
-    const stat = fs7.statSync(startPath);
+    const stat = fs8.statSync(startPath);
     let dir = stat.isDirectory() ? startPath : path5.dirname(startPath);
     for (let i2 = 0;i2 < 10; i2++) {
       const pkgPath = path5.join(dir, "package.json");
-      if (fs7.existsSync(pkgPath)) {
+      if (fs8.existsSync(pkgPath)) {
         try {
-          const content = fs7.readFileSync(pkgPath, "utf-8");
+          const content = fs8.readFileSync(pkgPath, "utf-8");
           const pkg = JSON.parse(content);
           if (pkg.name === PACKAGE_NAME)
             return pkgPath;
@@ -18614,7 +18721,7 @@ function getLocalDevVersion(directory) {
     const pkgPath = findPackageJsonUp(localPath);
     if (!pkgPath)
       return null;
-    const content = fs7.readFileSync(pkgPath, "utf-8");
+    const content = fs8.readFileSync(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     return pkg.version ?? null;
   } catch {
@@ -18624,9 +18731,9 @@ function getLocalDevVersion(directory) {
 function findPluginEntry(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!fs7.existsSync(configPath))
+      if (!fs8.existsSync(configPath))
         continue;
-      const content = fs7.readFileSync(configPath, "utf-8");
+      const content = fs8.readFileSync(configPath, "utf-8");
       const config = JSON.parse(stripJsonComments(content));
       const plugins = config.plugin ?? [];
       for (const entry of plugins) {
@@ -18647,8 +18754,8 @@ function findPluginEntry(directory) {
 }
 function getCachedVersion() {
   try {
-    if (fs7.existsSync(INSTALLED_PACKAGE_JSON)) {
-      const content = fs7.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
+    if (fs8.existsSync(INSTALLED_PACKAGE_JSON)) {
+      const content = fs8.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.version)
         return pkg.version;
@@ -18658,7 +18765,7 @@ function getCachedVersion() {
     const currentDir = path5.dirname(fileURLToPath(import.meta.url));
     const pkgPath = findPackageJsonUp(currentDir);
     if (pkgPath) {
-      const content = fs7.readFileSync(pkgPath, "utf-8");
+      const content = fs8.readFileSync(pkgPath, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.version)
         return pkg.version;
@@ -18670,7 +18777,7 @@ function getCachedVersion() {
 }
 function updatePinnedVersion(configPath, oldEntry, newVersion) {
   try {
-    const content = fs7.readFileSync(configPath, "utf-8");
+    const content = fs8.readFileSync(configPath, "utf-8");
     const newEntry = `${PACKAGE_NAME}@${newVersion}`;
     const pluginMatch = content.match(/"plugin"\s*:\s*\[/);
     if (!pluginMatch || pluginMatch.index === undefined) {
@@ -18702,7 +18809,7 @@ function updatePinnedVersion(configPath, oldEntry, newVersion) {
       log(`[auto-update-checker] No changes made to ${configPath}`);
       return false;
     }
-    fs7.writeFileSync(configPath, updatedContent, "utf-8");
+    fs8.writeFileSync(configPath, updatedContent, "utf-8");
     log(`[auto-update-checker] Updated ${configPath}: ${oldEntry} \u2192 ${newEntry}`);
     return true;
   } catch (err) {
@@ -18730,17 +18837,17 @@ async function getLatestVersion() {
 }
 
 // src/hooks/auto-update-checker/cache.ts
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 import * as path6 from "path";
 function stripTrailingCommas(json2) {
   return json2.replace(/,(\s*[}\]])/g, "$1");
 }
 function removeFromBunLock(packageName) {
   const lockPath = path6.join(CACHE_DIR, "bun.lock");
-  if (!fs8.existsSync(lockPath))
+  if (!fs9.existsSync(lockPath))
     return false;
   try {
-    const content = fs8.readFileSync(lockPath, "utf-8");
+    const content = fs9.readFileSync(lockPath, "utf-8");
     const lock = JSON.parse(stripTrailingCommas(content));
     let modified = false;
     if (lock.workspaces?.[""]?.dependencies?.[packageName]) {
@@ -18752,7 +18859,7 @@ function removeFromBunLock(packageName) {
       modified = true;
     }
     if (modified) {
-      fs8.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+      fs9.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
       log(`[auto-update-checker] Removed from bun.lock: ${packageName}`);
     }
     return modified;
@@ -18767,17 +18874,17 @@ function invalidatePackage(packageName = PACKAGE_NAME) {
     let packageRemoved = false;
     let dependencyRemoved = false;
     let lockRemoved = false;
-    if (fs8.existsSync(pkgDir)) {
-      fs8.rmSync(pkgDir, { recursive: true, force: true });
+    if (fs9.existsSync(pkgDir)) {
+      fs9.rmSync(pkgDir, { recursive: true, force: true });
       log(`[auto-update-checker] Package removed: ${pkgDir}`);
       packageRemoved = true;
     }
-    if (fs8.existsSync(pkgJsonPath)) {
-      const content = fs8.readFileSync(pkgJsonPath, "utf-8");
+    if (fs9.existsSync(pkgJsonPath)) {
+      const content = fs9.readFileSync(pkgJsonPath, "utf-8");
       const pkgJson = JSON.parse(content);
       if (pkgJson.dependencies?.[packageName]) {
         delete pkgJson.dependencies[packageName];
-        fs8.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+        fs9.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
         log(`[auto-update-checker] Dependency removed from package.json: ${packageName}`);
         dependencyRemoved = true;
       }
@@ -19040,7 +19147,6 @@ var TARGET_TOOLS = new Set([
   "webfetch",
   "context7_resolve-library-id",
   "context7_get-library-docs",
-  "websearch_exa_web_search_exa",
   "grep_app_searchgithub"
 ]);
 var AGENT_TOOLS = new Set([
@@ -20073,12 +20179,11 @@ function extractPromptText3(parts) {
 }
 
 // src/hooks/auto-slash-command/executor.ts
-import { existsSync as existsSync36, readdirSync as readdirSync12, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync35, readdirSync as readdirSync11, readFileSync as readFileSync23 } from "fs";
 import { join as join43, basename as basename2, dirname as dirname8 } from "path";
 import { homedir as homedir13 } from "os";
 // src/features/opencode-skill-loader/loader.ts
-import { existsSync as existsSync34, readdirSync as readdirSync11, readFileSync as readFileSync22 } from "fs";
-import { promises as fs9 } from "fs";
+import { promises as fs10 } from "fs";
 import { join as join42, basename } from "path";
 import { homedir as homedir11 } from "os";
 function parseSkillMcpConfigFromFrontmatter(content) {
@@ -20095,12 +20200,10 @@ function parseSkillMcpConfigFromFrontmatter(content) {
   }
   return;
 }
-function loadMcpJsonFromDir(skillDir) {
+async function loadMcpJsonFromDir(skillDir) {
   const mcpJsonPath = join42(skillDir, "mcp.json");
-  if (!existsSync34(mcpJsonPath))
-    return;
   try {
-    const content = readFileSync22(mcpJsonPath, "utf-8");
+    const content = await fs10.readFile(mcpJsonPath, "utf-8");
     const parsed = JSON.parse(content);
     if (parsed && typeof parsed === "object" && "mcpServers" in parsed && parsed.mcpServers) {
       return parsed.mcpServers;
@@ -20121,71 +20224,12 @@ function parseAllowedTools(allowedTools) {
     return;
   return allowedTools.split(/\s+/).filter(Boolean);
 }
-function loadSkillFromPath(skillPath, resolvedPath, defaultName, scope) {
-  try {
-    const content = readFileSync22(skillPath, "utf-8");
-    const { data } = parseFrontmatter(content);
-    const frontmatterMcp = parseSkillMcpConfigFromFrontmatter(content);
-    const mcpJsonMcp = loadMcpJsonFromDir(resolvedPath);
-    const mcpConfig = mcpJsonMcp || frontmatterMcp;
-    const skillName = data.name || defaultName;
-    const originalDescription = data.description || "";
-    const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
-    const formattedDescription = `(${scope} - Skill) ${originalDescription}`;
-    const lazyContent = {
-      loaded: false,
-      content: undefined,
-      load: async () => {
-        if (!lazyContent.loaded) {
-          const fileContent = await fs9.readFile(skillPath, "utf-8");
-          const { body } = parseFrontmatter(fileContent);
-          lazyContent.content = `<skill-instruction>
-Base directory for this skill: ${resolvedPath}/
-File references (@path) in this skill are relative to this directory.
-
-${body.trim()}
-</skill-instruction>
-
-<user-request>
-$ARGUMENTS
-</user-request>`;
-          lazyContent.loaded = true;
-        }
-        return lazyContent.content;
-      }
-    };
-    const definition = {
-      name: skillName,
-      description: formattedDescription,
-      template: "",
-      model: sanitizeModelField(data.model, isOpencodeSource ? "opencode" : "claude-code"),
-      agent: data.agent,
-      subtask: data.subtask,
-      argumentHint: data["argument-hint"]
-    };
-    return {
-      name: skillName,
-      path: skillPath,
-      resolvedPath,
-      definition,
-      scope,
-      license: data.license,
-      compatibility: data.compatibility,
-      metadata: data.metadata,
-      allowedTools: parseAllowedTools(data["allowed-tools"]),
-      mcpConfig,
-      lazyContent
-    };
-  } catch {
-    return null;
-  }
-}
-async function loadSkillFromPathAsync(skillPath, resolvedPath, defaultName, scope) {
+async function loadSkillFromPath(skillPath, resolvedPath, defaultName, scope) {
   try {
-    const content = await fs9.readFile(skillPath, "utf-8");
+    const content = await fs10.readFile(skillPath, "utf-8");
     const { data } = parseFrontmatter(content);
     const frontmatterMcp = parseSkillMcpConfigFromFrontmatter(content);
-    const mcpJsonMcp = loadMcpJsonFromDir(resolvedPath);
+    const mcpJsonMcp = await loadMcpJsonFromDir(resolvedPath);
     const mcpConfig = mcpJsonMcp || frontmatterMcp;
     const skillName = data.name || defaultName;
     const originalDescription = data.description || "";
@@ -20196,7 +20240,7 @@ async function loadSkillFromPathAsync(skillPath, resolvedPath, defaultName, scop
       content: undefined,
       load: async () => {
         if (!lazyContent.loaded) {
-          const fileContent = await fs9.readFile(skillPath, "utf-8");
+          const fileContent = await fs10.readFile(skillPath, "utf-8");
           const { body } = parseFrontmatter(fileContent);
           lazyContent.content = `<skill-instruction>
 Base directory for this skill: ${resolvedPath}/
@@ -20239,66 +20283,28 @@ $ARGUMENTS
     return null;
   }
 }
-function loadSkillsFromDir(skillsDir, scope) {
-  if (!existsSync34(skillsDir)) {
-    return [];
-  }
-  const entries = readdirSync11(skillsDir, { withFileTypes: true });
-  const skills = [];
-  for (const entry of entries) {
-    if (entry.name.startsWith("."))
-      continue;
-    const entryPath = join42(skillsDir, entry.name);
-    if (entry.isDirectory() || entry.isSymbolicLink()) {
-      const resolvedPath = resolveSymlink(entryPath);
-      const dirName = entry.name;
-      const skillMdPath = join42(resolvedPath, "SKILL.md");
-      if (existsSync34(skillMdPath)) {
-        const skill = loadSkillFromPath(skillMdPath, resolvedPath, dirName, scope);
-        if (skill)
-          skills.push(skill);
-        continue;
-      }
-      const namedSkillMdPath = join42(resolvedPath, `${dirName}.md`);
-      if (existsSync34(namedSkillMdPath)) {
-        const skill = loadSkillFromPath(namedSkillMdPath, resolvedPath, dirName, scope);
-        if (skill)
-          skills.push(skill);
-        continue;
-      }
-      continue;
-    }
-    if (isMarkdownFile(entry)) {
-      const skillName = basename(entry.name, ".md");
-      const skill = loadSkillFromPath(entryPath, skillsDir, skillName, scope);
-      if (skill)
-        skills.push(skill);
-    }
-  }
-  return skills;
-}
-async function loadSkillsFromDirAsync(skillsDir, scope) {
-  const entries = await fs9.readdir(skillsDir, { withFileTypes: true }).catch(() => []);
+async function loadSkillsFromDir(skillsDir, scope) {
+  const entries = await fs10.readdir(skillsDir, { withFileTypes: true }).catch(() => []);
   const skills = [];
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
     const entryPath = join42(skillsDir, entry.name);
     if (entry.isDirectory() || entry.isSymbolicLink()) {
-      const resolvedPath = resolveSymlink(entryPath);
+      const resolvedPath = await resolveSymlinkAsync(entryPath);
       const dirName = entry.name;
       const skillMdPath = join42(resolvedPath, "SKILL.md");
       try {
-        await fs9.access(skillMdPath);
-        const skill = await loadSkillFromPathAsync(skillMdPath, resolvedPath, dirName, scope);
+        await fs10.access(skillMdPath);
+        const skill = await loadSkillFromPath(skillMdPath, resolvedPath, dirName, scope);
         if (skill)
           skills.push(skill);
         continue;
       } catch {}
       const namedSkillMdPath = join42(resolvedPath, `${dirName}.md`);
       try {
-        await fs9.access(namedSkillMdPath);
-        const skill = await loadSkillFromPathAsync(namedSkillMdPath, resolvedPath, dirName, scope);
+        await fs10.access(namedSkillMdPath);
+        const skill = await loadSkillFromPath(namedSkillMdPath, resolvedPath, dirName, scope);
         if (skill)
           skills.push(skill);
         continue;
@@ -20307,7 +20313,7 @@ async function loadSkillsFromDirAsync(skillsDir, scope) {
     }
     if (isMarkdownFile(entry)) {
       const skillName = basename(entry.name, ".md");
-      const skill = await loadSkillFromPathAsync(entryPath, skillsDir, skillName, scope);
+      const skill = await loadSkillFromPath(entryPath, skillsDir, skillName, scope);
       if (skill)
         skills.push(skill);
     }
@@ -20322,70 +20328,68 @@ function skillsToRecord(skills) {
   }
   return result;
 }
-function loadUserSkills() {
+async function loadUserSkills() {
   const userSkillsDir = join42(getClaudeConfigDir(), "skills");
-  const skills = loadSkillsFromDir(userSkillsDir, "user");
+  const skills = await loadSkillsFromDir(userSkillsDir, "user");
   return skillsToRecord(skills);
 }
-function loadProjectSkills() {
+async function loadProjectSkills() {
   const projectSkillsDir = join42(process.cwd(), ".claude", "skills");
-  const skills = loadSkillsFromDir(projectSkillsDir, "project");
+  const skills = await loadSkillsFromDir(projectSkillsDir, "project");
   return skillsToRecord(skills);
 }
-function loadOpencodeGlobalSkills() {
+async function loadOpencodeGlobalSkills() {
   const opencodeSkillsDir = join42(homedir11(), ".config", "opencode", "skill");
-  const skills = loadSkillsFromDir(opencodeSkillsDir, "opencode");
+  const skills = await loadSkillsFromDir(opencodeSkillsDir, "opencode");
   return skillsToRecord(skills);
 }
-function loadOpencodeProjectSkills() {
+async function loadOpencodeProjectSkills() {
   const opencodeProjectDir = join42(process.cwd(), ".opencode", "skill");
-  const skills = loadSkillsFromDir(opencodeProjectDir, "opencode-project");
+  const skills = await loadSkillsFromDir(opencodeProjectDir, "opencode-project");
   return skillsToRecord(skills);
 }
-function discoverAllSkills() {
-  const opencodeProjectDir = join42(process.cwd(), ".opencode", "skill");
-  const projectDir = join42(process.cwd(), ".claude", "skills");
-  const opencodeGlobalDir = join42(homedir11(), ".config", "opencode", "skill");
-  const userDir = join42(getClaudeConfigDir(), "skills");
-  const opencodeProjectSkills = loadSkillsFromDir(opencodeProjectDir, "opencode-project");
-  const projectSkills = loadSkillsFromDir(projectDir, "project");
-  const opencodeGlobalSkills = loadSkillsFromDir(opencodeGlobalDir, "opencode");
-  const userSkills = loadSkillsFromDir(userDir, "user");
+async function discoverAllSkills() {
+  const [opencodeProjectSkills, projectSkills, opencodeGlobalSkills, userSkills] = await Promise.all([
+    discoverOpencodeProjectSkills(),
+    discoverProjectClaudeSkills(),
+    discoverOpencodeGlobalSkills(),
+    discoverUserClaudeSkills()
+  ]);
   return [...opencodeProjectSkills, ...projectSkills, ...opencodeGlobalSkills, ...userSkills];
 }
-function discoverSkills(options = {}) {
+async function discoverSkills(options = {}) {
   const { includeClaudeCodePaths = true } = options;
-  const opencodeProjectDir = join42(process.cwd(), ".opencode", "skill");
-  const opencodeGlobalDir = join42(homedir11(), ".config", "opencode", "skill");
-  const opencodeProjectSkills = loadSkillsFromDir(opencodeProjectDir, "opencode-project");
-  const opencodeGlobalSkills = loadSkillsFromDir(opencodeGlobalDir, "opencode");
+  const [opencodeProjectSkills, opencodeGlobalSkills] = await Promise.all([
+    discoverOpencodeProjectSkills(),
+    discoverOpencodeGlobalSkills()
+  ]);
   if (!includeClaudeCodePaths) {
     return [...opencodeProjectSkills, ...opencodeGlobalSkills];
   }
-  const projectDir = join42(process.cwd(), ".claude", "skills");
-  const userDir = join42(getClaudeConfigDir(), "skills");
-  const projectSkills = loadSkillsFromDir(projectDir, "project");
-  const userSkills = loadSkillsFromDir(userDir, "user");
+  const [projectSkills, userSkills] = await Promise.all([
+    discoverProjectClaudeSkills(),
+    discoverUserClaudeSkills()
+  ]);
   return [...opencodeProjectSkills, ...projectSkills, ...opencodeGlobalSkills, ...userSkills];
 }
-async function discoverUserClaudeSkillsAsync() {
+async function discoverUserClaudeSkills() {
   const userSkillsDir = join42(getClaudeConfigDir(), "skills");
-  return loadSkillsFromDirAsync(userSkillsDir, "user");
+  return loadSkillsFromDir(userSkillsDir, "user");
 }
-async function discoverProjectClaudeSkillsAsync() {
+async function discoverProjectClaudeSkills() {
   const projectSkillsDir = join42(process.cwd(), ".claude", "skills");
-  return loadSkillsFromDirAsync(projectSkillsDir, "project");
+  return loadSkillsFromDir(projectSkillsDir, "project");
 }
-async function discoverOpencodeGlobalSkillsAsync() {
+async function discoverOpencodeGlobalSkills() {
   const opencodeSkillsDir = join42(homedir11(), ".config", "opencode", "skill");
-  return loadSkillsFromDirAsync(opencodeSkillsDir, "opencode");
+  return loadSkillsFromDir(opencodeSkillsDir, "opencode");
 }
-async function discoverOpencodeProjectSkillsAsync() {
+async function discoverOpencodeProjectSkills() {
   const opencodeProjectDir = join42(process.cwd(), ".opencode", "skill");
-  return loadSkillsFromDirAsync(opencodeProjectDir, "opencode-project");
+  return loadSkillsFromDir(opencodeProjectDir, "opencode-project");
 }
 // src/features/opencode-skill-loader/merger.ts
-import { readFileSync as readFileSync23, existsSync as existsSync35 } from "fs";
+import { readFileSync as readFileSync22, existsSync as existsSync34 } from "fs";
 import { dirname as dirname7, resolve as resolve5, isAbsolute as isAbsolute2 } from "path";
 import { homedir as homedir12 } from "os";
 var SCOPE_PRIORITY = {
@@ -20433,9 +20437,9 @@ function resolveFilePath2(from, configDir) {
 }
 function loadSkillFromFile(filePath) {
   try {
-    if (!existsSync35(filePath))
+    if (!existsSync34(filePath))
       return null;
-    const content = readFileSync23(filePath, "utf-8");
+    const content = readFileSync22(filePath, "utf-8");
     const { data, body } = parseFrontmatter(content);
     return { template: body, metadata: data };
   } catch {
@@ -20589,10 +20593,10 @@ function mergeSkills(builtinSkills, config, userClaudeSkills, userOpencodeSkills
 }
 // src/hooks/auto-slash-command/executor.ts
 function discoverCommandsFromDir(commandsDir, scope) {
-  if (!existsSync36(commandsDir)) {
+  if (!existsSync35(commandsDir)) {
     return [];
   }
-  const entries = readdirSync12(commandsDir, { withFileTypes: true });
+  const entries = readdirSync11(commandsDir, { withFileTypes: true });
   const commands = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
@@ -20600,7 +20604,7 @@ function discoverCommandsFromDir(commandsDir, scope) {
     const commandPath = join43(commandsDir, entry.name);
     const commandName = basename2(entry.name, ".md");
     try {
-      const content = readFileSync24(commandPath, "utf-8");
+      const content = readFileSync23(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -20640,7 +20644,7 @@ function skillToCommandInfo(skill) {
     scope: "skill"
   };
 }
-function discoverAllCommands() {
+async function discoverAllCommands() {
   const userCommandsDir = join43(getClaudeConfigDir(), "commands");
   const projectCommandsDir = join43(process.cwd(), ".claude", "commands");
   const opencodeGlobalDir = join43(homedir13(), ".config", "opencode", "command");
@@ -20649,7 +20653,7 @@ function discoverAllCommands() {
   const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project");
   const opencodeProjectCommands = discoverCommandsFromDir(opencodeProjectDir, "opencode-project");
-  const skills = discoverAllSkills();
+  const skills = await discoverAllSkills();
   const skillCommands = skills.map(skillToCommandInfo);
   return [
     ...opencodeProjectCommands,
@@ -20659,8 +20663,8 @@ function discoverAllCommands() {
     ...skillCommands
   ];
 }
-function findCommand2(commandName) {
-  const allCommands = discoverAllCommands();
+async function findCommand2(commandName) {
+  const allCommands = await discoverAllCommands();
   return allCommands.find((cmd) => cmd.name.toLowerCase() === commandName.toLowerCase()) ?? null;
 }
 async function formatCommandTemplate(cmd, args) {
@@ -20706,7 +20710,7 @@ async function formatCommandTemplate(cmd, args) {
 `);
 }
 async function executeSlashCommand(parsed) {
-  const command = findCommand2(parsed.command);
+  const command = await findCommand2(parsed.command);
   if (!command) {
     return {
       success: false,
@@ -22800,7 +22804,7 @@ function createBuiltinSkills() {
   return [playwrightSkill];
 }
 // src/features/claude-code-mcp-loader/loader.ts
-import { existsSync as existsSync37, readFileSync as readFileSync25 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync24 } from "fs";
 import { join as join44 } from "path";
 
 // src/features/claude-code-mcp-loader/env-expander.ts
@@ -22876,7 +22880,7 @@ function getMcpConfigPaths() {
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync37(filePath)) {
+  if (!existsSync36(filePath)) {
     return null;
   }
   try {
@@ -22891,10 +22895,10 @@ function getSystemMcpServerNames() {
   const names = new Set;
   const paths = getMcpConfigPaths();
   for (const { path: path7 } of paths) {
-    if (!existsSync37(path7))
+    if (!existsSync36(path7))
       continue;
     try {
-      const content = readFileSync25(path7, "utf-8");
+      const content = readFileSync24(path7, "utf-8");
       const config = JSON.parse(content);
       if (!config?.mcpServers)
         continue;
@@ -23326,14 +23330,14 @@ var EXT_TO_LANG = {
   ".gql": "graphql"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync38, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync37, readFileSync as readFileSync25 } from "fs";
 import { join as join45 } from "path";
 import { homedir as homedir14 } from "os";
 function loadJsonFile(path7) {
-  if (!existsSync38(path7))
+  if (!existsSync37(path7))
     return null;
   try {
-    return JSON.parse(readFileSync26(path7, "utf-8"));
+    return JSON.parse(readFileSync25(path7, "utf-8"));
   } catch {
     return null;
   }
@@ -23456,7 +23460,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync38(cmd))
+    if (existsSync37(cmd))
       return true;
   }
   const isWindows2 = process.platform === "win32";
@@ -23465,7 +23469,7 @@ function isServerInstalled(command) {
   const pathSeparator = isWindows2 ? ";" : ":";
   const paths = pathEnv.split(pathSeparator);
   for (const p of paths) {
-    if (existsSync38(join45(p, cmd)) || existsSync38(join45(p, cmd + ext))) {
+    if (existsSync37(join45(p, cmd)) || existsSync37(join45(p, cmd + ext))) {
       return true;
     }
   }
@@ -23479,7 +23483,7 @@ function isServerInstalled(command) {
     join45(homedir14(), ".config", "opencode", "node_modules", ".bin", cmd + ext)
   ];
   for (const p of additionalPaths) {
-    if (existsSync38(p)) {
+    if (existsSync37(p)) {
       return true;
     }
   }
@@ -23532,7 +23536,7 @@ function getAllServers() {
 }
 // src/tools/lsp/client.ts
 var {spawn: spawn5 } = globalThis.Bun;
-import { readFileSync as readFileSync27 } from "fs";
+import { readFileSync as readFileSync26 } from "fs";
 import { extname, resolve as resolve6 } from "path";
 class LSPServerManager {
   static instance;
@@ -23962,7 +23966,7 @@ ${msg}`);
     const absPath = resolve6(filePath);
     if (this.openedFiles.has(absPath))
       return;
-    const text = readFileSync27(absPath, "utf-8");
+    const text = readFileSync26(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     this.notify("textDocument/didOpen", {
@@ -24078,16 +24082,16 @@ ${msg}`);
 // src/tools/lsp/utils.ts
 import { extname as extname2, resolve as resolve7 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { existsSync as existsSync39, readFileSync as readFileSync28, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync38, readFileSync as readFileSync27, writeFileSync as writeFileSync15 } from "fs";
 function findWorkspaceRoot(filePath) {
   let dir = resolve7(filePath);
-  if (!existsSync39(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  if (!existsSync38(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 (existsSync39(__require("path").join(dir, marker))) {
+      if (existsSync38(__require("path").join(dir, marker))) {
         return dir;
       }
     }
@@ -24283,7 +24287,7 @@ function formatCodeActions(actions) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync28(filePath, "utf-8");
+    let content = readFileSync27(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -24349,7 +24353,7 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = uriToPath(change.oldUri);
             const newPath = uriToPath(change.newUri);
-            const content = readFileSync28(oldPath, "utf-8");
+            const content = readFileSync27(oldPath, "utf-8");
             writeFileSync15(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
@@ -37051,11 +37055,11 @@ var lsp_code_action_resolve = tool({
 // src/tools/ast-grep/constants.ts
 import { createRequire as createRequire4 } from "module";
 import { dirname as dirname9, join as join47 } from "path";
-import { existsSync as existsSync41, statSync as statSync4 } from "fs";
+import { existsSync as existsSync40, statSync as statSync4 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 var {spawn: spawn6 } = globalThis.Bun;
-import { existsSync as existsSync40, mkdirSync as mkdirSync11, chmodSync as chmodSync2, unlinkSync as unlinkSync10 } from "fs";
+import { existsSync as existsSync39, mkdirSync as mkdirSync11, chmodSync as chmodSync2, unlinkSync as unlinkSync10 } from "fs";
 import { join as join46 } from "path";
 import { homedir as homedir15 } from "os";
 import { createRequire as createRequire3 } from "module";
@@ -37094,7 +37098,7 @@ function getBinaryName3() {
 }
 function getCachedBinaryPath2() {
   const binaryPath = join46(getCacheDir3(), getBinaryName3());
-  return existsSync40(binaryPath) ? binaryPath : null;
+  return existsSync39(binaryPath) ? binaryPath : null;
 }
 async function extractZip2(archivePath, destDir) {
   const proc = process.platform === "win32" ? spawn6([
@@ -37121,7 +37125,7 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
   const binaryPath = join46(cacheDir, binaryName);
-  if (existsSync40(binaryPath)) {
+  if (existsSync39(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os6 } = platformInfo;
@@ -37129,7 +37133,7 @@ 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 (!existsSync40(cacheDir)) {
+    if (!existsSync39(cacheDir)) {
       mkdirSync11(cacheDir, { recursive: true });
     }
     const response2 = await fetch(downloadUrl, { redirect: "follow" });
@@ -37140,10 +37144,10 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
     const arrayBuffer = await response2.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip2(archivePath, cacheDir);
-    if (existsSync40(archivePath)) {
+    if (existsSync39(archivePath)) {
       unlinkSync10(archivePath);
     }
-    if (process.platform !== "win32" && existsSync40(binaryPath)) {
+    if (process.platform !== "win32" && existsSync39(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -37195,7 +37199,7 @@ function findSgCliPathSync() {
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDir = dirname9(cliPkgPath);
     const sgPath = join47(cliDir, binaryName);
-    if (existsSync41(sgPath) && isValidBinary(sgPath)) {
+    if (existsSync40(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -37207,7 +37211,7 @@ function findSgCliPathSync() {
       const pkgDir = dirname9(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
       const binaryPath = join47(pkgDir, astGrepName);
-      if (existsSync41(binaryPath) && isValidBinary(binaryPath)) {
+      if (existsSync40(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -37215,7 +37219,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path7 of homebrewPaths) {
-      if (existsSync41(path7) && isValidBinary(path7)) {
+      if (existsSync40(path7) && isValidBinary(path7)) {
         return path7;
       }
     }
@@ -37270,11 +37274,11 @@ var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn7 } = globalThis.Bun;
-import { existsSync as existsSync42 } from "fs";
+import { existsSync as existsSync41 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync42(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync41(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -37282,7 +37286,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync42(syncPath)) {
+    if (syncPath && existsSync41(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -37316,7 +37320,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync42(cliPath) && cliPath !== "sg") {
+  if (!existsSync41(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -37580,17 +37584,17 @@ var ast_grep_replace = tool({
 var {spawn: spawn9 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
-import { existsSync as existsSync44 } from "fs";
+import { existsSync as existsSync43 } from "fs";
 import { join as join49, dirname as dirname10 } from "path";
 import { spawnSync } from "child_process";
 
 // src/tools/grep/downloader.ts
-import { existsSync as existsSync43, mkdirSync as mkdirSync12, chmodSync as chmodSync3, unlinkSync as unlinkSync11, readdirSync as readdirSync13 } from "fs";
+import { existsSync as existsSync42, mkdirSync as mkdirSync12, chmodSync as chmodSync3, unlinkSync as unlinkSync11, readdirSync as readdirSync12 } from "fs";
 import { join as join48 } from "path";
 var {spawn: spawn8 } = globalThis.Bun;
 function findFileRecursive(dir, filename) {
   try {
-    const entries = readdirSync13(dir, { withFileTypes: true, recursive: true });
+    const entries = readdirSync12(dir, { withFileTypes: true, recursive: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name === filename) {
         return join48(entry.parentPath ?? dir, entry.name);
@@ -37695,7 +37699,7 @@ async function downloadAndInstallRipgrep() {
   }
   const installDir = getInstallDir();
   const rgPath = getRgPath();
-  if (existsSync43(rgPath)) {
+  if (existsSync42(rgPath)) {
     return rgPath;
   }
   mkdirSync12(installDir, { recursive: true });
@@ -37712,12 +37716,12 @@ async function downloadAndInstallRipgrep() {
     if (process.platform !== "win32") {
       chmodSync3(rgPath, 493);
     }
-    if (!existsSync43(rgPath)) {
+    if (!existsSync42(rgPath)) {
       throw new Error("ripgrep binary not found after extraction");
     }
     return rgPath;
   } finally {
-    if (existsSync43(archivePath)) {
+    if (existsSync42(archivePath)) {
       try {
         unlinkSync11(archivePath);
       } catch {}
@@ -37726,7 +37730,7 @@ async function downloadAndInstallRipgrep() {
 }
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
-  return existsSync43(rgPath) ? rgPath : null;
+  return existsSync42(rgPath) ? rgPath : null;
 }
 
 // src/tools/grep/constants.ts
@@ -37757,7 +37761,7 @@ function getOpenCodeBundledRg() {
     join49(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync44(candidate)) {
+    if (existsSync43(candidate)) {
       return candidate;
     }
   }
@@ -38210,13 +38214,13 @@ var glob = tool({
   }
 });
 // src/tools/slashcommand/tools.ts
-import { existsSync as existsSync45, readdirSync as readdirSync14, readFileSync as readFileSync29 } from "fs";
+import { existsSync as existsSync44, readdirSync as readdirSync13, readFileSync as readFileSync28 } from "fs";
 import { join as join50, basename as basename3, dirname as dirname11 } from "path";
 function discoverCommandsFromDir2(commandsDir, scope) {
-  if (!existsSync45(commandsDir)) {
+  if (!existsSync44(commandsDir)) {
     return [];
   }
-  const entries = readdirSync14(commandsDir, { withFileTypes: true });
+  const entries = readdirSync13(commandsDir, { withFileTypes: true });
   const commands = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
@@ -38224,7 +38228,7 @@ function discoverCommandsFromDir2(commandsDir, scope) {
     const commandPath = join50(commandsDir, entry.name);
     const commandName = basename3(entry.name, ".md");
     try {
-      const content = readFileSync29(commandPath, "utf-8");
+      const content = readFileSync28(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -38276,17 +38280,6 @@ function skillToCommandInfo2(skill) {
     scope: skill.scope
   };
 }
-var availableCommands = discoverCommandsSync();
-var availableSkills = discoverAllSkills();
-var availableItems = [
-  ...availableCommands,
-  ...availableSkills.map(skillToCommandInfo2)
-];
-var commandListForDescription = availableItems.map((cmd) => {
-  const hint = cmd.metadata.argumentHint ? ` ${cmd.metadata.argumentHint}` : "";
-  return `- /${cmd.name}${hint}: ${cmd.metadata.description} (${cmd.scope})`;
-}).join(`
-`);
 async function formatLoadedCommand(cmd) {
   const sections = [];
   sections.push(`# /${cmd.name} Command
@@ -38339,49 +38332,86 @@ function formatCommandList(items) {
   return lines.join(`
 `);
 }
-var slashcommand = tool({
-  description: `Load a skill to get detailed instructions for a specific task.
+var TOOL_DESCRIPTION_PREFIX = `Load a skill to get detailed instructions for a specific task.
 
 Skills provide specialized knowledge and step-by-step guidance.
 Use this when a task matches an available skill's description.
-
+`;
+function buildDescriptionFromItems(items) {
+  const commandListForDescription = items.map((cmd) => {
+    const hint = cmd.metadata.argumentHint ? ` ${cmd.metadata.argumentHint}` : "";
+    return `- /${cmd.name}${hint}: ${cmd.metadata.description} (${cmd.scope})`;
+  }).join(`
+`);
+  return `${TOOL_DESCRIPTION_PREFIX}
 <available_skills>
 ${commandListForDescription}
-</available_skills>`,
-  args: {
-    command: tool.schema.string().describe("The slash command to execute (without the leading slash). E.g., 'commit', 'plan', 'execute'.")
-  },
-  async execute(args) {
-    const commands = discoverCommandsSync();
-    const skills = discoverAllSkills();
-    const allItems = [
-      ...commands,
-      ...skills.map(skillToCommandInfo2)
-    ];
-    if (!args.command) {
-      return formatCommandList(allItems) + `
+</available_skills>`;
+}
+function createSlashcommandTool(options = {}) {
+  let cachedCommands = options.commands ?? null;
+  let cachedSkills = options.skills ?? null;
+  let cachedDescription = null;
+  const getCommands = () => {
+    if (cachedCommands)
+      return cachedCommands;
+    cachedCommands = discoverCommandsSync();
+    return cachedCommands;
+  };
+  const getSkills = async () => {
+    if (cachedSkills)
+      return cachedSkills;
+    cachedSkills = await discoverAllSkills();
+    return cachedSkills;
+  };
+  const getAllItems = async () => {
+    const commands = getCommands();
+    const skills = await getSkills();
+    return [...commands, ...skills.map(skillToCommandInfo2)];
+  };
+  const buildDescription = async () => {
+    if (cachedDescription)
+      return cachedDescription;
+    const allItems = await getAllItems();
+    cachedDescription = buildDescriptionFromItems(allItems);
+    return cachedDescription;
+  };
+  buildDescription();
+  return tool({
+    get description() {
+      return cachedDescription ?? TOOL_DESCRIPTION_PREFIX;
+    },
+    args: {
+      command: tool.schema.string().describe("The slash command to execute (without the leading slash). E.g., 'commit', 'plan', 'execute'.")
+    },
+    async execute(args) {
+      const allItems = await getAllItems();
+      if (!args.command) {
+        return formatCommandList(allItems) + `
 
 Provide a command or skill name to execute.`;
-    }
-    const cmdName = args.command.replace(/^\//, "");
-    const exactMatch = allItems.find((cmd) => cmd.name.toLowerCase() === cmdName.toLowerCase());
-    if (exactMatch) {
-      return await formatLoadedCommand(exactMatch);
-    }
-    const partialMatches = allItems.filter((cmd) => cmd.name.toLowerCase().includes(cmdName.toLowerCase()));
-    if (partialMatches.length > 0) {
-      const matchList = partialMatches.map((cmd) => `/${cmd.name}`).join(", ");
-      return `No exact match for "/${cmdName}". Did you mean: ${matchList}?
+      }
+      const cmdName = args.command.replace(/^\//, "");
+      const exactMatch = allItems.find((cmd) => cmd.name.toLowerCase() === cmdName.toLowerCase());
+      if (exactMatch) {
+        return await formatLoadedCommand(exactMatch);
+      }
+      const partialMatches = allItems.filter((cmd) => cmd.name.toLowerCase().includes(cmdName.toLowerCase()));
+      if (partialMatches.length > 0) {
+        const matchList = partialMatches.map((cmd) => `/${cmd.name}`).join(", ");
+        return `No exact match for "/${cmdName}". Did you mean: ${matchList}?
 
 ` + formatCommandList(allItems);
-    }
-    return `Command or skill "/${cmdName}" not found.
+      }
+      return `Command or skill "/${cmdName}" not found.
 
 ` + formatCommandList(allItems) + `
 
 Try a different name.`;
-  }
-});
+    }
+  });
+}
+var slashcommand = createSlashcommandTool();
 // src/tools/session-manager/constants.ts
 import { join as join51 } from "path";
 var OPENCODE_STORAGE9 = getOpenCodeStorageDir();
@@ -38462,11 +38492,11 @@ Has Todos: Yes (12 items, 8 completed)
 Has Transcript: Yes (234 entries)`;
 
 // src/tools/session-manager/storage.ts
-import { existsSync as existsSync46, readdirSync as readdirSync15 } from "fs";
+import { existsSync as existsSync45, readdirSync as readdirSync14 } from "fs";
 import { readdir, readFile } from "fs/promises";
 import { join as join52 } from "path";
 async function getMainSessions(options) {
-  if (!existsSync46(SESSION_STORAGE))
+  if (!existsSync45(SESSION_STORAGE))
     return [];
   const sessions = [];
   try {
@@ -38498,7 +38528,7 @@ async function getMainSessions(options) {
   return sessions.sort((a, b) => b.time.updated - a.time.updated);
 }
 async function getAllSessions() {
-  if (!existsSync46(MESSAGE_STORAGE4))
+  if (!existsSync45(MESSAGE_STORAGE4))
     return [];
   const sessions = [];
   async function scanDirectory(dir) {
@@ -38523,16 +38553,16 @@ async function getAllSessions() {
   return [...new Set(sessions)];
 }
 function getMessageDir9(sessionID) {
-  if (!existsSync46(MESSAGE_STORAGE4))
+  if (!existsSync45(MESSAGE_STORAGE4))
     return "";
   const directPath = join52(MESSAGE_STORAGE4, sessionID);
-  if (existsSync46(directPath)) {
+  if (existsSync45(directPath)) {
     return directPath;
   }
   try {
-    for (const dir of readdirSync15(MESSAGE_STORAGE4)) {
+    for (const dir of readdirSync14(MESSAGE_STORAGE4)) {
       const sessionPath = join52(MESSAGE_STORAGE4, dir, sessionID);
-      if (existsSync46(sessionPath)) {
+      if (existsSync45(sessionPath)) {
         return sessionPath;
       }
     }
@@ -38546,7 +38576,7 @@ function sessionExists(sessionID) {
 }
 async function readSessionMessages(sessionID) {
   const messageDir = getMessageDir9(sessionID);
-  if (!messageDir || !existsSync46(messageDir))
+  if (!messageDir || !existsSync45(messageDir))
     return [];
   const messages = [];
   try {
@@ -38582,7 +38612,7 @@ async function readSessionMessages(sessionID) {
 }
 async function readParts2(messageID) {
   const partDir = join52(PART_STORAGE4, messageID);
-  if (!existsSync46(partDir))
+  if (!existsSync45(partDir))
     return [];
   const parts = [];
   try {
@@ -38603,7 +38633,7 @@ async function readParts2(messageID) {
   return parts.sort((a, b) => a.id.localeCompare(b.id));
 }
 async function readSessionTodos(sessionID) {
-  if (!existsSync46(TODO_DIR2))
+  if (!existsSync45(TODO_DIR2))
     return [];
   try {
     const allFiles = await readdir(TODO_DIR2);
@@ -38630,10 +38660,10 @@ async function readSessionTodos(sessionID) {
   return [];
 }
 async function readSessionTranscript(sessionID) {
-  if (!existsSync46(TRANSCRIPT_DIR2))
+  if (!existsSync45(TRANSCRIPT_DIR2))
     return 0;
   const transcriptFile = join52(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
-  if (!existsSync46(transcriptFile))
+  if (!existsSync45(transcriptFile))
     return 0;
   try {
     const content = await readFile(transcriptFile, "utf-8");
@@ -39104,13 +39134,13 @@ var interactive_bash = tool({
 });
 // src/tools/skill/constants.ts
 var TOOL_DESCRIPTION_NO_SKILLS = "Load a skill to get detailed instructions for a specific task. No skills are currently available.";
-var TOOL_DESCRIPTION_PREFIX = `Load a skill to get detailed instructions for a specific task.
+var TOOL_DESCRIPTION_PREFIX2 = `Load a skill to get detailed instructions for a specific task.
 
 Skills provide specialized knowledge and step-by-step guidance.
 Use this when a task matches an available skill's description.`;
 // src/tools/skill/tools.ts
 import { dirname as dirname12 } from "path";
-import { readFileSync as readFileSync30 } from "fs";
+import { readFileSync as readFileSync29 } from "fs";
 function loadedSkillToInfo(skill) {
   return {
     name: skill.name,
@@ -39153,7 +39183,7 @@ async function extractSkillBody(skill) {
     return templateMatch2 ? templateMatch2[1].trim() : fullTemplate;
   }
   if (skill.path) {
-    const content = readFileSync30(skill.path, "utf-8");
+    const content = readFileSync29(skill.path, "utf-8");
     const { body } = parseFrontmatter(content);
     return body.trim();
   }
@@ -39221,16 +39251,35 @@ async function formatMcpCapabilities(skill, manager, sessionID) {
 `);
 }
 function createSkillTool(options = {}) {
-  const skills = options.skills ?? discoverSkills({ includeClaudeCodePaths: !options.opencodeOnly });
-  const skillInfos = skills.map(loadedSkillToInfo);
-  const description = skillInfos.length === 0 ? TOOL_DESCRIPTION_NO_SKILLS : TOOL_DESCRIPTION_PREFIX + formatSkillsXml(skillInfos);
+  let cachedSkills = null;
+  let cachedDescription = null;
+  const getSkills = async () => {
+    if (options.skills)
+      return options.skills;
+    if (cachedSkills)
+      return cachedSkills;
+    cachedSkills = await discoverSkills({ includeClaudeCodePaths: !options.opencodeOnly });
+    return cachedSkills;
+  };
+  const getDescription = async () => {
+    if (cachedDescription)
+      return cachedDescription;
+    const skills = await getSkills();
+    const skillInfos = skills.map(loadedSkillToInfo);
+    cachedDescription = skillInfos.length === 0 ? TOOL_DESCRIPTION_NO_SKILLS : TOOL_DESCRIPTION_PREFIX2 + formatSkillsXml(skillInfos);
+    return cachedDescription;
+  };
+  getDescription();
   return tool({
-    description,
+    get description() {
+      return cachedDescription ?? TOOL_DESCRIPTION_PREFIX2;
+    },
     args: {
       name: tool.schema.string().describe("The skill identifier from available_skills (e.g., 'code-review')")
     },
     async execute(args) {
-      const skill = options.skills ? skills.find((s) => s.name === args.name) : skills.find((s) => s.name === args.name);
+      const skills = await getSkills();
+      const skill = skills.find((s) => s.name === args.name);
       if (!skill) {
         const available = skills.map((s) => s.name).join(", ");
         throw new Error(`Skill "${args.name}" not found. Available skills: ${available || "none"}`);
@@ -39401,7 +39450,7 @@ function createSkillMcpTool(options) {
   });
 }
 // src/tools/background-task/tools.ts
-import { existsSync as existsSync47, readdirSync as readdirSync16 } from "fs";
+import { existsSync as existsSync46, readdirSync as readdirSync15 } from "fs";
 import { join as join53 } from "path";
 
 // src/tools/background-task/constants.ts
@@ -39413,14 +39462,14 @@ var BACKGROUND_CANCEL_DESCRIPTION = `Cancel running background task(s). Use all=
 
 // src/tools/background-task/tools.ts
 function getMessageDir10(sessionID) {
-  if (!existsSync47(MESSAGE_STORAGE))
+  if (!existsSync46(MESSAGE_STORAGE))
     return null;
   const directPath = join53(MESSAGE_STORAGE, sessionID);
-  if (existsSync47(directPath))
+  if (existsSync46(directPath))
     return directPath;
-  for (const dir of readdirSync16(MESSAGE_STORAGE)) {
+  for (const dir of readdirSync15(MESSAGE_STORAGE)) {
     const sessionPath = join53(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync47(sessionPath))
+    if (existsSync46(sessionPath))
       return sessionPath;
   }
   return null;
@@ -39999,25 +40048,24 @@ var builtinTools = {
   ast_grep_replace,
   grep,
   glob,
-  slashcommand,
   session_list,
   session_read,
   session_search,
   session_info
 };
 // src/features/background-agent/manager.ts
-import { existsSync as existsSync48, readdirSync as readdirSync17 } from "fs";
+import { existsSync as existsSync47, readdirSync as readdirSync16 } from "fs";
 import { join as join54 } from "path";
 var TASK_TTL_MS = 30 * 60 * 1000;
 function getMessageDir11(sessionID) {
-  if (!existsSync48(MESSAGE_STORAGE))
+  if (!existsSync47(MESSAGE_STORAGE))
     return null;
   const directPath = join54(MESSAGE_STORAGE, sessionID);
-  if (existsSync48(directPath))
+  if (existsSync47(directPath))
     return directPath;
-  for (const dir of readdirSync17(MESSAGE_STORAGE)) {
+  for (const dir of readdirSync16(MESSAGE_STORAGE)) {
     const sessionPath = join54(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync48(sessionPath))
+    if (existsSync47(sessionPath))
       return sessionPath;
   }
   return null;
@@ -43178,11 +43226,12 @@ class SkillMcpManager {
   }
 }
 // src/plugin-config.ts
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 import * as path7 from "path";
 
 // src/mcp/types.ts
-var McpNameSchema = exports_external.enum(["websearch_exa", "context7", "grep_app"]);
+var McpNameSchema = exports_external.enum(["context7", "grep_app"]);
+var AnyMcpNameSchema = exports_external.string().min(1);
 
 // src/config/schema.ts
 var PermissionValue = exports_external.enum(["ask", "allow", "deny"]);
@@ -43380,7 +43429,7 @@ var RalphLoopConfigSchema = exports_external.object({
 });
 var OhMyOpenCodeConfigSchema = exports_external.object({
   $schema: exports_external.string().optional(),
-  disabled_mcps: exports_external.array(McpNameSchema).optional(),
+  disabled_mcps: exports_external.array(AnyMcpNameSchema).optional(),
   disabled_agents: exports_external.array(BuiltinAgentNameSchema).optional(),
   disabled_skills: exports_external.array(BuiltinSkillNameSchema).optional(),
   disabled_hooks: exports_external.array(HookNameSchema).optional(),
@@ -43398,8 +43447,8 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
 // src/plugin-config.ts
 function loadConfigFromPath2(configPath, ctx) {
   try {
-    if (fs10.existsSync(configPath)) {
-      const content = fs10.readFileSync(configPath, "utf-8");
+    if (fs11.existsSync(configPath)) {
+      const content = fs11.readFileSync(configPath, "utf-8");
       const rawConfig = parseJsonc(content);
       migrateConfigFile(configPath, rawConfig);
       const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
@@ -44115,9 +44164,9 @@ var SISYPHUS_SOFT_GUIDELINES = `## Soft Guidelines
 </Constraints>
 
 `;
-function buildDynamicSisyphusPrompt(availableAgents, availableTools = [], availableSkills2 = []) {
-  const keyTriggers = buildKeyTriggersSection(availableAgents, availableSkills2);
-  const toolSelection = buildToolSelectionTable(availableAgents, availableTools, availableSkills2);
+function buildDynamicSisyphusPrompt(availableAgents, availableTools = [], availableSkills = []) {
+  const keyTriggers = buildKeyTriggersSection(availableAgents, availableSkills);
+  const toolSelection = buildToolSelectionTable(availableAgents, availableTools, availableSkills);
   const exploreSection = buildExploreSection(availableAgents);
   const librarianSection = buildLibrarianSection(availableAgents);
   const frontendSection = buildFrontendSection(availableAgents);
@@ -44191,9 +44240,9 @@ function buildDynamicSisyphusPrompt(availableAgents, availableTools = [], availa
   return sections.filter((s) => s !== "").join(`
 `);
 }
-function createSisyphusAgent(model = DEFAULT_MODEL, availableAgents, availableToolNames, availableSkills2) {
+function createSisyphusAgent(model = DEFAULT_MODEL, availableAgents, availableToolNames, availableSkills) {
   const tools4 = availableToolNames ? categorizeTools(availableToolNames) : [];
-  const skills = availableSkills2 ?? [];
+  const skills = availableSkills ?? [];
   const prompt = availableAgents ? buildDynamicSisyphusPrompt(availableAgents, tools4, skills) : buildDynamicSisyphusPrompt([], tools4, skills);
   const base = {
     description: "Sisyphus - Powerful AI orchestrator from OhMyOpenCode. Plans obsessively with todos, assesses search complexity before exploration, delegates strategically to specialized agents. Uses explore for internal code (parallel-friendly), librarian only for external docs, and always delegates UI work to frontend engineer.",
@@ -44376,10 +44425,10 @@ Classify EVERY request into one of these categories before taking action:
 
 | Type | Trigger Examples | Tools |
 |------|------------------|-------|
-| **TYPE A: CONCEPTUAL** | "How do I use X?", "Best practice for Y?" | context7 + websearch_exa (parallel) |
+| **TYPE A: CONCEPTUAL** | "How do I use X?", "Best practice for Y?" | context7 + web search (if available) in parallel |
 | **TYPE B: IMPLEMENTATION** | "How does X implement Y?", "Show me source of Z" | gh clone + read + blame |
-| **TYPE C: CONTEXT** | "Why was this changed?", "History of X?" | gh issues/prs + git log/blame |
-| **TYPE D: COMPREHENSIVE** | Complex/ambiguous requests | ALL tools in parallel |
+| **TYPE C: CONTEXT** | "Why was this changed?", "What's the history?", "Related issues/PRs?" | gh issues/prs + git log/blame |
+| **TYPE D: COMPREHENSIVE** | Complex/ambiguous requests | ALL available tools in parallel |
 
 ---
 
@@ -44388,12 +44437,12 @@ Classify EVERY request into one of these categories before taking action:
 ### TYPE A: CONCEPTUAL QUESTION
 **Trigger**: "How do I...", "What is...", "Best practice for...", rough/general questions
 
-**Execute in parallel (3+ calls)**:
+**Execute in parallel (2+ calls)**:
 \`\`\`
 Tool 1: context7_resolve-library-id("library-name")
         \u2192 then context7_get-library-docs(id, topic: "specific-topic")
-Tool 2: websearch_exa_web_search_exa("library-name topic 2025")
-Tool 3: grep_app_searchGitHub(query: "usage pattern", language: ["TypeScript"])
+Tool 2: grep_app_searchGitHub(query: "usage pattern", language: ["TypeScript"])
+Tool 3 (optional): If web search is available, search "library-name topic 2025"
 \`\`\`
 
 **Output**: Summarize findings with links to official docs and real-world examples.
@@ -44455,21 +44504,22 @@ gh api repos/owner/repo/pulls/<number>/files
 ### TYPE D: COMPREHENSIVE RESEARCH
 **Trigger**: Complex questions, ambiguous requests, "deep dive into..."
 
-**Execute ALL in parallel (6+ calls)**:
+**Execute ALL available tools in parallel (5+ calls)**:
 \`\`\`
-// Documentation & Web
+// Documentation
 Tool 1: context7_resolve-library-id \u2192 context7_get-library-docs
-Tool 2: websearch_exa_web_search_exa("topic recent updates")
 
 // Code Search
-Tool 3: grep_app_searchGitHub(query: "pattern1", language: [...])
-Tool 4: grep_app_searchGitHub(query: "pattern2", useRegexp: true)
+Tool 2: grep_app_searchGitHub(query: "pattern1", language: [...])
+Tool 3: grep_app_searchGitHub(query: "pattern2", useRegexp: true)
 
 // Source Analysis
-Tool 5: gh repo clone owner/repo \${TMPDIR:-/tmp}/repo -- --depth 1
+Tool 4: gh repo clone owner/repo \${TMPDIR:-/tmp}/repo -- --depth 1
 
 // Context
-Tool 6: gh search issues "topic" --repo owner/repo
+Tool 5: gh search issues "topic" --repo owner/repo
+
+// Optional: If web search is available, search for recent updates
 \`\`\`
 
 ---
@@ -44515,7 +44565,6 @@ https://github.com/tanstack/query/blob/abc123def/packages/react-query/src/useQue
 | Purpose | Tool | Command/Usage |
 |---------|------|---------------|
 | **Official Docs** | context7 | \`context7_resolve-library-id\` \u2192 \`context7_get-library-docs\` |
-| **Latest Info** | websearch_exa | \`websearch_exa_web_search_exa("query 2025")\` |
 | **Fast Code Search** | grep_app | \`grep_app_searchGitHub(query, language, useRegexp)\` |
 | **Deep Code Search** | gh CLI | \`gh search code "query" --repo owner/repo\` |
 | **Clone Repo** | gh CLI | \`gh repo clone owner/repo \${TMPDIR:-/tmp}/name -- --depth 1\` |
@@ -44524,6 +44573,7 @@ https://github.com/tanstack/query/blob/abc123def/packages/react-query/src/useQue
 | **Release Info** | gh CLI | \`gh api repos/owner/repo/releases/latest\` |
 | **Git History** | git | \`git log\`, \`git blame\`, \`git show\` |
 | **Read URL** | webfetch | \`webfetch(url)\` for blog posts, SO threads |
+| **Web Search** | (if available) | Use any available web search tool for latest info |
 
 ### Temp Directory
 
@@ -45170,15 +45220,18 @@ function createBuiltinAgents(disabledAgents = [], agentOverrides = {}, directory
   return result;
 }
 // src/features/claude-code-command-loader/loader.ts
-import { existsSync as existsSync50, readdirSync as readdirSync18, readFileSync as readFileSync32, realpathSync as realpathSync2 } from "fs";
+import { promises as fs12 } from "fs";
 import { join as join56, basename as basename5 } from "path";
-function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix = "") {
-  if (!existsSync50(commandsDir)) {
+import { homedir as homedir16 } from "os";
+async function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix = "") {
+  try {
+    await fs12.access(commandsDir);
+  } catch {
     return [];
   }
   let realPath;
   try {
-    realPath = realpathSync2(commandsDir);
+    realPath = await fs12.realpath(commandsDir);
   } catch (error45) {
     log(`Failed to resolve command directory: ${commandsDir}`, error45);
     return [];
@@ -45189,7 +45242,7 @@ function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix = "")
   visited.add(realPath);
   let entries;
   try {
-    entries = readdirSync18(commandsDir, { withFileTypes: true });
+    entries = await fs12.readdir(commandsDir, { withFileTypes: true });
   } catch (error45) {
     log(`Failed to read command directory: ${commandsDir}`, error45);
     return [];
@@ -45201,7 +45254,8 @@ function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix = "")
         continue;
       const subDirPath = join56(commandsDir, entry.name);
       const subPrefix = prefix ? `${prefix}:${entry.name}` : entry.name;
-      commands.push(...loadCommandsFromDir(subDirPath, scope, visited, subPrefix));
+      const subCommands = await loadCommandsFromDir(subDirPath, scope, visited, subPrefix);
+      commands.push(...subCommands);
       continue;
     }
     if (!isMarkdownFile(entry))
@@ -45210,7 +45264,7 @@ function loadCommandsFromDir(commandsDir, scope, visited = new Set, prefix = "")
     const baseCommandName = basename5(entry.name, ".md");
     const commandName = prefix ? `${prefix}:${baseCommandName}` : baseCommandName;
     try {
-      const content = readFileSync32(commandPath, "utf-8");
+      const content = await fs12.readFile(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const wrappedTemplate = `<command-instruction>
 ${body.trim()}
@@ -45252,25 +45306,24 @@ function commandsToRecord(commands) {
   }
   return result;
 }
-function loadUserCommands() {
+async function loadUserCommands() {
   const userCommandsDir = join56(getClaudeConfigDir(), "commands");
-  const commands = loadCommandsFromDir(userCommandsDir, "user");
+  const commands = await loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands);
 }
-function loadProjectCommands() {
+async function loadProjectCommands() {
   const projectCommandsDir = join56(process.cwd(), ".claude", "commands");
-  const commands = loadCommandsFromDir(projectCommandsDir, "project");
+  const commands = await loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands);
 }
-function loadOpencodeGlobalCommands() {
-  const { homedir: homedir16 } = __require("os");
+async function loadOpencodeGlobalCommands() {
   const opencodeCommandsDir = join56(homedir16(), ".config", "opencode", "command");
-  const commands = loadCommandsFromDir(opencodeCommandsDir, "opencode");
+  const commands = await loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands);
 }
-function loadOpencodeProjectCommands() {
+async function loadOpencodeProjectCommands() {
   const opencodeProjectDir = join56(process.cwd(), ".opencode", "command");
-  const commands = loadCommandsFromDir(opencodeProjectDir, "opencode-project");
+  const commands = await loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands);
 }
 // src/features/builtin-commands/templates/init-deep.ts
@@ -45657,7 +45710,7 @@ function loadBuiltinCommands(disabledCommands) {
   return commands;
 }
 // src/features/claude-code-agent-loader/loader.ts
-import { existsSync as existsSync51, readdirSync as readdirSync19, readFileSync as readFileSync33 } from "fs";
+import { existsSync as existsSync49, readdirSync as readdirSync17, readFileSync as readFileSync31 } from "fs";
 import { join as join57, basename as basename6 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
@@ -45672,10 +45725,10 @@ function parseToolsConfig(toolsStr) {
   return result;
 }
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync51(agentsDir)) {
+  if (!existsSync49(agentsDir)) {
     return [];
   }
-  const entries = readdirSync19(agentsDir, { withFileTypes: true });
+  const entries = readdirSync17(agentsDir, { withFileTypes: true });
   const agents = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
@@ -45683,7 +45736,7 @@ function loadAgentsFromDir(agentsDir, scope) {
     const agentPath = join57(agentsDir, entry.name);
     const agentName = basename6(entry.name, ".md");
     try {
-      const content = readFileSync33(agentPath, "utf-8");
+      const content = readFileSync31(agentPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const name = data.name || agentName;
       const originalDescription = data.description || "";
@@ -45728,15 +45781,15 @@ function loadProjectAgents() {
   return result;
 }
 // src/features/claude-code-plugin-loader/loader.ts
-import { existsSync as existsSync52, readdirSync as readdirSync20, readFileSync as readFileSync34 } from "fs";
-import { homedir as homedir16 } from "os";
+import { existsSync as existsSync50, readdirSync as readdirSync18, readFileSync as readFileSync32 } from "fs";
+import { homedir as homedir17 } from "os";
 import { join as join58, basename as basename7 } from "path";
 var CLAUDE_PLUGIN_ROOT_VAR = "${CLAUDE_PLUGIN_ROOT}";
 function getPluginsBaseDir() {
   if (process.env.CLAUDE_PLUGINS_HOME) {
     return process.env.CLAUDE_PLUGINS_HOME;
   }
-  return join58(homedir16(), ".claude", "plugins");
+  return join58(homedir17(), ".claude", "plugins");
 }
 function getInstalledPluginsPath() {
   return join58(getPluginsBaseDir(), "installed_plugins.json");
@@ -45764,11 +45817,11 @@ function resolvePluginPaths(obj, pluginRoot) {
 }
 function loadInstalledPlugins() {
   const dbPath = getInstalledPluginsPath();
-  if (!existsSync52(dbPath)) {
+  if (!existsSync50(dbPath)) {
     return null;
   }
   try {
-    const content = readFileSync34(dbPath, "utf-8");
+    const content = readFileSync32(dbPath, "utf-8");
     return JSON.parse(content);
   } catch (error45) {
     log("Failed to load installed plugins database", error45);
@@ -45779,15 +45832,15 @@ function getClaudeSettingsPath() {
   if (process.env.CLAUDE_SETTINGS_PATH) {
     return process.env.CLAUDE_SETTINGS_PATH;
   }
-  return join58(homedir16(), ".claude", "settings.json");
+  return join58(homedir17(), ".claude", "settings.json");
 }
 function loadClaudeSettings() {
   const settingsPath = getClaudeSettingsPath();
-  if (!existsSync52(settingsPath)) {
+  if (!existsSync50(settingsPath)) {
     return null;
   }
   try {
-    const content = readFileSync34(settingsPath, "utf-8");
+    const content = readFileSync32(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch (error45) {
     log("Failed to load Claude settings", error45);
@@ -45796,11 +45849,11 @@ function loadClaudeSettings() {
 }
 function loadPluginManifest(installPath) {
   const manifestPath = join58(installPath, ".claude-plugin", "plugin.json");
-  if (!existsSync52(manifestPath)) {
+  if (!existsSync50(manifestPath)) {
     return null;
   }
   try {
-    const content = readFileSync34(manifestPath, "utf-8");
+    const content = readFileSync32(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error45) {
     log(`Failed to load plugin manifest from ${manifestPath}`, error45);
@@ -45847,7 +45900,7 @@ function discoverInstalledPlugins(options) {
       continue;
     }
     const { installPath, scope, version: version2 } = installation;
-    if (!existsSync52(installPath)) {
+    if (!existsSync50(installPath)) {
       errors3.push({
         pluginKey,
         installPath,
@@ -45865,21 +45918,21 @@ function discoverInstalledPlugins(options) {
       pluginKey,
       manifest: manifest ?? undefined
     };
-    if (existsSync52(join58(installPath, "commands"))) {
+    if (existsSync50(join58(installPath, "commands"))) {
       loadedPlugin.commandsDir = join58(installPath, "commands");
     }
-    if (existsSync52(join58(installPath, "agents"))) {
+    if (existsSync50(join58(installPath, "agents"))) {
       loadedPlugin.agentsDir = join58(installPath, "agents");
     }
-    if (existsSync52(join58(installPath, "skills"))) {
+    if (existsSync50(join58(installPath, "skills"))) {
       loadedPlugin.skillsDir = join58(installPath, "skills");
     }
     const hooksPath = join58(installPath, "hooks", "hooks.json");
-    if (existsSync52(hooksPath)) {
+    if (existsSync50(hooksPath)) {
       loadedPlugin.hooksPath = hooksPath;
     }
     const mcpPath = join58(installPath, ".mcp.json");
-    if (existsSync52(mcpPath)) {
+    if (existsSync50(mcpPath)) {
       loadedPlugin.mcpPath = mcpPath;
     }
     plugins.push(loadedPlugin);
@@ -45890,9 +45943,9 @@ function discoverInstalledPlugins(options) {
 function loadPluginCommands(plugins) {
   const commands2 = {};
   for (const plugin2 of plugins) {
-    if (!plugin2.commandsDir || !existsSync52(plugin2.commandsDir))
+    if (!plugin2.commandsDir || !existsSync50(plugin2.commandsDir))
       continue;
-    const entries = readdirSync20(plugin2.commandsDir, { withFileTypes: true });
+    const entries = readdirSync18(plugin2.commandsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
@@ -45900,7 +45953,7 @@ function loadPluginCommands(plugins) {
       const commandName = basename7(entry.name, ".md");
       const namespacedName = `${plugin2.name}:${commandName}`;
       try {
-        const content = readFileSync34(commandPath, "utf-8");
+        const content = readFileSync32(commandPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const wrappedTemplate = `<command-instruction>
 ${body.trim()}
@@ -45932,9 +45985,9 @@ $ARGUMENTS
 function loadPluginSkillsAsCommands(plugins) {
   const skills = {};
   for (const plugin2 of plugins) {
-    if (!plugin2.skillsDir || !existsSync52(plugin2.skillsDir))
+    if (!plugin2.skillsDir || !existsSync50(plugin2.skillsDir))
       continue;
-    const entries = readdirSync20(plugin2.skillsDir, { withFileTypes: true });
+    const entries = readdirSync18(plugin2.skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith("."))
         continue;
@@ -45943,10 +45996,10 @@ function loadPluginSkillsAsCommands(plugins) {
         continue;
       const resolvedPath = resolveSymlink(skillPath);
       const skillMdPath = join58(resolvedPath, "SKILL.md");
-      if (!existsSync52(skillMdPath))
+      if (!existsSync50(skillMdPath))
         continue;
       try {
-        const content = readFileSync34(skillMdPath, "utf-8");
+        const content = readFileSync32(skillMdPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const skillName = data.name || entry.name;
         const namespacedName = `${plugin2.name}:${skillName}`;
@@ -45993,9 +46046,9 @@ function parseToolsConfig2(toolsStr) {
 function loadPluginAgents(plugins) {
   const agents = {};
   for (const plugin2 of plugins) {
-    if (!plugin2.agentsDir || !existsSync52(plugin2.agentsDir))
+    if (!plugin2.agentsDir || !existsSync50(plugin2.agentsDir))
       continue;
-    const entries = readdirSync20(plugin2.agentsDir, { withFileTypes: true });
+    const entries = readdirSync18(plugin2.agentsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
@@ -46003,7 +46056,7 @@ function loadPluginAgents(plugins) {
       const agentName = basename7(entry.name, ".md");
       const namespacedName = `${plugin2.name}:${agentName}`;
       try {
-        const content = readFileSync34(agentPath, "utf-8");
+        const content = readFileSync32(agentPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const name = data.name || agentName;
         const originalDescription = data.description || "";
@@ -46029,7 +46082,7 @@ function loadPluginAgents(plugins) {
 async function loadPluginMcpServers(plugins) {
   const servers = {};
   for (const plugin2 of plugins) {
-    if (!plugin2.mcpPath || !existsSync52(plugin2.mcpPath))
+    if (!plugin2.mcpPath || !existsSync50(plugin2.mcpPath))
       continue;
     try {
       const content = await Bun.file(plugin2.mcpPath).text();
@@ -46061,10 +46114,10 @@ async function loadPluginMcpServers(plugins) {
 function loadPluginHooksConfigs(plugins) {
   const configs = [];
   for (const plugin2 of plugins) {
-    if (!plugin2.hooksPath || !existsSync52(plugin2.hooksPath))
+    if (!plugin2.hooksPath || !existsSync50(plugin2.hooksPath))
       continue;
     try {
-      const content = readFileSync34(plugin2.hooksPath, "utf-8");
+      const content = readFileSync32(plugin2.hooksPath, "utf-8");
       let config3 = JSON.parse(content);
       config3 = resolvePluginPaths(config3, plugin2.installPath);
       configs.push(config3);
@@ -46095,13 +46148,6 @@ async function loadAllPluginComponents(options) {
     errors: errors3
   };
 }
-// src/mcp/websearch-exa.ts
-var websearch_exa = {
-  type: "remote",
-  url: "https://mcp.exa.ai/mcp?tools=web_search_exa",
-  enabled: true
-};
-
 // src/mcp/context7.ts
 var context7 = {
   type: "remote",
@@ -46118,7 +46164,6 @@ var grep_app = {
 
 // src/mcp/index.ts
 var allBuiltinMcps = {
-  websearch_exa,
   context7,
   grep_app
 };
@@ -46279,11 +46324,12 @@ function createConfigHandler(deps) {
         agentConfig["OpenCode-Builder"] = openCodeBuilderOverride ? { ...openCodeBuilderBase, ...openCodeBuilderOverride } : openCodeBuilderBase;
       }
       if (plannerEnabled) {
-        const { name: _planName, ...planConfigWithoutName } = configAgent?.plan ?? {};
+        const { name: _planName, mode: _planMode, ...planConfigWithoutName } = configAgent?.plan ?? {};
         const migratedPlanConfig = migrateAgentConfig(planConfigWithoutName);
         const plannerSisyphusOverride = pluginConfig.agents?.["Planner-Sisyphus"];
+        const defaultModel = config3.model;
         const plannerSisyphusBase = {
-          ...migratedPlanConfig,
+          model: migratedPlanConfig.model ?? defaultModel,
           mode: "primary",
           prompt: PLAN_SYSTEM_PROMPT,
           permission: PLAN_PERMISSION,
@@ -46303,7 +46349,7 @@ function createConfigHandler(deps) {
         value ? migrateAgentConfig(value) : value
       ])) : {};
       const migratedBuild = configAgent?.build ? migrateAgentConfig(configAgent.build) : {};
-      const planDemoteConfig = replacePlan ? { disable: true } : undefined;
+      const planDemoteConfig = replacePlan ? { mode: "subagent", hidden: true } : undefined;
       config3.agent = {
         ...agentConfig,
         ...Object.fromEntries(Object.entries(builtinAgents).filter(([k]) => k !== "Sisyphus")),
@@ -46362,15 +46408,28 @@ function createConfigHandler(deps) {
       ...pluginComponents.mcpServers
     };
     const builtinCommands = loadBuiltinCommands(pluginConfig.disabled_commands);
-    const userCommands = pluginConfig.claude_code?.commands ?? true ? loadUserCommands() : {};
-    const opencodeGlobalCommands = loadOpencodeGlobalCommands();
     const systemCommands = config3.command ?? {};
-    const projectCommands = pluginConfig.claude_code?.commands ?? true ? loadProjectCommands() : {};
-    const opencodeProjectCommands = loadOpencodeProjectCommands();
-    const userSkills = pluginConfig.claude_code?.skills ?? true ? loadUserSkills() : {};
-    const projectSkills = pluginConfig.claude_code?.skills ?? true ? loadProjectSkills() : {};
-    const opencodeGlobalSkills = loadOpencodeGlobalSkills();
-    const opencodeProjectSkills = loadOpencodeProjectSkills();
+    const includeClaudeCommands = pluginConfig.claude_code?.commands ?? true;
+    const includeClaudeSkills = pluginConfig.claude_code?.skills ?? true;
+    const [
+      userCommands,
+      projectCommands,
+      opencodeGlobalCommands,
+      opencodeProjectCommands,
+      userSkills,
+      projectSkills,
+      opencodeGlobalSkills,
+      opencodeProjectSkills
+    ] = await Promise.all([
+      includeClaudeCommands ? loadUserCommands() : Promise.resolve({}),
+      includeClaudeCommands ? loadProjectCommands() : Promise.resolve({}),
+      loadOpencodeGlobalCommands(),
+      loadOpencodeProjectCommands(),
+      includeClaudeSkills ? loadUserSkills() : Promise.resolve({}),
+      includeClaudeSkills ? loadProjectSkills() : Promise.resolve({}),
+      loadOpencodeGlobalSkills(),
+      loadOpencodeProjectSkills()
+    ]);
     config3.command = {
       ...builtinCommands,
       ...userCommands,
@@ -46463,10 +46522,10 @@ var OhMyOpenCodePlugin = async (ctx) => {
   });
   const includeClaudeSkills = pluginConfig.claude_code?.skills !== false;
   const [userSkills, globalSkills, projectSkills, opencodeProjectSkills] = await Promise.all([
-    includeClaudeSkills ? discoverUserClaudeSkillsAsync() : Promise.resolve([]),
-    discoverOpencodeGlobalSkillsAsync(),
-    includeClaudeSkills ? discoverProjectClaudeSkillsAsync() : Promise.resolve([]),
-    discoverOpencodeProjectSkillsAsync()
+    includeClaudeSkills ? discoverUserClaudeSkills() : Promise.resolve([]),
+    discoverOpencodeGlobalSkills(),
+    includeClaudeSkills ? discoverProjectClaudeSkills() : Promise.resolve([]),
+    discoverOpencodeProjectSkills()
   ]);
   const mergedSkills = mergeSkills(builtinSkills, pluginConfig.skills, userSkills, globalSkills, projectSkills, opencodeProjectSkills);
   const skillMcpManager = new SkillMcpManager;
@@ -46481,6 +46540,11 @@ var OhMyOpenCodePlugin = async (ctx) => {
     getLoadedSkills: () => mergedSkills,
     getSessionID: getSessionIDForMcp
   });
+  const commands2 = discoverCommandsSync();
+  const slashcommandTool = createSlashcommandTool({
+    commands: commands2,
+    skills: mergedSkills
+  });
   const googleAuthHooks = pluginConfig.google_auth !== false ? await createGoogleAntigravityAuthPlugin(ctx) : null;
   const configHandler = createConfigHandler({
     ctx,
@@ -46496,9 +46560,13 @@ var OhMyOpenCodePlugin = async (ctx) => {
       look_at: lookAt,
       skill: skillTool,
       skill_mcp: skillMcpTool,
+      slashcommand: slashcommandTool,
       interactive_bash
     },
     "chat.message": async (input, output) => {
+      if (input.agent === "Sisyphus") {
+        output.message.variant = "max";
+      }
       await claudeCodeHooks["chat.message"]?.(input, output);
       await keywordDetector?.["chat.message"]?.(input, output);
       await contextInjector["chat.message"]?.(input, output);