oh-my-opencode 2.12.4 → 2.13.1

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}
+
+</ultrawork-mode>
 
-## TODO IS YOUR LIFELINE (NON-NEGOTIABLE)
+---
+
+`;
+  }
+  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.
+
+[CODE RED] Maximum precision required. Ultrathink before acting.
+
+YOU MUST LEVERAGE ALL AVAILABLE AGENTS TO THEIR FULLEST POTENTIAL.
+TELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.
 
-**USE TodoWrite OBSESSIVELY. This is the #1 most important tool.**
+## 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
 
-### 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]"
+## 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.
 
-### 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"
+## 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
 
-**YOUR WORK IS INVISIBLE WITHOUT TODOs. USE THEM.**
+## VERIFICATION GUARANTEE (NON-NEGOTIABLE)
 
-## TDD WORKFLOW (MANDATORY when tests exist)
+**NOTHING is "done" without PROOF it works.**
 
-Check for test infrastructure FIRST. If exists, follow strictly:
+### Pre-Implementation: Define Success Criteria
 
-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
+BEFORE writing ANY code, you MUST define:
 
-**NEVER write implementation before test. NEVER delete failing tests.**
+| 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" |
 
-## AGENT DEPLOYMENT
+Write these criteria explicitly. Share with user if scope is non-trivial.
 
-Fire available agents in PARALLEL via background tasks. Use explore/librarian agents liberally (multiple concurrent if needed).
+### Test Plan Template (MANDATORY for non-trivial tasks)
 
-## EVIDENCE-BASED ANSWERS
+\`\`\`
+## 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]
+\`\`\`
 
-- 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"
+### Execution & Evidence Requirements
 
-## ZERO TOLERANCE FOR SHORTCUTS (RIGOROUS & HONEST EXECUTION)
+| 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 |
 
-**CORE PRINCIPLE**: Execute user's ORIGINAL INTENT with maximum rigor. No shortcuts. No compromises. No matter how large the task.
+**WITHOUT evidence = NOT verified = NOT done.**
 
-### 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. |
+### TDD Workflow (when test infrastructure exists)
 
-### 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.
+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
 
-### 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"
+### 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
@@ -45614,6 +45667,632 @@ This will:
 
 Check if a loop is active and cancel it. Inform the user of the result.`;
 
