oh-my-opencode 2.7.2 → 2.8.0

package/dist/index.js

@@ -6406,7 +6406,7 @@ function createEmptyTaskResponseDetectorHook(_ctx) {
     }
   };
 }
-// src/hooks/anthropic-auto-compact/parser.ts
+// src/hooks/anthropic-context-window-limit-recovery/parser.ts
 var TOKEN_LIMIT_PATTERNS = [
   /(\d+)\s*tokens?\s*>\s*(\d+)\s*maximum/i,
   /prompt.*?(\d+).*?tokens.*?exceeds.*?(\d+)/i,
@@ -6571,7 +6571,7 @@ function parseAnthropicTokenLimitError(err) {
   return null;
 }
 
-// src/hooks/anthropic-auto-compact/types.ts
+// src/hooks/anthropic-context-window-limit-recovery/types.ts
 var RETRY_CONFIG = {
   maxAttempts: 2,
   initialDelayMs: 2000,
@@ -6589,17 +6589,17 @@ var TRUNCATE_CONFIG = {
   charsPerToken: 4
 };
 
-// src/hooks/anthropic-auto-compact/pruning-deduplication.ts
+// src/hooks/anthropic-context-window-limit-recovery/pruning-deduplication.ts
 import { existsSync as existsSync15, readdirSync as readdirSync4, readFileSync as readFileSync9 } from "fs";
 import { join as join20 } from "path";
 
-// src/hooks/anthropic-auto-compact/pruning-types.ts
+// src/hooks/anthropic-context-window-limit-recovery/pruning-types.ts
 var CHARS_PER_TOKEN = 4;
 function estimateTokens2(text) {
   return Math.ceil(text.length / CHARS_PER_TOKEN);
 }
 
-// src/hooks/anthropic-auto-compact/pruning-deduplication.ts
+// src/hooks/anthropic-context-window-limit-recovery/pruning-deduplication.ts
 function createToolSignature(toolName, input) {
   const sortedInput = sortObject(input);
   return `${toolName}::${JSON.stringify(sortedInput)}`;
@@ -6734,7 +6734,7 @@ function findToolOutput(messages, callID) {
   return null;
 }
 
-// src/hooks/anthropic-auto-compact/pruning-supersede.ts
+// src/hooks/anthropic-context-window-limit-recovery/pruning-supersede.ts
 import { existsSync as existsSync16, readdirSync as readdirSync5, readFileSync as readFileSync10 } from "fs";
 import { join as join21 } from "path";
 function getMessageDir4(sessionID) {
@@ -6896,7 +6896,7 @@ function findToolInput(messages, callID) {
   return null;
 }
 
-// src/hooks/anthropic-auto-compact/pruning-purge-errors.ts
+// src/hooks/anthropic-context-window-limit-recovery/pruning-purge-errors.ts
 import { existsSync as existsSync17, readdirSync as readdirSync6, readFileSync as readFileSync11 } from "fs";
 import { join as join22 } from "path";
 function getMessageDir5(sessionID) {
@@ -7001,7 +7001,7 @@ function executePurgeErrors(sessionID, state2, config, protectedTools) {
   return prunedCount;
 }
 
-// src/hooks/anthropic-auto-compact/pruning-storage.ts
+// src/hooks/anthropic-context-window-limit-recovery/pruning-storage.ts
 import { existsSync as existsSync18, readdirSync as readdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync5 } from "fs";
 import { join as join23 } from "path";
 function getMessageDir6(sessionID) {
@@ -7070,7 +7070,7 @@ async function applyPruning(sessionID, state2) {
   return totalTokensSaved;
 }
 
-// src/hooks/anthropic-auto-compact/pruning-executor.ts
+// src/hooks/anthropic-context-window-limit-recovery/pruning-executor.ts
 var DEFAULT_PROTECTED_TOOLS = new Set([
   "task",
   "todowrite",
@@ -7151,7 +7151,7 @@ async function executeDynamicContextPruning(sessionID, config, client) {
   return result;
 }
 
-// src/hooks/anthropic-auto-compact/storage.ts
+// src/hooks/anthropic-context-window-limit-recovery/storage.ts
 import { existsSync as existsSync19, readdirSync as readdirSync8, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
 import { join as join24 } from "path";
 var OPENCODE_STORAGE5 = getOpenCodeStorageDir();
@@ -7293,7 +7293,7 @@ function truncateUntilTargetTokens(sessionID, currentTokens, maxTokens, targetRa
   };
 }
 
-// src/hooks/anthropic-auto-compact/executor.ts
+// src/hooks/anthropic-context-window-limit-recovery/executor.ts
 var PLACEHOLDER_TEXT = "[user interrupted]";
 function getOrCreateRetryState(autoCompactState, sessionID) {
   let state2 = autoCompactState.retryStateBySession.get(sessionID);
@@ -7492,7 +7492,7 @@ async function fixEmptyMessages(sessionID, autoCompactState, client, messageInde
   }
   return fixed;
 }
-async function executeCompact(sessionID, msg, autoCompactState, client, directory, experimental) {
+async function executeCompact(sessionID, msg, autoCompactState, client, directory, experimental, dcpForCompaction) {
   if (autoCompactState.compactionInProgress.has(sessionID)) {
     await client.tui.showToast({
       body: {
@@ -7509,14 +7509,14 @@ async function executeCompact(sessionID, msg, autoCompactState, client, director
     const errorData = autoCompactState.errorDataBySession.get(sessionID);
     const truncateState = getOrCreateTruncateState(autoCompactState, sessionID);
     const dcpState = getOrCreateDcpState(autoCompactState, sessionID);
-    if (experimental?.dcp_for_compaction && !dcpState.attempted && errorData?.currentTokens && errorData?.maxTokens && errorData.currentTokens > errorData.maxTokens) {
+    if (dcpForCompaction !== false && !dcpState.attempted && errorData?.currentTokens && errorData?.maxTokens && errorData.currentTokens > errorData.maxTokens) {
       dcpState.attempted = true;
       log("[auto-compact] DCP triggered FIRST on token limit error", {
         sessionID,
         currentTokens: errorData.currentTokens,
         maxTokens: errorData.maxTokens
       });
-      const dcpConfig = experimental.dynamic_context_pruning ?? {
+      const dcpConfig = experimental?.dynamic_context_pruning ?? {
         enabled: true,
         notification: "detailed",
         protected_tools: ["task", "todowrite", "todoread", "lsp_rename", "lsp_code_action_resolve"]
@@ -7677,7 +7677,7 @@ async function executeCompact(sessionID, msg, autoCompactState, client, director
         const fixed = await fixEmptyMessages(sessionID, autoCompactState, client, errorData.messageIndex);
         if (fixed) {
           setTimeout(() => {
-            executeCompact(sessionID, msg, autoCompactState, client, directory, experimental);
+            executeCompact(sessionID, msg, autoCompactState, client, directory, experimental, dcpForCompaction);
           }, 500);
           return;
         }
@@ -7733,7 +7733,7 @@ async function executeCompact(sessionID, msg, autoCompactState, client, director
           const delay = RETRY_CONFIG.initialDelayMs * Math.pow(RETRY_CONFIG.backoffFactor, retryState.attempt - 1);
           const cappedDelay = Math.min(delay, RETRY_CONFIG.maxDelayMs);
           setTimeout(() => {
-            executeCompact(sessionID, msg, autoCompactState, client, directory, experimental);
+            executeCompact(sessionID, msg, autoCompactState, client, directory, experimental, dcpForCompaction);
           }, cappedDelay);
           return;
         }
@@ -7812,8 +7812,8 @@ async function executeCompact(sessionID, msg, autoCompactState, client, director
   }
 }
 
-// src/hooks/anthropic-auto-compact/index.ts
-function createAutoCompactState() {
+// src/hooks/anthropic-context-window-limit-recovery/index.ts
+function createRecoveryState() {
   return {
     pendingCompact: new Set,
     errorDataBySession: new Map,
@@ -7825,9 +7825,10 @@ function createAutoCompactState() {
     compactionInProgress: new Set
   };
 }
-function createAnthropicAutoCompactHook(ctx, options) {
-  const autoCompactState = createAutoCompactState();
+function createAnthropicContextWindowLimitRecoveryHook(ctx, options) {
+  const autoCompactState = createRecoveryState();
   const experimental = options?.experimental;
+  const dcpForCompaction = options?.dcpForCompaction;
   const eventHandler = async ({ event }) => {
     const props = event.properties;
     if (event.type === "session.deleted") {
@@ -7869,7 +7870,7 @@ function createAnthropicAutoCompactHook(ctx, options) {
           }
         }).catch(() => {});
         setTimeout(() => {
-          executeCompact(sessionID, { providerID, modelID }, autoCompactState, ctx.client, ctx.directory, experimental);
+          executeCompact(sessionID, { providerID, modelID }, autoCompactState, ctx.client, ctx.directory, experimental, dcpForCompaction);
         }, 300);
       }
       return;
@@ -7912,7 +7913,7 @@ function createAnthropicAutoCompactHook(ctx, options) {
           duration: 3000
         }
       }).catch(() => {});
-      await executeCompact(sessionID, { providerID, modelID }, autoCompactState, ctx.client, ctx.directory, experimental);
+      await executeCompact(sessionID, { providerID, modelID }, autoCompactState, ctx.client, ctx.directory, experimental, dcpForCompaction);
     }
   };
   return {
@@ -8263,43 +8264,45 @@ function extractPromptText(parts) {
 }
 
 // src/hooks/think-mode/switcher.ts
+function normalizeModelID(modelID) {
+  return modelID.replace(/\.(\d+)/g, "-$1");
+}
+function resolveProvider(providerID, modelID) {
+  if (providerID === "github-copilot") {
+    const modelLower = modelID.toLowerCase();
+    if (modelLower.includes("claude"))
+      return "anthropic";
+    if (modelLower.includes("gemini"))
+      return "google";
+    if (modelLower.includes("gpt") || modelLower.includes("o1") || modelLower.includes("o3")) {
+      return "openai";
+    }
+  }
+  return providerID;
+}
 var HIGH_VARIANT_MAP = {
   "claude-sonnet-4-5": "claude-sonnet-4-5-high",
   "claude-opus-4-5": "claude-opus-4-5-high",
   "gemini-3-pro": "gemini-3-pro-high",
   "gemini-3-pro-low": "gemini-3-pro-high",
+  "gemini-3-pro-preview": "gemini-3-pro-preview-high",
+  "gemini-3-flash": "gemini-3-flash-high",
+  "gemini-3-flash-preview": "gemini-3-flash-preview-high",
   "gpt-5": "gpt-5-high",
   "gpt-5-mini": "gpt-5-mini-high",
   "gpt-5-nano": "gpt-5-nano-high",
   "gpt-5-pro": "gpt-5-pro-high",
   "gpt-5-chat-latest": "gpt-5-chat-latest-high",
-  "gpt-5.1": "gpt-5.1-high",
-  "gpt-5.1-chat-latest": "gpt-5.1-chat-latest-high",
-  "gpt-5.1-codex": "gpt-5.1-codex-high",
-  "gpt-5.1-codex-mini": "gpt-5.1-codex-mini-high",
-  "gpt-5.1-codex-max": "gpt-5.1-codex-max-high",
-  "gpt-5.2": "gpt-5.2-high",
-  "gpt-5.2-chat-latest": "gpt-5.2-chat-latest-high",
-  "gpt-5.2-pro": "gpt-5.2-pro-high"
+  "gpt-5-1": "gpt-5-1-high",
+  "gpt-5-1-chat-latest": "gpt-5-1-chat-latest-high",
+  "gpt-5-1-codex": "gpt-5-1-codex-high",
+  "gpt-5-1-codex-mini": "gpt-5-1-codex-mini-high",
+  "gpt-5-1-codex-max": "gpt-5-1-codex-max-high",
+  "gpt-5-2": "gpt-5-2-high",
+  "gpt-5-2-chat-latest": "gpt-5-2-chat-latest-high",
+  "gpt-5-2-pro": "gpt-5-2-pro-high"
 };
-var ALREADY_HIGH = new Set([
-  "claude-sonnet-4-5-high",
-  "claude-opus-4-5-high",
-  "gemini-3-pro-high",
-  "gpt-5-high",
-  "gpt-5-mini-high",
-  "gpt-5-nano-high",
-  "gpt-5-pro-high",
-  "gpt-5-chat-latest-high",
-  "gpt-5.1-high",
-  "gpt-5.1-chat-latest-high",
-  "gpt-5.1-codex-high",
-  "gpt-5.1-codex-mini-high",
-  "gpt-5.1-codex-max-high",
-  "gpt-5.2-high",
-  "gpt-5.2-chat-latest-high",
-  "gpt-5.2-pro-high"
-]);
+var ALREADY_HIGH = new Set(Object.values(HIGH_VARIANT_MAP));
 var THINKING_CONFIGS = {
   anthropic: {
     thinking: {
@@ -8332,33 +8335,44 @@ var THINKING_CONFIGS = {
         }
       }
     }
+  },
+  openai: {
+    reasoning_effort: "high"
   }
 };
 var THINKING_CAPABLE_MODELS = {
   anthropic: ["claude-sonnet-4", "claude-opus-4", "claude-3"],
   "amazon-bedrock": ["claude", "anthropic"],
   google: ["gemini-2", "gemini-3"],
-  "google-vertex": ["gemini-2", "gemini-3"]
+  "google-vertex": ["gemini-2", "gemini-3"],
+  openai: ["gpt-5", "o1", "o3"]
 };
 function getHighVariant(modelID) {
-  if (ALREADY_HIGH.has(modelID)) {
+  const normalized = normalizeModelID(modelID);
+  if (ALREADY_HIGH.has(normalized)) {
     return null;
   }
-  return HIGH_VARIANT_MAP[modelID] ?? null;
+  return HIGH_VARIANT_MAP[normalized] ?? null;
 }
 function isAlreadyHighVariant(modelID) {
-  return ALREADY_HIGH.has(modelID) || modelID.endsWith("-high");
+  const normalized = normalizeModelID(modelID);
+  return ALREADY_HIGH.has(normalized) || normalized.endsWith("-high");
+}
+function isThinkingProvider(provider) {
+  return provider in THINKING_CONFIGS;
 }
 function getThinkingConfig(providerID, modelID) {
-  if (isAlreadyHighVariant(modelID)) {
+  const normalized = normalizeModelID(modelID);
+  if (isAlreadyHighVariant(normalized)) {
     return null;
   }
-  const config = THINKING_CONFIGS[providerID];
-  const capablePatterns = THINKING_CAPABLE_MODELS[providerID];
-  if (!config || !capablePatterns) {
+  const resolvedProvider = resolveProvider(providerID, modelID);
+  if (!isThinkingProvider(resolvedProvider)) {
     return null;
   }
-  const modelLower = modelID.toLowerCase();
+  const config = THINKING_CONFIGS[resolvedProvider];
+  const capablePatterns = THINKING_CAPABLE_MODELS[resolvedProvider];
+  const modelLower = normalized.toLowerCase();
   const isCapable = capablePatterns.some((pattern) => modelLower.includes(pattern.toLowerCase()));
   return isCapable ? config : null;
 }
@@ -11125,6 +11139,297 @@ function createThinkingBlockValidatorHook() {
     }
   };
 }
+// src/hooks/ralph-loop/index.ts
+import { existsSync as existsSync31, readFileSync as readFileSync21 } from "fs";
+
+// src/hooks/ralph-loop/storage.ts
+import { existsSync as existsSync30, readFileSync as readFileSync20, writeFileSync as writeFileSync13, unlinkSync as unlinkSync9, mkdirSync as mkdirSync10 } from "fs";
+import { dirname as dirname6, join as join40 } from "path";
+
+// src/hooks/ralph-loop/constants.ts
+var HOOK_NAME3 = "ralph-loop";
+var DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md";
+var DEFAULT_MAX_ITERATIONS = 100;
+var DEFAULT_COMPLETION_PROMISE = "DONE";
+
+// src/hooks/ralph-loop/storage.ts
+function getStateFilePath(directory, customPath) {
+  return customPath ? join40(directory, customPath) : join40(directory, DEFAULT_STATE_FILE);
+}
+function readState(directory, customPath) {
+  const filePath = getStateFilePath(directory, customPath);
+  if (!existsSync30(filePath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync20(filePath, "utf-8");
+    const { data, body } = parseFrontmatter(content);
+    const active = data.active;
+    const iteration = data.iteration;
+    if (active === undefined || iteration === undefined) {
+      return null;
+    }
+    const isActive = active === true || active === "true";
+    const iterationNum = typeof iteration === "number" ? iteration : Number(iteration);
+    if (isNaN(iterationNum)) {
+      return null;
+    }
+    const stripQuotes = (val) => {
+      const str = String(val ?? "");
+      return str.replace(/^["']|["']$/g, "");
+    };
+    return {
+      active: isActive,
+      iteration: iterationNum,
+      max_iterations: Number(data.max_iterations) || DEFAULT_MAX_ITERATIONS,
+      completion_promise: stripQuotes(data.completion_promise) || DEFAULT_COMPLETION_PROMISE,
+      started_at: stripQuotes(data.started_at) || new Date().toISOString(),
+      prompt: body.trim(),
+      session_id: data.session_id ? stripQuotes(data.session_id) : undefined
+    };
+  } catch {
+    return null;
+  }
+}
+function writeState(directory, state2, customPath) {
+  const filePath = getStateFilePath(directory, customPath);
+  try {
+    const dir = dirname6(filePath);
+    if (!existsSync30(dir)) {
+      mkdirSync10(dir, { recursive: true });
+    }
+    const sessionIdLine = state2.session_id ? `session_id: "${state2.session_id}"
+` : "";
+    const content = `---
+active: ${state2.active}
+iteration: ${state2.iteration}
+max_iterations: ${state2.max_iterations}
+completion_promise: "${state2.completion_promise}"
+started_at: "${state2.started_at}"
+${sessionIdLine}---
+${state2.prompt}
+`;
+    writeFileSync13(filePath, content, "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function clearState(directory, customPath) {
+  const filePath = getStateFilePath(directory, customPath);
+  try {
+    if (existsSync30(filePath)) {
+      unlinkSync9(filePath);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function incrementIteration(directory, customPath) {
+  const state2 = readState(directory, customPath);
+  if (!state2)
+    return null;
+  state2.iteration += 1;
+  if (writeState(directory, state2, customPath)) {
+    return state2;
+  }
+  return null;
+}
+
+// src/hooks/ralph-loop/index.ts
+var CONTINUATION_PROMPT2 = `[RALPH LOOP - ITERATION {{ITERATION}}/{{MAX}}]
+
+Your previous attempt did not output the completion promise. Continue working on the task.
+
+IMPORTANT:
+- Review your progress so far
+- Continue from where you left off  
+- When FULLY complete, output: <promise>{{PROMISE}}</promise>
+- Do not stop until the task is truly done
+
+Original task:
+{{PROMPT}}`;
+function createRalphLoopHook(ctx, options) {
+  const sessions = new Map;
+  const config = options?.config;
+  const stateDir = config?.state_dir;
+  function getSessionState(sessionID) {
+    let state2 = sessions.get(sessionID);
+    if (!state2) {
+      state2 = {};
+      sessions.set(sessionID, state2);
+    }
+    return state2;
+  }
+  function detectCompletionPromise(transcriptPath, promise) {
+    if (!transcriptPath)
+      return false;
+    try {
+      if (!existsSync31(transcriptPath))
+        return false;
+      const content = readFileSync21(transcriptPath, "utf-8");
+      const pattern = new RegExp(`<promise>\\s*${escapeRegex(promise)}\\s*</promise>`, "is");
+      return pattern.test(content);
+    } catch {
+      return false;
+    }
+  }
+  function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  const startLoop = (sessionID, prompt, loopOptions) => {
+    const state2 = {
+      active: true,
+      iteration: 1,
+      max_iterations: loopOptions?.maxIterations ?? config?.default_max_iterations ?? DEFAULT_MAX_ITERATIONS,
+      completion_promise: loopOptions?.completionPromise ?? DEFAULT_COMPLETION_PROMISE,
+      started_at: new Date().toISOString(),
+      prompt,
+      session_id: sessionID
+    };
+    const success = writeState(ctx.directory, state2, stateDir);
+    if (success) {
+      log(`[${HOOK_NAME3}] Loop started`, {
+        sessionID,
+        maxIterations: state2.max_iterations,
+        completionPromise: state2.completion_promise
+      });
+    }
+    return success;
+  };
+  const cancelLoop = (sessionID) => {
+    const state2 = readState(ctx.directory, stateDir);
+    if (!state2 || state2.session_id !== sessionID) {
+      return false;
+    }
+    const success = clearState(ctx.directory, stateDir);
+    if (success) {
+      log(`[${HOOK_NAME3}] Loop cancelled`, { sessionID, iteration: state2.iteration });
+    }
+    return success;
+  };
+  const getState = () => {
+    return readState(ctx.directory, stateDir);
+  };
+  const event = async ({
+    event: event2
+  }) => {
+    const props = event2.properties;
+    if (event2.type === "session.idle") {
+      const sessionID = props?.sessionID;
+      if (!sessionID)
+        return;
+      const sessionState = getSessionState(sessionID);
+      if (sessionState.isRecovering) {
+        log(`[${HOOK_NAME3}] Skipped: in recovery`, { sessionID });
+        return;
+      }
+      const state2 = readState(ctx.directory, stateDir);
+      if (!state2 || !state2.active) {
+        return;
+      }
+      if (state2.session_id && state2.session_id !== sessionID) {
+        return;
+      }
+      const transcriptPath = props?.transcriptPath;
+      if (detectCompletionPromise(transcriptPath, state2.completion_promise)) {
+        log(`[${HOOK_NAME3}] Completion detected!`, {
+          sessionID,
+          iteration: state2.iteration,
+          promise: state2.completion_promise
+        });
+        clearState(ctx.directory, stateDir);
+        await ctx.client.tui.showToast({
+          body: {
+            title: "Ralph Loop Complete!",
+            message: `Task completed after ${state2.iteration} iteration(s)`,
+            variant: "success",
+            duration: 5000
+          }
+        }).catch(() => {});
+        return;
+      }
+      if (state2.iteration >= state2.max_iterations) {
+        log(`[${HOOK_NAME3}] Max iterations reached`, {
+          sessionID,
+          iteration: state2.iteration,
+          max: state2.max_iterations
+        });
+        clearState(ctx.directory, stateDir);
+        await ctx.client.tui.showToast({
+          body: {
+            title: "Ralph Loop Stopped",
+            message: `Max iterations (${state2.max_iterations}) reached without completion`,
+            variant: "warning",
+            duration: 5000
+          }
+        }).catch(() => {});
+        return;
+      }
+      const newState = incrementIteration(ctx.directory, stateDir);
+      if (!newState) {
+        log(`[${HOOK_NAME3}] Failed to increment iteration`, { sessionID });
+        return;
+      }
+      log(`[${HOOK_NAME3}] Continuing loop`, {
+        sessionID,
+        iteration: newState.iteration,
+        max: newState.max_iterations
+      });
+      const continuationPrompt = CONTINUATION_PROMPT2.replace("{{ITERATION}}", String(newState.iteration)).replace("{{MAX}}", String(newState.max_iterations)).replace("{{PROMISE}}", newState.completion_promise).replace("{{PROMPT}}", newState.prompt);
+      await ctx.client.tui.showToast({
+        body: {
+          title: "Ralph Loop",
+          message: `Iteration ${newState.iteration}/${newState.max_iterations}`,
+          variant: "info",
+          duration: 2000
+        }
+      }).catch(() => {});
+      try {
+        await ctx.client.session.prompt({
+          path: { id: sessionID },
+          body: {
+            parts: [{ type: "text", text: continuationPrompt }]
+          },
+          query: { directory: ctx.directory }
+        });
+      } catch (err) {
+        log(`[${HOOK_NAME3}] Failed to inject continuation`, {
+          sessionID,
+          error: String(err)
+        });
+      }
+    }
+    if (event2.type === "session.deleted") {
+      const sessionInfo = props?.info;
+      if (sessionInfo?.id) {
+        const state2 = readState(ctx.directory, stateDir);
+        if (state2?.session_id === sessionInfo.id) {
+          clearState(ctx.directory, stateDir);
+          log(`[${HOOK_NAME3}] Session deleted, loop cleared`, { sessionID: sessionInfo.id });
+        }
+        sessions.delete(sessionInfo.id);
+      }
+    }
+    if (event2.type === "session.error") {
+      const sessionID = props?.sessionID;
+      if (sessionID) {
+        const sessionState = getSessionState(sessionID);
+        sessionState.isRecovering = true;
+        setTimeout(() => {
+          sessionState.isRecovering = false;
+        }, 5000);
+      }
+    }
+  };
+  return {
+    event,
+    startLoop,
+    cancelLoop,
+    getState
+  };
+}
 // src/auth/antigravity/constants.ts
 var ANTIGRAVITY_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
 var ANTIGRAVITY_CLIENT_SECRET = "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";
@@ -12955,10 +13260,10 @@ async function createGoogleAntigravityAuthPlugin({
   };
 }
 // src/features/claude-code-command-loader/loader.ts
-import { existsSync as existsSync30, readdirSync as readdirSync11, readFileSync as readFileSync20 } from "fs";
-import { join as join40, basename } from "path";
+import { existsSync as existsSync32, readdirSync as readdirSync11, readFileSync as readFileSync22 } from "fs";
+import { join as join41, basename } from "path";
 function loadCommandsFromDir(commandsDir, scope) {
-  if (!existsSync30(commandsDir)) {
+  if (!existsSync32(commandsDir)) {
     return [];
   }
   const entries = readdirSync11(commandsDir, { withFileTypes: true });
@@ -12966,10 +13271,10 @@ function loadCommandsFromDir(commandsDir, scope) {
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join40(commandsDir, entry.name);
+    const commandPath = join41(commandsDir, entry.name);
     const commandName = basename(entry.name, ".md");
     try {
-      const content = readFileSync20(commandPath, "utf-8");
+      const content = readFileSync22(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const wrappedTemplate = `<command-instruction>
 ${body.trim()}
@@ -13009,23 +13314,23 @@ function commandsToRecord(commands) {
   return result;
 }
 function loadUserCommands() {
-  const userCommandsDir = join40(getClaudeConfigDir(), "commands");
+  const userCommandsDir = join41(getClaudeConfigDir(), "commands");
   const commands = loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands);
 }
 function loadProjectCommands() {
-  const projectCommandsDir = join40(process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join41(process.cwd(), ".claude", "commands");
   const commands = loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands);
 }
 function loadOpencodeGlobalCommands() {
   const { homedir: homedir9 } = __require("os");
-  const opencodeCommandsDir = join40(homedir9(), ".config", "opencode", "command");
+  const opencodeCommandsDir = join41(homedir9(), ".config", "opencode", "command");
   const commands = loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands);
 }
 function loadOpencodeProjectCommands() {
-  const opencodeProjectDir = join40(process.cwd(), ".opencode", "command");
+  const opencodeProjectDir = join41(process.cwd(), ".opencode", "command");
   const commands = loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands);
 }
@@ -13425,6 +13730,45 @@ Hierarchy:
 - **LSP without fallback**: Always have explore agent backup if LSP unavailable
 - **Over-referencing**: Don't trace refs for EVERY symbol - focus on exports only`;
 
+// src/features/builtin-commands/templates/ralph-loop.ts
+var RALPH_LOOP_TEMPLATE = `You are starting a Ralph Loop - a self-referential development loop that runs until task completion.
+
+## How Ralph Loop Works
+
+1. You will work on the task continuously
+2. When you believe the task is FULLY complete, output: \`<promise>{{COMPLETION_PROMISE}}</promise>\`
+3. If you don't output the promise, the loop will automatically inject another prompt to continue
+4. Maximum iterations: Configurable (default 100)
+
+## Rules
+
+- Focus on completing the task fully, not partially
+- Don't output the completion promise until the task is truly done
+- Each iteration should make meaningful progress toward the goal
+- If stuck, try different approaches
+- Use todos to track your progress
+
+## Exit Conditions
+
+1. **Completion**: Output \`<promise>DONE</promise>\` (or custom promise text) when fully complete
+2. **Max Iterations**: Loop stops automatically at limit
+3. **Cancel**: User runs \`/cancel-ralph\` command
+
+## Your Task
+
+Parse the arguments below and begin working on the task. The format is:
+\`"task description" [--completion-promise=TEXT] [--max-iterations=N]\`
+
+Default completion promise is "DONE" and default max iterations is 100.`;
+var CANCEL_RALPH_TEMPLATE = `Cancel the currently active Ralph Loop.
+
+This will:
+1. Stop the loop from continuing
+2. Clear the loop state file
+3. Allow the session to end normally
+
+Check if a loop is active and cancel it. Inform the user of the result.`;
+
 // src/features/builtin-commands/commands.ts
 var BUILTIN_COMMAND_DEFINITIONS = {
   "init-deep": {
@@ -13437,6 +13781,23 @@ ${INIT_DEEP_TEMPLATE}
 $ARGUMENTS
 </user-request>`,
     argumentHint: "[--create-new] [--max-depth=N]"
+  },
+  "ralph-loop": {
+    description: "(builtin) Start self-referential development loop until completion",
+    template: `<command-instruction>
+${RALPH_LOOP_TEMPLATE}
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+    argumentHint: '"task description" [--completion-promise=TEXT] [--max-iterations=N]'
+  },
+  "cancel-ralph": {
+    description: "(builtin) Cancel active Ralph Loop",
+    template: `<command-instruction>
+${CANCEL_RALPH_TEMPLATE}
+</command-instruction>`
   }
 };
 function loadBuiltinCommands(disabledCommands) {
@@ -13452,9 +13813,373 @@ function loadBuiltinCommands(disabledCommands) {
   }
   return commands;
 }
+// src/features/opencode-skill-loader/loader.ts
+import { existsSync as existsSync33, readdirSync as readdirSync12, readFileSync as readFileSync23 } from "fs";
+import { join as join42, basename as basename2 } from "path";
+import { homedir as homedir9 } from "os";
+function parseAllowedTools(allowedTools) {
+  if (!allowedTools)
+    return;
+  return allowedTools.split(/\s+/).filter(Boolean);
+}
+function loadSkillFromPath(skillPath, resolvedPath, defaultName, scope) {
+  try {
+    const content = readFileSync23(skillPath, "utf-8");
+    const { data, body } = parseFrontmatter(content);
+    const skillName = data.name || defaultName;
+    const originalDescription = data.description || "";
+    const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
+    const formattedDescription = `(${scope} - Skill) ${originalDescription}`;
+    const wrappedTemplate = `<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>`;
+    const definition = {
+      name: skillName,
+      description: formattedDescription,
+      template: wrappedTemplate,
+      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"])
+    };
+  } catch {
+    return null;
+  }
+}
+function loadSkillsFromDir(skillsDir, scope) {
+  if (!existsSync33(skillsDir)) {
+    return [];
+  }
+  const entries = readdirSync12(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 (existsSync33(skillMdPath)) {
+        const skill = loadSkillFromPath(skillMdPath, resolvedPath, dirName, scope);
+        if (skill)
+          skills.push(skill);
+        continue;
+      }
+      const namedSkillMdPath = join42(resolvedPath, `${dirName}.md`);
+      if (existsSync33(namedSkillMdPath)) {
+        const skill = loadSkillFromPath(namedSkillMdPath, resolvedPath, dirName, scope);
+        if (skill)
+          skills.push(skill);
+        continue;
+      }
+      continue;
+    }
+    if (isMarkdownFile(entry)) {
+      const skillName = basename2(entry.name, ".md");
+      const skill = loadSkillFromPath(entryPath, skillsDir, skillName, scope);
+      if (skill)
+        skills.push(skill);
+    }
+  }
+  return skills;
+}
+function skillsToRecord(skills) {
+  const result = {};
+  for (const skill of skills) {
+    result[skill.name] = skill.definition;
+  }
+  return result;
+}
+function loadUserSkills() {
+  const userSkillsDir = join42(getClaudeConfigDir(), "skills");
+  const skills = loadSkillsFromDir(userSkillsDir, "user");
+  return skillsToRecord(skills);
+}
+function loadProjectSkills() {
+  const projectSkillsDir = join42(process.cwd(), ".claude", "skills");
+  const skills = loadSkillsFromDir(projectSkillsDir, "project");
+  return skillsToRecord(skills);
+}
+function loadOpencodeGlobalSkills() {
+  const opencodeSkillsDir = join42(homedir9(), ".config", "opencode", "skill");
+  const skills = loadSkillsFromDir(opencodeSkillsDir, "opencode");
+  return skillsToRecord(skills);
+}
+function loadOpencodeProjectSkills() {
+  const opencodeProjectDir = join42(process.cwd(), ".opencode", "skill");
+  const skills = 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(homedir9(), ".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");
+  return [...opencodeProjectSkills, ...projectSkills, ...opencodeGlobalSkills, ...userSkills];
+}
+function discoverSkills(options = {}) {
+  const { includeClaudeCodePaths = true } = options;
+  const opencodeProjectDir = join42(process.cwd(), ".opencode", "skill");
+  const opencodeGlobalDir = join42(homedir9(), ".config", "opencode", "skill");
+  const opencodeProjectSkills = loadSkillsFromDir(opencodeProjectDir, "opencode-project");
+  const opencodeGlobalSkills = loadSkillsFromDir(opencodeGlobalDir, "opencode");
+  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");
+  return [...opencodeProjectSkills, ...projectSkills, ...opencodeGlobalSkills, ...userSkills];
+}
+function discoverUserClaudeSkills() {
+  const userSkillsDir = join42(getClaudeConfigDir(), "skills");
+  return loadSkillsFromDir(userSkillsDir, "user");
+}
+function discoverProjectClaudeSkills() {
+  const projectSkillsDir = join42(process.cwd(), ".claude", "skills");
+  return loadSkillsFromDir(projectSkillsDir, "project");
+}
+function discoverOpencodeGlobalSkills() {
+  const opencodeSkillsDir = join42(homedir9(), ".config", "opencode", "skill");
+  return loadSkillsFromDir(opencodeSkillsDir, "opencode");
+}
+function discoverOpencodeProjectSkills() {
+  const opencodeProjectDir = join42(process.cwd(), ".opencode", "skill");
+  return loadSkillsFromDir(opencodeProjectDir, "opencode-project");
+}
+// src/features/opencode-skill-loader/merger.ts
+import { readFileSync as readFileSync24, existsSync as existsSync34 } from "fs";
+import { dirname as dirname8, resolve as resolve5, isAbsolute as isAbsolute2 } from "path";
+import { homedir as homedir10 } from "os";
+var SCOPE_PRIORITY = {
+  builtin: 1,
+  config: 2,
+  user: 3,
+  opencode: 4,
+  project: 5,
+  "opencode-project": 6
+};
+function builtinToLoaded(builtin) {
+  const definition = {
+    name: builtin.name,
+    description: `(builtin - Skill) ${builtin.description}`,
+    template: builtin.template,
+    model: builtin.model,
+    agent: builtin.agent,
+    subtask: builtin.subtask,
+    argumentHint: builtin.argumentHint
+  };
+  return {
+    name: builtin.name,
+    definition,
+    scope: "builtin",
+    license: builtin.license,
+    compatibility: builtin.compatibility,
+    metadata: builtin.metadata,
+    allowedTools: builtin.allowedTools
+  };
+}
+function resolveFilePath2(from, configDir) {
+  let filePath = from;
+  if (filePath.startsWith("{file:") && filePath.endsWith("}")) {
+    filePath = filePath.slice(6, -1);
+  }
+  if (filePath.startsWith("~/")) {
+    return resolve5(homedir10(), filePath.slice(2));
+  }
+  if (isAbsolute2(filePath)) {
+    return filePath;
+  }
+  const baseDir = configDir || process.cwd();
+  return resolve5(baseDir, filePath);
+}
+function loadSkillFromFile(filePath) {
+  try {
+    if (!existsSync34(filePath))
+      return null;
+    const content = readFileSync24(filePath, "utf-8");
+    const { data, body } = parseFrontmatter(content);
+    return { template: body, metadata: data };
+  } catch {
+    return null;
+  }
+}
+function configEntryToLoaded(name, entry, configDir) {
+  let template = entry.template || "";
+  let fileMetadata = {};
+  if (entry.from) {
+    const filePath = resolveFilePath2(entry.from, configDir);
+    const loaded = loadSkillFromFile(filePath);
+    if (loaded) {
+      template = loaded.template;
+      fileMetadata = loaded.metadata;
+    } else {
+      return null;
+    }
+  }
+  if (!template && !entry.from) {
+    return null;
+  }
+  const description = entry.description || fileMetadata.description || "";
+  const resolvedPath = entry.from ? dirname8(resolveFilePath2(entry.from, configDir)) : configDir || process.cwd();
+  const wrappedTemplate = `<skill-instruction>
+Base directory for this skill: ${resolvedPath}/
+File references (@path) in this skill are relative to this directory.
+
+${template.trim()}
+</skill-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`;
+  const definition = {
+    name,
+    description: `(config - Skill) ${description}`,
+    template: wrappedTemplate,
+    model: sanitizeModelField(entry.model || fileMetadata.model, "opencode"),
+    agent: entry.agent || fileMetadata.agent,
+    subtask: entry.subtask ?? fileMetadata.subtask,
+    argumentHint: entry["argument-hint"] || fileMetadata["argument-hint"]
+  };
+  const allowedTools = entry["allowed-tools"] || (fileMetadata["allowed-tools"] ? fileMetadata["allowed-tools"].split(/\s+/).filter(Boolean) : undefined);
+  return {
+    name,
+    path: entry.from ? resolveFilePath2(entry.from, configDir) : undefined,
+    resolvedPath,
+    definition,
+    scope: "config",
+    license: entry.license || fileMetadata.license,
+    compatibility: entry.compatibility || fileMetadata.compatibility,
+    metadata: entry.metadata || fileMetadata.metadata,
+    allowedTools
+  };
+}
+function normalizeConfig(config) {
+  if (!config) {
+    return { sources: [], enable: [], disable: [], entries: {} };
+  }
+  if (Array.isArray(config)) {
+    return { sources: [], enable: config, disable: [], entries: {} };
+  }
+  const { sources = [], enable = [], disable = [], ...entries } = config;
+  return { sources, enable, disable, entries };
+}
+function mergeSkillDefinitions(base, patch) {
+  const mergedMetadata = base.metadata || patch.metadata ? deepMerge(base.metadata || {}, patch.metadata || {}) : undefined;
+  const mergedTools = base.allowedTools || patch["allowed-tools"] ? [...base.allowedTools || [], ...patch["allowed-tools"] || []] : undefined;
+  const description = patch.description || base.definition.description?.replace(/^\([^)]+\) /, "");
+  return {
+    ...base,
+    definition: {
+      ...base.definition,
+      description: `(${base.scope} - Skill) ${description}`,
+      model: patch.model || base.definition.model,
+      agent: patch.agent || base.definition.agent,
+      subtask: patch.subtask ?? base.definition.subtask,
+      argumentHint: patch["argument-hint"] || base.definition.argumentHint
+    },
+    license: patch.license || base.license,
+    compatibility: patch.compatibility || base.compatibility,
+    metadata: mergedMetadata,
+    allowedTools: mergedTools ? [...new Set(mergedTools)] : undefined
+  };
+}
+function mergeSkills(builtinSkills, config, userClaudeSkills, userOpencodeSkills, projectClaudeSkills, projectOpencodeSkills, options = {}) {
+  const skillMap = new Map;
+  for (const builtin of builtinSkills) {
+    const loaded = builtinToLoaded(builtin);
+    skillMap.set(loaded.name, loaded);
+  }
+  const normalizedConfig = normalizeConfig(config);
+  for (const [name, entry] of Object.entries(normalizedConfig.entries)) {
+    if (entry === false)
+      continue;
+    if (entry === true)
+      continue;
+    if (entry.disable)
+      continue;
+    const loaded = configEntryToLoaded(name, entry, options.configDir);
+    if (loaded) {
+      const existing = skillMap.get(name);
+      if (existing && !entry.template && !entry.from) {
+        skillMap.set(name, mergeSkillDefinitions(existing, entry));
+      } else {
+        skillMap.set(name, loaded);
+      }
+    }
+  }
+  const fileSystemSkills = [
+    ...userClaudeSkills,
+    ...userOpencodeSkills,
+    ...projectClaudeSkills,
+    ...projectOpencodeSkills
+  ];
+  for (const skill of fileSystemSkills) {
+    const existing = skillMap.get(skill.name);
+    if (!existing || SCOPE_PRIORITY[skill.scope] > SCOPE_PRIORITY[existing.scope]) {
+      skillMap.set(skill.name, skill);
+    }
+  }
+  for (const [name, entry] of Object.entries(normalizedConfig.entries)) {
+    if (entry === true)
+      continue;
+    if (entry === false) {
+      skillMap.delete(name);
+      continue;
+    }
+    if (entry.disable) {
+      skillMap.delete(name);
+      continue;
+    }
+    const existing = skillMap.get(name);
+    if (existing && !entry.template && !entry.from) {
+      skillMap.set(name, mergeSkillDefinitions(existing, entry));
+    }
+  }
+  for (const name of normalizedConfig.disable) {
+    skillMap.delete(name);
+  }
+  if (normalizedConfig.enable.length > 0) {
+    const enableSet = new Set(normalizedConfig.enable);
+    for (const name of skillMap.keys()) {
+      if (!enableSet.has(name)) {
+        skillMap.delete(name);
+      }
+    }
+  }
+  return Array.from(skillMap.values());
+}
+// src/features/builtin-skills/skills.ts
+function createBuiltinSkills() {
+  return [];
+}
 // src/features/claude-code-agent-loader/loader.ts
-import { existsSync as existsSync31, readdirSync as readdirSync12, readFileSync as readFileSync21 } from "fs";
-import { join as join41, basename as basename2 } from "path";
+import { existsSync as existsSync35, readdirSync as readdirSync13, readFileSync as readFileSync25 } from "fs";
+import { join as join43, basename as basename3 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
     return;
@@ -13468,18 +14193,18 @@ function parseToolsConfig(toolsStr) {
   return result;
 }
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync31(agentsDir)) {
+  if (!existsSync35(agentsDir)) {
     return [];
   }
-  const entries = readdirSync12(agentsDir, { withFileTypes: true });
+  const entries = readdirSync13(agentsDir, { withFileTypes: true });
   const agents = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const agentPath = join41(agentsDir, entry.name);
-    const agentName = basename2(entry.name, ".md");
+    const agentPath = join43(agentsDir, entry.name);
+    const agentName = basename3(entry.name, ".md");
     try {
-      const content = readFileSync21(agentPath, "utf-8");
+      const content = readFileSync25(agentPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const name = data.name || agentName;
       const originalDescription = data.description || "";
@@ -13506,7 +14231,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   return agents;
 }
 function loadUserAgents() {
-  const userAgentsDir = join41(getClaudeConfigDir(), "agents");
+  const userAgentsDir = join43(getClaudeConfigDir(), "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user");
   const result = {};
   for (const agent of agents) {
@@ -13515,7 +14240,7 @@ function loadUserAgents() {
   return result;
 }
 function loadProjectAgents() {
-  const projectAgentsDir = join41(process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join43(process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project");
   const result = {};
   for (const agent of agents) {
@@ -13524,8 +14249,8 @@ function loadProjectAgents() {
   return result;
 }
 // src/features/claude-code-mcp-loader/loader.ts
-import { existsSync as existsSync32 } from "fs";
-import { join as join42 } from "path";
+import { existsSync as existsSync36 } from "fs";
+import { join as join44 } from "path";
 
 // src/features/claude-code-mcp-loader/env-expander.ts
 function expandEnvVars(value) {
@@ -13594,13 +14319,13 @@ function getMcpConfigPaths() {
   const claudeConfigDir = getClaudeConfigDir();
   const cwd = process.cwd();
   return [
-    { path: join42(claudeConfigDir, ".mcp.json"), scope: "user" },
-    { path: join42(cwd, ".mcp.json"), scope: "project" },
-    { path: join42(cwd, ".claude", ".mcp.json"), scope: "local" }
+    { path: join44(claudeConfigDir, ".mcp.json"), scope: "user" },
+    { path: join44(cwd, ".mcp.json"), scope: "project" },
+    { path: join44(cwd, ".claude", ".mcp.json"), scope: "local" }
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync32(filePath)) {
+  if (!existsSync36(filePath)) {
     return null;
   }
   try {
@@ -13641,18 +14366,18 @@ async function loadMcpConfigs() {
   return { servers, loadedServers };
 }
 // src/features/claude-code-plugin-loader/loader.ts
-import { existsSync as existsSync33, readdirSync as readdirSync13, readFileSync as readFileSync22 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join43, basename as basename3 } from "path";
+import { existsSync as existsSync37, readdirSync as readdirSync14, readFileSync as readFileSync26 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join45, basename as basename4 } 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 join43(homedir9(), ".claude", "plugins");
+  return join45(homedir11(), ".claude", "plugins");
 }
 function getInstalledPluginsPath() {
-  return join43(getPluginsBaseDir(), "installed_plugins.json");
+  return join45(getPluginsBaseDir(), "installed_plugins.json");
 }
 function resolvePluginPath(path7, pluginRoot) {
   return path7.replace(CLAUDE_PLUGIN_ROOT_VAR, pluginRoot);
@@ -13677,11 +14402,11 @@ function resolvePluginPaths(obj, pluginRoot) {
 }
 function loadInstalledPlugins() {
   const dbPath = getInstalledPluginsPath();
-  if (!existsSync33(dbPath)) {
+  if (!existsSync37(dbPath)) {
     return null;
   }
   try {
-    const content = readFileSync22(dbPath, "utf-8");
+    const content = readFileSync26(dbPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     log("Failed to load installed plugins database", error);
@@ -13692,15 +14417,15 @@ function getClaudeSettingsPath() {
   if (process.env.CLAUDE_SETTINGS_PATH) {
     return process.env.CLAUDE_SETTINGS_PATH;
   }
-  return join43(homedir9(), ".claude", "settings.json");
+  return join45(homedir11(), ".claude", "settings.json");
 }
 function loadClaudeSettings() {
   const settingsPath = getClaudeSettingsPath();
-  if (!existsSync33(settingsPath)) {
+  if (!existsSync37(settingsPath)) {
     return null;
   }
   try {
-    const content = readFileSync22(settingsPath, "utf-8");
+    const content = readFileSync26(settingsPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     log("Failed to load Claude settings", error);
@@ -13708,12 +14433,12 @@ function loadClaudeSettings() {
   }
 }
 function loadPluginManifest(installPath) {
-  const manifestPath = join43(installPath, ".claude-plugin", "plugin.json");
-  if (!existsSync33(manifestPath)) {
+  const manifestPath = join45(installPath, ".claude-plugin", "plugin.json");
+  if (!existsSync37(manifestPath)) {
     return null;
   }
   try {
-    const content = readFileSync22(manifestPath, "utf-8");
+    const content = readFileSync26(manifestPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     log(`Failed to load plugin manifest from ${manifestPath}`, error);
@@ -13760,7 +14485,7 @@ function discoverInstalledPlugins(options) {
       continue;
     }
     const { installPath, scope, version } = installation;
-    if (!existsSync33(installPath)) {
+    if (!existsSync37(installPath)) {
       errors.push({
         pluginKey,
         installPath,
@@ -13778,21 +14503,21 @@ function discoverInstalledPlugins(options) {
       pluginKey,
       manifest: manifest ?? undefined
     };
-    if (existsSync33(join43(installPath, "commands"))) {
-      loadedPlugin.commandsDir = join43(installPath, "commands");
+    if (existsSync37(join45(installPath, "commands"))) {
+      loadedPlugin.commandsDir = join45(installPath, "commands");
     }
-    if (existsSync33(join43(installPath, "agents"))) {
-      loadedPlugin.agentsDir = join43(installPath, "agents");
+    if (existsSync37(join45(installPath, "agents"))) {
+      loadedPlugin.agentsDir = join45(installPath, "agents");
     }
-    if (existsSync33(join43(installPath, "skills"))) {
-      loadedPlugin.skillsDir = join43(installPath, "skills");
+    if (existsSync37(join45(installPath, "skills"))) {
+      loadedPlugin.skillsDir = join45(installPath, "skills");
     }
-    const hooksPath = join43(installPath, "hooks", "hooks.json");
-    if (existsSync33(hooksPath)) {
+    const hooksPath = join45(installPath, "hooks", "hooks.json");
+    if (existsSync37(hooksPath)) {
       loadedPlugin.hooksPath = hooksPath;
     }
-    const mcpPath = join43(installPath, ".mcp.json");
-    if (existsSync33(mcpPath)) {
+    const mcpPath = join45(installPath, ".mcp.json");
+    if (existsSync37(mcpPath)) {
       loadedPlugin.mcpPath = mcpPath;
     }
     plugins.push(loadedPlugin);
@@ -13803,17 +14528,17 @@ function discoverInstalledPlugins(options) {
 function loadPluginCommands(plugins) {
   const commands2 = {};
   for (const plugin2 of plugins) {
-    if (!plugin2.commandsDir || !existsSync33(plugin2.commandsDir))
+    if (!plugin2.commandsDir || !existsSync37(plugin2.commandsDir))
       continue;
-    const entries = readdirSync13(plugin2.commandsDir, { withFileTypes: true });
+    const entries = readdirSync14(plugin2.commandsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const commandPath = join43(plugin2.commandsDir, entry.name);
-      const commandName = basename3(entry.name, ".md");
+      const commandPath = join45(plugin2.commandsDir, entry.name);
+      const commandName = basename4(entry.name, ".md");
       const namespacedName = `${plugin2.name}:${commandName}`;
       try {
-        const content = readFileSync22(commandPath, "utf-8");
+        const content = readFileSync26(commandPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const wrappedTemplate = `<command-instruction>
 ${body.trim()}
@@ -13843,21 +14568,21 @@ $ARGUMENTS
 function loadPluginSkillsAsCommands(plugins) {
   const skills = {};
   for (const plugin2 of plugins) {
-    if (!plugin2.skillsDir || !existsSync33(plugin2.skillsDir))
+    if (!plugin2.skillsDir || !existsSync37(plugin2.skillsDir))
       continue;
-    const entries = readdirSync13(plugin2.skillsDir, { withFileTypes: true });
+    const entries = readdirSync14(plugin2.skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith("."))
         continue;
-      const skillPath = join43(plugin2.skillsDir, entry.name);
+      const skillPath = join45(plugin2.skillsDir, entry.name);
       if (!entry.isDirectory() && !entry.isSymbolicLink())
         continue;
       const resolvedPath = resolveSymlink(skillPath);
-      const skillMdPath = join43(resolvedPath, "SKILL.md");
-      if (!existsSync33(skillMdPath))
+      const skillMdPath = join45(resolvedPath, "SKILL.md");
+      if (!existsSync37(skillMdPath))
         continue;
       try {
-        const content = readFileSync22(skillMdPath, "utf-8");
+        const content = readFileSync26(skillMdPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const skillName = data.name || entry.name;
         const namespacedName = `${plugin2.name}:${skillName}`;
@@ -13902,17 +14627,17 @@ function parseToolsConfig2(toolsStr) {
 function loadPluginAgents(plugins) {
   const agents = {};
   for (const plugin2 of plugins) {
-    if (!plugin2.agentsDir || !existsSync33(plugin2.agentsDir))
+    if (!plugin2.agentsDir || !existsSync37(plugin2.agentsDir))
       continue;
-    const entries = readdirSync13(plugin2.agentsDir, { withFileTypes: true });
+    const entries = readdirSync14(plugin2.agentsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!isMarkdownFile(entry))
         continue;
-      const agentPath = join43(plugin2.agentsDir, entry.name);
-      const agentName = basename3(entry.name, ".md");
+      const agentPath = join45(plugin2.agentsDir, entry.name);
+      const agentName = basename4(entry.name, ".md");
       const namespacedName = `${plugin2.name}:${agentName}`;
       try {
-        const content = readFileSync22(agentPath, "utf-8");
+        const content = readFileSync26(agentPath, "utf-8");
         const { data, body } = parseFrontmatter(content);
         const name = data.name || agentName;
         const originalDescription = data.description || "";
@@ -13938,7 +14663,7 @@ function loadPluginAgents(plugins) {
 async function loadPluginMcpServers(plugins) {
   const servers = {};
   for (const plugin2 of plugins) {
-    if (!plugin2.mcpPath || !existsSync33(plugin2.mcpPath))
+    if (!plugin2.mcpPath || !existsSync37(plugin2.mcpPath))
       continue;
     try {
       const content = await Bun.file(plugin2.mcpPath).text();
@@ -13970,10 +14695,10 @@ async function loadPluginMcpServers(plugins) {
 function loadPluginHooksConfigs(plugins) {
   const configs = [];
   for (const plugin2 of plugins) {
-    if (!plugin2.hooksPath || !existsSync33(plugin2.hooksPath))
+    if (!plugin2.hooksPath || !existsSync37(plugin2.hooksPath))
       continue;
     try {
-      const content = readFileSync22(plugin2.hooksPath, "utf-8");
+      const content = readFileSync26(plugin2.hooksPath, "utf-8");
       let config = JSON.parse(content);
       config = resolvePluginPaths(config, plugin2.installPath);
       configs.push(config);
@@ -14327,14 +15052,14 @@ var EXT_TO_LANG = {
   ".gql": "graphql"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync34, readFileSync as readFileSync23 } from "fs";
-import { join as join44 } from "path";
-import { homedir as homedir10 } from "os";
+import { existsSync as existsSync38, readFileSync as readFileSync27 } from "fs";
+import { join as join46 } from "path";
+import { homedir as homedir12 } from "os";
 function loadJsonFile(path7) {
-  if (!existsSync34(path7))
+  if (!existsSync38(path7))
     return null;
   try {
-    return JSON.parse(readFileSync23(path7, "utf-8"));
+    return JSON.parse(readFileSync27(path7, "utf-8"));
   } catch {
     return null;
   }
@@ -14342,9 +15067,9 @@ function loadJsonFile(path7) {
 function getConfigPaths2() {
   const cwd = process.cwd();
   return {
-    project: join44(cwd, ".opencode", "oh-my-opencode.json"),
-    user: join44(homedir10(), ".config", "opencode", "oh-my-opencode.json"),
-    opencode: join44(homedir10(), ".config", "opencode", "opencode.json")
+    project: join46(cwd, ".opencode", "oh-my-opencode.json"),
+    user: join46(homedir12(), ".config", "opencode", "oh-my-opencode.json"),
+    opencode: join46(homedir12(), ".config", "opencode", "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -14457,7 +15182,7 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    if (existsSync34(cmd))
+    if (existsSync38(cmd))
       return true;
   }
   const isWindows2 = process.platform === "win32";
@@ -14466,21 +15191,21 @@ function isServerInstalled(command) {
   const pathSeparator = isWindows2 ? ";" : ":";
   const paths = pathEnv.split(pathSeparator);
   for (const p of paths) {
-    if (existsSync34(join44(p, cmd)) || existsSync34(join44(p, cmd + ext))) {
+    if (existsSync38(join46(p, cmd)) || existsSync38(join46(p, cmd + ext))) {
       return true;
     }
   }
   const cwd = process.cwd();
   const additionalPaths = [
-    join44(cwd, "node_modules", ".bin", cmd),
-    join44(cwd, "node_modules", ".bin", cmd + ext),
-    join44(homedir10(), ".config", "opencode", "bin", cmd),
-    join44(homedir10(), ".config", "opencode", "bin", cmd + ext),
-    join44(homedir10(), ".config", "opencode", "node_modules", ".bin", cmd),
-    join44(homedir10(), ".config", "opencode", "node_modules", ".bin", cmd + ext)
+    join46(cwd, "node_modules", ".bin", cmd),
+    join46(cwd, "node_modules", ".bin", cmd + ext),
+    join46(homedir12(), ".config", "opencode", "bin", cmd),
+    join46(homedir12(), ".config", "opencode", "bin", cmd + ext),
+    join46(homedir12(), ".config", "opencode", "node_modules", ".bin", cmd),
+    join46(homedir12(), ".config", "opencode", "node_modules", ".bin", cmd + ext)
   ];
   for (const p of additionalPaths) {
-    if (existsSync34(p)) {
+    if (existsSync38(p)) {
       return true;
     }
   }
@@ -14533,8 +15258,8 @@ function getAllServers() {
 }
 // src/tools/lsp/client.ts
 var {spawn: spawn5 } = globalThis.Bun;
-import { readFileSync as readFileSync24 } from "fs";
-import { extname, resolve as resolve5 } from "path";
+import { readFileSync as readFileSync28 } from "fs";
+import { extname, resolve as resolve6 } from "path";
 class LSPServerManager {
   static instance;
   clients = new Map;
@@ -14714,7 +15439,7 @@ class LSPClient {
     }
     this.startReading();
     this.startStderrReading();
-    await new Promise((resolve6) => setTimeout(resolve6, 100));
+    await new Promise((resolve7) => setTimeout(resolve7, 100));
     if (this.proc.exitCode !== null) {
       const stderr = this.stderrBuffer.join(`
 `);
@@ -14851,8 +15576,8 @@ stderr: ${stderr}` : ""));
 \r
 `;
     this.proc.stdin.write(header + msg);
-    return new Promise((resolve6, reject) => {
-      this.pending.set(id, { resolve: resolve6, reject });
+    return new Promise((resolve7, reject) => {
+      this.pending.set(id, { resolve: resolve7, reject });
       setTimeout(() => {
         if (this.pending.has(id)) {
           this.pending.delete(id);
@@ -14960,10 +15685,10 @@ ${msg}`);
     await new Promise((r) => setTimeout(r, 300));
   }
   async openFile(filePath) {
-    const absPath = resolve5(filePath);
+    const absPath = resolve6(filePath);
     if (this.openedFiles.has(absPath))
       return;
-    const text = readFileSync24(absPath, "utf-8");
+    const text = readFileSync28(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     this.notify("textDocument/didOpen", {
@@ -14978,7 +15703,7 @@ ${msg}`);
     await new Promise((r) => setTimeout(r, 1000));
   }
   async hover(filePath, line, character) {
-    const absPath = resolve5(filePath);
+    const absPath = resolve6(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/hover", {
       textDocument: { uri: `file://${absPath}` },
@@ -14986,7 +15711,7 @@ ${msg}`);
     });
   }
   async definition(filePath, line, character) {
-    const absPath = resolve5(filePath);
+    const absPath = resolve6(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/definition", {
       textDocument: { uri: `file://${absPath}` },
@@ -14994,7 +15719,7 @@ ${msg}`);
     });
   }
   async references(filePath, line, character, includeDeclaration = true) {
-    const absPath = resolve5(filePath);
+    const absPath = resolve6(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/references", {
       textDocument: { uri: `file://${absPath}` },
@@ -15003,7 +15728,7 @@ ${msg}`);
     });
   }
   async documentSymbols(filePath) {
-    const absPath = resolve5(filePath);
+    const absPath = resolve6(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/documentSymbol", {
       textDocument: { uri: `file://${absPath}` }
@@ -15013,7 +15738,7 @@ ${msg}`);
     return this.send("workspace/symbol", { query });
   }
   async diagnostics(filePath) {
-    const absPath = resolve5(filePath);
+    const absPath = resolve6(filePath);
     const uri = `file://${absPath}`;
     await this.openFile(absPath);
     await new Promise((r) => setTimeout(r, 500));
@@ -15028,7 +15753,7 @@ ${msg}`);
     return { items: this.diagnosticsStore.get(uri) ?? [] };
   }
   async prepareRename(filePath, line, character) {
-    const absPath = resolve5(filePath);
+    const absPath = resolve6(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/prepareRename", {
       textDocument: { uri: `file://${absPath}` },
@@ -15036,7 +15761,7 @@ ${msg}`);
     });
   }
   async rename(filePath, line, character, newName) {
-    const absPath = resolve5(filePath);
+    const absPath = resolve6(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/rename", {
       textDocument: { uri: `file://${absPath}` },
@@ -15045,7 +15770,7 @@ ${msg}`);
     });
   }
   async codeAction(filePath, startLine, startChar, endLine, endChar, only) {
-    const absPath = resolve5(filePath);
+    const absPath = resolve6(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/codeAction", {
       textDocument: { uri: `file://${absPath}` },
@@ -15077,23 +15802,27 @@ ${msg}`);
   }
 }
 // src/tools/lsp/utils.ts
-import { extname as extname2, resolve as resolve6 } from "path";
-import { existsSync as existsSync35, readFileSync as readFileSync25, writeFileSync as writeFileSync13 } from "fs";
+import { extname as extname2, resolve as resolve7 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { existsSync as existsSync39, readFileSync as readFileSync29, writeFileSync as writeFileSync14 } from "fs";
 function findWorkspaceRoot(filePath) {
-  let dir = resolve6(filePath);
-  if (!existsSync35(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  let dir = resolve7(filePath);
+  if (!existsSync39(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 (existsSync35(__require("path").join(dir, marker))) {
+      if (existsSync39(__require("path").join(dir, marker))) {
         return dir;
       }
     }
     dir = __require("path").dirname(dir);
   }
-  return __require("path").dirname(resolve6(filePath));
+  return __require("path").dirname(resolve7(filePath));
+}
+function uriToPath(uri) {
+  return fileURLToPath2(uri);
 }
 function formatServerLookupError(result) {
   if (result.status === "not_installed") {
@@ -15125,13 +15854,12 @@ function formatServerLookupError(result) {
     `        "command": ["my-lsp", "--stdio"],`,
     `        "extensions": ["${result.extension}"]`,
     `      }`,
-    `    }`,
-    `  }`
+    `    }`
   ].join(`
 `);
 }
 async function withLspClient(filePath, fn) {
-  const absPath = resolve6(filePath);
+  const absPath = resolve7(filePath);
   const ext = extname2(absPath);
   const result = findServerForExtension(ext);
   if (result.status !== "found") {
@@ -15173,12 +15901,12 @@ function formatHoverResult(result) {
 }
 function formatLocation(loc) {
   if ("targetUri" in loc) {
-    const uri2 = loc.targetUri.replace("file://", "");
+    const uri2 = uriToPath(loc.targetUri);
     const line2 = loc.targetRange.start.line + 1;
     const char2 = loc.targetRange.start.character;
     return `${uri2}:${line2}:${char2}`;
   }
-  const uri = loc.uri.replace("file://", "");
+  const uri = uriToPath(loc.uri);
   const line = loc.range.start.line + 1;
   const char = loc.range.start.character;
   return `${uri}:${line}:${char}`;
@@ -15281,7 +16009,7 @@ function formatCodeActions(actions) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync25(filePath, "utf-8");
+    let content = readFileSync29(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -15306,7 +16034,7 @@ function applyTextEditsToFile(filePath, edits) {
 `));
       }
     }
-    writeFileSync13(filePath, lines.join(`
+    writeFileSync14(filePath, lines.join(`
 `), "utf-8");
     return { success: true, editCount: edits.length };
   } catch (err) {
@@ -15320,7 +16048,7 @@ function applyWorkspaceEdit(edit) {
   const result = { success: true, filesModified: [], totalEdits: 0, errors: [] };
   if (edit.changes) {
     for (const [uri, edits] of Object.entries(edit.changes)) {
-      const filePath = uri.replace("file://", "");
+      const filePath = uriToPath(uri);
       const applyResult = applyTextEditsToFile(filePath, edits);
       if (applyResult.success) {
         result.filesModified.push(filePath);
@@ -15336,8 +16064,8 @@ function applyWorkspaceEdit(edit) {
       if ("kind" in change) {
         if (change.kind === "create") {
           try {
-            const filePath = change.uri.replace("file://", "");
-            writeFileSync13(filePath, "", "utf-8");
+            const filePath = uriToPath(change.uri);
+            writeFileSync14(filePath, "", "utf-8");
             result.filesModified.push(filePath);
           } catch (err) {
             result.success = false;
@@ -15345,10 +16073,10 @@ function applyWorkspaceEdit(edit) {
           }
         } else if (change.kind === "rename") {
           try {
-            const oldPath = change.oldUri.replace("file://", "");
-            const newPath = change.newUri.replace("file://", "");
-            const content = readFileSync25(oldPath, "utf-8");
-            writeFileSync13(newPath, content, "utf-8");
+            const oldPath = uriToPath(change.oldUri);
+            const newPath = uriToPath(change.newUri);
+            const content = readFileSync29(oldPath, "utf-8");
+            writeFileSync14(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
           } catch (err) {
@@ -15357,7 +16085,7 @@ function applyWorkspaceEdit(edit) {
           }
         } else if (change.kind === "delete") {
           try {
-            const filePath = change.uri.replace("file://", "");
+            const filePath = uriToPath(change.uri);
             __require("fs").unlinkSync(filePath);
             result.filesModified.push(filePath);
           } catch (err) {
@@ -15366,7 +16094,7 @@ function applyWorkspaceEdit(edit) {
           }
         }
       } else {
-        const filePath = change.textDocument.uri.replace("file://", "");
+        const filePath = uriToPath(change.textDocument.uri);
         const applyResult = applyTextEditsToFile(filePath, change.edits);
         if (applyResult.success) {
           result.filesModified.push(filePath);
@@ -25483,10 +26211,10 @@ function _property(property, schema, params) {
     ...normalizeParams(params)
   });
 }
-function _mime(types11, params) {
+function _mime(types14, params) {
   return new $ZodCheckMimeType({
     check: "mime_type",
-    mime: types11,
+    mime: types14,
     ...normalizeParams(params)
   });
 }
@@ -27396,7 +28124,7 @@ var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
   ZodType.init(inst, def);
   inst.min = (size, params) => inst.check(_minSize(size, params));
   inst.max = (size, params) => inst.check(_maxSize(size, params));
-  inst.mime = (types11, params) => inst.check(_mime(Array.isArray(types11) ? types11 : [types11], params));
+  inst.mime = (types14, params) => inst.check(_mime(Array.isArray(types14) ? types14 : [types14], params));
 });
 function file(params) {
   return _file(ZodFile, params);
@@ -28048,14 +28776,14 @@ var lsp_code_action_resolve = tool({
 });
 // src/tools/ast-grep/constants.ts
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname6, join as join46 } from "path";
-import { existsSync as existsSync37, statSync as statSync4 } from "fs";
+import { dirname as dirname9, join as join48 } from "path";
+import { existsSync as existsSync41, statSync as statSync4 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 var {spawn: spawn6 } = globalThis.Bun;
-import { existsSync as existsSync36, mkdirSync as mkdirSync10, chmodSync as chmodSync2, unlinkSync as unlinkSync9 } from "fs";
-import { join as join45 } from "path";
-import { homedir as homedir11 } from "os";
+import { existsSync as existsSync40, mkdirSync as mkdirSync11, chmodSync as chmodSync2, unlinkSync as unlinkSync10 } from "fs";
+import { join as join47 } from "path";
+import { homedir as homedir13 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
 var DEFAULT_VERSION = "0.40.0";
@@ -28080,19 +28808,19 @@ var PLATFORM_MAP2 = {
 function getCacheDir3() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join45(homedir11(), "AppData", "Local");
-    return join45(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join47(homedir13(), "AppData", "Local");
+    return join47(base2, "oh-my-opencode", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join45(homedir11(), ".cache");
-  return join45(base, "oh-my-opencode", "bin");
+  const base = xdgCache || join47(homedir13(), ".cache");
+  return join47(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath2() {
-  const binaryPath = join45(getCacheDir3(), getBinaryName3());
-  return existsSync36(binaryPath) ? binaryPath : null;
+  const binaryPath = join47(getCacheDir3(), getBinaryName3());
+  return existsSync40(binaryPath) ? binaryPath : null;
 }
 async function extractZip2(archivePath, destDir) {
   const proc = process.platform === "win32" ? spawn6([
@@ -28118,8 +28846,8 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
-  const binaryPath = join45(cacheDir, binaryName);
-  if (existsSync36(binaryPath)) {
+  const binaryPath = join47(cacheDir, binaryName);
+  if (existsSync40(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os5 } = platformInfo;
@@ -28127,21 +28855,21 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   const downloadUrl = `https://github.com/${REPO2}/releases/download/${version2}/${assetName}`;
   console.log(`[oh-my-opencode] Downloading ast-grep binary...`);
   try {
-    if (!existsSync36(cacheDir)) {
-      mkdirSync10(cacheDir, { recursive: true });
+    if (!existsSync40(cacheDir)) {
+      mkdirSync11(cacheDir, { recursive: true });
     }
     const response2 = await fetch(downloadUrl, { redirect: "follow" });
     if (!response2.ok) {
       throw new Error(`HTTP ${response2.status}: ${response2.statusText}`);
     }
-    const archivePath = join45(cacheDir, assetName);
+    const archivePath = join47(cacheDir, assetName);
     const arrayBuffer = await response2.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip2(archivePath, cacheDir);
-    if (existsSync36(archivePath)) {
-      unlinkSync9(archivePath);
+    if (existsSync40(archivePath)) {
+      unlinkSync10(archivePath);
     }
-    if (process.platform !== "win32" && existsSync36(binaryPath)) {
+    if (process.platform !== "win32" && existsSync40(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -28191,9 +28919,9 @@ function findSgCliPathSync() {
   try {
     const require2 = createRequire4(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
-    const cliDir = dirname6(cliPkgPath);
-    const sgPath = join46(cliDir, binaryName);
-    if (existsSync37(sgPath) && isValidBinary(sgPath)) {
+    const cliDir = dirname9(cliPkgPath);
+    const sgPath = join48(cliDir, binaryName);
+    if (existsSync41(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -28202,10 +28930,10 @@ function findSgCliPathSync() {
     try {
       const require2 = createRequire4(import.meta.url);
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
-      const pkgDir = dirname6(pkgPath);
+      const pkgDir = dirname9(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join46(pkgDir, astGrepName);
-      if (existsSync37(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join48(pkgDir, astGrepName);
+      if (existsSync41(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -28213,7 +28941,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path7 of homebrewPaths) {
-      if (existsSync37(path7) && isValidBinary(path7)) {
+      if (existsSync41(path7) && isValidBinary(path7)) {
         return path7;
       }
     }
@@ -28268,11 +28996,11 @@ var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn7 } = globalThis.Bun;
-import { existsSync as existsSync38 } from "fs";
+import { existsSync as existsSync42 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync38(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync42(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -28280,7 +29008,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync38(syncPath)) {
+    if (syncPath && existsSync42(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -28314,7 +29042,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync38(cliPath) && cliPath !== "sg") {
+  if (!existsSync42(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -28578,20 +29306,20 @@ var ast_grep_replace = tool({
 var {spawn: spawn9 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
-import { existsSync as existsSync40 } from "fs";
-import { join as join48, dirname as dirname7 } from "path";
+import { existsSync as existsSync44 } from "fs";
+import { join as join50, dirname as dirname10 } from "path";
 import { spawnSync } from "child_process";
 
 // src/tools/grep/downloader.ts
-import { existsSync as existsSync39, mkdirSync as mkdirSync11, chmodSync as chmodSync3, unlinkSync as unlinkSync10, readdirSync as readdirSync14 } from "fs";
-import { join as join47 } from "path";
+import { existsSync as existsSync43, mkdirSync as mkdirSync12, chmodSync as chmodSync3, unlinkSync as unlinkSync11, readdirSync as readdirSync15 } from "fs";
+import { join as join49 } from "path";
 var {spawn: spawn8 } = globalThis.Bun;
 function findFileRecursive(dir, filename) {
   try {
-    const entries = readdirSync14(dir, { withFileTypes: true, recursive: true });
+    const entries = readdirSync15(dir, { withFileTypes: true, recursive: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name === filename) {
-        return join47(entry.parentPath ?? dir, entry.name);
+        return join49(entry.parentPath ?? dir, entry.name);
       }
     }
   } catch {
@@ -28612,11 +29340,11 @@ function getPlatformKey() {
 }
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join47(homeDir, ".cache", "oh-my-opencode", "bin");
+  return join49(homeDir, ".cache", "oh-my-opencode", "bin");
 }
 function getRgPath() {
   const isWindows2 = process.platform === "win32";
-  return join47(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
+  return join49(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
 }
 async function downloadFile(url2, destPath) {
   const response2 = await fetch(url2);
@@ -28653,7 +29381,7 @@ async function extractZipWindows(archivePath, destDir) {
   }
   const foundPath = findFileRecursive(destDir, "rg.exe");
   if (foundPath) {
-    const destPath = join47(destDir, "rg.exe");
+    const destPath = join49(destDir, "rg.exe");
     if (foundPath !== destPath) {
       const { renameSync } = await import("fs");
       renameSync(foundPath, destPath);
@@ -28671,7 +29399,7 @@ async function extractZipUnix(archivePath, destDir) {
   }
   const foundPath = findFileRecursive(destDir, "rg");
   if (foundPath) {
-    const destPath = join47(destDir, "rg");
+    const destPath = join49(destDir, "rg");
     if (foundPath !== destPath) {
       const { renameSync } = await import("fs");
       renameSync(foundPath, destPath);
@@ -28693,13 +29421,13 @@ async function downloadAndInstallRipgrep() {
   }
   const installDir = getInstallDir();
   const rgPath = getRgPath();
-  if (existsSync39(rgPath)) {
+  if (existsSync43(rgPath)) {
     return rgPath;
   }
-  mkdirSync11(installDir, { recursive: true });
+  mkdirSync12(installDir, { recursive: true });
   const filename = `ripgrep-${RG_VERSION}-${config3.platform}.${config3.extension}`;
   const url2 = `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/${filename}`;
-  const archivePath = join47(installDir, filename);
+  const archivePath = join49(installDir, filename);
   try {
     await downloadFile(url2, archivePath);
     if (config3.extension === "tar.gz") {
@@ -28710,21 +29438,21 @@ async function downloadAndInstallRipgrep() {
     if (process.platform !== "win32") {
       chmodSync3(rgPath, 493);
     }
-    if (!existsSync39(rgPath)) {
+    if (!existsSync43(rgPath)) {
       throw new Error("ripgrep binary not found after extraction");
     }
     return rgPath;
   } finally {
-    if (existsSync39(archivePath)) {
+    if (existsSync43(archivePath)) {
       try {
-        unlinkSync10(archivePath);
+        unlinkSync11(archivePath);
       } catch {}
     }
   }
 }
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
-  return existsSync39(rgPath) ? rgPath : null;
+  return existsSync43(rgPath) ? rgPath : null;
 }
 
 // src/tools/grep/constants.ts
@@ -28744,18 +29472,18 @@ function findExecutable(name) {
 }
 function getOpenCodeBundledRg() {
   const execPath = process.execPath;
-  const execDir = dirname7(execPath);
+  const execDir = dirname10(execPath);
   const isWindows2 = process.platform === "win32";
   const rgName = isWindows2 ? "rg.exe" : "rg";
   const candidates = [
-    join48(getDataDir(), "opencode", "bin", rgName),
-    join48(execDir, rgName),
-    join48(execDir, "bin", rgName),
-    join48(execDir, "..", "bin", rgName),
-    join48(execDir, "..", "libexec", rgName)
+    join50(getDataDir(), "opencode", "bin", rgName),
+    join50(execDir, rgName),
+    join50(execDir, "bin", rgName),
+    join50(execDir, "..", "bin", rgName),
+    join50(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync40(candidate)) {
+    if (existsSync44(candidate)) {
       return candidate;
     }
   }
@@ -29208,21 +29936,21 @@ var glob = tool({
   }
 });
 // src/tools/slashcommand/tools.ts
-import { existsSync as existsSync41, readdirSync as readdirSync15, readFileSync as readFileSync26 } from "fs";
-import { join as join49, basename as basename4, dirname as dirname8 } from "path";
+import { existsSync as existsSync45, readdirSync as readdirSync16, readFileSync as readFileSync30 } from "fs";
+import { join as join51, basename as basename5, dirname as dirname11 } from "path";
 function discoverCommandsFromDir(commandsDir, scope) {
-  if (!existsSync41(commandsDir)) {
+  if (!existsSync45(commandsDir)) {
     return [];
   }
-  const entries = readdirSync15(commandsDir, { withFileTypes: true });
+  const entries = readdirSync16(commandsDir, { withFileTypes: true });
   const commands2 = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join49(commandsDir, entry.name);
-    const commandName = basename4(entry.name, ".md");
+    const commandPath = join51(commandsDir, entry.name);
+    const commandName = basename5(entry.name, ".md");
     try {
-      const content = readFileSync26(commandPath, "utf-8");
+      const content = readFileSync30(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -29247,19 +29975,40 @@ function discoverCommandsFromDir(commandsDir, scope) {
   return commands2;
 }
 function discoverCommandsSync() {
-  const { homedir: homedir12 } = __require("os");
-  const userCommandsDir = join49(getClaudeConfigDir(), "commands");
-  const projectCommandsDir = join49(process.cwd(), ".claude", "commands");
-  const opencodeGlobalDir = join49(homedir12(), ".config", "opencode", "command");
-  const opencodeProjectDir = join49(process.cwd(), ".opencode", "command");
+  const { homedir: homedir14 } = __require("os");
+  const userCommandsDir = join51(getClaudeConfigDir(), "commands");
+  const projectCommandsDir = join51(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join51(homedir14(), ".config", "opencode", "command");
+  const opencodeProjectDir = join51(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project");
   const opencodeProjectCommands = discoverCommandsFromDir(opencodeProjectDir, "opencode-project");
   return [...opencodeProjectCommands, ...projectCommands, ...opencodeGlobalCommands, ...userCommands];
 }
+function skillToCommandInfo(skill) {
+  return {
+    name: skill.name,
+    path: skill.path,
+    metadata: {
+      name: skill.name,
+      description: skill.definition.description || "",
+      argumentHint: skill.definition.argumentHint,
+      model: skill.definition.model,
+      agent: skill.definition.agent,
+      subtask: skill.definition.subtask
+    },
+    content: skill.definition.template,
+    scope: skill.scope
+  };
+}
 var availableCommands = discoverCommandsSync();
-var commandListForDescription = availableCommands.map((cmd) => {
+var availableSkills = discoverAllSkills();
+var availableItems = [
+  ...availableCommands,
+  ...availableSkills.map(skillToCommandInfo)
+];
+var commandListForDescription = availableItems.map((cmd) => {
   const hint = cmd.metadata.argumentHint ? ` ${cmd.metadata.argumentHint}` : "";
   return `- /${cmd.name}${hint}: ${cmd.metadata.description} (${cmd.scope})`;
 }).join(`
@@ -29294,93 +30043,78 @@ async function formatLoadedCommand(cmd) {
 `);
   sections.push(`## Command Instructions
 `);
-  const commandDir = dirname8(cmd.path);
-  const withFileRefs = await resolveFileReferencesInText(cmd.content, commandDir);
+  const commandDir = cmd.path ? dirname11(cmd.path) : process.cwd();
+  const withFileRefs = await resolveFileReferencesInText(cmd.content || "", commandDir);
   const resolvedContent = await resolveCommandsInText(withFileRefs);
   sections.push(resolvedContent.trim());
   return sections.join(`
 `);
 }
-function formatCommandList(commands2) {
-  if (commands2.length === 0) {
-    return "No commands found.";
+function formatCommandList(items) {
+  if (items.length === 0) {
+    return "No commands or skills found.";
   }
-  const lines = [`# Available Commands
+  const lines = [`# Available Commands & Skills
 `];
-  for (const cmd of commands2) {
+  for (const cmd of items) {
     const hint = cmd.metadata.argumentHint ? ` ${cmd.metadata.argumentHint}` : "";
     lines.push(`- **/${cmd.name}${hint}**: ${cmd.metadata.description || "(no description)"} (${cmd.scope})`);
   }
   lines.push(`
-**Total**: ${commands2.length} commands`);
+**Total**: ${items.length} items`);
   return lines.join(`
 `);
 }
 var slashcommand = tool({
-  description: `Execute a slash command within the main conversation.
-
-When you use this tool, the slash command gets expanded to a full prompt that provides detailed instructions on how to complete the task.
-
-How slash commands work:
-- Invoke commands using this tool with the command name (without arguments)
-- The command's prompt will expand and provide detailed instructions
-- Arguments from user input should be passed separately
-
-Important:
-- Only use commands listed in Available Commands below
-- Do not invoke a command that is already running
-- **CRITICAL**: When user's message starts with '/' (e.g., "/commit", "/plan"), you MUST immediately invoke this tool with that command. Do NOT attempt to handle the command manually.
-
-Commands are loaded from (priority order, highest wins):
-- .opencode/command/ (opencode-project - OpenCode project-specific commands)
-- ./.claude/commands/ (project - Claude Code project-specific commands)
-- ~/.config/opencode/command/ (opencode - OpenCode global commands)
-- $CLAUDE_CONFIG_DIR/commands/ or ~/.claude/commands/ (user - Claude Code global commands)
-
-Each command is a markdown file with:
-- YAML frontmatter: description, argument-hint, model, agent, subtask (optional)
-- Markdown body: The command instructions/prompt
-- File references: @path/to/file (relative to command file location)
-- Shell injection: \`!\`command\`\` (executes and injects output)
-
-Available Commands:
-${commandListForDescription}`,
+  description: `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.
+
+<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 commands2 = discoverCommandsSync();
+    const skills = discoverAllSkills();
+    const allItems = [
+      ...commands2,
+      ...skills.map(skillToCommandInfo)
+    ];
     if (!args.command) {
-      return formatCommandList(commands2) + `
+      return formatCommandList(allItems) + `
 
-Provide a command name to execute.`;
+Provide a command or skill name to execute.`;
     }
     const cmdName = args.command.replace(/^\//, "");
-    const exactMatch = commands2.find((cmd) => cmd.name.toLowerCase() === cmdName.toLowerCase());
+    const exactMatch = allItems.find((cmd) => cmd.name.toLowerCase() === cmdName.toLowerCase());
     if (exactMatch) {
       return await formatLoadedCommand(exactMatch);
     }
-    const partialMatches = commands2.filter((cmd) => cmd.name.toLowerCase().includes(cmdName.toLowerCase()));
+    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(commands2);
+` + formatCommandList(allItems);
     }
-    return `Command "/${cmdName}" not found.
+    return `Command or skill "/${cmdName}" not found.
 
-` + formatCommandList(commands2) + `
+` + formatCommandList(allItems) + `
 
-Try a different command name.`;
+Try a different name.`;
   }
 });
 // src/tools/session-manager/constants.ts
-import { join as join50 } from "path";
+import { join as join52 } from "path";
 var OPENCODE_STORAGE9 = getOpenCodeStorageDir();
-var MESSAGE_STORAGE4 = join50(OPENCODE_STORAGE9, "message");
-var PART_STORAGE4 = join50(OPENCODE_STORAGE9, "part");
-var TODO_DIR2 = join50(getClaudeConfigDir(), "todos");
-var TRANSCRIPT_DIR2 = join50(getClaudeConfigDir(), "transcripts");
+var MESSAGE_STORAGE4 = join52(OPENCODE_STORAGE9, "message");
+var PART_STORAGE4 = join52(OPENCODE_STORAGE9, "part");
+var TODO_DIR2 = join52(getClaudeConfigDir(), "todos");
+var TRANSCRIPT_DIR2 = join52(getClaudeConfigDir(), "transcripts");
 var SESSION_LIST_DESCRIPTION = `List all OpenCode sessions with optional filtering.
 
 Returns a list of available session IDs with metadata including message count, date range, and agents used.
@@ -29453,11 +30187,11 @@ Has Todos: Yes (12 items, 8 completed)
 Has Transcript: Yes (234 entries)`;
 
 // src/tools/session-manager/storage.ts
-import { existsSync as existsSync42, readdirSync as readdirSync16 } from "fs";
+import { existsSync as existsSync46, readdirSync as readdirSync17 } from "fs";
 import { readdir, readFile } from "fs/promises";
-import { join as join51 } from "path";
+import { join as join53 } from "path";
 async function getAllSessions() {
-  if (!existsSync42(MESSAGE_STORAGE4))
+  if (!existsSync46(MESSAGE_STORAGE4))
     return [];
   const sessions = [];
   async function scanDirectory(dir) {
@@ -29465,7 +30199,7 @@ async function getAllSessions() {
       const entries = await readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const sessionPath = join51(dir, entry.name);
+          const sessionPath = join53(dir, entry.name);
           const files = await readdir(sessionPath);
           if (files.some((f) => f.endsWith(".json"))) {
             sessions.push(entry.name);
@@ -29482,16 +30216,16 @@ async function getAllSessions() {
   return [...new Set(sessions)];
 }
 function getMessageDir9(sessionID) {
-  if (!existsSync42(MESSAGE_STORAGE4))
+  if (!existsSync46(MESSAGE_STORAGE4))
     return "";
-  const directPath = join51(MESSAGE_STORAGE4, sessionID);
-  if (existsSync42(directPath)) {
+  const directPath = join53(MESSAGE_STORAGE4, sessionID);
+  if (existsSync46(directPath)) {
     return directPath;
   }
   try {
-    for (const dir of readdirSync16(MESSAGE_STORAGE4)) {
-      const sessionPath = join51(MESSAGE_STORAGE4, dir, sessionID);
-      if (existsSync42(sessionPath)) {
+    for (const dir of readdirSync17(MESSAGE_STORAGE4)) {
+      const sessionPath = join53(MESSAGE_STORAGE4, dir, sessionID);
+      if (existsSync46(sessionPath)) {
         return sessionPath;
       }
     }
@@ -29505,7 +30239,7 @@ function sessionExists(sessionID) {
 }
 async function readSessionMessages(sessionID) {
   const messageDir = getMessageDir9(sessionID);
-  if (!messageDir || !existsSync42(messageDir))
+  if (!messageDir || !existsSync46(messageDir))
     return [];
   const messages = [];
   try {
@@ -29514,7 +30248,7 @@ async function readSessionMessages(sessionID) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join51(messageDir, file2), "utf-8");
+        const content = await readFile(join53(messageDir, file2), "utf-8");
         const meta = JSON.parse(content);
         const parts = await readParts2(meta.id);
         messages.push({
@@ -29540,8 +30274,8 @@ async function readSessionMessages(sessionID) {
   });
 }
 async function readParts2(messageID) {
-  const partDir = join51(PART_STORAGE4, messageID);
-  if (!existsSync42(partDir))
+  const partDir = join53(PART_STORAGE4, messageID);
+  if (!existsSync46(partDir))
     return [];
   const parts = [];
   try {
@@ -29550,7 +30284,7 @@ async function readParts2(messageID) {
       if (!file2.endsWith(".json"))
         continue;
       try {
-        const content = await readFile(join51(partDir, file2), "utf-8");
+        const content = await readFile(join53(partDir, file2), "utf-8");
         parts.push(JSON.parse(content));
       } catch {
         continue;
@@ -29562,14 +30296,14 @@ async function readParts2(messageID) {
   return parts.sort((a, b) => a.id.localeCompare(b.id));
 }
 async function readSessionTodos(sessionID) {
-  if (!existsSync42(TODO_DIR2))
+  if (!existsSync46(TODO_DIR2))
     return [];
   try {
     const allFiles = await readdir(TODO_DIR2);
     const todoFiles = allFiles.filter((f) => f.includes(sessionID) && f.endsWith(".json"));
     for (const file2 of todoFiles) {
       try {
-        const content = await readFile(join51(TODO_DIR2, file2), "utf-8");
+        const content = await readFile(join53(TODO_DIR2, file2), "utf-8");
         const data = JSON.parse(content);
         if (Array.isArray(data)) {
           return data.map((item) => ({
@@ -29589,10 +30323,10 @@ async function readSessionTodos(sessionID) {
   return [];
 }
 async function readSessionTranscript(sessionID) {
-  if (!existsSync42(TRANSCRIPT_DIR2))
+  if (!existsSync46(TRANSCRIPT_DIR2))
     return 0;
-  const transcriptFile = join51(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
-  if (!existsSync42(transcriptFile))
+  const transcriptFile = join53(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
+  if (!existsSync46(transcriptFile))
     return 0;
   try {
     const content = await readFile(transcriptFile, "utf-8");
@@ -29913,6 +30647,8 @@ var BLOCKED_TMUX_SUBCOMMANDS = [
 ];
 var INTERACTIVE_BASH_DESCRIPTION = `Execute tmux commands. Use "omo-{name}" session pattern.
 
+For: server processes, long-running tasks, background jobs, interactive CLI tools.
+
 Blocked (use bash instead): capture-pane, save-buffer, show-buffer, pipe-pane.`;
 
 // src/tools/interactive-bash/utils.ts
@@ -30050,9 +30786,91 @@ 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.
+
+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 readFileSync31 } from "fs";
+function loadedSkillToInfo(skill) {
+  return {
+    name: skill.name,
+    description: skill.definition.description || "",
+    location: skill.path,
+    scope: skill.scope,
+    license: skill.license,
+    compatibility: skill.compatibility,
+    metadata: skill.metadata,
+    allowedTools: skill.allowedTools
+  };
+}
+function formatSkillsXml(skills) {
+  if (skills.length === 0)
+    return "";
+  const skillsXml = skills.map((skill) => {
+    const lines = [
+      "  <skill>",
+      `    <name>${skill.name}</name>`,
+      `    <description>${skill.description}</description>`
+    ];
+    if (skill.compatibility) {
+      lines.push(`    <compatibility>${skill.compatibility}</compatibility>`);
+    }
+    lines.push("  </skill>");
+    return lines.join(`
+`);
+  }).join(`
+`);
+  return `
+
+<available_skills>
+${skillsXml}
+</available_skills>`;
+}
+function extractSkillBody(skill) {
+  if (skill.path) {
+    const content = readFileSync31(skill.path, "utf-8");
+    const { body } = parseFrontmatter(content);
+    return body.trim();
+  }
+  const templateMatch = skill.definition.template?.match(/<skill-instruction>([\s\S]*?)<\/skill-instruction>/);
+  return templateMatch ? templateMatch[1].trim() : skill.definition.template || "";
+}
+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);
+  return tool({
+    description,
+    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);
+      if (!skill) {
+        const available = skills.map((s) => s.name).join(", ");
+        throw new Error(`Skill "${args.name}" not found. Available skills: ${available || "none"}`);
+      }
+      const body = extractSkillBody(skill);
+      const dir = skill.path ? dirname12(skill.path) : skill.resolvedPath || process.cwd();
+      return [
+        `## Skill: ${skill.name}`,
+        "",
+        `**Base directory**: ${dir}`,
+        "",
+        body
+      ].join(`
+`);
+    }
+  });
+}
+var skill = createSkillTool();
 // src/tools/background-task/tools.ts
-import { existsSync as existsSync43, readdirSync as readdirSync17 } from "fs";
-import { join as join52 } from "path";
+import { existsSync as existsSync47, readdirSync as readdirSync18 } from "fs";
+import { join as join54 } from "path";
 
 // src/tools/background-task/constants.ts
 var BACKGROUND_TASK_DESCRIPTION = `Run agent task in background. Returns task_id immediately; notifies on completion.
@@ -30063,14 +30881,14 @@ var BACKGROUND_CANCEL_DESCRIPTION = `Cancel running background task(s). Use all=
 
 // src/tools/background-task/tools.ts
 function getMessageDir10(sessionID) {
-  if (!existsSync43(MESSAGE_STORAGE))
+  if (!existsSync47(MESSAGE_STORAGE))
     return null;
-  const directPath = join52(MESSAGE_STORAGE, sessionID);
-  if (existsSync43(directPath))
+  const directPath = join54(MESSAGE_STORAGE, sessionID);
+  if (existsSync47(directPath))
     return directPath;
-  for (const dir of readdirSync17(MESSAGE_STORAGE)) {
-    const sessionPath = join52(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync43(sessionPath))
+  for (const dir of readdirSync18(MESSAGE_STORAGE)) {
+    const sessionPath = join54(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync47(sessionPath))
       return sessionPath;
   }
   return null;
@@ -30137,7 +30955,7 @@ Use \`background_output\` tool with task_id="${task.id}" to check progress:
   });
 }
 function delay(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
 }
 function truncateText(text, maxLength) {
   if (text.length <= maxLength)
@@ -30512,9 +31330,9 @@ session_id: ${sessionID}
 }
 // src/tools/look-at/constants.ts
 var MULTIMODAL_LOOKER_AGENT = "multimodal-looker";
-var LOOK_AT_DESCRIPTION = `Analyze media files (PDFs, images, diagrams) via Gemini 2.5 Flash in separate context. Saves main context tokens.`;
+var LOOK_AT_DESCRIPTION = `Analyze media files (PDFs, images, diagrams) that require interpretation beyond raw text. Extracts specific information or summaries from documents, describes visual content. Use when you need analyzed/extracted data rather than literal file contents.`;
 // src/tools/look-at/tools.ts
-import { extname as extname3, basename as basename5 } from "path";
+import { extname as extname3, basename as basename6 } from "path";
 import { pathToFileURL } from "url";
 function inferMimeType(filePath) {
   const ext = extname3(filePath).toLowerCase();
@@ -30522,20 +31340,34 @@ function inferMimeType(filePath) {
     ".jpg": "image/jpeg",
     ".jpeg": "image/jpeg",
     ".png": "image/png",
-    ".gif": "image/gif",
     ".webp": "image/webp",
-    ".svg": "image/svg+xml",
-    ".bmp": "image/bmp",
-    ".ico": "image/x-icon",
+    ".heic": "image/heic",
+    ".heif": "image/heif",
+    ".mp4": "video/mp4",
+    ".mpeg": "video/mpeg",
+    ".mpg": "video/mpeg",
+    ".mov": "video/mov",
+    ".avi": "video/avi",
+    ".flv": "video/x-flv",
+    ".webm": "video/webm",
+    ".wmv": "video/wmv",
+    ".3gpp": "video/3gpp",
+    ".3gp": "video/3gpp",
+    ".wav": "audio/wav",
+    ".mp3": "audio/mp3",
+    ".aiff": "audio/aiff",
+    ".aac": "audio/aac",
+    ".ogg": "audio/ogg",
+    ".flac": "audio/flac",
     ".pdf": "application/pdf",
     ".txt": "text/plain",
-    ".md": "text/markdown",
+    ".csv": "text/csv",
+    ".md": "text/md",
+    ".html": "text/html",
     ".json": "application/json",
     ".xml": "application/xml",
-    ".html": "text/html",
-    ".css": "text/css",
     ".js": "text/javascript",
-    ".ts": "text/typescript"
+    ".py": "text/x-python"
   };
   return mimeTypes[ext] || "application/octet-stream";
 }
@@ -30549,7 +31381,7 @@ function createLookAt(ctx) {
     async execute(args, toolContext) {
       log(`[look_at] Analyzing file: ${args.file_path}, goal: ${args.goal}`);
       const mimeType = inferMimeType(args.file_path);
-      const filename = basename5(args.file_path);
+      const filename = basename6(args.file_path);
       const prompt = `Analyze this file and extract the requested information.
 
 Goal: ${args.goal}
@@ -30642,17 +31474,17 @@ var builtinTools = {
   session_info
 };
 // src/features/background-agent/manager.ts
-import { existsSync as existsSync44, readdirSync as readdirSync18 } from "fs";
-import { join as join53 } from "path";
+import { existsSync as existsSync48, readdirSync as readdirSync19 } from "fs";
+import { join as join55 } from "path";
 function getMessageDir11(sessionID) {
-  if (!existsSync44(MESSAGE_STORAGE))
+  if (!existsSync48(MESSAGE_STORAGE))
     return null;
-  const directPath = join53(MESSAGE_STORAGE, sessionID);
-  if (existsSync44(directPath))
+  const directPath = join55(MESSAGE_STORAGE, sessionID);
+  if (existsSync48(directPath))
     return directPath;
-  for (const dir of readdirSync18(MESSAGE_STORAGE)) {
-    const sessionPath = join53(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync44(sessionPath))
+  for (const dir of readdirSync19(MESSAGE_STORAGE)) {
+    const sessionPath = join55(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync48(sessionPath))
       return sessionPath;
   }
   return null;
@@ -31091,7 +31923,7 @@ var HookNameSchema = exports_external.enum([
   "directory-readme-injector",
   "empty-task-response-detector",
   "think-mode",
-  "anthropic-auto-compact",
+  "anthropic-context-window-limit-recovery",
   "rules-injector",
   "background-notification",
   "auto-update-checker",
@@ -31101,7 +31933,9 @@ var HookNameSchema = exports_external.enum([
   "non-interactive-env",
   "interactive-bash-session",
   "empty-message-sanitizer",
-  "thinking-block-validator"
+  "thinking-block-validator",
+  "ralph-loop",
+  "dcp-for-compaction"
 ]);
 var BuiltinCommandNameSchema = exports_external.enum([
   "init-deep"
@@ -31187,8 +32021,46 @@ var ExperimentalConfigSchema = exports_external.object({
   preemptive_compaction: exports_external.boolean().optional(),
   preemptive_compaction_threshold: exports_external.number().min(0.5).max(0.95).optional(),
   truncate_all_tool_outputs: exports_external.boolean().default(true),
-  dynamic_context_pruning: DynamicContextPruningConfigSchema.optional(),
-  dcp_for_compaction: exports_external.boolean().optional()
+  dynamic_context_pruning: DynamicContextPruningConfigSchema.optional()
+});
+var SkillSourceSchema = exports_external.union([
+  exports_external.string(),
+  exports_external.object({
+    path: exports_external.string(),
+    recursive: exports_external.boolean().optional(),
+    glob: exports_external.string().optional()
+  })
+]);
+var SkillDefinitionSchema = exports_external.object({
+  description: exports_external.string().optional(),
+  template: exports_external.string().optional(),
+  from: exports_external.string().optional(),
+  model: exports_external.string().optional(),
+  agent: exports_external.string().optional(),
+  subtask: exports_external.boolean().optional(),
+  "argument-hint": exports_external.string().optional(),
+  license: exports_external.string().optional(),
+  compatibility: exports_external.string().optional(),
+  metadata: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  "allowed-tools": exports_external.array(exports_external.string()).optional(),
+  disable: exports_external.boolean().optional()
+});
+var SkillEntrySchema = exports_external.union([
+  exports_external.boolean(),
+  SkillDefinitionSchema
+]);
+var SkillsConfigSchema = exports_external.union([
+  exports_external.array(exports_external.string()),
+  exports_external.record(exports_external.string(), SkillEntrySchema).and(exports_external.object({
+    sources: exports_external.array(SkillSourceSchema).optional(),
+    enable: exports_external.array(exports_external.string()).optional(),
+    disable: exports_external.array(exports_external.string()).optional()
+  }).partial())
+]);
+var RalphLoopConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(false),
+  default_max_iterations: exports_external.number().min(1).max(1000).default(100),
+  state_dir: exports_external.string().optional()
 });
 var OhMyOpenCodeConfigSchema = exports_external.object({
   $schema: exports_external.string().optional(),
@@ -31202,7 +32074,9 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   sisyphus_agent: SisyphusAgentConfigSchema.optional(),
   comment_checker: CommentCheckerConfigSchema.optional(),
   experimental: ExperimentalConfigSchema.optional(),
-  auto_update: exports_external.boolean().optional()
+  auto_update: exports_external.boolean().optional(),
+  skills: SkillsConfigSchema.optional(),
+  ralph_loop: RalphLoopConfigSchema.optional()
 });
 // src/agents/plan-prompt.ts
 var PLAN_SYSTEM_PROMPT = `<system-reminder>
@@ -31434,7 +32308,10 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const claudeCodeHooks = createClaudeCodeHooksHook(ctx, {
     disabledHooks: pluginConfig.claude_code?.hooks ?? true ? undefined : true
   });
-  const anthropicAutoCompact = isHookEnabled("anthropic-auto-compact") ? createAnthropicAutoCompactHook(ctx, { experimental: pluginConfig.experimental }) : null;
+  const anthropicContextWindowLimitRecovery = isHookEnabled("anthropic-context-window-limit-recovery") ? createAnthropicContextWindowLimitRecoveryHook(ctx, {
+    experimental: pluginConfig.experimental,
+    dcpForCompaction: isHookEnabled("dcp-for-compaction")
+  }) : null;
   const compactionContextInjector = createCompactionContextInjector();
   const preemptiveCompaction = createPreemptiveCompactionHook(ctx, {
     experimental: pluginConfig.experimental,
@@ -31453,6 +32330,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const interactiveBashSession = isHookEnabled("interactive-bash-session") ? createInteractiveBashSessionHook(ctx) : null;
   const emptyMessageSanitizer = isHookEnabled("empty-message-sanitizer") ? createEmptyMessageSanitizerHook() : null;
   const thinkingBlockValidator = isHookEnabled("thinking-block-validator") ? createThinkingBlockValidatorHook() : null;
+  const ralphLoop = isHookEnabled("ralph-loop") ? createRalphLoopHook(ctx, { config: pluginConfig.ralph_loop }) : null;
   const backgroundManager = new BackgroundManager(ctx);
   const todoContinuationEnforcer = isHookEnabled("todo-continuation-enforcer") ? createTodoContinuationEnforcer(ctx, { backgroundManager }) : null;
   if (sessionRecovery && todoContinuationEnforcer) {
@@ -31463,6 +32341,10 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const backgroundTools = createBackgroundTools(backgroundManager, ctx.client);
   const callOmoAgent = createCallOmoAgent(ctx, backgroundManager);
   const lookAt = createLookAt(ctx);
+  const builtinSkills = createBuiltinSkills();
+  const includeClaudeSkills = pluginConfig.claude_code?.skills !== false;
+  const mergedSkills = mergeSkills(builtinSkills, pluginConfig.skills, includeClaudeSkills ? discoverUserClaudeSkills() : [], discoverOpencodeGlobalSkills(), includeClaudeSkills ? discoverProjectClaudeSkills() : [], discoverOpencodeProjectSkills());
+  const skillTool = createSkillTool({ skills: mergedSkills });
   const googleAuthHooks = pluginConfig.google_auth !== false ? await createGoogleAntigravityAuthPlugin(ctx) : null;
   const tmuxAvailable = await getTmuxPath();
   return {
@@ -31472,11 +32354,35 @@ var OhMyOpenCodePlugin = async (ctx) => {
       ...backgroundTools,
       call_omo_agent: callOmoAgent,
       look_at: lookAt,
+      skill: skillTool,
       ...tmuxAvailable ? { interactive_bash } : {}
     },
     "chat.message": async (input, output) => {
       await claudeCodeHooks["chat.message"]?.(input, output);
       await keywordDetector?.["chat.message"]?.(input, output);
+      if (ralphLoop) {
+        const parts = output.parts;
+        const promptText = parts?.filter((p) => p.type === "text" && p.text).map((p) => p.text).join(`
+`).trim() || "";
+        const isRalphLoopTemplate = promptText.includes("You are starting a Ralph Loop") && promptText.includes("<user-task>");
+        const isCancelRalphTemplate = promptText.includes("Cancel the currently active Ralph Loop");
+        if (isRalphLoopTemplate) {
+          const taskMatch = promptText.match(/<user-task>\s*([\s\S]*?)\s*<\/user-task>/i);
+          const rawTask = taskMatch?.[1]?.trim() || "";
+          const quotedMatch = rawTask.match(/^["'](.+?)["']/);
+          const prompt = quotedMatch?.[1] || rawTask.split(/\s+--/)[0]?.trim() || "Complete the task as instructed";
+          const maxIterMatch = rawTask.match(/--max-iterations=(\d+)/i);
+          const promiseMatch = rawTask.match(/--completion-promise=["']?([^"'\s]+)["']?/i);
+          log("[ralph-loop] Starting loop from chat.message", { sessionID: input.sessionID, prompt });
+          ralphLoop.startLoop(input.sessionID, prompt, {
+            maxIterations: maxIterMatch ? parseInt(maxIterMatch[1], 10) : undefined,
+            completionPromise: promiseMatch?.[1]
+          });
+        } else if (isCancelRalphTemplate) {
+          log("[ralph-loop] Cancelling loop from chat.message", { sessionID: input.sessionID });
+          ralphLoop.cancelLoop(input.sessionID);
+        }
+      }
     },
     "experimental.chat.messages.transform": async (input, output) => {
       await thinkingBlockValidator?.["experimental.chat.messages.transform"]?.(input, output);
@@ -31611,14 +32517,23 @@ var OhMyOpenCodePlugin = async (ctx) => {
       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();
       config3.command = {
         ...builtinCommands,
         ...userCommands,
+        ...userSkills,
         ...opencodeGlobalCommands,
+        ...opencodeGlobalSkills,
         ...systemCommands,
         ...projectCommands,
+        ...projectSkills,
         ...opencodeProjectCommands,
-        ...pluginComponents.commands
+        ...opencodeProjectSkills,
+        ...pluginComponents.commands,
+        ...pluginComponents.skills
       };
     },
     event: async (input) => {
@@ -31632,10 +32547,11 @@ var OhMyOpenCodePlugin = async (ctx) => {
       await directoryReadmeInjector?.event(input);
       await rulesInjector?.event(input);
       await thinkMode?.event(input);
-      await anthropicAutoCompact?.event(input);
+      await anthropicContextWindowLimitRecovery?.event(input);
       await preemptiveCompaction?.event(input);
       await agentUsageReminder?.event(input);
       await interactiveBashSession?.event(input);
+      await ralphLoop?.event(input);
       const { event } = input;
       const props = event.properties;
       if (event.type === "session.created") {
@@ -31688,6 +32604,24 @@ var OhMyOpenCodePlugin = async (ctx) => {
           ...isExploreOrLibrarian ? { call_omo_agent: false } : {}
         };
       }
+      if (ralphLoop && input.tool === "slashcommand") {
+        const args = output.args;
+        const command = args?.command?.replace(/^\//, "").toLowerCase();
+        const sessionID = input.sessionID || getMainSessionID();
+        if (command === "ralph-loop" && sessionID) {
+          const rawArgs = args?.command?.replace(/^\/?(ralph-loop)\s*/i, "") || "";
+          const taskMatch = rawArgs.match(/^["'](.+?)["']/);
+          const prompt = taskMatch?.[1] || rawArgs.split(/\s+--/)[0]?.trim() || "Complete the task as instructed";
+          const maxIterMatch = rawArgs.match(/--max-iterations=(\d+)/i);
+          const promiseMatch = rawArgs.match(/--completion-promise=["']?([^"'\s]+)["']?/i);
+          ralphLoop.startLoop(sessionID, prompt, {
+            maxIterations: maxIterMatch ? parseInt(maxIterMatch[1], 10) : undefined,
+            completionPromise: promiseMatch?.[1]
+          });
+        } else if (command === "cancel-ralph" && sessionID) {
+          ralphLoop.cancelLoop(sessionID);
+        }
+      }
     },
     "tool.execute.after": async (input, output) => {
       await claudeCodeHooks["tool.execute.after"](input, output);