oh-my-opencode 2.4.4 → 2.4.6

package/dist/index.js

@@ -2674,7 +2674,7 @@ You are a technical writer who creates documentation that developers actually wa
 var multimodalLookerAgent = {
   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.",
   mode: "subagent",
-  model: "google/gemini-2.5-flash",
+  model: "google/gemini-3-flash",
   temperature: 0.1,
   tools: { write: false, edit: false, bash: false, background_task: false },
   prompt: `You interpret media files that cannot be read as plain text.
@@ -6061,6 +6061,10 @@ function createAnthropicAutoCompactHook(ctx, options) {
     event: eventHandler
   };
 }
+// src/hooks/preemptive-compaction/index.ts
+import { existsSync as existsSync15, readdirSync as readdirSync5 } from "fs";
+import { join as join19 } from "path";
+
 // src/hooks/preemptive-compaction/constants.ts
 var DEFAULT_THRESHOLD = 0.85;
 var MIN_TOKENS_FOR_COMPACTION = 50000;
@@ -6072,6 +6076,19 @@ var CLAUDE_DEFAULT_CONTEXT_LIMIT = 200000;
 function isSupportedModel(modelID) {
   return CLAUDE_MODEL_PATTERN.test(modelID);
 }
+function getMessageDir4(sessionID) {
+  if (!existsSync15(MESSAGE_STORAGE))
+    return null;
+  const directPath = join19(MESSAGE_STORAGE, sessionID);
+  if (existsSync15(directPath))
+    return directPath;
+  for (const dir of readdirSync5(MESSAGE_STORAGE)) {
+    const sessionPath = join19(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync15(sessionPath))
+      return sessionPath;
+  }
+  return null;
+}
 function createState() {
   return {
     lastCompactionTime: new Map,
@@ -6211,6 +6228,19 @@ function createPreemptiveCompactionHook(ctx, options) {
         if (assistants.length === 0)
           return;
         const lastAssistant = assistants[assistants.length - 1];
+        if (!lastAssistant.providerID || !lastAssistant.modelID) {
+          const messageDir = getMessageDir4(sessionID);
+          const storedMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
+          if (storedMessage?.model?.providerID && storedMessage?.model?.modelID) {
+            lastAssistant.providerID = storedMessage.model.providerID;
+            lastAssistant.modelID = storedMessage.model.modelID;
+            log("[preemptive-compaction] using stored message model info", {
+              sessionID,
+              providerID: lastAssistant.providerID,
+              modelID: lastAssistant.modelID
+            });
+          }
+        }
         await checkAndTriggerCompaction(sessionID, lastAssistant);
       } catch {}
     }
@@ -6534,8 +6564,8 @@ function createThinkModeHook() {
 }
 // src/hooks/claude-code-hooks/config.ts
 import { homedir as homedir6 } from "os";
-import { join as join19 } from "path";
-import { existsSync as existsSync15 } from "fs";
+import { join as join20 } from "path";
+import { existsSync as existsSync16 } from "fs";
 function normalizeHookMatcher(raw) {
   return {
     matcher: raw.matcher ?? raw.pattern ?? "*",
@@ -6560,11 +6590,11 @@ function normalizeHooksConfig(raw) {
 function getClaudeSettingsPaths(customPath) {
   const home = homedir6();
   const paths = [
-    join19(home, ".claude", "settings.json"),
-    join19(process.cwd(), ".claude", "settings.json"),
-    join19(process.cwd(), ".claude", "settings.local.json")
+    join20(home, ".claude", "settings.json"),
+    join20(process.cwd(), ".claude", "settings.json"),
+    join20(process.cwd(), ".claude", "settings.local.json")
   ];
-  if (customPath && existsSync15(customPath)) {
+  if (customPath && existsSync16(customPath)) {
     paths.unshift(customPath);
   }
   return paths;
@@ -6588,7 +6618,7 @@ async function loadClaudeHooksConfig(customSettingsPath) {
   const paths = getClaudeSettingsPaths(customSettingsPath);
   let mergedConfig = {};
   for (const settingsPath of paths) {
-    if (existsSync15(settingsPath)) {
+    if (existsSync16(settingsPath)) {
       try {
         const content = await Bun.file(settingsPath).text();
         const settings = JSON.parse(content);
@@ -6605,15 +6635,15 @@ async function loadClaudeHooksConfig(customSettingsPath) {
 }
 
 // src/hooks/claude-code-hooks/config-loader.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join20 } from "path";
-var USER_CONFIG_PATH = join20(homedir7(), ".config", "opencode", "opencode-cc-plugin.json");
+import { join as join21 } from "path";
+var USER_CONFIG_PATH = join21(homedir7(), ".config", "opencode", "opencode-cc-plugin.json");
 function getProjectConfigPath() {
-  return join20(process.cwd(), ".opencode", "opencode-cc-plugin.json");
+  return join21(process.cwd(), ".opencode", "opencode-cc-plugin.json");
 }
 async function loadConfigFromPath(path4) {
-  if (!existsSync16(path4)) {
+  if (!existsSync17(path4)) {
     return null;
   }
   try {
@@ -6792,16 +6822,16 @@ async function executePreToolUseHooks(ctx, config, extendedConfig) {
 }
 
 // src/hooks/claude-code-hooks/transcript.ts
-import { join as join21 } from "path";
-import { mkdirSync as mkdirSync6, appendFileSync as appendFileSync5, existsSync as existsSync17, writeFileSync as writeFileSync6, unlinkSync as unlinkSync5 } from "fs";
+import { join as join22 } from "path";
+import { mkdirSync as mkdirSync6, appendFileSync as appendFileSync5, existsSync as existsSync18, writeFileSync as writeFileSync6, unlinkSync as unlinkSync5 } from "fs";
 import { homedir as homedir8, tmpdir as tmpdir5 } from "os";
 import { randomUUID } from "crypto";
-var TRANSCRIPT_DIR = join21(homedir8(), ".claude", "transcripts");
+var TRANSCRIPT_DIR = join22(homedir8(), ".claude", "transcripts");
 function getTranscriptPath(sessionId) {
-  return join21(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
+  return join22(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
 }
 function ensureTranscriptDir() {
-  if (!existsSync17(TRANSCRIPT_DIR)) {
+  if (!existsSync18(TRANSCRIPT_DIR)) {
     mkdirSync6(TRANSCRIPT_DIR, { recursive: true });
   }
 }
@@ -6888,7 +6918,7 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
       }
     };
     entries.push(JSON.stringify(currentEntry));
-    const tempPath = join21(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+    const tempPath = join22(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
     writeFileSync6(tempPath, entries.join(`
 `) + `
 `);
@@ -6908,7 +6938,7 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
           ]
         }
       };
-      const tempPath = join21(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+      const tempPath = join22(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
       writeFileSync6(tempPath, JSON.stringify(currentEntry) + `
 `);
       return tempPath;
@@ -7120,11 +7150,11 @@ ${USER_PROMPT_SUBMIT_TAG_CLOSE}`);
 }
 
 // src/hooks/claude-code-hooks/todo.ts
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 import { homedir as homedir9 } from "os";
-var TODO_DIR = join22(homedir9(), ".claude", "todos");
+var TODO_DIR = join23(homedir9(), ".claude", "todos");
 function getTodoPath(sessionId) {
-  return join22(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
+  return join23(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
 }
 
 // src/hooks/claude-code-hooks/stop.ts
@@ -7462,17 +7492,17 @@ import { relative as relative3, resolve as resolve4 } from "path";
 
 // src/hooks/rules-injector/finder.ts
 import {
-  existsSync as existsSync18,
-  readdirSync as readdirSync5,
+  existsSync as existsSync19,
+  readdirSync as readdirSync6,
   realpathSync,
   statSync as statSync2
 } from "fs";
-import { dirname as dirname4, join as join24, relative } from "path";
+import { dirname as dirname4, join as join25, relative } from "path";
 
 // src/hooks/rules-injector/constants.ts
-import { join as join23 } from "path";
-var OPENCODE_STORAGE6 = join23(xdgData2 ?? "", "opencode", "storage");
-var RULES_INJECTOR_STORAGE = join23(OPENCODE_STORAGE6, "rules-injector");
+import { join as join24 } from "path";
+var OPENCODE_STORAGE6 = join24(xdgData2 ?? "", "opencode", "storage");
+var RULES_INJECTOR_STORAGE = join24(OPENCODE_STORAGE6, "rules-injector");
 var PROJECT_MARKERS = [
   ".git",
   "pyproject.toml",
@@ -7499,8 +7529,8 @@ function findProjectRoot(startPath) {
   }
   while (true) {
     for (const marker of PROJECT_MARKERS) {
-      const markerPath = join24(current, marker);
-      if (existsSync18(markerPath)) {
+      const markerPath = join25(current, marker);
+      if (existsSync19(markerPath)) {
         return current;
       }
     }
@@ -7512,12 +7542,12 @@ function findProjectRoot(startPath) {
   }
 }
 function findRuleFilesRecursive(dir, results) {
-  if (!existsSync18(dir))
+  if (!existsSync19(dir))
     return;
   try {
-    const entries = readdirSync5(dir, { withFileTypes: true });
+    const entries = readdirSync6(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join24(dir, entry.name);
+      const fullPath = join25(dir, entry.name);
       if (entry.isDirectory()) {
         findRuleFilesRecursive(fullPath, results);
       } else if (entry.isFile()) {
@@ -7543,7 +7573,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
   let distance = 0;
   while (true) {
     for (const [parent, subdir] of PROJECT_RULE_SUBDIRS) {
-      const ruleDir = join24(currentDir, parent, subdir);
+      const ruleDir = join25(currentDir, parent, subdir);
       const files = [];
       findRuleFilesRecursive(ruleDir, files);
       for (const filePath of files) {
@@ -7567,7 +7597,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
     currentDir = parentDir;
     distance++;
   }
-  const userRuleDir = join24(homeDir, USER_RULE_DIR);
+  const userRuleDir = join25(homeDir, USER_RULE_DIR);
   const userFiles = [];
   findRuleFilesRecursive(userRuleDir, userFiles);
   for (const filePath of userFiles) {
@@ -7756,19 +7786,19 @@ function mergeGlobs(existing, newValue) {
 
 // src/hooks/rules-injector/storage.ts
 import {
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync7,
   readFileSync as readFileSync9,
   writeFileSync as writeFileSync7,
   unlinkSync as unlinkSync6
 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 function getStoragePath3(sessionID) {
-  return join25(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
+  return join26(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedRules(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (!existsSync19(filePath))
+  if (!existsSync20(filePath))
     return { contentHashes: new Set, realPaths: new Set };
   try {
     const content = readFileSync9(filePath, "utf-8");
@@ -7782,7 +7812,7 @@ function loadInjectedRules(sessionID) {
   }
 }
 function saveInjectedRules(sessionID, data) {
-  if (!existsSync19(RULES_INJECTOR_STORAGE)) {
+  if (!existsSync20(RULES_INJECTOR_STORAGE)) {
     mkdirSync7(RULES_INJECTOR_STORAGE, { recursive: true });
   }
   const storageData = {
@@ -7795,7 +7825,7 @@ function saveInjectedRules(sessionID, data) {
 }
 function clearInjectedRules(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (existsSync19(filePath)) {
+  if (existsSync20(filePath)) {
     unlinkSync6(filePath);
   }
 }
@@ -8365,18 +8395,18 @@ async function showLocalDevToast(ctx, version, isSisyphusEnabled) {
 }
 // src/hooks/agent-usage-reminder/storage.ts
 import {
-  existsSync as existsSync22,
+  existsSync as existsSync23,
   mkdirSync as mkdirSync8,
   readFileSync as readFileSync13,
   writeFileSync as writeFileSync10,
   unlinkSync as unlinkSync7
 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 
 // src/hooks/agent-usage-reminder/constants.ts
-import { join as join29 } from "path";
-var OPENCODE_STORAGE7 = join29(xdgData2 ?? "", "opencode", "storage");
-var AGENT_USAGE_REMINDER_STORAGE = join29(OPENCODE_STORAGE7, "agent-usage-reminder");
+import { join as join30 } from "path";
+var OPENCODE_STORAGE7 = join30(xdgData2 ?? "", "opencode", "storage");
+var AGENT_USAGE_REMINDER_STORAGE = join30(OPENCODE_STORAGE7, "agent-usage-reminder");
 var TARGET_TOOLS = new Set([
   "grep",
   "safe_grep",
@@ -8421,11 +8451,11 @@ ALWAYS prefer: Multiple parallel background_task calls > Direct tool calls
 
 // src/hooks/agent-usage-reminder/storage.ts
 function getStoragePath4(sessionID) {
-  return join30(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
+  return join31(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
 }
 function loadAgentUsageState(sessionID) {
   const filePath = getStoragePath4(sessionID);
-  if (!existsSync22(filePath))
+  if (!existsSync23(filePath))
     return null;
   try {
     const content = readFileSync13(filePath, "utf-8");
@@ -8435,7 +8465,7 @@ function loadAgentUsageState(sessionID) {
   }
 }
 function saveAgentUsageState(state2) {
-  if (!existsSync22(AGENT_USAGE_REMINDER_STORAGE)) {
+  if (!existsSync23(AGENT_USAGE_REMINDER_STORAGE)) {
     mkdirSync8(AGENT_USAGE_REMINDER_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath4(state2.sessionID);
@@ -8443,7 +8473,7 @@ function saveAgentUsageState(state2) {
 }
 function clearAgentUsageState(sessionID) {
   const filePath = getStoragePath4(sessionID);
-  if (existsSync22(filePath)) {
+  if (existsSync23(filePath)) {
     unlinkSync7(filePath);
   }
 }
@@ -8643,10 +8673,65 @@ var NON_INTERACTIVE_ENV = {
   VISUAL: "true",
   GIT_SEQUENCE_EDITOR: "true",
   GIT_PAGER: "cat",
-  PAGER: "cat"
+  PAGER: "cat",
+  npm_config_yes: "true",
+  PIP_NO_INPUT: "1",
+  YARN_ENABLE_IMMUTABLE_INSTALLS: "false"
+};
+var SHELL_COMMAND_PATTERNS = {
+  npm: {
+    bad: ["npm init", "npm install (prompts)"],
+    good: ["npm init -y", "npm install --yes"]
+  },
+  apt: {
+    bad: ["apt-get install pkg"],
+    good: ["apt-get install -y pkg", "DEBIAN_FRONTEND=noninteractive apt-get install pkg"]
+  },
+  pip: {
+    bad: ["pip install pkg (with prompts)"],
+    good: ["pip install --no-input pkg", "PIP_NO_INPUT=1 pip install pkg"]
+  },
+  git: {
+    bad: ["git commit", "git merge branch", "git add -p", "git rebase -i"],
+    good: ["git commit -m 'msg'", "git merge --no-edit branch", "git add .", "git rebase --no-edit"]
+  },
+  system: {
+    bad: ["rm file (prompts)", "cp a b (prompts)", "ssh host"],
+    good: ["rm -f file", "cp -f a b", "ssh -o BatchMode=yes host", "unzip -o file.zip"]
+  },
+  banned: [
+    "vim",
+    "nano",
+    "vi",
+    "emacs",
+    "less",
+    "more",
+    "man",
+    "python (REPL)",
+    "node (REPL)",
+    "git add -p",
+    "git rebase -i"
+  ],
+  workarounds: {
+    yesPipe: "yes | ./script.sh",
+    heredoc: `./script.sh <<EOF
+option1
+option2
+EOF`,
+    expectAlternative: "Use environment variables or config files instead of expect"
+  }
 };
 
 // src/hooks/non-interactive-env/index.ts
+var BANNED_COMMAND_PATTERNS = SHELL_COMMAND_PATTERNS.banned.filter((cmd) => !cmd.includes("(")).map((cmd) => new RegExp(`\\b${cmd}\\b`));
+function detectBannedCommand(command) {
+  for (let i = 0;i < BANNED_COMMAND_PATTERNS.length; i++) {
+    if (BANNED_COMMAND_PATTERNS[i].test(command)) {
+      return SHELL_COMMAND_PATTERNS.banned[i];
+    }
+  }
+  return;
+}
 function createNonInteractiveEnvHook(_ctx) {
   return {
     "tool.execute.before": async (input, output) => {
@@ -8661,6 +8746,10 @@ function createNonInteractiveEnvHook(_ctx) {
         ...output.args.env,
         ...NON_INTERACTIVE_ENV
       };
+      const bannedCmd = detectBannedCommand(command);
+      if (bannedCmd) {
+        output.message = `\u26A0\uFE0F Warning: '${bannedCmd}' is an interactive command that may hang in non-interactive environments.`;
+      }
       log(`[${HOOK_NAME2}] Set non-interactive environment variables`, {
         sessionID: input.sessionID,
         env: NON_INTERACTIVE_ENV
@@ -8670,18 +8759,18 @@ function createNonInteractiveEnvHook(_ctx) {
 }
 // src/hooks/interactive-bash-session/storage.ts
 import {
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   mkdirSync as mkdirSync9,
   readFileSync as readFileSync14,
   writeFileSync as writeFileSync11,
   unlinkSync as unlinkSync8
 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 
 // src/hooks/interactive-bash-session/constants.ts
-import { join as join31 } from "path";
-var OPENCODE_STORAGE8 = join31(xdgData2 ?? "", "opencode", "storage");
-var INTERACTIVE_BASH_SESSION_STORAGE = join31(OPENCODE_STORAGE8, "interactive-bash-session");
+import { join as join32 } from "path";
+var OPENCODE_STORAGE8 = join32(xdgData2 ?? "", "opencode", "storage");
+var INTERACTIVE_BASH_SESSION_STORAGE = join32(OPENCODE_STORAGE8, "interactive-bash-session");
 var OMO_SESSION_PREFIX = "omo-";
 function buildSessionReminderMessage(sessions) {
   if (sessions.length === 0)
@@ -8693,11 +8782,11 @@ function buildSessionReminderMessage(sessions) {
 
 // src/hooks/interactive-bash-session/storage.ts
 function getStoragePath5(sessionID) {
-  return join32(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
+  return join33(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
 }
 function loadInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath5(sessionID);
-  if (!existsSync23(filePath))
+  if (!existsSync24(filePath))
     return null;
   try {
     const content = readFileSync14(filePath, "utf-8");
@@ -8712,7 +8801,7 @@ function loadInteractiveBashSessionState(sessionID) {
   }
 }
 function saveInteractiveBashSessionState(state2) {
-  if (!existsSync23(INTERACTIVE_BASH_SESSION_STORAGE)) {
+  if (!existsSync24(INTERACTIVE_BASH_SESSION_STORAGE)) {
     mkdirSync9(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath5(state2.sessionID);
@@ -8725,7 +8814,7 @@ function saveInteractiveBashSessionState(state2) {
 }
 function clearInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath5(sessionID);
-  if (existsSync23(filePath)) {
+  if (existsSync24(filePath)) {
     unlinkSync8(filePath);
   }
 }
@@ -10669,19 +10758,19 @@ async function createGoogleAntigravityAuthPlugin({
   };
 }
 // src/features/claude-code-command-loader/loader.ts
-import { existsSync as existsSync24, readdirSync as readdirSync6, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync25, readdirSync as readdirSync7, readFileSync as readFileSync15 } from "fs";
 import { homedir as homedir12 } from "os";
-import { join as join33, basename } from "path";
+import { join as join34, basename } from "path";
 function loadCommandsFromDir(commandsDir, scope) {
-  if (!existsSync24(commandsDir)) {
+  if (!existsSync25(commandsDir)) {
     return [];
   }
-  const entries = readdirSync6(commandsDir, { withFileTypes: true });
+  const entries = readdirSync7(commandsDir, { withFileTypes: true });
   const commands = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join33(commandsDir, entry.name);
+    const commandPath = join34(commandsDir, entry.name);
     const commandName = basename(entry.name, ".md");
     try {
       const content = readFileSync15(commandPath, "utf-8");
@@ -10724,44 +10813,44 @@ function commandsToRecord(commands) {
   return result;
 }
 function loadUserCommands() {
-  const userCommandsDir = join33(homedir12(), ".claude", "commands");
+  const userCommandsDir = join34(homedir12(), ".claude", "commands");
   const commands = loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands);
 }
 function loadProjectCommands() {
-  const projectCommandsDir = join33(process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join34(process.cwd(), ".claude", "commands");
   const commands = loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands);
 }
 function loadOpencodeGlobalCommands() {
-  const opencodeCommandsDir = join33(homedir12(), ".config", "opencode", "command");
+  const opencodeCommandsDir = join34(homedir12(), ".config", "opencode", "command");
   const commands = loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands);
 }
 function loadOpencodeProjectCommands() {
-  const opencodeProjectDir = join33(process.cwd(), ".opencode", "command");
+  const opencodeProjectDir = join34(process.cwd(), ".opencode", "command");
   const commands = loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands);
 }
 // src/features/claude-code-skill-loader/loader.ts
-import { existsSync as existsSync25, readdirSync as readdirSync7, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync26, readdirSync as readdirSync8, readFileSync as readFileSync16 } from "fs";
 import { homedir as homedir13 } from "os";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 function loadSkillsFromDir(skillsDir, scope) {
-  if (!existsSync25(skillsDir)) {
+  if (!existsSync26(skillsDir)) {
     return [];
   }
-  const entries = readdirSync7(skillsDir, { withFileTypes: true });
+  const entries = readdirSync8(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
-    const skillPath = join34(skillsDir, entry.name);
+    const skillPath = join35(skillsDir, entry.name);
     if (!entry.isDirectory() && !entry.isSymbolicLink())
       continue;
     const resolvedPath = resolveSymlink(skillPath);
-    const skillMdPath = join34(resolvedPath, "SKILL.md");
-    if (!existsSync25(skillMdPath))
+    const skillMdPath = join35(resolvedPath, "SKILL.md");
+    if (!existsSync26(skillMdPath))
       continue;
     try {
       const content = readFileSync16(skillMdPath, "utf-8");
@@ -10798,7 +10887,7 @@ $ARGUMENTS
   return skills;
 }
 function loadUserSkillsAsCommands() {
-  const userSkillsDir = join34(homedir13(), ".claude", "skills");
+  const userSkillsDir = join35(homedir13(), ".claude", "skills");
   const skills = loadSkillsFromDir(userSkillsDir, "user");
   return skills.reduce((acc, skill) => {
     acc[skill.name] = skill.definition;
@@ -10806,7 +10895,7 @@ function loadUserSkillsAsCommands() {
   }, {});
 }
 function loadProjectSkillsAsCommands() {
-  const projectSkillsDir = join34(process.cwd(), ".claude", "skills");
+  const projectSkillsDir = join35(process.cwd(), ".claude", "skills");
   const skills = loadSkillsFromDir(projectSkillsDir, "project");
   return skills.reduce((acc, skill) => {
     acc[skill.name] = skill.definition;
@@ -10814,9 +10903,9 @@ function loadProjectSkillsAsCommands() {
   }, {});
 }
 // src/features/claude-code-agent-loader/loader.ts
-import { existsSync as existsSync26, readdirSync as readdirSync8, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync27, readdirSync as readdirSync9, readFileSync as readFileSync17 } from "fs";
 import { homedir as homedir14 } from "os";
-import { join as join35, basename as basename2 } from "path";
+import { join as join36, basename as basename2 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
     return;
@@ -10830,15 +10919,15 @@ function parseToolsConfig(toolsStr) {
   return result;
 }
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync26(agentsDir)) {
+  if (!existsSync27(agentsDir)) {
     return [];
   }
-  const entries = readdirSync8(agentsDir, { withFileTypes: true });
+  const entries = readdirSync9(agentsDir, { withFileTypes: true });
   const agents = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const agentPath = join35(agentsDir, entry.name);
+    const agentPath = join36(agentsDir, entry.name);
     const agentName = basename2(entry.name, ".md");
     try {
       const content = readFileSync17(agentPath, "utf-8");
@@ -10868,7 +10957,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   return agents;
 }
 function loadUserAgents() {
-  const userAgentsDir = join35(homedir14(), ".claude", "agents");
+  const userAgentsDir = join36(homedir14(), ".claude", "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user");
   const result = {};
   for (const agent of agents) {
@@ -10877,7 +10966,7 @@ function loadUserAgents() {
   return result;
 }
 function loadProjectAgents() {
-  const projectAgentsDir = join35(process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join36(process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project");
   const result = {};
   for (const agent of agents) {
@@ -10886,9 +10975,9 @@ function loadProjectAgents() {
   return result;
 }
 // src/features/claude-code-mcp-loader/loader.ts
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import { homedir as homedir15 } from "os";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 
 // src/features/claude-code-mcp-loader/env-expander.ts
 function expandEnvVars(value) {
@@ -10957,13 +11046,13 @@ function getMcpConfigPaths() {
   const home = homedir15();
   const cwd = process.cwd();
   return [
-    { path: join36(home, ".claude", ".mcp.json"), scope: "user" },
-    { path: join36(cwd, ".mcp.json"), scope: "project" },
-    { path: join36(cwd, ".claude", ".mcp.json"), scope: "local" }
+    { path: join37(home, ".claude", ".mcp.json"), scope: "user" },
+    { path: join37(cwd, ".mcp.json"), scope: "project" },
+    { path: join37(cwd, ".claude", ".mcp.json"), scope: "local" }
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync27(filePath)) {
+  if (!existsSync28(filePath)) {
     return null;
   }
   try {
@@ -11298,11 +11387,11 @@ var EXT_TO_LANG = {
   ".gql": "graphql"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync28, readFileSync as readFileSync18 } from "fs";
-import { join as join37 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync18 } from "fs";
+import { join as join38 } from "path";
 import { homedir as homedir16 } from "os";
 function loadJsonFile(path7) {
-  if (!existsSync28(path7))
+  if (!existsSync29(path7))
     return null;
   try {
     return JSON.parse(readFileSync18(path7, "utf-8"));
@@ -11313,9 +11402,9 @@ function loadJsonFile(path7) {
 function getConfigPaths2() {
   const cwd = process.cwd();
   return {
-    project: join37(cwd, ".opencode", "oh-my-opencode.json"),
-    user: join37(homedir16(), ".config", "opencode", "oh-my-opencode.json"),
-    opencode: join37(homedir16(), ".config", "opencode", "opencode.json")
+    project: join38(cwd, ".opencode", "oh-my-opencode.json"),
+    user: join38(homedir16(), ".config", "opencode", "oh-my-opencode.json"),
+    opencode: join38(homedir16(), ".config", "opencode", "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -11411,21 +11500,21 @@ function isServerInstalled(command) {
   const pathSeparator = isWindows2 ? ";" : ":";
   const paths = pathEnv.split(pathSeparator);
   for (const p of paths) {
-    if (existsSync28(join37(p, cmd)) || existsSync28(join37(p, cmd + ext))) {
+    if (existsSync29(join38(p, cmd)) || existsSync29(join38(p, cmd + ext))) {
       return true;
     }
   }
   const cwd = process.cwd();
   const additionalPaths = [
-    join37(cwd, "node_modules", ".bin", cmd),
-    join37(cwd, "node_modules", ".bin", cmd + ext),
-    join37(homedir16(), ".config", "opencode", "bin", cmd),
-    join37(homedir16(), ".config", "opencode", "bin", cmd + ext),
-    join37(homedir16(), ".config", "opencode", "node_modules", ".bin", cmd),
-    join37(homedir16(), ".config", "opencode", "node_modules", ".bin", cmd + ext)
+    join38(cwd, "node_modules", ".bin", cmd),
+    join38(cwd, "node_modules", ".bin", cmd + ext),
+    join38(homedir16(), ".config", "opencode", "bin", cmd),
+    join38(homedir16(), ".config", "opencode", "bin", cmd + ext),
+    join38(homedir16(), ".config", "opencode", "node_modules", ".bin", cmd),
+    join38(homedir16(), ".config", "opencode", "node_modules", ".bin", cmd + ext)
   ];
   for (const p of additionalPaths) {
-    if (existsSync28(p)) {
+    if (existsSync29(p)) {
       return true;
     }
   }
@@ -12020,16 +12109,16 @@ ${msg}`);
 }
 // src/tools/lsp/utils.ts
 import { extname as extname2, resolve as resolve6 } from "path";
-import { existsSync as existsSync29, readFileSync as readFileSync20, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync20, writeFileSync as writeFileSync12 } from "fs";
 function findWorkspaceRoot(filePath) {
   let dir = resolve6(filePath);
-  if (!existsSync29(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  if (!existsSync30(dir) || !__require("fs").statSync(dir).isDirectory()) {
     dir = __require("path").dirname(dir);
   }
   const markers = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
   while (dir !== "/") {
     for (const marker of markers) {
-      if (existsSync29(__require("path").join(dir, marker))) {
+      if (existsSync30(__require("path").join(dir, marker))) {
         return dir;
       }
     }
@@ -24954,13 +25043,13 @@ var lsp_code_action_resolve = tool({
 });
 // src/tools/ast-grep/constants.ts
 import { createRequire as createRequire4 } from "module";
-import { dirname as dirname6, join as join39 } from "path";
-import { existsSync as existsSync31, statSync as statSync4 } from "fs";
+import { dirname as dirname6, join as join40 } from "path";
+import { existsSync as existsSync32, statSync as statSync4 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 var {spawn: spawn5 } = globalThis.Bun;
-import { existsSync as existsSync30, mkdirSync as mkdirSync10, chmodSync as chmodSync2, unlinkSync as unlinkSync9 } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync31, mkdirSync as mkdirSync10, chmodSync as chmodSync2, unlinkSync as unlinkSync9 } from "fs";
+import { join as join39 } from "path";
 import { homedir as homedir17 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
@@ -24986,19 +25075,19 @@ var PLATFORM_MAP2 = {
 function getCacheDir3() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join38(homedir17(), "AppData", "Local");
-    return join38(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join39(homedir17(), "AppData", "Local");
+    return join39(base2, "oh-my-opencode", "bin");
   }
   const xdgCache2 = process.env.XDG_CACHE_HOME;
-  const base = xdgCache2 || join38(homedir17(), ".cache");
-  return join38(base, "oh-my-opencode", "bin");
+  const base = xdgCache2 || join39(homedir17(), ".cache");
+  return join39(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath2() {
-  const binaryPath = join38(getCacheDir3(), getBinaryName3());
-  return existsSync30(binaryPath) ? binaryPath : null;
+  const binaryPath = join39(getCacheDir3(), getBinaryName3());
+  return existsSync31(binaryPath) ? binaryPath : null;
 }
 async function extractZip2(archivePath, destDir) {
   const proc = process.platform === "win32" ? spawn5([
@@ -25024,8 +25113,8 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
-  const binaryPath = join38(cacheDir, binaryName);
-  if (existsSync30(binaryPath)) {
+  const binaryPath = join39(cacheDir, binaryName);
+  if (existsSync31(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os5 } = platformInfo;
@@ -25033,21 +25122,21 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   const downloadUrl = `https://github.com/${REPO2}/releases/download/${version2}/${assetName}`;
   console.log(`[oh-my-opencode] Downloading ast-grep binary...`);
   try {
-    if (!existsSync30(cacheDir)) {
+    if (!existsSync31(cacheDir)) {
       mkdirSync10(cacheDir, { recursive: true });
     }
     const response2 = await fetch(downloadUrl, { redirect: "follow" });
     if (!response2.ok) {
       throw new Error(`HTTP ${response2.status}: ${response2.statusText}`);
     }
-    const archivePath = join38(cacheDir, assetName);
+    const archivePath = join39(cacheDir, assetName);
     const arrayBuffer = await response2.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip2(archivePath, cacheDir);
-    if (existsSync30(archivePath)) {
+    if (existsSync31(archivePath)) {
       unlinkSync9(archivePath);
     }
-    if (process.platform !== "win32" && existsSync30(binaryPath)) {
+    if (process.platform !== "win32" && existsSync31(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -25098,8 +25187,8 @@ function findSgCliPathSync() {
     const require2 = createRequire4(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDir = dirname6(cliPkgPath);
-    const sgPath = join39(cliDir, binaryName);
-    if (existsSync31(sgPath) && isValidBinary(sgPath)) {
+    const sgPath = join40(cliDir, binaryName);
+    if (existsSync32(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -25110,8 +25199,8 @@ function findSgCliPathSync() {
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
       const pkgDir = dirname6(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
-      const binaryPath = join39(pkgDir, astGrepName);
-      if (existsSync31(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join40(pkgDir, astGrepName);
+      if (existsSync32(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -25119,7 +25208,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path7 of homebrewPaths) {
-      if (existsSync31(path7) && isValidBinary(path7)) {
+      if (existsSync32(path7) && isValidBinary(path7)) {
         return path7;
       }
     }
@@ -25175,11 +25264,11 @@ var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn6 } = globalThis.Bun;
-import { existsSync as existsSync32 } from "fs";
+import { existsSync as existsSync33 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync32(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync33(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -25187,7 +25276,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync32(syncPath)) {
+    if (syncPath && existsSync33(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -25221,7 +25310,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync32(cliPath) && cliPath !== "sg") {
+  if (!existsSync33(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -25485,24 +25574,24 @@ var ast_grep_replace = tool({
 var {spawn: spawn7 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
-import { existsSync as existsSync34 } from "fs";
-import { join as join41, dirname as dirname7 } from "path";
+import { existsSync as existsSync35 } from "fs";
+import { join as join42, dirname as dirname7 } from "path";
 import { spawnSync } from "child_process";
 
 // src/tools/grep/downloader.ts
-import { existsSync as existsSync33, mkdirSync as mkdirSync11, chmodSync as chmodSync3, unlinkSync as unlinkSync10, readdirSync as readdirSync9 } from "fs";
-import { join as join40 } from "path";
+import { existsSync as existsSync34, mkdirSync as mkdirSync11, chmodSync as chmodSync3, unlinkSync as unlinkSync10, readdirSync as readdirSync10 } from "fs";
+import { join as join41 } from "path";
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join40(homeDir, ".cache", "oh-my-opencode", "bin");
+  return join41(homeDir, ".cache", "oh-my-opencode", "bin");
 }
 function getRgPath() {
   const isWindows2 = process.platform === "win32";
-  return join40(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
+  return join41(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
 }
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
-  return existsSync33(rgPath) ? rgPath : null;
+  return existsSync34(rgPath) ? rgPath : null;
 }
 
 // src/tools/grep/constants.ts
@@ -25525,13 +25614,13 @@ function getOpenCodeBundledRg() {
   const isWindows2 = process.platform === "win32";
   const rgName = isWindows2 ? "rg.exe" : "rg";
   const candidates = [
-    join41(execDir, rgName),
-    join41(execDir, "bin", rgName),
-    join41(execDir, "..", "bin", rgName),
-    join41(execDir, "..", "libexec", rgName)
+    join42(execDir, rgName),
+    join42(execDir, "bin", rgName),
+    join42(execDir, "..", "bin", rgName),
+    join42(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync34(candidate)) {
+    if (existsSync35(candidate)) {
       return candidate;
     }
   }
@@ -25934,19 +26023,19 @@ var glob = tool({
   }
 });
 // src/tools/slashcommand/tools.ts
-import { existsSync as existsSync35, readdirSync as readdirSync10, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync36, readdirSync as readdirSync11, readFileSync as readFileSync21 } from "fs";
 import { homedir as homedir18 } from "os";
-import { join as join42, basename as basename3, dirname as dirname8 } from "path";
+import { join as join43, basename as basename3, dirname as dirname8 } from "path";
 function discoverCommandsFromDir(commandsDir, scope) {
-  if (!existsSync35(commandsDir)) {
+  if (!existsSync36(commandsDir)) {
     return [];
   }
-  const entries = readdirSync10(commandsDir, { withFileTypes: true });
+  const entries = readdirSync11(commandsDir, { withFileTypes: true });
   const commands = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join42(commandsDir, entry.name);
+    const commandPath = join43(commandsDir, entry.name);
     const commandName = basename3(entry.name, ".md");
     try {
       const content = readFileSync21(commandPath, "utf-8");
@@ -25974,10 +26063,10 @@ function discoverCommandsFromDir(commandsDir, scope) {
   return commands;
 }
 function discoverCommandsSync() {
-  const userCommandsDir = join42(homedir18(), ".claude", "commands");
-  const projectCommandsDir = join42(process.cwd(), ".claude", "commands");
-  const opencodeGlobalDir = join42(homedir18(), ".config", "opencode", "command");
-  const opencodeProjectDir = join42(process.cwd(), ".opencode", "command");
+  const userCommandsDir = join43(homedir18(), ".claude", "commands");
+  const projectCommandsDir = join43(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join43(homedir18(), ".config", "opencode", "command");
+  const opencodeProjectDir = join43(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project");
@@ -26100,246 +26189,6 @@ Provide a command name to execute.`;
 Try a different command name.`;
   }
 });
-// src/tools/skill/types.ts
-var SkillFrontmatterSchema = exports_external.object({
-  name: exports_external.string().regex(/^[a-z0-9-]+$/, "Name must be lowercase alphanumeric with hyphens only").min(1, "Name cannot be empty"),
-  description: exports_external.string().min(20, "Description must be at least 20 characters for discoverability"),
-  license: exports_external.string().optional(),
-  "allowed-tools": exports_external.array(exports_external.string()).optional(),
-  metadata: exports_external.record(exports_external.string(), exports_external.string()).optional()
-});
-// src/tools/skill/tools.ts
-import { existsSync as existsSync36, readdirSync as readdirSync11, readFileSync as readFileSync22 } from "fs";
-import { homedir as homedir19 } from "os";
-import { join as join43, basename as basename4 } from "path";
-function parseSkillFrontmatter(data) {
-  return {
-    name: typeof data.name === "string" ? data.name : "",
-    description: typeof data.description === "string" ? data.description : "",
-    license: typeof data.license === "string" ? data.license : undefined,
-    "allowed-tools": Array.isArray(data["allowed-tools"]) ? data["allowed-tools"] : undefined,
-    metadata: typeof data.metadata === "object" && data.metadata !== null ? data.metadata : undefined
-  };
-}
-function discoverSkillsFromDir(skillsDir, scope) {
-  if (!existsSync36(skillsDir)) {
-    return [];
-  }
-  const entries = readdirSync11(skillsDir, { withFileTypes: true });
-  const skills = [];
-  for (const entry of entries) {
-    if (entry.name.startsWith("."))
-      continue;
-    const skillPath = join43(skillsDir, entry.name);
-    if (entry.isDirectory() || entry.isSymbolicLink()) {
-      const resolvedPath = resolveSymlink(skillPath);
-      const skillMdPath = join43(resolvedPath, "SKILL.md");
-      if (!existsSync36(skillMdPath))
-        continue;
-      try {
-        const content = readFileSync22(skillMdPath, "utf-8");
-        const { data } = parseFrontmatter(content);
-        skills.push({
-          name: data.name || entry.name,
-          description: data.description || "",
-          scope
-        });
-      } catch {
-        continue;
-      }
-    }
-  }
-  return skills;
-}
-function discoverSkillsSync() {
-  const userSkillsDir = join43(homedir19(), ".claude", "skills");
-  const projectSkillsDir = join43(process.cwd(), ".claude", "skills");
-  const userSkills = discoverSkillsFromDir(userSkillsDir, "user");
-  const projectSkills = discoverSkillsFromDir(projectSkillsDir, "project");
-  return [...projectSkills, ...userSkills];
-}
-var availableSkills = discoverSkillsSync();
-var skillListForDescription = availableSkills.map((s) => `- ${s.name}: ${s.description} (${s.scope})`).join(`
-`);
-async function parseSkillMd(skillPath) {
-  const resolvedPath = resolveSymlink(skillPath);
-  const skillMdPath = join43(resolvedPath, "SKILL.md");
-  if (!existsSync36(skillMdPath)) {
-    return null;
-  }
-  try {
-    let content = readFileSync22(skillMdPath, "utf-8");
-    content = await resolveCommandsInText(content);
-    const { data, body } = parseFrontmatter(content);
-    const frontmatter2 = parseSkillFrontmatter(data);
-    const metadata = {
-      name: frontmatter2.name || basename4(skillPath),
-      description: frontmatter2.description,
-      license: frontmatter2.license,
-      allowedTools: frontmatter2["allowed-tools"],
-      metadata: frontmatter2.metadata
-    };
-    const referencesDir = join43(resolvedPath, "references");
-    const scriptsDir = join43(resolvedPath, "scripts");
-    const assetsDir = join43(resolvedPath, "assets");
-    const references = existsSync36(referencesDir) ? readdirSync11(referencesDir).filter((f) => !f.startsWith(".")) : [];
-    const scripts = existsSync36(scriptsDir) ? readdirSync11(scriptsDir).filter((f) => !f.startsWith(".") && !f.startsWith("__")) : [];
-    const assets = existsSync36(assetsDir) ? readdirSync11(assetsDir).filter((f) => !f.startsWith(".")) : [];
-    return {
-      name: metadata.name,
-      path: resolvedPath,
-      basePath: resolvedPath,
-      metadata,
-      content: body,
-      references,
-      scripts,
-      assets
-    };
-  } catch {
-    return null;
-  }
-}
-async function discoverSkillsFromDirAsync(skillsDir) {
-  if (!existsSync36(skillsDir)) {
-    return [];
-  }
-  const entries = readdirSync11(skillsDir, { withFileTypes: true });
-  const skills = [];
-  for (const entry of entries) {
-    if (entry.name.startsWith("."))
-      continue;
-    const skillPath = join43(skillsDir, entry.name);
-    if (entry.isDirectory() || entry.isSymbolicLink()) {
-      const skillInfo = await parseSkillMd(skillPath);
-      if (skillInfo) {
-        skills.push(skillInfo);
-      }
-    }
-  }
-  return skills;
-}
-async function discoverSkills() {
-  const userSkillsDir = join43(homedir19(), ".claude", "skills");
-  const projectSkillsDir = join43(process.cwd(), ".claude", "skills");
-  const userSkills = await discoverSkillsFromDirAsync(userSkillsDir);
-  const projectSkills = await discoverSkillsFromDirAsync(projectSkillsDir);
-  return [...projectSkills, ...userSkills];
-}
-function findMatchingSkills(skills, query) {
-  const queryLower = query.toLowerCase();
-  const queryTerms = queryLower.split(/\s+/).filter(Boolean);
-  return skills.map((skill) => {
-    let score = 0;
-    const nameLower = skill.metadata.name.toLowerCase();
-    const descLower = skill.metadata.description.toLowerCase();
-    if (nameLower === queryLower)
-      score += 100;
-    if (nameLower.includes(queryLower))
-      score += 50;
-    for (const term of queryTerms) {
-      if (nameLower.includes(term))
-        score += 20;
-      if (descLower.includes(term))
-        score += 10;
-    }
-    return { skill, score };
-  }).filter(({ score }) => score > 0).sort((a, b) => b.score - a.score).map(({ skill }) => skill);
-}
-async function loadSkillWithReferences(skill, includeRefs) {
-  const referencesLoaded = [];
-  if (includeRefs && skill.references.length > 0) {
-    for (const ref of skill.references) {
-      const refPath = join43(skill.path, "references", ref);
-      try {
-        let content = readFileSync22(refPath, "utf-8");
-        content = await resolveCommandsInText(content);
-        referencesLoaded.push({ path: ref, content });
-      } catch {}
-    }
-  }
-  return {
-    name: skill.name,
-    metadata: skill.metadata,
-    basePath: skill.basePath,
-    body: skill.content,
-    referencesLoaded
-  };
-}
-function formatSkillList(skills) {
-  if (skills.length === 0) {
-    return "No skills found in ~/.claude/skills/";
-  }
-  const lines = [`# Available Skills
-`];
-  for (const skill of skills) {
-    lines.push(`- **${skill.metadata.name}**: ${skill.metadata.description || "(no description)"}`);
-  }
-  lines.push(`
-**Total**: ${skills.length} skills`);
-  return lines.join(`
-`);
-}
-function formatLoadedSkills(loadedSkills) {
-  if (loadedSkills.length === 0) {
-    return "No skills loaded.";
-  }
-  const skill = loadedSkills[0];
-  const sections = [];
-  sections.push(`Base directory for this skill: ${skill.basePath}/`);
-  sections.push("");
-  sections.push(skill.body.trim());
-  if (skill.referencesLoaded.length > 0) {
-    sections.push(`
----
-### Loaded References
-`);
-    for (const ref of skill.referencesLoaded) {
-      sections.push(`#### ${ref.path}
-`);
-      sections.push("```");
-      sections.push(ref.content.trim());
-      sections.push("```\n");
-    }
-  }
-  sections.push(`
----
-**Launched skill**: ${skill.metadata.name}`);
-  return sections.join(`
-`);
-}
-var skill = tool({
-  description: `Execute a skill within the main conversation.
-
-When you invoke a skill, the skill's prompt will expand and provide detailed instructions on how to complete the task.
-
-Available Skills:
-${skillListForDescription}`,
-  args: {
-    skill: tool.schema.string().describe("The skill name or search query to find and load. Can be exact skill name (e.g., 'python-programmer') or keywords (e.g., 'python', 'plan').")
-  },
-  async execute(args) {
-    const skills = await discoverSkills();
-    if (!args.skill) {
-      return formatSkillList(skills) + `
-
-Provide a skill name to load.`;
-    }
-    const matchingSkills = findMatchingSkills(skills, args.skill);
-    if (matchingSkills.length === 0) {
-      return `No skills found matching "${args.skill}".
-
-` + formatSkillList(skills) + `
-
-Try a different skill name.`;
-    }
-    const loadedSkills = [];
-    for (const skillInfo of matchingSkills.slice(0, 3)) {
-      const loaded = await loadSkillWithReferences(skillInfo, true);
-      loadedSkills.push(loaded);
-    }
-    return formatLoadedSkills(loadedSkills);
-  }
-});
 // src/tools/interactive-bash/constants.ts
 var DEFAULT_TIMEOUT_MS4 = 60000;
 var BLOCKED_TMUX_SUBCOMMANDS = [
@@ -26920,6 +26769,30 @@ session_id: ${sessionID}
 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.`;
 // src/tools/look-at/tools.ts
+import { extname as extname3, basename as basename4 } from "path";
+function inferMimeType(filePath) {
+  const ext = extname3(filePath).toLowerCase();
+  const mimeTypes = {
+    ".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",
+    ".pdf": "application/pdf",
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".json": "application/json",
+    ".xml": "application/xml",
+    ".html": "text/html",
+    ".css": "text/css",
+    ".js": "text/javascript",
+    ".ts": "text/typescript"
+  };
+  return mimeTypes[ext] || "application/octet-stream";
+}
 function createLookAt(ctx) {
   return tool({
     description: LOOK_AT_DESCRIPTION,
@@ -26929,12 +26802,13 @@ 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 = basename4(args.file_path);
       const prompt = `Analyze this file and extract the requested information.
 
-File path: ${args.file_path}
 Goal: ${args.goal}
 
-Read the file using the Read tool, then provide ONLY the extracted information that matches the goal.
+Provide ONLY the extracted information that matches the goal.
 Be thorough on what was requested, concise on everything else.
 If the requested information is not found, clearly state what is missing.`;
       log(`[look_at] Creating session with parent: ${toolContext.sessionID}`);
@@ -26950,7 +26824,7 @@ If the requested information is not found, clearly state what is missing.`;
       }
       const sessionID = createResult.data.id;
       log(`[look_at] Created session: ${sessionID}`);
-      log(`[look_at] Sending prompt to session ${sessionID}`);
+      log(`[look_at] Sending prompt with file passthrough to session ${sessionID}`);
       await ctx.client.session.prompt({
         path: { id: sessionID },
         body: {
@@ -26958,9 +26832,13 @@ If the requested information is not found, clearly state what is missing.`;
           tools: {
             task: false,
             call_omo_agent: false,
-            look_at: false
+            look_at: false,
+            read: false
           },
-          parts: [{ type: "text", text: prompt }]
+          parts: [
+            { type: "text", text: prompt },
+            { type: "file", mime: mimeType, url: `file://${args.file_path}`, filename }
+          ]
         }
       });
       log(`[look_at] Prompt sent, fetching messages...`);
@@ -27011,13 +26889,12 @@ var builtinTools = {
   ast_grep_replace,
   grep,
   glob,
-  slashcommand,
-  skill
+  slashcommand
 };
 // src/features/background-agent/manager.ts
 import { existsSync as existsSync37, readdirSync as readdirSync12 } from "fs";
 import { join as join44 } from "path";
-function getMessageDir4(sessionID) {
+function getMessageDir5(sessionID) {
   if (!existsSync37(MESSAGE_STORAGE))
     return null;
   const directPath = join44(MESSAGE_STORAGE, sessionID);
@@ -27261,7 +27138,7 @@ class BackgroundManager {
     log("[background-agent] Sending notification to parent session:", { parentSessionID: task.parentSessionID });
     setTimeout(async () => {
       try {
-        const messageDir = getMessageDir4(task.parentSessionID);
+        const messageDir = getMessageDir5(task.parentSessionID);
         const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
         await this.client.session.prompt({
           path: { id: task.parentSessionID },