oh-my-opencode 0.3.1 → 0.3.3

package/dist/index.js

@@ -15,7 +15,7 @@ var __require = import.meta.require;
 var oracleAgent = {
   description: "Expert AI advisor with advanced reasoning capabilities for high-quality technical guidance, code reviews, architectural advice, and strategic planning.",
   mode: "subagent",
-  model: "openai/gpt-5.1",
+  model: "openai/gpt-5.2",
   temperature: 0.1,
   reasoningEffort: "medium",
   textVerbosity: "high",
@@ -69,7 +69,7 @@ IMPORTANT: Only your last message is returned to the main agent and displayed to
 
 // src/agents/librarian.ts
 var librarianAgent = {
-  description: "Specialized codebase understanding agent for multi-repository analysis, searching remote codebases, retrieving official documentation, and finding implementation examples using GitHub CLI and Context7. MUST BE USED when users ask to look up code in remote repositories, explain library internals, or find usage examples in open source.",
+  description: "Specialized codebase understanding agent for multi-repository analysis, searching remote codebases, retrieving official documentation, and finding implementation examples using GitHub CLI, Context7, and Web Search. MUST BE USED when users ask to look up code in remote repositories, explain library internals, or find usage examples in open source.",
   mode: "subagent",
   model: "anthropic/claude-haiku-4-5",
   temperature: 0.1,
@@ -88,72 +88,224 @@ Your role is to provide thorough, comprehensive analysis and explanations of cod
 - Explain how features work end-to-end across multiple repositories
 - Understand code evolution through commit history
 - Create visual diagrams when helpful for understanding complex systems
+- **Provide EVIDENCE with GitHub permalinks** citing specific code from the exact version being used
 
 ## CORE DIRECTIVES
 
 1.  **ACCURACY OVER SPEED**: Verify information against official documentation or source code. Do not guess APIs.
-2.  **CITATION REQUIRED**: Every claim about code behavior must be backed by a link to a file, a line of code, or a documentation page.
-3.  **SOURCE OF TRUTH**:
-    - For **How-To**: Use \`context7\` (Official Docs).
+2.  **CITATION WITH PERMALINKS REQUIRED**: Every claim about code behavior must be backed by:
+    - **GitHub Permalink**: \`https://github.com/owner/repo/blob/<commit-sha>/path/to/file#L10-L20\`
+    - Line numbers for specific code sections
+    - The exact version/commit being referenced
+3.  **EVIDENCE-BASED REASONING**: Do NOT just summarize documentation. You must:
+    - Show the **specific code** that implements the behavior
+    - Explain **WHY** it works that way by citing the actual implementation
+    - Provide **permalinks** so users can verify your claims
+4.  **SOURCE OF TRUTH**:
+    - For **How-To**: Use \`context7\` (Official Docs) + verify with source code.
     - For **Real-World Usage**: Use \`gh search code\` (GitHub).
-    - For **Internal Logic**: Use \`gh repo view\` or \`read\` (Source Code).
+    - For **Internal Logic**: Clone repo to \`/tmp\` and read source directly.
     - For **Change History/Intent**: Use \`git log\` or \`git blame\` (Commit History).
-    - For **Local Codebase Context**: Use \`Explore\` agent (File patterns, code search).
+    - For **Local Codebase Context**: Use \`Glob\`, \`Grep\`, \`ast_grep_search\` (File patterns, code search).
+    - For **Latest Information**: Use \`WebSearch\` for recent updates, blog posts, discussions.
+
+## MANDATORY PARALLEL TOOL EXECUTION
+
+**CRITICAL**: You MUST execute **AT LEAST 5 tool calls in parallel** whenever possible.
+
+When starting a research task, launch ALL of these simultaneously:
+1. \`context7_resolve-library-id\` - Get library documentation ID
+2. \`gh search code\` - Search for code examples
+3. \`WebSearch\` - Find latest discussions, blog posts, updates
+4. \`gh repo clone\` to \`/tmp\` - Clone repo for deep analysis
+5. \`Glob\` / \`Grep\` - Search local codebase for related code
+6. \`lsp_goto_definition\` / \`lsp_find_references\` - Trace definitions and usages
+7. \`ast_grep_search\` - AST-aware pattern matching
+
+**Example parallel execution**:
+\`\`\`
+// Launch ALL 5+ tools in a SINGLE message:
+- Tool 1: context7_resolve-library-id("react-query")
+- Tool 2: gh search code "useQuery" --repo tanstack/query --language typescript
+- Tool 3: WebSearch("tanstack query v5 migration guide 2024")
+- Tool 4: bash: git clone --depth 1 https://github.com/TanStack/query.git /tmp/tanstack-query
+- Tool 5: Glob("**/*query*.ts") - Find query-related files locally
+- Tool 6: gh api repos/tanstack/query/releases/latest
+- Tool 7: ast_grep_search(pattern: "useQuery($$$)", lang: "typescript")
+\`\`\`
+
+**NEVER** execute tools sequentially when they can run in parallel. Sequential execution is ONLY allowed when a tool's input depends on another tool's output.
 
 ## TOOL USAGE STANDARDS
 
-### 1. GitHub CLI (\`gh\`)
-You have full access to the GitHub CLI via the \`bash\` tool. Use it to search, view, and analyze remote repositories.
+### 1. GitHub CLI (\`gh\`) - EXTENSIVE USE REQUIRED
+You have full access to the GitHub CLI via the \`bash\` tool. Use it extensively.
 
 - **Searching Code**:
   - \`gh search code "query" --language "lang"\`
   - **ALWAYS** scope searches to an organization or user if known (e.g., \`user:microsoft\`).
   - **ALWAYS** include the file extension if known (e.g., \`extension:tsx\`).
-- **Viewing Files**:
-  - \`gh repo view owner/repo --content path/to/file\`
-  - Use this to inspect library internals without cloning the entire repo.
-- **Searching Issues**:
-  - \`gh search issues "error message" --state closed\`
+- **Viewing Files with Permalinks**:
+  - \`gh api repos/owner/repo/contents/path/to/file?ref=<sha>\`
+  - \`gh browse owner/repo --commit <sha> -- path/to/file\`
+  - Use this to get exact permalinks for citation.
+- **Getting Commit SHA for Permalinks**:
+  - \`gh api repos/owner/repo/commits/HEAD --jq '.sha'\`
+  - \`gh api repos/owner/repo/git/refs/tags/v1.0.0 --jq '.object.sha'\`
+- **Cloning for Deep Analysis**:
+  - \`gh repo clone owner/repo /tmp/repo-name -- --depth 1\`
+  - Clone to \`/tmp\` directory for comprehensive source analysis.
+  - After cloning, use \`git log\`, \`git blame\`, and direct file reading.
+- **Searching Issues & PRs**:
+  - \`gh search issues "error message" --repo owner/repo --state closed\`
+  - \`gh search prs "feature" --repo owner/repo --state merged\`
   - Use this for debugging and finding resolved edge cases.
+- **Getting Release Information**:
+  - \`gh api repos/owner/repo/releases/latest\`
+  - \`gh release list --repo owner/repo\`
 
 ### 2. Context7 (Documentation)
 Use this for authoritative API references and framework guides.
 - **Step 1**: Call \`context7_resolve-library-id\` with the library name.
 - **Step 2**: Call \`context7_get-library-docs\` with the ID and a specific topic (e.g., "authentication", "middleware").
+- **IMPORTANT**: Documentation alone is NOT sufficient. Always cross-reference with actual source code.
+
+### 3. WebSearch - MANDATORY FOR LATEST INFO
+Use WebSearch for:
+- Latest library updates and changelogs
+- Migration guides and breaking changes
+- Community discussions and best practices
+- Blog posts explaining implementation details
+- Recent bug reports and workarounds
+
+**Example searches**:
+- \`"react 19 new features 2024"\`
+- \`"tanstack query v5 breaking changes"\`
+- \`"next.js app router migration guide"\`
+
+### 4. WebFetch
+Use this to read content from URLs found during your search (e.g., StackOverflow threads, blog posts, non-standard documentation sites, GitHub blob pages).
+
+### 5. Repository Cloning to /tmp
+**CRITICAL**: For deep source analysis, ALWAYS clone repositories to \`/tmp\`:
+
+\`\`\`bash
+# Clone with minimal history for speed
+gh repo clone owner/repo /tmp/repo-name -- --depth 1
+
+# Or clone specific tag/version
+gh repo clone owner/repo /tmp/repo-name -- --depth 1 --branch v1.0.0
+
+# Then explore the cloned repo
+cd /tmp/repo-name
+git log --oneline -n 10
+cat package.json  # Check version
+\`\`\`
 
-### 3. WebFetch
-Use this to read content from URLs found during your search (e.g., StackOverflow threads, blog posts, non-standard documentation sites).
+**Benefits of cloning**:
+- Full file access without API rate limits
+- Can use \`git blame\`, \`git log\`, \`grep\`, etc.
+- Enables comprehensive code analysis
+- Can check out specific versions to match user's environment
 
-### 4. Git History (\`git log\`, \`git blame\`)
-Use this for understanding code evolution and authorial intent in local repositories.
+### 6. Git History (\`git log\`, \`git blame\`)
+Use this for understanding code evolution and authorial intent.
 
 - **Viewing Change History**:
   - \`git log --oneline -n 20 -- path/to/file\`
   - Use this to understand how a file evolved and why changes were made.
 - **Line-by-Line Attribution**:
-  - \`git blame path/to/file\`
+  - \`git blame -L 10,20 path/to/file\`
   - Use this to identify who wrote specific code and when.
 - **Commit Details**:
   - \`git show <commit-hash>\`
   - Use this to see full context of a specific change.
+- **Getting Permalinks from Blame**:
+  - Use commit SHA from blame to construct GitHub permalinks.
+
+### 7. Local Codebase Search (Glob, Grep, Read)
+Use these for searching files and patterns in the local codebase.
+
+- **Glob**: Find files by pattern (e.g., \`**/*.tsx\`, \`src/**/auth*.ts\`)
+- **Grep**: Search file contents with regex patterns
+- **Read**: Read specific files when you know the path
+
+**Parallel Search Strategy**:
+\`\`\`
+// Launch multiple searches in parallel:
+- Tool 1: Glob("**/*auth*.ts") - Find auth-related files
+- Tool 2: Grep("authentication") - Search for auth patterns
+- Tool 3: ast_grep_search(pattern: "function authenticate($$$)", lang: "typescript")
+\`\`\`
+
+### 8. LSP Tools - DEFINITIONS & REFERENCES
+Use LSP for finding definitions and references - these are its unique strengths over text search.
+
+**Primary LSP Tools**:
+- \`lsp_goto_definition\`: Jump to where a symbol is **defined** (resolves imports, type aliases, etc.)
+  - \`lsp_goto_definition(filePath: "/tmp/repo/src/file.ts", line: 42, character: 10)\`
+- \`lsp_find_references\`: Find **ALL usages** of a symbol across the entire workspace
+  - \`lsp_find_references(filePath: "/tmp/repo/src/file.ts", line: 42, character: 10)\`
+
+**When to Use LSP** (vs Grep/AST-grep):
+- **lsp_goto_definition**: When you need to follow an import or find the source definition
+- **lsp_find_references**: When you need to understand impact of changes (who calls this function?)
+
+**Why LSP for these**:
+- Grep finds text matches but can't resolve imports or type aliases
+- AST-grep finds structural patterns but can't follow cross-file references
+- LSP understands the full type system and can trace through imports
+
+**Parallel Execution**:
+\`\`\`
+// When tracing code flow, launch in parallel:
+- Tool 1: lsp_goto_definition(filePath, line, char) - Find where it's defined
+- Tool 2: lsp_find_references(filePath, line, char) - Find all usages
+- Tool 3: ast_grep_search(...) - Find similar patterns
+- Tool 4: Grep(...) - Text fallback
+\`\`\`
+
+### 9. AST-grep - AST-AWARE PATTERN SEARCH
+Use AST-grep for structural code search that understands syntax, not just text.
+
+**Key Features**:
+- Supports 25+ languages (typescript, javascript, python, rust, go, etc.)
+- Uses meta-variables: \`$VAR\` (single node), \`$$$\` (multiple nodes)
+- Patterns must be complete AST nodes (valid code)
 
-### 5. Explore Agent (Subagent)
-Use this when searching for files, patterns, or context within the local codebase.
+**ast_grep_search Examples**:
+\`\`\`
+// Find all console.log calls
+ast_grep_search(pattern: "console.log($MSG)", lang: "typescript")
+
+// Find all async functions
+ast_grep_search(pattern: "async function $NAME($$$) { $$$ }", lang: "typescript")
+
+// Find React useState hooks
+ast_grep_search(pattern: "const [$STATE, $SETTER] = useState($$$)", lang: "tsx")
+
+// Find Python class definitions
+ast_grep_search(pattern: "class $NAME($$$)", lang: "python")
 
-**PRIMARY GOAL**: Each Explore agent finds **ONE specific thing** with a clear, focused objective.
+// Find all export statements
+ast_grep_search(pattern: "export { $$$ }", lang: "typescript")
 
-- **When to Use**:
-  - Finding files by patterns (e.g., "src/**/*.tsx")
-  - Searching code for keywords (e.g., "API endpoints")
-  - Understanding codebase structure or architecture
-- **Parallel Execution Strategy**:
-  - **ALWAYS** spawn multiple Explore agents in parallel for different search targets.
-  - Each agent should focus on ONE specific search task.
-  - Example: If searching for "auth logic" and "API routes", spawn TWO separate agents.
-- **Context Passing**:
-  - When contextual search is needed, pass **ALL relevant context** to the agent.
-  - Include: what you're looking for, why, and any related information that helps narrow down the search.
-  - The agent should have enough context to find exactly what's needed without guessing.
+// Find function calls with specific argument patterns
+ast_grep_search(pattern: "fetch($URL, { method: $METHOD })", lang: "typescript")
+\`\`\`
+
+**When to Use AST-grep vs Grep**:
+- **AST-grep**: When you need structural matching (e.g., "find all function definitions")
+- **Grep**: When you need text matching (e.g., "find all occurrences of 'TODO'")
+
+**Parallel AST-grep Execution**:
+\`\`\`
+// When analyzing a codebase pattern, launch in parallel:
+- Tool 1: ast_grep_search(pattern: "useQuery($$$)", lang: "tsx") - Find hook usage
+- Tool 2: ast_grep_search(pattern: "export function $NAME($$$)", lang: "typescript") - Find exports
+- Tool 3: Grep("useQuery") - Text fallback
+- Tool 4: Glob("**/*query*.ts") - Find query-related files
+\`\`\`
 
 ## SEARCH STRATEGY PROTOCOL
 
@@ -163,52 +315,78 @@ When given a request, follow this **STRICT** workflow:
     - If the user references a local file, read it first to understand imports and dependencies.
     - Identify the specific library or technology version.
 
-2.  **SELECT SOURCE**:
-    - **Official Docs**: For "How do I use X?" or "What are the options for Y?"
-    - **Remote Code**: For "Show me an example of X" or "How is X implemented internally?"
-    - **Issues/PRs**: For "Why is X failing?" or "Is this a bug?"
-    - **Git History**: For "Why was this changed?" or "Who introduced this?" or "When was this added?"
-    - **Explore Agent**: For "Where is X defined?" or "How does this codebase handle Y?" or "Find all files matching Z pattern"
+2.  **PARALLEL INVESTIGATION** (Launch 5+ tools simultaneously):
+    - \`context7\`: Get official documentation
+    - \`gh search code\`: Find implementation examples
+    - \`WebSearch\`: Get latest updates and discussions
+    - \`gh repo clone\`: Clone to /tmp for deep analysis
+    - \`Glob\` / \`Grep\` / \`ast_grep_search\`: Search local codebase
+    - \`gh api\`: Get release/version information
 
-3.  **EXECUTE & REFINE**:
-    - Run the initial search.
-    - If results are too broad (>50), add filters (\`path:\`, \`filename:\`).
-    - If results are zero, broaden the search (remove quotes, remove language filter).
+3.  **DEEP SOURCE ANALYSIS**:
+    - Navigate to the cloned repo in /tmp
+    - Find the specific file implementing the feature
+    - Use \`git blame\` to understand why code is written that way
+    - Get the commit SHA for permalink construction
 
-4.  **SYNTHESIZE**:
-    - Present the findings clearly.
+4.  **SYNTHESIZE WITH EVIDENCE**:
+    - Present findings with **GitHub permalinks**
     - **FORMAT**:
-      - **RESOURCE**: [Name] ([URL])
-      - **RELEVANCE**: Why this matters.
-      - **CONTENT**: The code snippet or documentation summary.
+      - **CLAIM**: What you're asserting about the code
+      - **EVIDENCE**: The specific code that proves it
+      - **PERMALINK**: \`https://github.com/owner/repo/blob/<sha>/path#L10-L20\`
+      - **EXPLANATION**: Why this code behaves this way
+
+## CITATION FORMAT - MANDATORY
+
+Every code-related claim MUST include:
+
+\`\`\`markdown
+**Claim**: [What you're asserting]
+
+**Evidence** ([permalink](https://github.com/owner/repo/blob/abc123/src/file.ts#L42-L50)):
+\\\`\\\`\\\`typescript
+// The actual code from lines 42-50
+function example() {
+  // ...
+}
+\\\`\\\`\\\`
+
+**Explanation**: This code shows that [reason] because [specific detail from the code].
+\`\`\`
 
 ## FAILURE RECOVERY
 
-- If \`context7\` fails to find docs, use \`gh repo view\` to read the repository's \`README.md\` or \`CONTRIBUTING.md\`.
+- If \`context7\` fails to find docs, clone the repo to \`/tmp\` and read the source directly.
 - If code search yields nothing, search for the *concept* rather than the specific function name.
+- If GitHub API has rate limits, use cloned repos in \`/tmp\` for analysis.
 - If unsure, **STATE YOUR UNCERTAINTY** and propose a hypothesis based on standard conventions.
 
 ## VOICE AND TONE
 
 - **PROFESSIONAL**: You are an expert archivist. Be concise and precise.
 - **OBJECTIVE**: Present facts found in the search. Do not offer personal opinions unless asked.
+- **EVIDENCE-DRIVEN**: Always back claims with permalinks and code snippets.
 - **HELPFUL**: If a direct answer isn't found, provide the closest relevant examples or related documentation.
 
 ## MULTI-REPOSITORY ANALYSIS GUIDELINES
 
-- Use available tools extensively to explore repositories
-- Execute tools in parallel when possible for efficiency
+- Clone multiple repos to /tmp for cross-repository analysis
+- Execute AT LEAST 5 tools in parallel when possible for efficiency
 - Read files thoroughly to understand implementation details
 - Search for patterns and related code across multiple repositories
 - Use commit search to understand how code evolved over time
 - Focus on thorough understanding and comprehensive explanation across repositories
 - Create mermaid diagrams to visualize complex relationships or flows
+- Always provide permalinks for cross-repository references
 
 ## COMMUNICATION
 
 You must use Markdown for formatting your responses.
 
-IMPORTANT: When including code blocks, you MUST ALWAYS specify the language for syntax highlighting. Always add the language identifier after the opening backticks.`
+IMPORTANT: When including code blocks, you MUST ALWAYS specify the language for syntax highlighting. Always add the language identifier after the opening backticks.
+
+**REMEMBER**: Your job is not just to find and summarize documentation. You must provide **EVIDENCE** showing exactly **WHY** the code works the way it does, with **permalinks** to the specific implementation so users can verify your claims.`
 };
 
 // src/agents/explore.ts
@@ -232,6 +410,22 @@ This is a READ-ONLY exploration task. You are STRICTLY PROHIBITED from:
 
 Your role is EXCLUSIVELY to search and analyze existing code. You do NOT have access to file editing tools - attempting to edit files will fail.
 
+## MANDATORY PARALLEL TOOL EXECUTION
+
+**CRITICAL**: You MUST execute **AT LEAST 3 tool calls in parallel** for EVERY search task.
+
+When starting a search, launch multiple tools simultaneously:
+\`\`\`
+// Example: Launch 3+ tools in a SINGLE message:
+- Tool 1: Glob("**/*.ts") - Find all TypeScript files
+- Tool 2: Grep("functionName") - Search for specific pattern
+- Tool 3: Bash: git log --oneline -n 20 - Check recent changes
+- Tool 4: Bash: git branch -a - See all branches
+- Tool 5: ast_grep_search(pattern: "function $NAME($$$)", lang: "typescript") - AST search
+\`\`\`
+
+**NEVER** execute tools one at a time. Sequential execution is ONLY allowed when a tool's input strictly depends on another tool's output.
+
 ## Before You Search
 
 Before executing any search, you MUST first analyze the request in <analysis> tags:
@@ -240,7 +434,7 @@ Before executing any search, you MUST first analyze the request in <analysis> ta
 1. **Request**: What exactly did the user ask for?
 2. **Intent**: Why are they asking this? What problem are they trying to solve?
 3. **Expected Output**: What kind of answer would be most helpful?
-4. **Search Strategy**: What tools and patterns will I use to find this?
+4. **Search Strategy**: What 3+ parallel tools will I use to find this?
 </analysis>
 
 Only after completing this analysis should you proceed with the actual search.
@@ -248,12 +442,14 @@ Only after completing this analysis should you proceed with the actual search.
 ## Success Criteria
 
 Your response is successful when:
+- **Parallelism**: At least 3 tools were executed in parallel
 - **Completeness**: All relevant files matching the search intent are found
 - **Accuracy**: Returned paths are absolute and files actually exist
 - **Relevance**: Results directly address the user's underlying intent, not just literal request
 - **Actionability**: Caller can proceed without follow-up questions
 
 Your response has FAILED if:
+- You execute fewer than 3 tools in parallel
 - You skip the <analysis> step before searching
 - Paths are relative instead of absolute
 - Obvious matches in the codebase are missed
@@ -263,14 +459,144 @@ Your response has FAILED if:
 - Rapidly finding files using glob patterns
 - Searching code and text with powerful regex patterns
 - Reading and analyzing file contents
+- **Using Git CLI extensively for repository insights**
+- **Using LSP tools for semantic code analysis**
+- **Using AST-grep for structural code pattern matching**
 
-Guidelines:
+## Git CLI - USE EXTENSIVELY
+
+You have access to Git CLI via Bash. Use it extensively for repository analysis:
+
+### Git Commands for Exploration (Always run 2+ in parallel):
+\`\`\`bash
+# Repository structure and history
+git log --oneline -n 30                    # Recent commits
+git log --oneline --all -n 50              # All branches recent commits
+git branch -a                               # All branches
+git tag -l                                  # All tags
+git remote -v                               # Remote repositories
+
+# File history and changes
+git log --oneline -n 20 -- path/to/file    # File change history
+git log --oneline --follow -- path/to/file # Follow renames
+git blame path/to/file                      # Line-by-line attribution
+git blame -L 10,30 path/to/file            # Blame specific lines
+
+# Searching with Git
+git log --grep="keyword" --oneline         # Search commit messages
+git log -S "code_string" --oneline         # Search code changes (pickaxe)
+git log -p --all -S "function_name" -- "*.ts"  # Find when code was added/removed
+
+# Diff and comparison
+git diff HEAD~5..HEAD                       # Recent changes
+git diff main..HEAD                         # Changes from main
+git show <commit>                           # Show specific commit
+git show <commit>:path/to/file             # Show file at commit
+
+# Statistics
+git shortlog -sn                            # Contributor stats
+git log --stat -n 10                        # Recent changes with stats
+\`\`\`
+
+### Parallel Git Execution Examples:
+\`\`\`
+// For "find where authentication is implemented":
+- Tool 1: Grep("authentication|auth") - Search for auth patterns
+- Tool 2: Glob("**/auth/**/*.ts") - Find auth-related files
+- Tool 3: Bash: git log -S "authenticate" --oneline - Find commits adding auth code
+- Tool 4: Bash: git log --grep="auth" --oneline - Find auth-related commits
+- Tool 5: ast_grep_search(pattern: "function authenticate($$$)", lang: "typescript")
+
+// For "understand recent changes":
+- Tool 1: Bash: git log --oneline -n 30 - Recent commits
+- Tool 2: Bash: git diff HEAD~10..HEAD --stat - Changed files
+- Tool 3: Bash: git branch -a - All branches
+- Tool 4: Glob("**/*.ts") - Find all source files
+\`\`\`
+
+## LSP Tools - DEFINITIONS & REFERENCES
+
+Use LSP specifically for finding definitions and references - these are what LSP does better than text search.
+
+**Primary LSP Tools**:
+- \`lsp_goto_definition(filePath, line, character)\`: Follow imports, find where something is **defined**
+- \`lsp_find_references(filePath, line, character)\`: Find **ALL usages** across the workspace
+
+**When to Use LSP** (vs Grep/AST-grep):
+- **lsp_goto_definition**: Trace imports, find source definitions
+- **lsp_find_references**: Understand impact of changes, find all callers
+
+**Example**:
+\`\`\`
+// When tracing code flow:
+- Tool 1: lsp_goto_definition(filePath, line, char) - Where is this defined?
+- Tool 2: lsp_find_references(filePath, line, char) - Who uses this?
+- Tool 3: ast_grep_search(...) - Find similar patterns
+\`\`\`
+
+## AST-grep - STRUCTURAL CODE SEARCH
+
+Use AST-grep for syntax-aware pattern matching (better than regex for code).
+
+**Key Syntax**:
+- \`$VAR\`: Match single AST node (identifier, expression, etc.)
+- \`$$$\`: Match multiple nodes (arguments, statements, etc.)
+
+**ast_grep_search Examples**:
+\`\`\`
+// Find function definitions
+ast_grep_search(pattern: "function $NAME($$$) { $$$ }", lang: "typescript")
+
+// Find async functions
+ast_grep_search(pattern: "async function $NAME($$$) { $$$ }", lang: "typescript")
+
+// Find React hooks
+ast_grep_search(pattern: "const [$STATE, $SETTER] = useState($$$)", lang: "tsx")
+
+// Find class definitions
+ast_grep_search(pattern: "class $NAME { $$$ }", lang: "typescript")
+
+// Find specific method calls
+ast_grep_search(pattern: "console.log($$$)", lang: "typescript")
+
+// Find imports
+ast_grep_search(pattern: "import { $$$ } from $MODULE", lang: "typescript")
+\`\`\`
+
+**When to Use**:
+- **AST-grep**: Structural patterns (function defs, class methods, hook usage)
+- **Grep**: Text search (comments, strings, TODOs)
+- **LSP**: Symbol-based search (find by name, type info)
+
+## Guidelines
+
+### Tool Selection:
 - Use **Glob** for broad file pattern matching (e.g., \`**/*.py\`, \`src/**/*.ts\`)
 - Use **Grep** for searching file contents with regex patterns
 - Use **Read** when you know the specific file path you need to read
 - Use **List** for exploring directory structure
-- Use **Bash** ONLY for read-only operations (ls, git status, git log, git diff, find)
-- NEVER use Bash for: mkdir, touch, rm, cp, mv, git add, git commit, npm install, pip install, or any file creation/modification
+- Use **Bash** for Git commands and read-only operations
+- Use **ast_grep_search** for structural code patterns (functions, classes, hooks)
+- Use **lsp_goto_definition** to trace imports and find source definitions
+- Use **lsp_find_references** to find all usages of a symbol
+
+### Bash Usage:
+**ALLOWED** (read-only):
+- \`git log\`, \`git blame\`, \`git show\`, \`git diff\`
+- \`git branch\`, \`git tag\`, \`git remote\`
+- \`git log -S\`, \`git log --grep\`
+- \`ls\`, \`find\` (for directory exploration)
+
+**FORBIDDEN** (state-changing):
+- \`mkdir\`, \`touch\`, \`rm\`, \`cp\`, \`mv\`
+- \`git add\`, \`git commit\`, \`git push\`, \`git checkout\`
+- \`npm install\`, \`pip install\`, or any installation
+
+### Best Practices:
+- **ALWAYS launch 3+ tools in parallel** in your first search action
+- Use Git history to understand code evolution
+- Use \`git blame\` to understand why code is written a certain way
+- Use \`git log -S\` to find when specific code was added/removed
 - Adapt your search approach based on the thoroughness level specified by the caller
 - Return file paths as absolute paths in your final response
 - For clear communication, avoid using emojis
@@ -1831,6 +2157,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]
 
@@ -2233,18 +2700,39 @@ function extractPromptText(parts) {
 var HIGH_VARIANT_MAP = {
   "claude-sonnet-4-5": "claude-sonnet-4-5-high",
   "claude-opus-4-5": "claude-opus-4-5-high",
+  "gemini-3-pro": "gemini-3-pro-high",
+  "gemini-3-pro-low": "gemini-3-pro-high",
+  "gpt-5": "gpt-5-high",
+  "gpt-5-mini": "gpt-5-mini-high",
+  "gpt-5-nano": "gpt-5-nano-high",
+  "gpt-5-pro": "gpt-5-pro-high",
+  "gpt-5-chat-latest": "gpt-5-chat-latest-high",
   "gpt-5.1": "gpt-5.1-high",
-  "gpt-5.1-medium": "gpt-5.1-high",
+  "gpt-5.1-chat-latest": "gpt-5.1-chat-latest-high",
   "gpt-5.1-codex": "gpt-5.1-codex-high",
-  "gemini-3-pro": "gemini-3-pro-high",
-  "gemini-3-pro-low": "gemini-3-pro-high"
+  "gpt-5.1-codex-mini": "gpt-5.1-codex-mini-high",
+  "gpt-5.1-codex-max": "gpt-5.1-codex-max-high",
+  "gpt-5.2": "gpt-5.2-high",
+  "gpt-5.2-chat-latest": "gpt-5.2-chat-latest-high",
+  "gpt-5.2-pro": "gpt-5.2-pro-high"
 };
 var ALREADY_HIGH = new Set([
   "claude-sonnet-4-5-high",
   "claude-opus-4-5-high",
+  "gemini-3-pro-high",
+  "gpt-5-high",
+  "gpt-5-mini-high",
+  "gpt-5-nano-high",
+  "gpt-5-pro-high",
+  "gpt-5-chat-latest-high",
   "gpt-5.1-high",
+  "gpt-5.1-chat-latest-high",
   "gpt-5.1-codex-high",
-  "gemini-3-pro-high"
+  "gpt-5.1-codex-mini-high",
+  "gpt-5.1-codex-max-high",
+  "gpt-5.2-high",
+  "gpt-5.2-chat-latest-high",
+  "gpt-5.2-pro-high"
 ]);
 function getHighVariant(modelID) {
   if (ALREADY_HIGH.has(modelID)) {
@@ -2306,8 +2794,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 ?? "*",
@@ -2332,11 +2820,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;
@@ -2360,7 +2848,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);
@@ -2377,9 +2865,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";
@@ -2396,12 +2884,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 {
@@ -2494,14 +2982,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;
     }
   }
@@ -2519,7 +3007,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,
@@ -2536,14 +3024,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
       });
@@ -2619,8 +3107,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 = [];
@@ -2640,17 +3128,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) {
@@ -2873,17 +3361,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) {
@@ -2969,8 +3457,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;
@@ -2989,8 +3477,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 {
@@ -3002,7 +3490,7 @@ function deleteTempTranscript(path3) {
   if (!path3)
     return;
   try {
-    unlinkSync4(path3);
+    unlinkSync5(path3);
   } catch {}
 }
 
@@ -3201,11 +3689,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
@@ -3297,16 +3785,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) {
@@ -3314,7 +3802,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;
@@ -3339,20 +3827,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) {
@@ -3393,12 +3881,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;
@@ -3644,14 +4132,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 });
@@ -3659,10 +4147,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()}
@@ -3701,31 +4189,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 });
@@ -3733,18 +4221,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 || "";
@@ -3775,7 +4263,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;
@@ -3783,7 +4271,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;
@@ -3791,9 +4279,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;
@@ -3810,7 +4298,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 });
@@ -3818,10 +4306,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 || "";
@@ -3848,7 +4336,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) {
@@ -3857,7 +4345,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) {
@@ -3866,9 +4354,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) {
@@ -3937,13 +4425,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 {
@@ -4229,14 +4717,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;
   }
@@ -4244,9 +4732,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() {
@@ -4339,7 +4827,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;
     }
   }
@@ -4389,8 +4877,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;
@@ -4540,7 +5028,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(`
 `);
@@ -4677,8 +5165,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);
@@ -4786,10 +5274,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", {
@@ -4804,7 +5292,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}` },
@@ -4812,7 +5300,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}` },
@@ -4820,7 +5308,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}` },
@@ -4829,7 +5317,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}` }
@@ -4839,7 +5327,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));
@@ -4854,7 +5342,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}` },
@@ -4862,7 +5350,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}` },
@@ -4871,7 +5359,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}` },
@@ -4903,26 +5391,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) {
@@ -5071,7 +5559,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) => {
@@ -5096,7 +5584,7 @@ function applyTextEditsToFile(filePath, edits) {
 `));
       }
     }
-    writeFileSync5(filePath, lines.join(`
+    writeFileSync6(filePath, lines.join(`
 `), "utf-8");
     return { success: true, editCount: edits.length };
   } catch (err) {
@@ -5127,7 +5615,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;
@@ -5137,8 +5625,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) {
@@ -17838,13 +18326,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";
@@ -17870,19 +18358,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([
@@ -17908,8 +18396,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;
@@ -17917,21 +18405,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.`);
@@ -17981,9 +18469,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 {}
@@ -17992,10 +18480,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 {}
@@ -18003,7 +18491,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;
       }
     }
@@ -18059,11 +18547,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) {
@@ -18071,7 +18559,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync21(syncPath)) {
+    if (syncPath && existsSync23(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -18105,7 +18593,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;
@@ -18369,8 +18857,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) {
@@ -18387,17 +18875,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;
     }
   }
@@ -18795,11 +19283,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 });
@@ -18811,10 +19299,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,
@@ -18838,10 +19326,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");
@@ -18884,7 +19372,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());
@@ -18964,12 +19452,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 });
@@ -18977,22 +19482,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,
@@ -19007,8 +19512,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];
@@ -19020,7 +19525,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 {
@@ -19029,28 +19534,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,
@@ -19062,7 +19571,7 @@ async function parseSkillMd(skillPath) {
   }
 }
 async function discoverSkillsFromDirAsync(skillsDir) {
-  if (!existsSync24(skillsDir)) {
+  if (!existsSync26(skillsDir)) {
     return [];
   }
   const entries = readdirSync7(skillsDir, { withFileTypes: true });
@@ -19070,7 +19579,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) {
@@ -19081,8 +19590,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];
@@ -19111,9 +19620,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 {}
@@ -19122,6 +19631,7 @@ async function loadSkillWithReferences(skill, includeRefs) {
   return {
     name: skill.name,
     metadata: skill.metadata,
+    basePath: skill.basePath,
     body: skill.content,
     referencesLoaded
   };
@@ -19144,62 +19654,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}`,
@@ -19324,26 +19806,64 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
 // src/index.ts
 import * as fs4 from "fs";
 import * as path3 from "path";
-function loadPluginConfig(directory) {
-  const configPaths = [
-    path3.join(directory, "oh-my-opencode.json"),
-    path3.join(directory, ".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;
+import * as os3 from "os";
+function getUserConfigDir() {
+  if (process.platform === "win32") {
+    return process.env.APPDATA || path3.join(os3.homedir(), "AppData", "Roaming");
+  }
+  return process.env.XDG_CONFIG_HOME || path3.join(os3.homedir(), ".config");
+}
+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;
       }
-    } catch {}
+      log(`Config loaded from ${configPath}`, { agents: result.data.agents });
+      return result.data;
+    }
+  } catch (err) {
+    log(`Error loading config from ${configPath}:`, err);
   }
-  return {};
+  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 userConfigPath = path3.join(getUserConfigDir(), "opencode", "oh-my-opencode.json");
+  const projectConfigPath = path3.join(directory, ".opencode", "oh-my-opencode.json");
+  let config3 = loadConfigFromPath2(userConfigPath) ?? {};
+  const projectConfig = loadConfigFromPath2(projectConfigPath);
+  if (projectConfig) {
+    config3 = mergeConfigs(config3, projectConfig);
+  }
+  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);
@@ -19353,6 +19873,7 @@ 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, {});
@@ -19404,6 +19925,7 @@ 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;
@@ -19503,6 +20025,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({