+// src/features/builtin-commands/templates/refactor.ts
+var REFACTOR_TEMPLATE = `# Intelligent Refactor Command
+
+## Usage
+\`\`\`
+/refactor <refactoring-target> [--scope=<file|module|project>] [--strategy=<safe|aggressive>]
+
+Arguments:
+  refactoring-target: What to refactor. Can be:
+    - File path: src/auth/handler.ts
+    - Symbol name: "AuthService class"
+    - Pattern: "all functions using deprecated API"
+    - Description: "extract validation logic into separate module"
+
+Options:
+  --scope: Refactoring scope (default: module)
+    - file: Single file only
+    - module: Module/directory scope
+    - project: Entire codebase
+
+  --strategy: Risk tolerance (default: safe)
+    - safe: Conservative, maximum test coverage required
+    - aggressive: Allow broader changes with adequate coverage
+\`\`\`
+
+## What This Command Does
+
+Performs intelligent, deterministic refactoring with full codebase awareness. Unlike blind search-and-replace, this command:
+
+1. **Understands your intent** - Analyzes what you actually want to achieve
+2. **Maps the codebase** - Builds a definitive codemap before touching anything
+3. **Assesses risk** - Evaluates test coverage and determines verification strategy
+4. **Plans meticulously** - Creates a detailed plan with Plan agent
+5. **Executes precisely** - Step-by-step refactoring with LSP and AST-grep
+6. **Verifies constantly** - Runs tests after each change to ensure zero regression
+
+---
+
+# PHASE 0: INTENT GATE (MANDATORY FIRST STEP)
+
+**BEFORE ANY ACTION, classify and validate the request.**
+
+## Step 0.1: Parse Request Type
+
+| Signal | Classification | Action |
+|--------|----------------|--------|
+| Specific file/symbol | Explicit | Proceed to codebase analysis |
+| "Refactor X to Y" | Clear transformation | Proceed to codebase analysis |
+| "Improve", "Clean up" | Open-ended | **MUST ask**: "What specific improvement?" |
+| Ambiguous scope | Uncertain | **MUST ask**: "Which modules/files?" |
+| Missing context | Incomplete | **MUST ask**: "What's the desired outcome?" |
+
+## Step 0.2: Validate Understanding
+
+Before proceeding, confirm:
+- [ ] Target is clearly identified
+- [ ] Desired outcome is understood
+- [ ] Scope is defined (file/module/project)
+- [ ] Success criteria can be articulated
+
+**If ANY of above is unclear, ASK CLARIFYING QUESTION:**
+
+\`\`\`
+I want to make sure I understand the refactoring goal correctly.
+
+**What I understood**: [interpretation]
+**What I'm unsure about**: [specific ambiguity]
+
+Options I see:
+1. [Option A] - [implications]
+2. [Option B] - [implications]
+
+**My recommendation**: [suggestion with reasoning]
+
+Should I proceed with [recommendation], or would you prefer differently?
+\`\`\`
+
+## Step 0.3: Create Initial Todos
+
+**IMMEDIATELY after understanding the request, create todos:**
+
+\`\`\`
+TodoWrite([
+  {"id": "phase-1", "content": "PHASE 1: Codebase Analysis - launch parallel explore agents", "status": "pending", "priority": "high"},
+  {"id": "phase-2", "content": "PHASE 2: Build Codemap - map dependencies and impact zones", "status": "pending", "priority": "high"},
+  {"id": "phase-3", "content": "PHASE 3: Test Assessment - analyze test coverage and verification strategy", "status": "pending", "priority": "high"},
+  {"id": "phase-4", "content": "PHASE 4: Plan Generation - invoke Plan agent for detailed refactoring plan", "status": "pending", "priority": "high"},
+  {"id": "phase-5", "content": "PHASE 5: Execute Refactoring - step-by-step with continuous verification", "status": "pending", "priority": "high"},
+  {"id": "phase-6", "content": "PHASE 6: Final Verification - full test suite and regression check", "status": "pending", "priority": "high"}
+])
+\`\`\`
+
+---
+
+# PHASE 1: CODEBASE ANALYSIS (PARALLEL EXPLORATION)
+
+**Mark phase-1 as in_progress.**
+
+## 1.1: Launch Parallel Explore Agents (BACKGROUND)
+
+Fire ALL of these simultaneously using \`call_omo_agent\`:
+
+\`\`\`
+// Agent 1: Find the refactoring target
+call_omo_agent(
+  subagent_type="explore",
+  run_in_background=true,
+  prompt="Find all occurrences and definitions of [TARGET]. 
+  Report: file paths, line numbers, usage patterns."
+)
+
+// Agent 2: Find related code
+call_omo_agent(
+  subagent_type="explore", 
+  run_in_background=true,
+  prompt="Find all code that imports, uses, or depends on [TARGET].
+  Report: dependency chains, import graphs."
+)
+
+// Agent 3: Find similar patterns
+call_omo_agent(
+  subagent_type="explore",
+  run_in_background=true,
+  prompt="Find similar code patterns to [TARGET] in the codebase.
+  Report: analogous implementations, established conventions."
+)
+
+// Agent 4: Find tests
+call_omo_agent(
+  subagent_type="explore",
+  run_in_background=true,
+  prompt="Find all test files related to [TARGET].
+  Report: test file paths, test case names, coverage indicators."
+)
+
+// Agent 5: Architecture context
+call_omo_agent(
+  subagent_type="explore",
+  run_in_background=true,
+  prompt="Find architectural patterns and module organization around [TARGET].
+  Report: module boundaries, layer structure, design patterns in use."
+)
+\`\`\`
+
+## 1.2: Direct Tool Exploration (WHILE AGENTS RUN)
+
+While background agents are running, use direct tools:
+
+### LSP Tools for Precise Analysis:
+
+\`\`\`typescript
+// Get symbol information at target location
+lsp_hover(filePath, line, character)  // Type info, docs, signatures
+
+// Find definition(s)
+lsp_goto_definition(filePath, line, character)  // Where is it defined?
+
+// Find ALL usages across workspace
+lsp_find_references(filePath, line, character, includeDeclaration=true)
+
+// Get file structure
+lsp_document_symbols(filePath)  // Hierarchical outline
+
+// Search symbols by name
+lsp_workspace_symbols(filePath, query="[target_symbol]")
+
+// Get current diagnostics
+lsp_diagnostics(filePath)  // Errors, warnings before we start
+\`\`\`
+
+### AST-Grep for Pattern Analysis:
+
+\`\`\`typescript
+// Find structural patterns
+ast_grep_search(
+  pattern="function $NAME($$$) { $$$ }",  // or relevant pattern
+  lang="typescript",  // or relevant language
+  paths=["src/"]
+)
+
+// Preview refactoring (DRY RUN)
+ast_grep_replace(
+  pattern="[old_pattern]",
+  rewrite="[new_pattern]",
+  lang="[language]",
+  dryRun=true  // ALWAYS preview first
+)
+\`\`\`
+
+### Grep for Text Patterns:
+
+\`\`\`
+grep(pattern="[search_term]", path="src/", include="*.ts")
+\`\`\`
+
+## 1.3: Collect Background Results
+
+\`\`\`
+background_output(task_id="[agent_1_id]")
+background_output(task_id="[agent_2_id]")
+...
+\`\`\`
+
+**Mark phase-1 as completed after all results collected.**
+
+---
+
+# PHASE 2: BUILD CODEMAP (DEPENDENCY MAPPING)
+
+**Mark phase-2 as in_progress.**
+
+## 2.1: Construct Definitive Codemap
+
+Based on Phase 1 results, build:
+
+\`\`\`
+## CODEMAP: [TARGET]
+
+### Core Files (Direct Impact)
+- \`path/to/file.ts:L10-L50\` - Primary definition
+- \`path/to/file2.ts:L25\` - Key usage
+
+### Dependency Graph
+\`\`\`
+[TARGET] 
+\u251C\u2500\u2500 imports from: 
+\u2502   \u251C\u2500\u2500 module-a (types)
+\u2502   \u2514\u2500\u2500 module-b (utils)
+\u251C\u2500\u2500 imported by:
+\u2502   \u251C\u2500\u2500 consumer-1.ts
+\u2502   \u251C\u2500\u2500 consumer-2.ts
+\u2502   \u2514\u2500\u2500 consumer-3.ts
+\u2514\u2500\u2500 used by:
+    \u251C\u2500\u2500 handler.ts (direct call)
+    \u2514\u2500\u2500 service.ts (dependency injection)
+\`\`\`
+
+### Impact Zones
+| Zone | Risk Level | Files Affected | Test Coverage |
+|------|------------|----------------|---------------|
+| Core | HIGH | 3 files | 85% covered |
+| Consumers | MEDIUM | 8 files | 70% covered |
+| Edge | LOW | 2 files | 50% covered |
+
+### Established Patterns
+- Pattern A: [description] - used in N places
+- Pattern B: [description] - established convention
+\`\`\`
+
+## 2.2: Identify Refactoring Constraints
+
+Based on codemap:
+- **MUST follow**: [existing patterns identified]
+- **MUST NOT break**: [critical dependencies]
+- **Safe to change**: [isolated code zones]
+- **Requires migration**: [breaking changes impact]
+
+**Mark phase-2 as completed.**
+
+---
+
+# PHASE 3: TEST ASSESSMENT (VERIFICATION STRATEGY)
+
+**Mark phase-3 as in_progress.**
+
+## 3.1: Detect Test Infrastructure
+
+\`\`\`bash
+# Check for test commands
+cat package.json | jq '.scripts | keys[] | select(test("test"))'
+
+# Or for Python
+ls -la pytest.ini pyproject.toml setup.cfg
+
+# Or for Go
+ls -la *_test.go
+\`\`\`
+
+## 3.2: Analyze Test Coverage
+
+\`\`\`
+// Find all tests related to target
+call_omo_agent(
+  subagent_type="explore",
+  run_in_background=false,  // Need this synchronously
+  prompt="Analyze test coverage for [TARGET]:
+  1. Which test files cover this code?
+  2. What test cases exist?
+  3. Are there integration tests?
+  4. What edge cases are tested?
+  5. Estimated coverage percentage?"
+)
+\`\`\`
+
+## 3.3: Determine Verification Strategy
+
+Based on test analysis:
+
+| Coverage Level | Strategy |
+|----------------|----------|
+| HIGH (>80%) | Run existing tests after each step |
+| MEDIUM (50-80%) | Run tests + add safety assertions |
+| LOW (<50%) | **PAUSE**: Propose adding tests first |
+| NONE | **BLOCK**: Refuse aggressive refactoring |
+
+**If coverage is LOW or NONE, ask user:**
+
+\`\`\`
+Test coverage for [TARGET] is [LEVEL].
+
+**Risk Assessment**: Refactoring without adequate tests is dangerous.
+
+Options:
+1. Add tests first, then refactor (RECOMMENDED)
+2. Proceed with extra caution, manual verification required
+3. Abort refactoring
+
+Which approach do you prefer?
+\`\`\`
+
+## 3.4: Document Verification Plan
+
+\`\`\`
+## VERIFICATION PLAN
+
+### Test Commands
+- Unit: \`bun test\` / \`npm test\` / \`pytest\` / etc.
+- Integration: [command if exists]
+- Type check: \`tsc --noEmit\` / \`pyright\` / etc.
+
+### Verification Checkpoints
+After each refactoring step:
+1. lsp_diagnostics \u2192 zero new errors
+2. Run test command \u2192 all pass
+3. Type check \u2192 clean
+
+### Regression Indicators
+- [Specific test that must pass]
+- [Behavior that must be preserved]
+- [API contract that must not change]
+\`\`\`
+
+**Mark phase-3 as completed.**
+
+---
+
+# PHASE 4: PLAN GENERATION (PLAN AGENT)
+
+**Mark phase-4 as in_progress.**
+
+## 4.1: Invoke Plan Agent
+
+\`\`\`
+Task(
+  subagent_type="plan",
+  prompt="Create a detailed refactoring plan:
+
+  ## Refactoring Goal
+  [User's original request]
+
+  ## Codemap (from Phase 2)
+  [Insert codemap here]
+
+  ## Test Coverage (from Phase 3)
+  [Insert verification plan here]
+
+  ## Constraints
+  - MUST follow existing patterns: [list]
+  - MUST NOT break: [critical paths]
+  - MUST run tests after each step
+
+  ## Requirements
+  1. Break down into atomic refactoring steps
+  2. Each step must be independently verifiable
+  3. Order steps by dependency (what must happen first)
+  4. Specify exact files and line ranges for each step
+  5. Include rollback strategy for each step
+  6. Define commit checkpoints"
+)
+\`\`\`
+
+## 4.2: Review and Validate Plan
+
+After receiving plan from Plan agent:
+
+1. **Verify completeness**: All identified files addressed?
+2. **Verify safety**: Each step reversible?
+3. **Verify order**: Dependencies respected?
+4. **Verify verification**: Test commands specified?
+
+## 4.3: Register Detailed Todos
+
+Convert Plan agent output into granular todos:
+
+\`\`\`
+TodoWrite([
+  // Each step from the plan becomes a todo
+  {"id": "refactor-1", "content": "Step 1: [description]", "status": "pending", "priority": "high"},
+  {"id": "verify-1", "content": "Verify Step 1: run tests", "status": "pending", "priority": "high"},
+  {"id": "refactor-2", "content": "Step 2: [description]", "status": "pending", "priority": "medium"},
+  {"id": "verify-2", "content": "Verify Step 2: run tests", "status": "pending", "priority": "medium"},
+  // ... continue for all steps
+])
+\`\`\`
+
+**Mark phase-4 as completed.**
+
+---
+
+# PHASE 5: EXECUTE REFACTORING (DETERMINISTIC EXECUTION)
+
+**Mark phase-5 as in_progress.**
+
+## 5.1: Execution Protocol
+
+For EACH refactoring step:
+
+### Pre-Step
+1. Mark step todo as \`in_progress\`
+2. Read current file state
+3. Verify lsp_diagnostics is baseline
+
+### Execute Step
+Use appropriate tool:
+
+**For Symbol Renames:**
+\`\`\`typescript
+lsp_prepare_rename(filePath, line, character)  // Validate rename is possible
+lsp_rename(filePath, line, character, newName)  // Execute rename
+\`\`\`
+
+**For Pattern Transformations:**
+\`\`\`typescript
+// Preview first
+ast_grep_replace(pattern, rewrite, lang, dryRun=true)
+
+// If preview looks good, execute
+ast_grep_replace(pattern, rewrite, lang, dryRun=false)
+\`\`\`
+
+**For Structural Changes:**
+\`\`\`typescript
+// Use Edit tool for precise changes
+edit(filePath, oldString, newString)
+\`\`\`
+
+### Post-Step Verification (MANDATORY)
+
+\`\`\`typescript
+// 1. Check diagnostics
+lsp_diagnostics(filePath)  // Must be clean or same as baseline
+
+// 2. Run tests
+bash("bun test")  // Or appropriate test command
+
+// 3. Type check
+bash("tsc --noEmit")  // Or appropriate type check
+\`\`\`
+
+### Step Completion
+1. If verification passes \u2192 Mark step todo as \`completed\`
+2. If verification fails \u2192 **STOP AND FIX**
+
+## 5.2: Failure Recovery Protocol
+
+If ANY verification fails:
+
+1. **STOP** immediately
+2. **REVERT** the failed change
+3. **DIAGNOSE** what went wrong
+4. **OPTIONS**:
+   - Fix the issue and retry
+   - Skip this step (if optional)
+   - Consult oracle agent for help
+   - Ask user for guidance
+
+**NEVER proceed to next step with broken tests.**
+
+## 5.3: Commit Checkpoints
+
+After each logical group of changes:
+
+\`\`\`bash
+git add [changed-files]
+git commit -m "refactor(scope): description
+
+[details of what was changed and why]"
+\`\`\`
+
+**Mark phase-5 as completed when all refactoring steps done.**
+
+---
+
+# PHASE 6: FINAL VERIFICATION (REGRESSION CHECK)
+
+**Mark phase-6 as in_progress.**
+
+## 6.1: Full Test Suite
+
+\`\`\`bash
+# Run complete test suite
+bun test  # or npm test, pytest, go test, etc.
+\`\`\`
+
+## 6.2: Type Check
+
+\`\`\`bash
+# Full type check
+tsc --noEmit  # or equivalent
+\`\`\`
+
+## 6.3: Lint Check
+
+\`\`\`bash
+# Run linter
+eslint .  # or equivalent
+\`\`\`
+
+## 6.4: Build Verification (if applicable)
+
+\`\`\`bash
+# Ensure build still works
+bun run build  # or npm run build, etc.
+\`\`\`
+
+## 6.5: Final Diagnostics
+
+\`\`\`typescript
+// Check all changed files
+for (file of changedFiles) {
+  lsp_diagnostics(file)  // Must all be clean
+}
+\`\`\`
+
+## 6.6: Generate Summary
+
+\`\`\`markdown
+## Refactoring Complete
+
+### What Changed
+- [List of changes made]
+
+### Files Modified
+- \`path/to/file.ts\` - [what changed]
+- \`path/to/file2.ts\` - [what changed]
+
+### Verification Results
+- Tests: PASSED (X/Y passing)
+- Type Check: CLEAN
+- Lint: CLEAN
+- Build: SUCCESS
+
+### No Regressions Detected
+All existing tests pass. No new errors introduced.
+\`\`\`
+
+**Mark phase-6 as completed.**
+
+---
+
+# CRITICAL RULES
+
+## NEVER DO
+- Skip lsp_diagnostics check after changes
+- Proceed with failing tests
+- Make changes without understanding impact
+- Use \`as any\`, \`@ts-ignore\`, \`@ts-expect-error\`
+- Delete tests to make them pass
+- Commit broken code
+- Refactor without understanding existing patterns
+
+## ALWAYS DO
+- Understand before changing
+- Preview before applying (ast_grep dryRun=true)
+- Verify after every change
+- Follow existing codebase patterns
+- Keep todos updated in real-time
+- Commit at logical checkpoints
+- Report issues immediately
+
+## ABORT CONDITIONS
+If any of these occur, **STOP and consult user**:
+- Test coverage is zero for target code
+- Changes would break public API
+- Refactoring scope is unclear
+- 3 consecutive verification failures
+- User-defined constraints violated
+
+---
+
+# Tool Usage Philosophy
+
+You already know these tools. Use them intelligently:
+
+## LSP Tools
+Leverage the full LSP toolset (\`lsp_*\`) for precision analysis. Key patterns:
+- **Understand before changing**: \`lsp_hover\`, \`lsp_goto_definition\` to grasp context
+- **Impact analysis**: \`lsp_find_references\` to map all usages before modification
+- **Safe refactoring**: \`lsp_prepare_rename\` \u2192 \`lsp_rename\` for symbol renames
+- **Continuous verification**: \`lsp_diagnostics\` after every change
+
+## AST-Grep
+Use \`ast_grep_search\` and \`ast_grep_replace\` for structural transformations.
+**Critical**: Always \`dryRun=true\` first, review, then execute.
+
+## Agents
+- \`explore\`: Parallel codebase pattern discovery
+- \`plan\`: Detailed refactoring plan generation
+- \`oracle\`: Consult for complex architectural decisions
+- \`librarian\`: **Use proactively** when encountering deprecated methods or library migration tasks. Query official docs and OSS examples for modern replacements.
+
+## Deprecated Code & Library Migration
+When you encounter deprecated methods/APIs during refactoring:
+1. Fire \`librarian\` to find the recommended modern alternative
+2. **DO NOT auto-upgrade to latest version** unless user explicitly requests migration
+3. If user requests library migration, use \`librarian\` to fetch latest API docs before making changes
+
+---
+
+**Remember: Refactoring without tests is reckless. Refactoring without understanding is destructive. This command ensures you do neither.**
+
+<user-request>
+$ARGUMENTS
+</user-request>
+`;
+
 // src/features/builtin-commands/commands.ts
 var BUILTIN_COMMAND_DEFINITIONS = {
   "init-deep": {
@@ -45643,6 +46322,13 @@ $ARGUMENTS
     template: `<command-instruction>
 ${CANCEL_RALPH_TEMPLATE}
 </command-instruction>`
+  },
+  refactor: {
+    description: "(builtin) Intelligent refactoring command with LSP, AST-grep, architecture analysis, codemap, and TDD verification.",
+    template: `<command-instruction>
+${REFACTOR_TEMPLATE}
+</command-instruction>`,
+    argumentHint: "<refactoring-target> [--scope=<file|module|project>] [--strategy=<safe|aggressive>]"
   }
 };
 function loadBuiltinCommands(disabledCommands) {
@@ -45657,7 +46343,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 +46358,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 +46369,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 +46414,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 +46450,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 +46465,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 +46482,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 +46533,7 @@ function discoverInstalledPlugins(options) {
       continue;
     }
     const { installPath, scope, version: version2 } = installation;
-    if (!existsSync52(installPath)) {
+    if (!existsSync50(installPath)) {
       errors3.push({
         pluginKey,
         installPath,
@@ -45865,21 +46551,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 +46576,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 +46586,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 +46618,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 +46629,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 +46679,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 +46689,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 +46715,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 +46747,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 +46781,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 +46797,6 @@ var grep_app = {
 
 // src/mcp/index.ts
 var allBuiltinMcps = {
-  websearch_exa,
   context7,
   grep_app
 };
@@ -46243,17 +46921,9 @@ function createConfigHandler(deps) {
       log(`Plugin load errors`, { errors: pluginComponents.errors });
     }
     const builtinAgents = createBuiltinAgents(pluginConfig.disabled_agents, pluginConfig.agents, ctx.directory, config3.model);
-    const rawUserAgents = pluginConfig.claude_code?.agents ?? true ? loadUserAgents() : {};
-    const rawProjectAgents = pluginConfig.claude_code?.agents ?? true ? loadProjectAgents() : {};
+    const userAgents = pluginConfig.claude_code?.agents ?? true ? loadUserAgents() : {};
+    const projectAgents = pluginConfig.claude_code?.agents ?? true ? loadProjectAgents() : {};
     const rawPluginAgents = pluginComponents.agents;
-    const userAgents = Object.fromEntries(Object.entries(rawUserAgents).map(([k, v]) => [
-      k,
-      v ? migrateAgentConfig(v) : v
-    ]));
-    const projectAgents = Object.fromEntries(Object.entries(rawProjectAgents).map(([k, v]) => [
-      k,
-      v ? migrateAgentConfig(v) : v
-    ]));
     const pluginAgents = Object.fromEntries(Object.entries(rawPluginAgents).map(([k, v]) => [
       k,
       v ? migrateAgentConfig(v) : v
@@ -46285,7 +46955,7 @@ function createConfigHandler(deps) {
         const defaultModel = config3.model;
         const plannerSisyphusBase = {
           model: migratedPlanConfig.model ?? defaultModel,
-          mode: "all",
+          mode: "primary",
           prompt: PLAN_SYSTEM_PROMPT,
           permission: PLAN_PERMISSION,
           description: `${configAgent?.plan?.description ?? "Plan agent"} (OhMyOpenCode version)`,
@@ -46363,15 +47033,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,
@@ -46464,10 +47147,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;
@@ -46482,6 +47165,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,
@@ -46497,6 +47185,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
       look_at: lookAt,
       skill: skillTool,
       skill_mcp: skillMcpTool,
+      slashcommand: slashcommandTool,
       interactive_bash
     },
     "chat.message": async (input, output) => {