oh-my-opencode 0.3.0 → 0.3.2

package/dist/index.js

@@ -633,6 +633,7 @@ function createTodoContinuationEnforcer(ctx) {
   const remindedSessions = new Set;
   const interruptedSessions = new Set;
   const errorSessions = new Set;
+  const pendingTimers = new Map;
   return async ({ event }) => {
     const props = event.properties;
     if (event.type === "session.error") {
@@ -642,6 +643,11 @@ function createTodoContinuationEnforcer(ctx) {
         if (detectInterrupt(props?.error)) {
           interruptedSessions.add(sessionID);
         }
+        const timer = pendingTimers.get(sessionID);
+        if (timer) {
+          clearTimeout(timer);
+          pendingTimers.delete(sessionID);
+        }
       }
       return;
     }
@@ -649,61 +655,73 @@ function createTodoContinuationEnforcer(ctx) {
       const sessionID = props?.sessionID;
       if (!sessionID)
         return;
-      await new Promise((resolve) => setTimeout(resolve, 150));
-      const shouldBypass = interruptedSessions.has(sessionID) || errorSessions.has(sessionID);
-      interruptedSessions.delete(sessionID);
-      errorSessions.delete(sessionID);
-      if (shouldBypass) {
-        return;
-      }
-      if (remindedSessions.has(sessionID)) {
-        return;
-      }
-      let todos = [];
-      try {
-        const response = await ctx.client.session.todo({
-          path: { id: sessionID }
-        });
-        todos = response.data ?? response;
-      } catch {
-        return;
-      }
-      if (!todos || todos.length === 0) {
-        return;
-      }
-      const incomplete = todos.filter((t) => t.status !== "completed" && t.status !== "cancelled");
-      if (incomplete.length === 0) {
-        return;
-      }
-      remindedSessions.add(sessionID);
-      if (interruptedSessions.has(sessionID) || errorSessions.has(sessionID)) {
-        remindedSessions.delete(sessionID);
-        return;
-      }
-      try {
-        await ctx.client.session.prompt({
-          path: { id: sessionID },
-          body: {
-            parts: [
-              {
-                type: "text",
-                text: `${CONTINUATION_PROMPT}
+      const existingTimer = pendingTimers.get(sessionID);
+      if (existingTimer) {
+        clearTimeout(existingTimer);
+      }
+      const timer = setTimeout(async () => {
+        pendingTimers.delete(sessionID);
+        const shouldBypass = interruptedSessions.has(sessionID) || errorSessions.has(sessionID);
+        interruptedSessions.delete(sessionID);
+        errorSessions.delete(sessionID);
+        if (shouldBypass) {
+          return;
+        }
+        if (remindedSessions.has(sessionID)) {
+          return;
+        }
+        let todos = [];
+        try {
+          const response = await ctx.client.session.todo({
+            path: { id: sessionID }
+          });
+          todos = response.data ?? response;
+        } catch {
+          return;
+        }
+        if (!todos || todos.length === 0) {
+          return;
+        }
+        const incomplete = todos.filter((t) => t.status !== "completed" && t.status !== "cancelled");
+        if (incomplete.length === 0) {
+          return;
+        }
+        remindedSessions.add(sessionID);
+        if (interruptedSessions.has(sessionID) || errorSessions.has(sessionID)) {
+          remindedSessions.delete(sessionID);
+          return;
+        }
+        try {
+          await ctx.client.session.prompt({
+            path: { id: sessionID },
+            body: {
+              parts: [
+                {
+                  type: "text",
+                  text: `${CONTINUATION_PROMPT}
 
 [Status: ${todos.length - incomplete.length}/${todos.length} completed, ${incomplete.length} remaining]`
-              }
-            ]
-          },
-          query: { directory: ctx.directory }
-        });
-      } catch {
-        remindedSessions.delete(sessionID);
-      }
+                }
+              ]
+            },
+            query: { directory: ctx.directory }
+          });
+        } catch {
+          remindedSessions.delete(sessionID);
+        }
+      }, 200);
+      pendingTimers.set(sessionID, timer);
     }
     if (event.type === "message.updated") {
       const info = props?.info;
       const sessionID = info?.sessionID;
       if (sessionID && info?.role === "user") {
         remindedSessions.delete(sessionID);
+        const timer = pendingTimers.get(sessionID);
+        if (timer) {
+          clearTimeout(timer);
+          pendingTimers.delete(sessionID);
+        }
       }
     }
     if (event.type === "session.deleted") {
@@ -712,6 +730,11 @@ function createTodoContinuationEnforcer(ctx) {
         remindedSessions.delete(sessionInfo.id);
         interruptedSessions.delete(sessionInfo.id);
         errorSessions.delete(sessionInfo.id);
+        const timer = pendingTimers.get(sessionInfo.id);
+        if (timer) {
+          clearTimeout(timer);
+          pendingTimers.delete(sessionInfo.id);
+        }
       }
     }
   };
@@ -723,16 +746,8 @@ var CONTEXT_WARNING_THRESHOLD = 0.7;
 var CONTEXT_REMINDER = `[SYSTEM REMINDER - 1M Context Window]
 
 You are using Anthropic Claude with 1M context window.
-Current usage has exceeded 75%.
-
-RECOMMENDATIONS:
-- Consider compacting the session if available
-- Break complex tasks into smaller, focused sessions
-- Be concise in your responses
-- Avoid redundant file reads
-
-You have access to 1M tokens - use them wisely. Do NOT rush or skip tasks.
-Complete your work thoroughly despite the context usage warning.`;
+You have plenty of context remaining - do NOT rush or skip tasks.
+Complete your work thoroughly and methodically.`;
 function createContextWindowMonitorHook(ctx) {
   const remindedSessions = new Set;
   const toolExecuteAfter = async (input, output) => {
@@ -854,7 +869,13 @@ function readMessages(sessionID) {
       continue;
     }
   }
-  return messages.sort((a, b) => a.id.localeCompare(b.id));
+  return messages.sort((a, b) => {
+    const aTime = a.time?.created ?? 0;
+    const bTime = b.time?.created ?? 0;
+    if (aTime !== bTime)
+      return aTime - bTime;
+    return a.id.localeCompare(b.id);
+  });
 }
 function readParts(messageID) {
   const partDir = join2(PART_STORAGE, messageID);
@@ -918,19 +939,26 @@ function injectTextPart(sessionID, messageID, text) {
 function findEmptyMessages(sessionID) {
   const messages = readMessages(sessionID);
   const emptyIds = [];
-  for (let i = 0;i < messages.length; i++) {
-    const msg = messages[i];
+  for (const msg of messages) {
     if (msg.role !== "assistant")
       continue;
-    const isLastMessage = i === messages.length - 1;
-    if (isLastMessage)
-      continue;
     if (!messageHasContent(msg.id)) {
       emptyIds.push(msg.id);
     }
   }
   return emptyIds;
 }
+function findEmptyMessageByIndex(sessionID, targetIndex) {
+  const messages = readMessages(sessionID);
+  if (targetIndex < 0 || targetIndex >= messages.length)
+    return null;
+  const targetMsg = messages[targetIndex];
+  if (targetMsg.role !== "assistant")
+    return null;
+  if (messageHasContent(targetMsg.id))
+    return null;
+  return targetMsg.id;
+}
 function findMessagesWithThinkingBlocks(sessionID) {
   const messages = readMessages(sessionID);
   const result = [];
@@ -1025,6 +1053,11 @@ function getErrorMessage(error) {
   const errorObj = error;
   return (errorObj.data?.message || errorObj.error?.message || errorObj.message || "").toLowerCase();
 }
+function extractMessageIndex(error) {
+  const message = getErrorMessage(error);
+  const match = message.match(/messages\.(\d+)/);
+  return match ? parseInt(match[1], 10) : null;
+}
 function detectErrorType(error) {
   const message = getErrorMessage(error);
   if (message.includes("tool_use") && message.includes("tool_result")) {
@@ -1091,14 +1124,21 @@ async function recoverThinkingDisabledViolation(_client, sessionID, _failedAssis
   }
   return anySuccess;
 }
-async function recoverEmptyContentMessage(_client, sessionID, failedAssistantMsg, _directory) {
-  const emptyMessageIDs = findEmptyMessages(sessionID);
-  if (emptyMessageIDs.length === 0) {
-    const fallbackID = failedAssistantMsg.info?.id;
-    if (!fallbackID)
-      return false;
-    return injectTextPart(sessionID, fallbackID, "(interrupted)");
+async function recoverEmptyContentMessage(_client, sessionID, failedAssistantMsg, _directory, error) {
+  const targetIndex = extractMessageIndex(error);
+  const failedID = failedAssistantMsg.info?.id;
+  if (targetIndex !== null) {
+    const targetMessageID = findEmptyMessageByIndex(sessionID, targetIndex);
+    if (targetMessageID) {
+      return injectTextPart(sessionID, targetMessageID, "(interrupted)");
+    }
   }
+  if (failedID) {
+    if (injectTextPart(sessionID, failedID, "(interrupted)")) {
+      return true;
+    }
+  }
+  const emptyMessageIDs = findEmptyMessages(sessionID);
   let anySuccess = false;
   for (const messageID of emptyMessageIDs) {
     if (injectTextPart(sessionID, messageID, "(interrupted)")) {
@@ -1171,10 +1211,11 @@ function createSessionRecoveryHook(ctx) {
       } else if (errorType === "thinking_disabled_violation") {
         success = await recoverThinkingDisabledViolation(ctx.client, sessionID, failedMsg);
       } else if (errorType === "empty_content_message") {
-        success = await recoverEmptyContentMessage(ctx.client, sessionID, failedMsg, ctx.directory);
+        success = await recoverEmptyContentMessage(ctx.client, sessionID, failedMsg, ctx.directory, info.error);
       }
       return success;
-    } catch {
+    } catch (err) {
+      console.error("[session-recovery] Recovery failed:", err);
       return false;
     } finally {
       processingErrors.delete(assistantMsgID);
@@ -1790,6 +1831,147 @@ ${content}`;
     event: eventHandler
   };
 }
+// src/hooks/directory-readme-injector/index.ts
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname3, join as join10, resolve as resolve2 } from "path";
+
+// src/hooks/directory-readme-injector/storage.ts
+import {
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync3,
+  unlinkSync as unlinkSync4
+} from "fs";
+import { join as join9 } from "path";
+
+// src/hooks/directory-readme-injector/constants.ts
+import { join as join8 } from "path";
+var OPENCODE_STORAGE3 = join8(xdgData ?? "", "opencode", "storage");
+var README_INJECTOR_STORAGE = join8(OPENCODE_STORAGE3, "directory-readme");
+var README_FILENAME = "README.md";
+
+// src/hooks/directory-readme-injector/storage.ts
+function getStoragePath2(sessionID) {
+  return join9(README_INJECTOR_STORAGE, `${sessionID}.json`);
+}
+function loadInjectedPaths2(sessionID) {
+  const filePath = getStoragePath2(sessionID);
+  if (!existsSync7(filePath))
+    return new Set;
+  try {
+    const content = readFileSync4(filePath, "utf-8");
+    const data = JSON.parse(content);
+    return new Set(data.injectedPaths);
+  } catch {
+    return new Set;
+  }
+}
+function saveInjectedPaths2(sessionID, paths) {
+  if (!existsSync7(README_INJECTOR_STORAGE)) {
+    mkdirSync4(README_INJECTOR_STORAGE, { recursive: true });
+  }
+  const data = {
+    sessionID,
+    injectedPaths: [...paths],
+    updatedAt: Date.now()
+  };
+  writeFileSync3(getStoragePath2(sessionID), JSON.stringify(data, null, 2));
+}
+function clearInjectedPaths2(sessionID) {
+  const filePath = getStoragePath2(sessionID);
+  if (existsSync7(filePath)) {
+    unlinkSync4(filePath);
+  }
+}
+
+// src/hooks/directory-readme-injector/index.ts
+function createDirectoryReadmeInjectorHook(ctx) {
+  const sessionCaches = new Map;
+  function getSessionCache(sessionID) {
+    if (!sessionCaches.has(sessionID)) {
+      sessionCaches.set(sessionID, loadInjectedPaths2(sessionID));
+    }
+    return sessionCaches.get(sessionID);
+  }
+  function resolveFilePath(title) {
+    if (!title)
+      return null;
+    if (title.startsWith("/"))
+      return title;
+    return resolve2(ctx.directory, title);
+  }
+  function findReadmeMdUp(startDir) {
+    const found = [];
+    let current = startDir;
+    while (true) {
+      const readmePath = join10(current, README_FILENAME);
+      if (existsSync8(readmePath)) {
+        found.push(readmePath);
+      }
+      if (current === ctx.directory)
+        break;
+      const parent = dirname3(current);
+      if (parent === current)
+        break;
+      if (!parent.startsWith(ctx.directory))
+        break;
+      current = parent;
+    }
+    return found.reverse();
+  }
+  const toolExecuteAfter = async (input, output) => {
+    if (input.tool.toLowerCase() !== "read")
+      return;
+    const filePath = resolveFilePath(output.title);
+    if (!filePath)
+      return;
+    const dir = dirname3(filePath);
+    const cache = getSessionCache(input.sessionID);
+    const readmePaths = findReadmeMdUp(dir);
+    const toInject = [];
+    for (const readmePath of readmePaths) {
+      const readmeDir = dirname3(readmePath);
+      if (cache.has(readmeDir))
+        continue;
+      try {
+        const content = readFileSync5(readmePath, "utf-8");
+        toInject.push({ path: readmePath, content });
+        cache.add(readmeDir);
+      } catch {}
+    }
+    if (toInject.length === 0)
+      return;
+    for (const { path: path2, content } of toInject) {
+      output.output += `
+
+[Project README: ${path2}]
+${content}`;
+    }
+    saveInjectedPaths2(input.sessionID, cache);
+  };
+  const eventHandler = async ({ event }) => {
+    const props = event.properties;
+    if (event.type === "session.deleted") {
+      const sessionInfo = props?.info;
+      if (sessionInfo?.id) {
+        sessionCaches.delete(sessionInfo.id);
+        clearInjectedPaths2(sessionInfo.id);
+      }
+    }
+    if (event.type === "session.compacted") {
+      const sessionID = props?.sessionID ?? props?.info?.id;
+      if (sessionID) {
+        sessionCaches.delete(sessionID);
+        clearInjectedPaths2(sessionID);
+      }
+    }
+  };
+  return {
+    "tool.execute.after": toolExecuteAfter,
+    event: eventHandler
+  };
+}
 // src/hooks/empty-task-response-detector.ts
 var EMPTY_RESPONSE_WARNING = `[Task Empty Response Warning]
 
@@ -1811,6 +1993,280 @@ function createEmptyTaskResponseDetectorHook(_ctx) {
     }
   };
 }
+// src/hooks/anthropic-auto-compact/parser.ts
+var TOKEN_LIMIT_PATTERNS = [
+  /(\d+)\s*tokens?\s*>\s*(\d+)\s*maximum/i,
+  /prompt.*?(\d+).*?tokens.*?exceeds.*?(\d+)/i,
+  /(\d+).*?tokens.*?limit.*?(\d+)/i,
+  /context.*?length.*?(\d+).*?maximum.*?(\d+)/i,
+  /max.*?context.*?(\d+).*?but.*?(\d+)/i
+];
+var TOKEN_LIMIT_KEYWORDS = [
+  "prompt is too long",
+  "is too long",
+  "context_length_exceeded",
+  "max_tokens",
+  "token limit",
+  "context length",
+  "too many tokens"
+];
+function extractTokensFromMessage(message) {
+  for (const pattern of TOKEN_LIMIT_PATTERNS) {
+    const match = message.match(pattern);
+    if (match) {
+      const num1 = parseInt(match[1], 10);
+      const num2 = parseInt(match[2], 10);
+      return num1 > num2 ? { current: num1, max: num2 } : { current: num2, max: num1 };
+    }
+  }
+  return null;
+}
+function isTokenLimitError(text) {
+  const lower = text.toLowerCase();
+  return TOKEN_LIMIT_KEYWORDS.some((kw) => lower.includes(kw.toLowerCase()));
+}
+function parseAnthropicTokenLimitError(err) {
+  if (typeof err === "string") {
+    if (isTokenLimitError(err)) {
+      const tokens = extractTokensFromMessage(err);
+      return {
+        currentTokens: tokens?.current ?? 0,
+        maxTokens: tokens?.max ?? 0,
+        errorType: "token_limit_exceeded_string"
+      };
+    }
+    return null;
+  }
+  if (!err || typeof err !== "object")
+    return null;
+  const errObj = err;
+  const dataObj = errObj.data;
+  const responseBody = dataObj?.responseBody;
+  const errorMessage = errObj.message;
+  const errorData = errObj.error;
+  const nestedError = errorData?.error;
+  const textSources = [];
+  if (typeof responseBody === "string")
+    textSources.push(responseBody);
+  if (typeof errorMessage === "string")
+    textSources.push(errorMessage);
+  if (typeof errorData?.message === "string")
+    textSources.push(errorData.message);
+  if (typeof errObj.body === "string")
+    textSources.push(errObj.body);
+  if (typeof errObj.details === "string")
+    textSources.push(errObj.details);
+  if (typeof errObj.reason === "string")
+    textSources.push(errObj.reason);
+  if (typeof errObj.description === "string")
+    textSources.push(errObj.description);
+  if (typeof nestedError?.message === "string")
+    textSources.push(nestedError.message);
+  if (typeof dataObj?.message === "string")
+    textSources.push(dataObj.message);
+  if (typeof dataObj?.error === "string")
+    textSources.push(dataObj.error);
+  if (textSources.length === 0) {
+    try {
+      const jsonStr = JSON.stringify(errObj);
+      if (isTokenLimitError(jsonStr)) {
+        textSources.push(jsonStr);
+      }
+    } catch {}
+  }
+  const combinedText = textSources.join(" ");
+  if (!isTokenLimitError(combinedText))
+    return null;
+  if (typeof responseBody === "string") {
+    try {
+      const jsonPatterns = [
+        /data:\s*(\{[\s\S]*?\})\s*$/m,
+        /(\{"type"\s*:\s*"error"[\s\S]*?\})/,
+        /(\{[\s\S]*?"error"[\s\S]*?\})/
+      ];
+      for (const pattern of jsonPatterns) {
+        const dataMatch = responseBody.match(pattern);
+        if (dataMatch) {
+          try {
+            const jsonData = JSON.parse(dataMatch[1]);
+            const message = jsonData.error?.message || "";
+            const tokens = extractTokensFromMessage(message);
+            if (tokens) {
+              return {
+                currentTokens: tokens.current,
+                maxTokens: tokens.max,
+                requestId: jsonData.request_id,
+                errorType: jsonData.error?.type || "token_limit_exceeded"
+              };
+            }
+          } catch {}
+        }
+      }
+      const bedrockJson = JSON.parse(responseBody);
+      if (typeof bedrockJson.message === "string" && isTokenLimitError(bedrockJson.message)) {
+        return {
+          currentTokens: 0,
+          maxTokens: 0,
+          errorType: "bedrock_input_too_long"
+        };
+      }
+    } catch {}
+  }
+  for (const text of textSources) {
+    const tokens = extractTokensFromMessage(text);
+    if (tokens) {
+      return {
+        currentTokens: tokens.current,
+        maxTokens: tokens.max,
+        errorType: "token_limit_exceeded"
+      };
+    }
+  }
+  if (isTokenLimitError(combinedText)) {
+    return {
+      currentTokens: 0,
+      maxTokens: 0,
+      errorType: "token_limit_exceeded_unknown"
+    };
+  }
+  return null;
+}
+
+// src/hooks/anthropic-auto-compact/executor.ts
+async function getLastAssistant(sessionID, client, directory) {
+  try {
+    const resp = await client.session.messages({
+      path: { id: sessionID },
+      query: { directory }
+    });
+    const data = resp.data;
+    if (!Array.isArray(data))
+      return null;
+    const reversed = [...data].reverse();
+    const last = reversed.find((m) => {
+      const msg = m;
+      const info = msg.info;
+      return info?.role === "assistant";
+    });
+    if (!last)
+      return null;
+    return last.info ?? null;
+  } catch {
+    return null;
+  }
+}
+async function executeCompact(sessionID, msg, autoCompactState, client, directory) {
+  try {
+    const providerID = msg.providerID;
+    const modelID = msg.modelID;
+    if (providerID && modelID) {
+      await client.session.summarize({
+        path: { id: sessionID },
+        body: { providerID, modelID },
+        query: { directory }
+      });
+      setTimeout(async () => {
+        try {
+          await client.tui.submitPrompt({ query: { directory } });
+        } catch {}
+      }, 500);
+    }
+    autoCompactState.pendingCompact.delete(sessionID);
+    autoCompactState.errorDataBySession.delete(sessionID);
+  } catch {}
+}
+
+// src/hooks/anthropic-auto-compact/index.ts
+function createAutoCompactState() {
+  return {
+    pendingCompact: new Set,
+    errorDataBySession: new Map
+  };
+}
+function createAnthropicAutoCompactHook(ctx) {
+  const autoCompactState = createAutoCompactState();
+  const eventHandler = async ({ event }) => {
+    const props = event.properties;
+    if (event.type === "session.deleted") {
+      const sessionInfo = props?.info;
+      if (sessionInfo?.id) {
+        autoCompactState.pendingCompact.delete(sessionInfo.id);
+        autoCompactState.errorDataBySession.delete(sessionInfo.id);
+      }
+      return;
+    }
+    if (event.type === "session.error") {
+      const sessionID = props?.sessionID;
+      if (!sessionID)
+        return;
+      const parsed = parseAnthropicTokenLimitError(props?.error);
+      if (parsed) {
+        autoCompactState.pendingCompact.add(sessionID);
+        autoCompactState.errorDataBySession.set(sessionID, parsed);
+      }
+      return;
+    }
+    if (event.type === "message.updated") {
+      const info = props?.info;
+      const sessionID = info?.sessionID;
+      if (sessionID && info?.role === "assistant" && info.error) {
+        const parsed = parseAnthropicTokenLimitError(info.error);
+        if (parsed) {
+          parsed.providerID = info.providerID;
+          parsed.modelID = info.modelID;
+          autoCompactState.pendingCompact.add(sessionID);
+          autoCompactState.errorDataBySession.set(sessionID, parsed);
+        }
+      }
+      return;
+    }
+    if (event.type === "session.idle") {
+      const sessionID = props?.sessionID;
+      if (!sessionID)
+        return;
+      if (!autoCompactState.pendingCompact.has(sessionID))
+        return;
+      const errorData = autoCompactState.errorDataBySession.get(sessionID);
+      if (errorData?.providerID && errorData?.modelID) {
+        await ctx.client.tui.showToast({
+          body: {
+            title: "Auto Compact",
+            message: "Token limit exceeded. Summarizing session...",
+            variant: "warning",
+            duration: 3000
+          }
+        }).catch(() => {});
+        await executeCompact(sessionID, { providerID: errorData.providerID, modelID: errorData.modelID }, autoCompactState, ctx.client, ctx.directory);
+        return;
+      }
+      const lastAssistant = await getLastAssistant(sessionID, ctx.client, ctx.directory);
+      if (!lastAssistant) {
+        autoCompactState.pendingCompact.delete(sessionID);
+        return;
+      }
+      if (lastAssistant.summary === true) {
+        autoCompactState.pendingCompact.delete(sessionID);
+        return;
+      }
+      if (!lastAssistant.modelID || !lastAssistant.providerID) {
+        autoCompactState.pendingCompact.delete(sessionID);
+        return;
+      }
+      await ctx.client.tui.showToast({
+        body: {
+          title: "Auto Compact",
+          message: "Token limit exceeded. Summarizing session...",
+          variant: "warning",
+          duration: 3000
+        }
+      }).catch(() => {});
+      await executeCompact(sessionID, lastAssistant, autoCompactState, ctx.client, ctx.directory);
+    }
+  };
+  return {
+    event: eventHandler
+  };
+}
 // src/hooks/think-mode/detector.ts
 var ENGLISH_PATTERNS = [/\bultrathink\b/i, /\bthink\b/i];
 var MULTILINGUAL_KEYWORDS = [
@@ -1991,8 +2447,8 @@ function createThinkModeHook() {
 }
 // src/hooks/claude-code-hooks/config.ts
 import { homedir as homedir2 } from "os";
-import { join as join8 } from "path";
-import { existsSync as existsSync7 } from "fs";
+import { join as join11 } from "path";
+import { existsSync as existsSync9 } from "fs";
 function normalizeHookMatcher(raw) {
   return {
     matcher: raw.matcher ?? raw.pattern ?? "*",
@@ -2017,11 +2473,11 @@ function normalizeHooksConfig(raw) {
 function getClaudeSettingsPaths(customPath) {
   const home = homedir2();
   const paths = [
-    join8(home, ".claude", "settings.json"),
-    join8(process.cwd(), ".claude", "settings.json"),
-    join8(process.cwd(), ".claude", "settings.local.json")
+    join11(home, ".claude", "settings.json"),
+    join11(process.cwd(), ".claude", "settings.json"),
+    join11(process.cwd(), ".claude", "settings.local.json")
   ];
-  if (customPath && existsSync7(customPath)) {
+  if (customPath && existsSync9(customPath)) {
     paths.unshift(customPath);
   }
   return paths;
@@ -2045,7 +2501,7 @@ async function loadClaudeHooksConfig(customSettingsPath) {
   const paths = getClaudeSettingsPaths(customSettingsPath);
   let mergedConfig = {};
   for (const settingsPath of paths) {
-    if (existsSync7(settingsPath)) {
+    if (existsSync9(settingsPath)) {
       try {
         const content = await Bun.file(settingsPath).text();
         const settings = JSON.parse(content);
@@ -2062,9 +2518,9 @@ async function loadClaudeHooksConfig(customSettingsPath) {
 }
 
 // src/hooks/claude-code-hooks/config-loader.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join10 } from "path";
+import { join as join13 } from "path";
 
 // src/shared/logger.ts
 import * as fs3 from "fs";
@@ -2081,12 +2537,12 @@ function log(message, data) {
 }
 
 // src/hooks/claude-code-hooks/config-loader.ts
-var USER_CONFIG_PATH = join10(homedir3(), ".config", "opencode", "opencode-cc-plugin.json");
+var USER_CONFIG_PATH = join13(homedir3(), ".config", "opencode", "opencode-cc-plugin.json");
 function getProjectConfigPath() {
-  return join10(process.cwd(), ".opencode", "opencode-cc-plugin.json");
+  return join13(process.cwd(), ".opencode", "opencode-cc-plugin.json");
 }
 async function loadConfigFromPath(path3) {
-  if (!existsSync8(path3)) {
+  if (!existsSync10(path3)) {
     return null;
   }
   try {
@@ -2179,14 +2635,14 @@ function parseFrontmatter(content) {
 import { spawn as spawn3 } from "child_process";
 import { exec } from "child_process";
 import { promisify } from "util";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 var DEFAULT_ZSH_PATHS = ["/bin/zsh", "/usr/bin/zsh", "/usr/local/bin/zsh"];
 function findZshPath(customZshPath) {
-  if (customZshPath && existsSync9(customZshPath)) {
+  if (customZshPath && existsSync11(customZshPath)) {
     return customZshPath;
   }
   for (const path3 of DEFAULT_ZSH_PATHS) {
-    if (existsSync9(path3)) {
+    if (existsSync11(path3)) {
       return path3;
     }
   }
@@ -2204,7 +2660,7 @@ async function executeHookCommand(command, stdin, cwd, options) {
       finalCommand = `${zshPath} -lc '${escapedCommand}'`;
     }
   }
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const proc = spawn3(finalCommand, {
       cwd,
       shell: true,
@@ -2221,14 +2677,14 @@ async function executeHookCommand(command, stdin, cwd, options) {
     proc.stdin?.write(stdin);
     proc.stdin?.end();
     proc.on("close", (code) => {
-      resolve2({
+      resolve3({
         exitCode: code ?? 0,
         stdout: stdout.trim(),
         stderr: stderr.trim()
       });
     });
     proc.on("error", (err) => {
-      resolve2({
+      resolve3({
         exitCode: 1,
         stderr: err.message
       });
@@ -2304,8 +2760,8 @@ async function resolveCommandsInText(text, depth = 0, maxDepth = 3) {
   return resolved;
 }
 // src/shared/file-reference-resolver.ts
-import { existsSync as existsSync10, readFileSync as readFileSync4, statSync } from "fs";
-import { join as join11, isAbsolute } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync6, statSync } from "fs";
+import { join as join14, isAbsolute } from "path";
 var FILE_REFERENCE_PATTERN = /@([^\s@]+)/g;
 function findFileReferences(text) {
   const matches = [];
@@ -2325,17 +2781,17 @@ function resolveFilePath(filePath, cwd) {
   if (isAbsolute(filePath)) {
     return filePath;
   }
-  return join11(cwd, filePath);
+  return join14(cwd, filePath);
 }
 function readFileContent(resolvedPath) {
-  if (!existsSync10(resolvedPath)) {
+  if (!existsSync12(resolvedPath)) {
     return `[file not found: ${resolvedPath}]`;
   }
   const stat = statSync(resolvedPath);
   if (stat.isDirectory()) {
     return `[cannot read directory: ${resolvedPath}]`;
   }
-  const content = readFileSync4(resolvedPath, "utf-8");
+  const content = readFileSync6(resolvedPath, "utf-8");
   return content;
 }
 async function resolveFileReferencesInText(text, cwd = process.cwd(), depth = 0, maxDepth = 3) {
@@ -2558,17 +3014,17 @@ async function executePreToolUseHooks(ctx, config, extendedConfig) {
 }
 
 // src/hooks/claude-code-hooks/transcript.ts
-import { join as join12 } from "path";
-import { mkdirSync as mkdirSync4, appendFileSync as appendFileSync5, existsSync as existsSync11, writeFileSync as writeFileSync3, unlinkSync as unlinkSync4 } from "fs";
+import { join as join15 } from "path";
+import { mkdirSync as mkdirSync5, appendFileSync as appendFileSync5, existsSync as existsSync13, writeFileSync as writeFileSync4, unlinkSync as unlinkSync5 } from "fs";
 import { homedir as homedir4, tmpdir as tmpdir2 } from "os";
 import { randomUUID } from "crypto";
-var TRANSCRIPT_DIR = join12(homedir4(), ".claude", "transcripts");
+var TRANSCRIPT_DIR = join15(homedir4(), ".claude", "transcripts");
 function getTranscriptPath(sessionId) {
-  return join12(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
+  return join15(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
 }
 function ensureTranscriptDir() {
-  if (!existsSync11(TRANSCRIPT_DIR)) {
-    mkdirSync4(TRANSCRIPT_DIR, { recursive: true });
+  if (!existsSync13(TRANSCRIPT_DIR)) {
+    mkdirSync5(TRANSCRIPT_DIR, { recursive: true });
   }
 }
 function appendTranscriptEntry(sessionId, entry) {
@@ -2654,8 +3110,8 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
       }
     };
     entries.push(JSON.stringify(currentEntry));
-    const tempPath = join12(tmpdir2(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
-    writeFileSync3(tempPath, entries.join(`
+    const tempPath = join15(tmpdir2(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+    writeFileSync4(tempPath, entries.join(`
 `) + `
 `);
     return tempPath;
@@ -2674,8 +3130,8 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
           ]
         }
       };
-      const tempPath = join12(tmpdir2(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
-      writeFileSync3(tempPath, JSON.stringify(currentEntry) + `
+      const tempPath = join15(tmpdir2(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+      writeFileSync4(tempPath, JSON.stringify(currentEntry) + `
 `);
       return tempPath;
     } catch {
@@ -2687,7 +3143,7 @@ function deleteTempTranscript(path3) {
   if (!path3)
     return;
   try {
-    unlinkSync4(path3);
+    unlinkSync5(path3);
   } catch {}
 }
 
@@ -2886,11 +3342,11 @@ ${USER_PROMPT_SUBMIT_TAG_CLOSE}`);
 }
 
 // src/hooks/claude-code-hooks/todo.ts
-import { join as join13 } from "path";
+import { join as join16 } from "path";
 import { homedir as homedir5 } from "os";
-var TODO_DIR = join13(homedir5(), ".claude", "todos");
+var TODO_DIR = join16(homedir5(), ".claude", "todos");
 function getTodoPath(sessionId) {
-  return join13(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
+  return join16(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
 }
 
 // src/hooks/claude-code-hooks/stop.ts
@@ -2982,16 +3438,16 @@ setInterval(() => {
 }, CACHE_TTL);
 
 // src/features/hook-message-injector/injector.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync5, readdirSync as readdirSync2, writeFileSync as writeFileSync4 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync6, readFileSync as readFileSync7, readdirSync as readdirSync2, writeFileSync as writeFileSync5 } from "fs";
+import { join as join18 } from "path";
 
 // src/features/hook-message-injector/constants.ts
-import { join as join14 } from "path";
+import { join as join17 } from "path";
 import { homedir as homedir6 } from "os";
-var xdgData2 = process.env.XDG_DATA_HOME || join14(homedir6(), ".local", "share");
-var OPENCODE_STORAGE3 = join14(xdgData2, "opencode", "storage");
-var MESSAGE_STORAGE2 = join14(OPENCODE_STORAGE3, "message");
-var PART_STORAGE2 = join14(OPENCODE_STORAGE3, "part");
+var xdgData2 = process.env.XDG_DATA_HOME || join17(homedir6(), ".local", "share");
+var OPENCODE_STORAGE4 = join17(xdgData2, "opencode", "storage");
+var MESSAGE_STORAGE2 = join17(OPENCODE_STORAGE4, "message");
+var PART_STORAGE2 = join17(OPENCODE_STORAGE4, "part");
 
 // src/features/hook-message-injector/injector.ts
 function findNearestMessageWithFields(messageDir) {
@@ -2999,7 +3455,7 @@ function findNearestMessageWithFields(messageDir) {
     const files = readdirSync2(messageDir).filter((f) => f.endsWith(".json")).sort().reverse();
     for (const file of files) {
       try {
-        const content = readFileSync5(join15(messageDir, file), "utf-8");
+        const content = readFileSync7(join18(messageDir, file), "utf-8");
         const msg = JSON.parse(content);
         if (msg.agent && msg.model?.providerID && msg.model?.modelID) {
           return msg;
@@ -3024,20 +3480,20 @@ function generatePartId2() {
   return `prt_${timestamp}${random}`;
 }
 function getOrCreateMessageDir(sessionID) {
-  if (!existsSync12(MESSAGE_STORAGE2)) {
-    mkdirSync5(MESSAGE_STORAGE2, { recursive: true });
+  if (!existsSync14(MESSAGE_STORAGE2)) {
+    mkdirSync6(MESSAGE_STORAGE2, { recursive: true });
   }
-  const directPath = join15(MESSAGE_STORAGE2, sessionID);
-  if (existsSync12(directPath)) {
+  const directPath = join18(MESSAGE_STORAGE2, sessionID);
+  if (existsSync14(directPath)) {
     return directPath;
   }
   for (const dir of readdirSync2(MESSAGE_STORAGE2)) {
-    const sessionPath = join15(MESSAGE_STORAGE2, dir, sessionID);
-    if (existsSync12(sessionPath)) {
+    const sessionPath = join18(MESSAGE_STORAGE2, dir, sessionID);
+    if (existsSync14(sessionPath)) {
       return sessionPath;
     }
   }
-  mkdirSync5(directPath, { recursive: true });
+  mkdirSync6(directPath, { recursive: true });
   return directPath;
 }
 function injectHookMessage(sessionID, hookContent, originalMessage) {
@@ -3078,12 +3534,12 @@ function injectHookMessage(sessionID, hookContent, originalMessage) {
     sessionID
   };
   try {
-    writeFileSync4(join15(messageDir, `${messageID}.json`), JSON.stringify(messageMeta, null, 2));
-    const partDir = join15(PART_STORAGE2, messageID);
-    if (!existsSync12(partDir)) {
-      mkdirSync5(partDir, { recursive: true });
+    writeFileSync5(join18(messageDir, `${messageID}.json`), JSON.stringify(messageMeta, null, 2));
+    const partDir = join18(PART_STORAGE2, messageID);
+    if (!existsSync14(partDir)) {
+      mkdirSync6(partDir, { recursive: true });
     }
-    writeFileSync4(join15(partDir, `${partID}.json`), JSON.stringify(textPart, null, 2));
+    writeFileSync5(join18(partDir, `${partID}.json`), JSON.stringify(textPart, null, 2));
     return true;
   } catch {
     return false;
@@ -3329,14 +3785,14 @@ ${result.message}`;
   };
 }
 // src/features/claude-code-command-loader/loader.ts
-import { existsSync as existsSync13, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync15, readdirSync as readdirSync3, readFileSync as readFileSync8 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join16, basename } from "path";
+import { join as join19, basename } from "path";
 function isMarkdownFile(entry) {
   return !entry.name.startsWith(".") && entry.name.endsWith(".md") && entry.isFile();
 }
 function loadCommandsFromDir(commandsDir, scope) {
-  if (!existsSync13(commandsDir)) {
+  if (!existsSync15(commandsDir)) {
     return [];
   }
   const entries = readdirSync3(commandsDir, { withFileTypes: true });
@@ -3344,10 +3800,10 @@ function loadCommandsFromDir(commandsDir, scope) {
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join16(commandsDir, entry.name);
+    const commandPath = join19(commandsDir, entry.name);
     const commandName = basename(entry.name, ".md");
     try {
-      const content = readFileSync6(commandPath, "utf-8");
+      const content = readFileSync8(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const wrappedTemplate = `<command-instruction>
 ${body.trim()}
@@ -3386,31 +3842,31 @@ function commandsToRecord(commands) {
   return result;
 }
 function loadUserCommands() {
-  const userCommandsDir = join16(homedir7(), ".claude", "commands");
+  const userCommandsDir = join19(homedir7(), ".claude", "commands");
   const commands = loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands);
 }
 function loadProjectCommands() {
-  const projectCommandsDir = join16(process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join19(process.cwd(), ".claude", "commands");
   const commands = loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands);
 }
 function loadOpencodeGlobalCommands() {
-  const opencodeCommandsDir = join16(homedir7(), ".config", "opencode", "command");
+  const opencodeCommandsDir = join19(homedir7(), ".config", "opencode", "command");
   const commands = loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands);
 }
 function loadOpencodeProjectCommands() {
-  const opencodeProjectDir = join16(process.cwd(), ".opencode", "command");
+  const opencodeProjectDir = join19(process.cwd(), ".opencode", "command");
   const commands = loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands);
 }
 // src/features/claude-code-skill-loader/loader.ts
-import { existsSync as existsSync14, readdirSync as readdirSync4, readFileSync as readFileSync7, statSync as statSync2, readlinkSync } from "fs";
+import { existsSync as existsSync16, readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync2, readlinkSync } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join17, resolve as resolve2 } from "path";
+import { join as join20, resolve as resolve3 } from "path";
 function loadSkillsFromDir(skillsDir, scope) {
-  if (!existsSync14(skillsDir)) {
+  if (!existsSync16(skillsDir)) {
     return [];
   }
   const entries = readdirSync4(skillsDir, { withFileTypes: true });
@@ -3418,18 +3874,18 @@ function loadSkillsFromDir(skillsDir, scope) {
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
-    const skillPath = join17(skillsDir, entry.name);
+    const skillPath = join20(skillsDir, entry.name);
     if (!entry.isDirectory() && !entry.isSymbolicLink())
       continue;
     let resolvedPath = skillPath;
     if (statSync2(skillPath, { throwIfNoEntry: false })?.isSymbolicLink()) {
-      resolvedPath = resolve2(skillPath, "..", readlinkSync(skillPath));
+      resolvedPath = resolve3(skillPath, "..", readlinkSync(skillPath));
     }
-    const skillMdPath = join17(resolvedPath, "SKILL.md");
-    if (!existsSync14(skillMdPath))
+    const skillMdPath = join20(resolvedPath, "SKILL.md");
+    if (!existsSync16(skillMdPath))
       continue;
     try {
-      const content = readFileSync7(skillMdPath, "utf-8");
+      const content = readFileSync9(skillMdPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const skillName = data.name || entry.name;
       const originalDescription = data.description || "";
@@ -3460,7 +3916,7 @@ $ARGUMENTS
   return skills;
 }
 function loadUserSkillsAsCommands() {
-  const userSkillsDir = join17(homedir8(), ".claude", "skills");
+  const userSkillsDir = join20(homedir8(), ".claude", "skills");
   const skills = loadSkillsFromDir(userSkillsDir, "user");
   return skills.reduce((acc, skill) => {
     acc[skill.name] = skill.definition;
@@ -3468,7 +3924,7 @@ function loadUserSkillsAsCommands() {
   }, {});
 }
 function loadProjectSkillsAsCommands() {
-  const projectSkillsDir = join17(process.cwd(), ".claude", "skills");
+  const projectSkillsDir = join20(process.cwd(), ".claude", "skills");
   const skills = loadSkillsFromDir(projectSkillsDir, "project");
   return skills.reduce((acc, skill) => {
     acc[skill.name] = skill.definition;
@@ -3476,9 +3932,9 @@ function loadProjectSkillsAsCommands() {
   }, {});
 }
 // src/features/claude-code-agent-loader/loader.ts
-import { existsSync as existsSync15, readdirSync as readdirSync5, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync17, readdirSync as readdirSync5, readFileSync as readFileSync10 } from "fs";
 import { homedir as homedir9 } from "os";
-import { join as join18, basename as basename2 } from "path";
+import { join as join21, basename as basename2 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
     return;
@@ -3495,7 +3951,7 @@ function isMarkdownFile2(entry) {
   return !entry.name.startsWith(".") && entry.name.endsWith(".md") && entry.isFile();
 }
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync15(agentsDir)) {
+  if (!existsSync17(agentsDir)) {
     return [];
   }
   const entries = readdirSync5(agentsDir, { withFileTypes: true });
@@ -3503,10 +3959,10 @@ function loadAgentsFromDir(agentsDir, scope) {
   for (const entry of entries) {
     if (!isMarkdownFile2(entry))
       continue;
-    const agentPath = join18(agentsDir, entry.name);
+    const agentPath = join21(agentsDir, entry.name);
     const agentName = basename2(entry.name, ".md");
     try {
-      const content = readFileSync8(agentPath, "utf-8");
+      const content = readFileSync10(agentPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const name = data.name || agentName;
       const originalDescription = data.description || "";
@@ -3533,7 +3989,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   return agents;
 }
 function loadUserAgents() {
-  const userAgentsDir = join18(homedir9(), ".claude", "agents");
+  const userAgentsDir = join21(homedir9(), ".claude", "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user");
   const result = {};
   for (const agent of agents) {
@@ -3542,7 +3998,7 @@ function loadUserAgents() {
   return result;
 }
 function loadProjectAgents() {
-  const projectAgentsDir = join18(process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join21(process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project");
   const result = {};
   for (const agent of agents) {
@@ -3551,9 +4007,9 @@ function loadProjectAgents() {
   return result;
 }
 // src/features/claude-code-mcp-loader/loader.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync18 } from "fs";
 import { homedir as homedir10 } from "os";
-import { join as join19 } from "path";
+import { join as join22 } from "path";
 
 // src/features/claude-code-mcp-loader/env-expander.ts
 function expandEnvVars(value) {
@@ -3622,13 +4078,13 @@ function getMcpConfigPaths() {
   const home = homedir10();
   const cwd = process.cwd();
   return [
-    { path: join19(home, ".claude", ".mcp.json"), scope: "user" },
-    { path: join19(cwd, ".mcp.json"), scope: "project" },
-    { path: join19(cwd, ".claude", ".mcp.json"), scope: "local" }
+    { path: join22(home, ".claude", ".mcp.json"), scope: "user" },
+    { path: join22(cwd, ".mcp.json"), scope: "project" },
+    { path: join22(cwd, ".claude", ".mcp.json"), scope: "local" }
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync16(filePath)) {
+  if (!existsSync18(filePath)) {
     return null;
   }
   try {
@@ -3914,14 +4370,14 @@ var EXT_TO_LANG = {
   ".tfvars": "terraform"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync17, readFileSync as readFileSync9 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync11 } from "fs";
+import { join as join23 } from "path";
 import { homedir as homedir11 } from "os";
 function loadJsonFile(path3) {
-  if (!existsSync17(path3))
+  if (!existsSync19(path3))
     return null;
   try {
-    return JSON.parse(readFileSync9(path3, "utf-8"));
+    return JSON.parse(readFileSync11(path3, "utf-8"));
   } catch {
     return null;
   }
@@ -3929,9 +4385,9 @@ function loadJsonFile(path3) {
 function getConfigPaths() {
   const cwd = process.cwd();
   return {
-    project: join20(cwd, ".opencode", "oh-my-opencode.json"),
-    user: join20(homedir11(), ".config", "opencode", "oh-my-opencode.json"),
-    opencode: join20(homedir11(), ".config", "opencode", "opencode.json")
+    project: join23(cwd, ".opencode", "oh-my-opencode.json"),
+    user: join23(homedir11(), ".config", "opencode", "oh-my-opencode.json"),
+    opencode: join23(homedir11(), ".config", "opencode", "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -4024,7 +4480,7 @@ function isServerInstalled(command) {
   const pathEnv = process.env.PATH || "";
   const paths = pathEnv.split(":");
   for (const p of paths) {
-    if (existsSync17(join20(p, cmd))) {
+    if (existsSync19(join23(p, cmd))) {
       return true;
     }
   }
@@ -4074,8 +4530,8 @@ function getAllServers() {
 }
 // src/tools/lsp/client.ts
 var {spawn: spawn4 } = globalThis.Bun;
-import { readFileSync as readFileSync10 } from "fs";
-import { extname, resolve as resolve3 } from "path";
+import { readFileSync as readFileSync12 } from "fs";
+import { extname, resolve as resolve4 } from "path";
 class LSPServerManager {
   static instance;
   clients = new Map;
@@ -4225,7 +4681,7 @@ class LSPClient {
     }
     this.startReading();
     this.startStderrReading();
-    await new Promise((resolve4) => setTimeout(resolve4, 100));
+    await new Promise((resolve5) => setTimeout(resolve5, 100));
     if (this.proc.exitCode !== null) {
       const stderr = this.stderrBuffer.join(`
 `);
@@ -4362,8 +4818,8 @@ stderr: ${stderr}` : ""));
 \r
 `;
     this.proc.stdin.write(header + msg);
-    return new Promise((resolve4, reject) => {
-      this.pending.set(id, { resolve: resolve4, reject });
+    return new Promise((resolve5, reject) => {
+      this.pending.set(id, { resolve: resolve5, reject });
       setTimeout(() => {
         if (this.pending.has(id)) {
           this.pending.delete(id);
@@ -4471,10 +4927,10 @@ ${msg}`);
     await new Promise((r) => setTimeout(r, 300));
   }
   async openFile(filePath) {
-    const absPath = resolve3(filePath);
+    const absPath = resolve4(filePath);
     if (this.openedFiles.has(absPath))
       return;
-    const text = readFileSync10(absPath, "utf-8");
+    const text = readFileSync12(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     this.notify("textDocument/didOpen", {
@@ -4489,7 +4945,7 @@ ${msg}`);
     await new Promise((r) => setTimeout(r, 1000));
   }
   async hover(filePath, line, character) {
-    const absPath = resolve3(filePath);
+    const absPath = resolve4(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/hover", {
       textDocument: { uri: `file://${absPath}` },
@@ -4497,7 +4953,7 @@ ${msg}`);
     });
   }
   async definition(filePath, line, character) {
-    const absPath = resolve3(filePath);
+    const absPath = resolve4(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/definition", {
       textDocument: { uri: `file://${absPath}` },
@@ -4505,7 +4961,7 @@ ${msg}`);
     });
   }
   async references(filePath, line, character, includeDeclaration = true) {
-    const absPath = resolve3(filePath);
+    const absPath = resolve4(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/references", {
       textDocument: { uri: `file://${absPath}` },
@@ -4514,7 +4970,7 @@ ${msg}`);
     });
   }
   async documentSymbols(filePath) {
-    const absPath = resolve3(filePath);
+    const absPath = resolve4(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/documentSymbol", {
       textDocument: { uri: `file://${absPath}` }
@@ -4524,7 +4980,7 @@ ${msg}`);
     return this.send("workspace/symbol", { query });
   }
   async diagnostics(filePath) {
-    const absPath = resolve3(filePath);
+    const absPath = resolve4(filePath);
     const uri = `file://${absPath}`;
     await this.openFile(absPath);
     await new Promise((r) => setTimeout(r, 500));
@@ -4539,7 +4995,7 @@ ${msg}`);
     return { items: this.diagnosticsStore.get(uri) ?? [] };
   }
   async prepareRename(filePath, line, character) {
-    const absPath = resolve3(filePath);
+    const absPath = resolve4(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/prepareRename", {
       textDocument: { uri: `file://${absPath}` },
@@ -4547,7 +5003,7 @@ ${msg}`);
     });
   }
   async rename(filePath, line, character, newName) {
-    const absPath = resolve3(filePath);
+    const absPath = resolve4(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/rename", {
       textDocument: { uri: `file://${absPath}` },
@@ -4556,7 +5012,7 @@ ${msg}`);
     });
   }
   async codeAction(filePath, startLine, startChar, endLine, endChar, only) {
-    const absPath = resolve3(filePath);
+    const absPath = resolve4(filePath);
     await this.openFile(absPath);
     return this.send("textDocument/codeAction", {
       textDocument: { uri: `file://${absPath}` },
@@ -4588,26 +5044,26 @@ ${msg}`);
   }
 }
 // src/tools/lsp/utils.ts
-import { extname as extname2, resolve as resolve4 } from "path";
-import { existsSync as existsSync18, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
+import { extname as extname2, resolve as resolve5 } from "path";
+import { existsSync as existsSync20, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
 function findWorkspaceRoot(filePath) {
-  let dir = resolve4(filePath);
-  if (!existsSync18(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  let dir = resolve5(filePath);
+  if (!existsSync20(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 (existsSync18(__require("path").join(dir, marker))) {
+      if (existsSync20(__require("path").join(dir, marker))) {
         return dir;
       }
     }
     dir = __require("path").dirname(dir);
   }
-  return __require("path").dirname(resolve4(filePath));
+  return __require("path").dirname(resolve5(filePath));
 }
 async function withLspClient(filePath, fn) {
-  const absPath = resolve4(filePath);
+  const absPath = resolve5(filePath);
   const ext = extname2(absPath);
   const server = findServerForExtension(ext);
   if (!server) {
@@ -4756,7 +5212,7 @@ function formatCodeActions(actions) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync11(filePath, "utf-8");
+    let content = readFileSync13(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -4781,7 +5237,7 @@ function applyTextEditsToFile(filePath, edits) {
 `));
       }
     }
-    writeFileSync5(filePath, lines.join(`
+    writeFileSync6(filePath, lines.join(`
 `), "utf-8");
     return { success: true, editCount: edits.length };
   } catch (err) {
@@ -4812,7 +5268,7 @@ function applyWorkspaceEdit(edit) {
         if (change.kind === "create") {
           try {
             const filePath = change.uri.replace("file://", "");
-            writeFileSync5(filePath, "", "utf-8");
+            writeFileSync6(filePath, "", "utf-8");
             result.filesModified.push(filePath);
           } catch (err) {
             result.success = false;
@@ -4822,8 +5278,8 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = change.oldUri.replace("file://", "");
             const newPath = change.newUri.replace("file://", "");
-            const content = readFileSync11(oldPath, "utf-8");
-            writeFileSync5(newPath, content, "utf-8");
+            const content = readFileSync13(oldPath, "utf-8");
+            writeFileSync6(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
           } catch (err) {
@@ -17523,13 +17979,13 @@ var lsp_code_action_resolve = tool({
 });
 // src/tools/ast-grep/constants.ts
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname3, join as join22 } from "path";
-import { existsSync as existsSync20, statSync as statSync3 } from "fs";
+import { dirname as dirname4, join as join25 } from "path";
+import { existsSync as existsSync22, statSync as statSync3 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 var {spawn: spawn5 } = globalThis.Bun;
-import { existsSync as existsSync19, mkdirSync as mkdirSync6, chmodSync as chmodSync2, unlinkSync as unlinkSync5 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync7, chmodSync as chmodSync2, unlinkSync as unlinkSync6 } from "fs";
+import { join as join24 } from "path";
 import { homedir as homedir12 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
@@ -17555,19 +18011,19 @@ var PLATFORM_MAP2 = {
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join21(homedir12(), "AppData", "Local");
-    return join21(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join24(homedir12(), "AppData", "Local");
+    return join24(base2, "oh-my-opencode", "bin");
   }
   const xdgCache2 = process.env.XDG_CACHE_HOME;
-  const base = xdgCache2 || join21(homedir12(), ".cache");
-  return join21(base, "oh-my-opencode", "bin");
+  const base = xdgCache2 || join24(homedir12(), ".cache");
+  return join24(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath2() {
-  const binaryPath = join21(getCacheDir2(), getBinaryName3());
-  return existsSync19(binaryPath) ? binaryPath : null;
+  const binaryPath = join24(getCacheDir2(), getBinaryName3());
+  return existsSync21(binaryPath) ? binaryPath : null;
 }
 async function extractZip2(archivePath, destDir) {
   const proc = process.platform === "win32" ? spawn5([
@@ -17593,8 +18049,8 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir2();
   const binaryName = getBinaryName3();
-  const binaryPath = join21(cacheDir, binaryName);
-  if (existsSync19(binaryPath)) {
+  const binaryPath = join24(cacheDir, binaryName);
+  if (existsSync21(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os3 } = platformInfo;
@@ -17602,21 +18058,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 (!existsSync19(cacheDir)) {
-      mkdirSync6(cacheDir, { recursive: true });
+    if (!existsSync21(cacheDir)) {
+      mkdirSync7(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const archivePath = join21(cacheDir, assetName);
+    const archivePath = join24(cacheDir, assetName);
     const arrayBuffer = await response.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip2(archivePath, cacheDir);
-    if (existsSync19(archivePath)) {
-      unlinkSync5(archivePath);
+    if (existsSync21(archivePath)) {
+      unlinkSync6(archivePath);
     }
-    if (process.platform !== "win32" && existsSync19(binaryPath)) {
+    if (process.platform !== "win32" && existsSync21(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -17666,9 +18122,9 @@ function findSgCliPathSync() {
   try {
     const require2 = createRequire4(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
-    const cliDir = dirname3(cliPkgPath);
-    const sgPath = join22(cliDir, binaryName);
-    if (existsSync20(sgPath) && isValidBinary(sgPath)) {
+    const cliDir = dirname4(cliPkgPath);
+    const sgPath = join25(cliDir, binaryName);
+    if (existsSync22(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -17677,10 +18133,10 @@ function findSgCliPathSync() {
     try {
       const require2 = createRequire4(import.meta.url);
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
-      const pkgDir = dirname3(pkgPath);
+      const pkgDir = dirname4(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join22(pkgDir, astGrepName);
-      if (existsSync20(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join25(pkgDir, astGrepName);
+      if (existsSync22(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -17688,7 +18144,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path3 of homebrewPaths) {
-      if (existsSync20(path3) && isValidBinary(path3)) {
+      if (existsSync22(path3) && isValidBinary(path3)) {
         return path3;
       }
     }
@@ -17744,11 +18200,11 @@ var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn6 } = globalThis.Bun;
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync23 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync21(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync23(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -17756,7 +18212,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync21(syncPath)) {
+    if (syncPath && existsSync23(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -17790,7 +18246,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync21(cliPath) && cliPath !== "sg") {
+  if (!existsSync23(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -18054,8 +18510,8 @@ var ast_grep_replace = tool({
 var {spawn: spawn7 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
-import { existsSync as existsSync22 } from "fs";
-import { join as join23, dirname as dirname4 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { join as join26, dirname as dirname5 } from "path";
 import { spawnSync } from "child_process";
 var cachedCli = null;
 function findExecutable(name) {
@@ -18072,17 +18528,17 @@ function findExecutable(name) {
 }
 function getOpenCodeBundledRg() {
   const execPath = process.execPath;
-  const execDir = dirname4(execPath);
+  const execDir = dirname5(execPath);
   const isWindows = process.platform === "win32";
   const rgName = isWindows ? "rg.exe" : "rg";
   const candidates = [
-    join23(execDir, rgName),
-    join23(execDir, "bin", rgName),
-    join23(execDir, "..", "bin", rgName),
-    join23(execDir, "..", "libexec", rgName)
+    join26(execDir, rgName),
+    join26(execDir, "bin", rgName),
+    join26(execDir, "..", "bin", rgName),
+    join26(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync22(candidate)) {
+    if (existsSync24(candidate)) {
       return candidate;
     }
   }
@@ -18480,11 +18936,11 @@ var glob = tool({
   }
 });
 // src/tools/slashcommand/tools.ts
-import { existsSync as existsSync23, readdirSync as readdirSync6, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync25, readdirSync as readdirSync6, readFileSync as readFileSync14 } from "fs";
 import { homedir as homedir13 } from "os";
-import { join as join24, basename as basename3, dirname as dirname5 } from "path";
+import { join as join27, basename as basename3, dirname as dirname6 } from "path";
 function discoverCommandsFromDir(commandsDir, scope) {
-  if (!existsSync23(commandsDir)) {
+  if (!existsSync25(commandsDir)) {
     return [];
   }
   const entries = readdirSync6(commandsDir, { withFileTypes: true });
@@ -18496,10 +18952,10 @@ function discoverCommandsFromDir(commandsDir, scope) {
       continue;
     if (!entry.isFile())
       continue;
-    const commandPath = join24(commandsDir, entry.name);
+    const commandPath = join27(commandsDir, entry.name);
     const commandName = basename3(entry.name, ".md");
     try {
-      const content = readFileSync12(commandPath, "utf-8");
+      const content = readFileSync14(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const metadata = {
         name: commandName,
@@ -18523,10 +18979,10 @@ function discoverCommandsFromDir(commandsDir, scope) {
   return commands;
 }
 function discoverCommandsSync() {
-  const userCommandsDir = join24(homedir13(), ".claude", "commands");
-  const projectCommandsDir = join24(process.cwd(), ".claude", "commands");
-  const opencodeGlobalDir = join24(homedir13(), ".config", "opencode", "command");
-  const opencodeProjectDir = join24(process.cwd(), ".opencode", "command");
+  const userCommandsDir = join27(homedir13(), ".claude", "commands");
+  const projectCommandsDir = join27(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join27(homedir13(), ".config", "opencode", "command");
+  const opencodeProjectDir = join27(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project");
@@ -18569,7 +19025,7 @@ async function formatLoadedCommand(cmd) {
 `);
   sections.push(`## Command Instructions
 `);
-  const commandDir = dirname5(cmd.path);
+  const commandDir = dirname6(cmd.path);
   const withFileRefs = await resolveFileReferencesInText(cmd.content, commandDir);
   const resolvedContent = await resolveCommandsInText(withFileRefs);
   sections.push(resolvedContent.trim());
@@ -18649,12 +19105,29 @@ Provide a command name to execute.`;
 Try a different command name.`;
   }
 });
+// src/tools/skill/types.ts
+var SkillFrontmatterSchema = exports_external.object({
+  name: exports_external.string().regex(/^[a-z0-9-]+$/, "Name must be lowercase alphanumeric with hyphens only").min(1, "Name cannot be empty"),
+  description: exports_external.string().min(20, "Description must be at least 20 characters for discoverability"),
+  license: exports_external.string().optional(),
+  "allowed-tools": exports_external.array(exports_external.string()).optional(),
+  metadata: exports_external.record(exports_external.string(), exports_external.string()).optional()
+});
 // src/tools/skill/tools.ts
-import { existsSync as existsSync24, readdirSync as readdirSync7, statSync as statSync4, readlinkSync as readlinkSync2, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync26, readdirSync as readdirSync7, statSync as statSync4, readlinkSync as readlinkSync2, readFileSync as readFileSync15 } from "fs";
 import { homedir as homedir14 } from "os";
-import { join as join25, resolve as resolve5, basename as basename4 } from "path";
+import { join as join28, resolve as resolve6, basename as basename4 } from "path";
+function parseSkillFrontmatter(data) {
+  return {
+    name: typeof data.name === "string" ? data.name : "",
+    description: typeof data.description === "string" ? data.description : "",
+    license: typeof data.license === "string" ? data.license : undefined,
+    "allowed-tools": Array.isArray(data["allowed-tools"]) ? data["allowed-tools"] : undefined,
+    metadata: typeof data.metadata === "object" && data.metadata !== null ? data.metadata : undefined
+  };
+}
 function discoverSkillsFromDir(skillsDir, scope) {
-  if (!existsSync24(skillsDir)) {
+  if (!existsSync26(skillsDir)) {
     return [];
   }
   const entries = readdirSync7(skillsDir, { withFileTypes: true });
@@ -18662,22 +19135,22 @@ function discoverSkillsFromDir(skillsDir, scope) {
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
-    const skillPath = join25(skillsDir, entry.name);
+    const skillPath = join28(skillsDir, entry.name);
     if (entry.isDirectory() || entry.isSymbolicLink()) {
       let resolvedPath = skillPath;
       try {
         const stats = statSync4(skillPath, { throwIfNoEntry: false });
         if (stats?.isSymbolicLink()) {
-          resolvedPath = resolve5(skillPath, "..", readlinkSync2(skillPath));
+          resolvedPath = resolve6(skillPath, "..", readlinkSync2(skillPath));
         }
       } catch {
         continue;
       }
-      const skillMdPath = join25(resolvedPath, "SKILL.md");
-      if (!existsSync24(skillMdPath))
+      const skillMdPath = join28(resolvedPath, "SKILL.md");
+      if (!existsSync26(skillMdPath))
         continue;
       try {
-        const content = readFileSync13(skillMdPath, "utf-8");
+        const content = readFileSync15(skillMdPath, "utf-8");
         const { data } = parseFrontmatter(content);
         skills.push({
           name: data.name || entry.name,
@@ -18692,8 +19165,8 @@ function discoverSkillsFromDir(skillsDir, scope) {
   return skills;
 }
 function discoverSkillsSync() {
-  const userSkillsDir = join25(homedir14(), ".claude", "skills");
-  const projectSkillsDir = join25(process.cwd(), ".claude", "skills");
+  const userSkillsDir = join28(homedir14(), ".claude", "skills");
+  const projectSkillsDir = join28(process.cwd(), ".claude", "skills");
   const userSkills = discoverSkillsFromDir(userSkillsDir, "user");
   const projectSkills = discoverSkillsFromDir(projectSkillsDir, "project");
   return [...projectSkills, ...userSkills];
@@ -18705,7 +19178,7 @@ function resolveSymlink(skillPath) {
   try {
     const stats = statSync4(skillPath, { throwIfNoEntry: false });
     if (stats?.isSymbolicLink()) {
-      return resolve5(skillPath, "..", readlinkSync2(skillPath));
+      return resolve6(skillPath, "..", readlinkSync2(skillPath));
     }
     return skillPath;
   } catch {
@@ -18714,28 +19187,32 @@ function resolveSymlink(skillPath) {
 }
 async function parseSkillMd(skillPath) {
   const resolvedPath = resolveSymlink(skillPath);
-  const skillMdPath = join25(resolvedPath, "SKILL.md");
-  if (!existsSync24(skillMdPath)) {
+  const skillMdPath = join28(resolvedPath, "SKILL.md");
+  if (!existsSync26(skillMdPath)) {
     return null;
   }
   try {
-    let content = readFileSync13(skillMdPath, "utf-8");
+    let content = readFileSync15(skillMdPath, "utf-8");
     content = await resolveCommandsInText(content);
     const { data, body } = parseFrontmatter(content);
+    const frontmatter2 = parseSkillFrontmatter(data);
     const metadata = {
-      name: data.name || basename4(skillPath),
-      description: data.description || "",
-      license: data.license
+      name: frontmatter2.name || basename4(skillPath),
+      description: frontmatter2.description,
+      license: frontmatter2.license,
+      allowedTools: frontmatter2["allowed-tools"],
+      metadata: frontmatter2.metadata
     };
-    const referencesDir = join25(resolvedPath, "references");
-    const scriptsDir = join25(resolvedPath, "scripts");
-    const assetsDir = join25(resolvedPath, "assets");
-    const references = existsSync24(referencesDir) ? readdirSync7(referencesDir).filter((f) => !f.startsWith(".")) : [];
-    const scripts = existsSync24(scriptsDir) ? readdirSync7(scriptsDir).filter((f) => !f.startsWith(".") && !f.startsWith("__")) : [];
-    const assets = existsSync24(assetsDir) ? readdirSync7(assetsDir).filter((f) => !f.startsWith(".")) : [];
+    const referencesDir = join28(resolvedPath, "references");
+    const scriptsDir = join28(resolvedPath, "scripts");
+    const assetsDir = join28(resolvedPath, "assets");
+    const references = existsSync26(referencesDir) ? readdirSync7(referencesDir).filter((f) => !f.startsWith(".")) : [];
+    const scripts = existsSync26(scriptsDir) ? readdirSync7(scriptsDir).filter((f) => !f.startsWith(".") && !f.startsWith("__")) : [];
+    const assets = existsSync26(assetsDir) ? readdirSync7(assetsDir).filter((f) => !f.startsWith(".")) : [];
     return {
       name: metadata.name,
       path: resolvedPath,
+      basePath: resolvedPath,
       metadata,
       content: body,
       references,
@@ -18747,7 +19224,7 @@ async function parseSkillMd(skillPath) {
   }
 }
 async function discoverSkillsFromDirAsync(skillsDir) {
-  if (!existsSync24(skillsDir)) {
+  if (!existsSync26(skillsDir)) {
     return [];
   }
   const entries = readdirSync7(skillsDir, { withFileTypes: true });
@@ -18755,7 +19232,7 @@ async function discoverSkillsFromDirAsync(skillsDir) {
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
-    const skillPath = join25(skillsDir, entry.name);
+    const skillPath = join28(skillsDir, entry.name);
     if (entry.isDirectory() || entry.isSymbolicLink()) {
       const skillInfo = await parseSkillMd(skillPath);
       if (skillInfo) {
@@ -18766,8 +19243,8 @@ async function discoverSkillsFromDirAsync(skillsDir) {
   return skills;
 }
 async function discoverSkills() {
-  const userSkillsDir = join25(homedir14(), ".claude", "skills");
-  const projectSkillsDir = join25(process.cwd(), ".claude", "skills");
+  const userSkillsDir = join28(homedir14(), ".claude", "skills");
+  const projectSkillsDir = join28(process.cwd(), ".claude", "skills");
   const userSkills = await discoverSkillsFromDirAsync(userSkillsDir);
   const projectSkills = await discoverSkillsFromDirAsync(projectSkillsDir);
   return [...projectSkills, ...userSkills];
@@ -18796,9 +19273,9 @@ async function loadSkillWithReferences(skill, includeRefs) {
   const referencesLoaded = [];
   if (includeRefs && skill.references.length > 0) {
     for (const ref of skill.references) {
-      const refPath = join25(skill.path, "references", ref);
+      const refPath = join28(skill.path, "references", ref);
       try {
-        let content = readFileSync13(refPath, "utf-8");
+        let content = readFileSync15(refPath, "utf-8");
         content = await resolveCommandsInText(content);
         referencesLoaded.push({ path: ref, content });
       } catch {}
@@ -18807,6 +19284,7 @@ async function loadSkillWithReferences(skill, includeRefs) {
   return {
     name: skill.name,
     metadata: skill.metadata,
+    basePath: skill.basePath,
     body: skill.content,
     referencesLoaded
   };
@@ -18829,62 +19307,34 @@ function formatLoadedSkills(loadedSkills) {
   if (loadedSkills.length === 0) {
     return "No skills loaded.";
   }
-  const sections = [`# Loaded Skills
-`];
-  for (const skill of loadedSkills) {
-    sections.push(`## ${skill.metadata.name}
-`);
-    sections.push(`**Description**: ${skill.metadata.description || "(no description)"}
-`);
-    sections.push(`### Skill Instructions
-`);
-    sections.push(skill.body.trim());
-    if (skill.referencesLoaded.length > 0) {
-      sections.push(`
+  const skill = loadedSkills[0];
+  const sections = [];
+  sections.push(`Base directory for this skill: ${skill.basePath}/`);
+  sections.push("");
+  sections.push(skill.body.trim());
+  if (skill.referencesLoaded.length > 0) {
+    sections.push(`
+---
 ### Loaded References
 `);
-      for (const ref of skill.referencesLoaded) {
-        sections.push(`#### ${ref.path}
+    for (const ref of skill.referencesLoaded) {
+      sections.push(`#### ${ref.path}
 `);
-        sections.push("```");
-        sections.push(ref.content.trim());
-        sections.push("```\n");
-      }
+      sections.push("```");
+      sections.push(ref.content.trim());
+      sections.push("```\n");
     }
-    sections.push(`
----
-`);
   }
-  const skillNames = loadedSkills.map((s) => s.metadata.name).join(", ");
-  sections.push(`**Skills loaded**: ${skillNames}`);
-  sections.push(`**Total**: ${loadedSkills.length} skill(s)`);
   sections.push(`
-Please confirm these skills match your needs before proceeding.`);
+---
+**Launched skill**: ${skill.metadata.name}`);
   return sections.join(`
 `);
 }
 var skill = tool({
   description: `Execute a skill within the main conversation.
 
-When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
-
-How to use skills:
-- Invoke skills using this tool with the skill name only (no arguments)
-- When you invoke a skill, the skill's prompt will expand and provide detailed instructions on how to complete the task
-
-Important:
-- Only use skills listed in Available Skills below
-- Do not invoke a skill that is already running
-
-Skills are loaded from:
-- ~/.claude/skills/ (user scope - global skills)
-- ./.claude/skills/ (project scope - project-specific skills)
-
-Each skill contains:
-- SKILL.md: Main instructions with YAML frontmatter (name, description)
-- references/: Documentation files loaded into context as needed
-- scripts/: Executable code for deterministic operations
-- assets/: Files used in output (templates, icons, etc.)
+When you invoke a skill, the skill's prompt will expand and provide detailed instructions on how to complete the task.
 
 Available Skills:
 ${skillListForDescription}`,
@@ -19009,26 +19459,62 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
 // src/index.ts
 import * as fs4 from "fs";
 import * as path3 from "path";
+import * as os3 from "os";
+function loadConfigFromPath2(configPath) {
+  try {
+    if (fs4.existsSync(configPath)) {
+      const content = fs4.readFileSync(configPath, "utf-8");
+      const rawConfig = JSON.parse(content);
+      const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
+      if (!result.success) {
+        log(`Config validation error in ${configPath}:`, result.error.issues);
+        return null;
+      }
+      log(`Config loaded from ${configPath}`, { agents: result.data.agents });
+      return result.data;
+    }
+  } catch (err) {
+    log(`Error loading config from ${configPath}:`, err);
+  }
+  return null;
+}
+function mergeConfigs(base, override) {
+  return {
+    ...base,
+    ...override,
+    agents: override.agents !== undefined ? { ...base.agents ?? {}, ...override.agents } : base.agents,
+    disabled_agents: [
+      ...new Set([...base.disabled_agents ?? [], ...override.disabled_agents ?? []])
+    ],
+    disabled_mcps: [
+      ...new Set([...base.disabled_mcps ?? [], ...override.disabled_mcps ?? []])
+    ]
+  };
+}
 function loadPluginConfig(directory) {
-  const configPaths = [
-    path3.join(directory, "oh-my-opencode.json"),
-    path3.join(directory, ".oh-my-opencode.json")
+  const userConfigPaths = [
+    path3.join(os3.homedir(), ".config", "opencode", "oh-my-opencode.json")
   ];
-  for (const configPath of configPaths) {
-    try {
-      if (fs4.existsSync(configPath)) {
-        const content = fs4.readFileSync(configPath, "utf-8");
-        const rawConfig = JSON.parse(content);
-        const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
-        if (!result.success) {
-          log(`Config validation error in ${configPath}:`, result.error.issues);
-          return {};
-        }
-        return result.data;
-      }
-    } catch {}
+  const projectConfigPaths = [
+    path3.join(directory, ".opencode", "oh-my-opencode.json")
+  ];
+  let config3 = {};
+  for (const configPath of userConfigPaths) {
+    const userConfig = loadConfigFromPath2(configPath);
+    if (userConfig) {
+      config3 = userConfig;
+      break;
+    }
+  }
+  for (const configPath of projectConfigPaths) {
+    const projectConfig = loadConfigFromPath2(configPath);
+    if (projectConfig) {
+      config3 = mergeConfigs(config3, projectConfig);
+      break;
+    }
   }
-  return {};
+  log("Final merged config", { agents: config3.agents, disabled_agents: config3.disabled_agents, disabled_mcps: config3.disabled_mcps });
+  return config3;
 }
 var OhMyOpenCodePlugin = async (ctx) => {
   const pluginConfig = loadPluginConfig(ctx.directory);
@@ -19038,9 +19524,11 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const commentChecker = createCommentCheckerHooks();
   const grepOutputTruncator = createGrepOutputTruncatorHook(ctx);
   const directoryAgentsInjector = createDirectoryAgentsInjectorHook(ctx);
+  const directoryReadmeInjector = createDirectoryReadmeInjectorHook(ctx);
   const emptyTaskResponseDetector = createEmptyTaskResponseDetectorHook(ctx);
   const thinkMode = createThinkModeHook();
   const claudeCodeHooks = createClaudeCodeHooksHook(ctx, {});
+  const anthropicAutoCompact = createAnthropicAutoCompactHook(ctx);
   updateTerminalTitle({ sessionId: "main" });
   return {
     tool: builtinTools,
@@ -19088,7 +19576,9 @@ var OhMyOpenCodePlugin = async (ctx) => {
       await todoContinuationEnforcer(input);
       await contextWindowMonitor.event(input);
       await directoryAgentsInjector.event(input);
+      await directoryReadmeInjector.event(input);
       await thinkMode.event(input);
+      await anthropicAutoCompact.event(input);
       const { event } = input;
       const props = event.properties;
       if (event.type === "session.created") {
@@ -19186,6 +19676,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
       await contextWindowMonitor["tool.execute.after"](input, output);
       await commentChecker["tool.execute.after"](input, output);
       await directoryAgentsInjector["tool.execute.after"](input, output);
+      await directoryReadmeInjector["tool.execute.after"](input, output);
       await emptyTaskResponseDetector["tool.execute.after"](input, output);
       if (input.sessionID === getMainSessionID()) {
         updateTerminalTitle({