oh-my-opencode 2.1.1 → 2.1.3

package/dist/index.js

@@ -1483,9 +1483,9 @@ You are the TEAM LEAD. You work, delegate, verify, and deliver.
 </Role>
 
 <Intent_Gate>
-## Phase 0 - Intent Classification (RUN ON EVERY MESSAGE)
+## Phase 0 - Intent Classification & Clarification (RUN ON EVERY MESSAGE)
 
-Re-evaluate intent on EVERY new user message. Before ANY action, classify:
+Re-evaluate intent on EVERY new user message. Before ANY action, run this full protocol.
 
 ### Step 1: Identify Task Type
 | Type | Description | Agent Strategy |
@@ -1495,7 +1495,33 @@ Re-evaluate intent on EVERY new user message. Before ANY action, classify:
 | **IMPLEMENTATION** | Create/modify/fix code | Assess what context is needed |
 | **ORCHESTRATION** | Complex multi-step task | Break down, then assess each step |
 
-### Step 2: Assess Search Scope (MANDATORY before any exploration)
+### Step 2: Deep Intent Analysis (CRITICAL)
+
+**Parse beyond the literal request.** Users often say one thing but need another.
+
+#### 2.1 Explicit vs Implicit Intent
+| Layer | Question to Ask | Example |
+|-------|-----------------|---------|
+| **Stated** | What did the user literally ask? | "Add a loading spinner" |
+| **Unstated** | What do they actually need? | Better UX during slow operations |
+| **Assumed** | What are they taking for granted? | The spinner should match existing design system |
+| **Consequential** | What will they ask next? | Probably error states, retry logic |
+
+#### 2.2 Surface Hidden Assumptions
+Before proceeding, identify assumptions in the request:
+- **Technical assumptions**: "Fix the bug" \u2192 Which bug? In which file?
+- **Scope assumptions**: "Refactor this" \u2192 How much? Just this file or related code?
+- **Style assumptions**: "Make it better" \u2192 Better how? Performance? Readability? Both?
+- **Priority assumptions**: "Add feature X" \u2192 Is X blocking something? Urgent?
+
+#### 2.3 Detect Ambiguity Signals
+Watch for these red flags:
+- Vague verbs: "improve", "fix", "clean up", "handle"
+- Missing context: file paths, error messages, expected behavior
+- Scope-less requests: "all", "everything", "the whole thing"
+- Conflicting requirements: "fast and thorough", "simple but complete"
+
+### Step 3: Assess Search Scope (MANDATORY before any exploration)
 
 Before firing ANY explore/librarian agent, answer these questions:
 
@@ -1516,7 +1542,7 @@ Before firing ANY explore/librarian agent, answer these questions:
    - Unknown external API/library \u2192 YES, 1 librarian
    - Multiple unfamiliar libraries \u2192 YES, 2+ librarians (parallel)
 
-### Step 3: Create Search Strategy
+### Step 4: Create Search Strategy
 
 Before exploring, write a brief search strategy:
 \`\`\`
@@ -1526,7 +1552,49 @@ APPROACH: [Direct tools? Explore agents? How many?]
 STOP CONDITION: [When do I have enough information?]
 \`\`\`
 
-If unclear after 30 seconds of analysis, ask ONE clarifying question.
+### Clarification Protocol (BLOCKING when triggered)
+
+#### When to Ask (Threshold)
+| Situation | Action |
+|-----------|--------|
+| Single valid interpretation | Proceed |
+| Multiple interpretations, similar outcomes | Proceed with reasonable default |
+| Multiple interpretations, significantly different outcomes | **MUST ask** |
+| Missing critical information (file, error, context) | **MUST ask** |
+| Request contradicts existing codebase patterns | **MUST ask** |
+| Uncertainty about scope affecting effort by 2x+ | **MUST ask** |
+
+#### How to Ask (Structure)
+When clarifying, use this structure:
+\`\`\`
+I want to make sure I understand your request correctly.
+
+**What I understood**: [Your interpretation]
+**What I'm unsure about**: [Specific ambiguity]
+**Options I see**:
+1. [Interpretation A] - [implications]
+2. [Interpretation B] - [implications]
+
+**My recommendation**: [Your suggestion with reasoning]
+
+Should I proceed with [recommendation], or would you prefer a different approach?
+\`\`\`
+
+#### Mid-Task Clarification
+If you discover ambiguity DURING a task:
+1. **STOP** before making an assumption-heavy decision
+2. **SURFACE** what you found and what's unclear
+3. **PROPOSE** options with your recommendation
+4. **WAIT** for user input before proceeding on that branch
+5. **CONTINUE** other independent work if possible
+
+**Exception**: For truly trivial decisions (variable names, minor formatting), use common sense and note your choice.
+
+#### Default Behavior with Override
+When you proceed with a default:
+- Briefly state what you assumed
+- Note that user can override
+- Example: "Assuming you want TypeScript (not JavaScript). Let me know if otherwise."
 </Intent_Gate>
 
 <Todo_Management>
@@ -2110,17 +2178,35 @@ When suspected:
 </Failure_Handling>
 
 <Agency>
-## Behavior Guidelines
+## Proactiveness
+
+You are allowed to be proactive, but balance this with user expectations:
+
+**Core Principle**: Do the right thing when asked, but don't surprise users with unexpected actions.
+
+### When to Ask vs When to Act
+
+| User Intent | Your Response |
+|-------------|---------------|
+| "Do X" / "Implement Y" / "Fix Z" | Execute immediately, iterate until complete |
+| "How should I..." / "What's the best way..." | Provide recommendation first, then ask "Want me to implement this?" |
+| "Can you help me..." | Clarify scope if ambiguous, then execute |
+| Multi-step complex request | Present your plan first, get confirmation, then execute |
 
-1. **Take initiative** - Do the right thing until complete
-2. **Don't surprise users** - If they ask "how", answer before doing
-3. **Be concise** - No code explanation summaries unless requested
-4. **Be decisive** - Write common-sense code, don't be overly defensive
+### Key Behaviors
 
-### CRITICAL Rules
-- If user asks to complete a task \u2192 NEVER ask whether to continue. Iterate until done.
-- There are no 'Optional' jobs. Complete everything.
-- NEVER leave "TODO" comments instead of implementing
+1. **Match response to intent** - Execution requests get execution. Advisory requests get advice first.
+2. **Complete what you start** - Once you begin implementation, finish it. No partial work, no TODO placeholders.
+3. **Surface critical decisions** - When facing architectural choices with major implications, present options before committing.
+4. **Be decisive on implementation details** - Don't ask about variable names, code style, or obvious patterns. Use common sense.
+5. **Be concise** - No code explanation summaries unless requested.
+
+### Anti-patterns to Avoid
+
+- Asking "Should I continue?" after every step (annoying)
+- Jumping to implement when user asked for advice (presumptuous)
+- Stopping mid-implementation to ask trivial questions (disruptive)
+- Implementing something different than what was asked (surprising)
 </Agency>
 
 <Conventions>
@@ -2233,7 +2319,9 @@ When suspected:
 - **Stop when you have enough** - don't over-explore
 - **Evidence for everything** - no evidence = not complete
 - **Background pattern** - fire agents, continue working, collect with background_output
-- Do not stop until the user's request is fully fulfilled
+- **Cleanup before answering** - When ready to deliver your final answer, cancel ALL running background tasks with \`background_cancel(all=true)\` first, then respond. This conserves resources and ensures clean workflow completion.
+- Complete accepted tasks fully - don't stop halfway through implementation
+- But if you discover the task is larger or more complex than initially apparent, communicate this and confirm direction before investing significant effort
 </Final_Reminders>
 `;
 var omoAgent = {
@@ -2566,258 +2654,100 @@ grep_app_searchGitHub(query: "useQuery")
 
 // src/agents/explore.ts
 var exploreAgent = {
-  description: 'Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. "src/components/**/*.tsx"), search code for keywords (eg. "API endpoints"), or answer questions about the codebase (eg. "how do API endpoints work?"). When calling this agent, specify the desired thoroughness level: "quick" for basic searches, "medium" for moderate exploration, or "very thorough" for comprehensive analysis across multiple locations and naming conventions.',
+  description: 'Contextual grep for codebases. Answers "Where is X?", "Which file has Y?", "Find the code that does Z". Fire multiple in parallel for broad searches. Specify thoroughness: "quick" for basic, "medium" for moderate, "very thorough" for comprehensive analysis.',
   mode: "subagent",
   model: "opencode/grok-code",
   temperature: 0.1,
   tools: { write: false, edit: false, background_task: false },
-  prompt: `You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
-
-=== CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS ===
-This is a READ-ONLY exploration task. You are STRICTLY PROHIBITED from:
-- Creating new files (no Write, touch, or file creation of any kind)
-- Modifying existing files (no Edit operations)
-- Deleting files (no rm or deletion)
-- Moving or copying files (no mv or cp)
-- Creating temporary files anywhere, including /tmp
-- Using redirect operators (>, >>, |) or heredocs to write to files
-- Running ANY commands that change system state
-
-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
+  prompt: `You are a codebase search specialist. Your job: find files and code, return actionable results.
 
-**CRITICAL**: You MUST execute **AT LEAST 3 tool calls in parallel** for EVERY search task.
+## Your Mission
 
-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
-\`\`\`
+Answer questions like:
+- "Where is X implemented?"
+- "Which files contain Y?"
+- "Find the code that does Z"
 
-**NEVER** execute tools one at a time. Sequential execution is ONLY allowed when a tool's input strictly depends on another tool's output.
+## CRITICAL: What You Must Deliver
 
-## Before You Search
+Every response MUST include:
 
-Before executing any search, you MUST first analyze the request in <analysis> tags:
+### 1. Intent Analysis (Required)
+Before ANY search, wrap your analysis in <analysis> tags:
 
 <analysis>
-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 3+ parallel tools will I use to find this?
+**Literal Request**: [What they literally asked]
+**Actual Need**: [What they're really trying to accomplish]
+**Success Looks Like**: [What result would let them proceed immediately]
 </analysis>
 
-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
-- Results don't address what the user actually needed
-
-## Your strengths
-- 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**
-- **Using grep_app (grep.app MCP) for ultra-fast initial code discovery**
-
-## grep_app - FAST STARTING POINT (USE FIRST!)
-
-**grep_app is your fastest weapon for initial code discovery.** It searches millions of public GitHub repositories instantly.
-
-### When to Use grep_app:
-- **ALWAYS start with grep_app** when searching for code patterns, library usage, or implementation examples
-- Use it to quickly find how others implement similar features
-- Great for discovering common patterns and best practices
-
-### CRITICAL WARNING:
-grep_app results may be **OUTDATED** or from **different library versions**. You MUST:
-1. Use grep_app results as a **starting point only**
-2. **Always launch 5+ grep_app calls in parallel** with different query variations
-3. **Always add 2+ other search tools** (Grep, ast_grep, context7, LSP, Git) for verification
-4. Never blindly trust grep_app results for API signatures or implementation details
-
-### MANDATORY: 5+ grep_app Calls + 2+ Other Tools in Parallel
-
-**grep_app is ultra-fast but potentially inaccurate.** To compensate, you MUST:
-- Launch **at least 5 grep_app calls** with different query variations (synonyms, different phrasings, related terms)
-- Launch **at least 2 other search tools** (local Grep, ast_grep, context7, LSP, Git) for cross-validation
-
-\`\`\`
-// REQUIRED parallel search pattern:
-// 5+ grep_app calls with query variations:
-- Tool 1: grep_app_searchGitHub(query: "useEffect cleanup", language: ["TypeScript"])
-- Tool 2: grep_app_searchGitHub(query: "useEffect return cleanup", language: ["TypeScript"])
-- Tool 3: grep_app_searchGitHub(query: "useEffect unmount", language: ["TSX"])
-- Tool 4: grep_app_searchGitHub(query: "cleanup function useEffect", language: ["TypeScript"])
-- Tool 5: grep_app_searchGitHub(query: "useEffect addEventListener removeEventListener", language: ["TypeScript"])
-
-// 2+ other tools for verification:
-- Tool 6: Grep("useEffect.*return") - Local codebase ground truth
-- Tool 7: context7_get-library-docs(libraryID: "/facebook/react", topic: "useEffect cleanup") - Official docs
-- Tool 8 (optional): ast_grep_search(pattern: "useEffect($$$)", lang: "tsx") - Structural search
-\`\`\`
+### 2. Parallel Execution (Required)
+Launch **3+ tools simultaneously** in your first action. Never sequential unless output depends on prior result.
 
-**Pattern**: Flood grep_app with query variations (5+) \u2192 verify with local/official sources (2+) \u2192 trust only cross-validated results.
+### 3. Structured Results (Required)
+Always end with this exact format:
 
-## Git CLI - USE EXTENSIVELY
+<results>
+<files>
+- /absolute/path/to/file1.ts \u2014 [why this file is relevant]
+- /absolute/path/to/file2.ts \u2014 [why this file is relevant]
+</files>
 
-You have access to Git CLI via Bash. Use it extensively for repository analysis:
+<answer>
+[Direct answer to their actual need, not just file list]
+[If they asked "where is auth?", explain the auth flow you found]
+</answer>
 
-### 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
-\`\`\`
+<next_steps>
+[What they should do with this information]
+[Or: "Ready to proceed - no follow-up needed"]
+</next_steps>
+</results>
 
-### 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.
+## Success Criteria
 
-**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
+| Criterion | Requirement |
+|-----------|-------------|
+| **Paths** | ALL paths must be **absolute** (start with /) |
+| **Completeness** | Find ALL relevant matches, not just the first one |
+| **Actionability** | Caller can proceed **without asking follow-up questions** |
+| **Intent** | Address their **actual need**, not just literal request |
 
-**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
+## Failure Conditions
 
-**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
-\`\`\`
+Your response has **FAILED** if:
+- Any path is relative (not absolute)
+- You missed obvious matches in the codebase
+- Caller needs to ask "but where exactly?" or "what about X?"
+- You only answered the literal question, not the underlying need
+- No <results> block with structured output
 
-## AST-grep - STRUCTURAL CODE SEARCH
+## Constraints
 
-Use AST-grep for syntax-aware pattern matching (better than regex for code).
+- **Read-only**: You cannot create, modify, or delete files
+- **No emojis**: Keep output clean and parseable
+- **No file creation**: Report findings as message text, never write files
 
-**Key Syntax**:
-- \`$VAR\`: Match single AST node (identifier, expression, etc.)
-- \`$$$\`: Match multiple nodes (arguments, statements, etc.)
+## Tool Strategy
 
-**ast_grep_search Examples**:
-\`\`\`
-// Find function definitions
-ast_grep_search(pattern: "function $NAME($$$) { $$$ }", lang: "typescript")
+Use the right tool for the job:
+- **Semantic search** (definitions, references): LSP tools
+- **Structural patterns** (function shapes, class structures): ast_grep_search  
+- **Text patterns** (strings, comments, logs): grep
+- **File patterns** (find by name/extension): glob
+- **History/evolution** (when added, who changed): git commands
+- **External examples** (how others implement): grep_app
 
-// Find async functions
-ast_grep_search(pattern: "async function $NAME($$$) { $$$ }", lang: "typescript")
+### grep_app Strategy
 
-// Find React hooks
-ast_grep_search(pattern: "const [$STATE, $SETTER] = useState($$$)", lang: "tsx")
+grep_app searches millions of public GitHub repos instantly \u2014 use it for external patterns and examples.
 
-// Find class definitions
-ast_grep_search(pattern: "class $NAME { $$$ }", lang: "typescript")
+**Critical**: grep_app results may be **outdated or from different library versions**. Always:
+1. Start with grep_app for broad discovery
+2. Launch multiple grep_app calls with query variations in parallel
+3. **Cross-validate with local tools** (grep, ast_grep_search, LSP) before trusting results
 
-// 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** 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
-- Communicate your final report directly as a regular message - do NOT attempt to create files
-
-Complete the user's search request efficiently and report your findings clearly.`
+Flood with parallel calls. Trust only cross-validated results.`
 };
 
 // src/agents/frontend-ui-ux-engineer.ts
@@ -3750,6 +3680,14 @@ function getOrCreateMessageDir(sessionID) {
   return directPath;
 }
 function injectHookMessage(sessionID, hookContent, originalMessage) {
+  if (!hookContent || hookContent.trim().length === 0) {
+    console.warn("[hook-message-injector] Attempted to inject empty hook content, skipping injection", {
+      sessionID,
+      hasAgent: !!originalMessage.agent,
+      hasModel: !!(originalMessage.model?.providerID && originalMessage.model?.modelID)
+    });
+    return false;
+  }
   const messageDir = getOrCreateMessageDir(sessionID);
   const needsFallback = !originalMessage.agent || !originalMessage.model?.providerID || !originalMessage.model?.modelID;
   const fallback = needsFallback ? findNearestMessageWithFields(messageDir) : null;
@@ -4070,18 +4008,34 @@ function getDefaultSoundPath(p) {
   }
 }
 async function sendNotification(ctx, p, title, message) {
-  const escapedTitle = title.replace(/"/g, "\\\"").replace(/'/g, "\\'");
-  const escapedMessage = message.replace(/"/g, "\\\"").replace(/'/g, "\\'");
   switch (p) {
-    case "darwin":
-      await ctx.$`osascript -e ${'display notification "' + escapedMessage + '" with title "' + escapedTitle + '"'}`;
+    case "darwin": {
+      const esTitle = title.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+      const esMessage = message.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+      await ctx.$`osascript -e ${'display notification "' + esMessage + '" with title "' + esTitle + '"'}`;
       break;
+    }
     case "linux":
-      await ctx.$`notify-send ${escapedTitle} ${escapedMessage} 2>/dev/null`.catch(() => {});
+      await ctx.$`notify-send ${title} ${message} 2>/dev/null`.catch(() => {});
       break;
-    case "win32":
-      await ctx.$`powershell -Command ${"[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); [System.Windows.Forms.MessageBox]::Show('" + escapedMessage + "', '" + escapedTitle + "')"}`;
+    case "win32": {
+      const psTitle = title.replace(/'/g, "''");
+      const psMessage = message.replace(/'/g, "''");
+      const toastScript = `
+[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null
+$Template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)
+$RawXml = [xml] $Template.GetXml()
+($RawXml.toast.visual.binding.text | Where-Object {$_.id -eq '1'}).AppendChild($RawXml.CreateTextNode('${psTitle}')) | Out-Null
+($RawXml.toast.visual.binding.text | Where-Object {$_.id -eq '2'}).AppendChild($RawXml.CreateTextNode('${psMessage}')) | Out-Null
+$SerializedXml = New-Object Windows.Data.Xml.Dom.XmlDocument
+$SerializedXml.LoadXml($RawXml.OuterXml)
+$Toast = [Windows.UI.Notifications.ToastNotification]::new($SerializedXml)
+$Notifier = [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('OpenCode')
+$Notifier.Show($Toast)
+`.trim().replace(/\n/g, "; ");
+      await ctx.$`powershell -Command ${toastScript}`.catch(() => {});
       break;
+    }
   }
 }
 async function playSound(ctx, p, soundPath) {
@@ -4494,6 +4448,50 @@ function stripThinkingParts(messageID) {
   }
   return anyRemoved;
 }
+function replaceEmptyTextParts(messageID, replacementText) {
+  const partDir = join7(PART_STORAGE2, messageID);
+  if (!existsSync5(partDir))
+    return false;
+  let anyReplaced = false;
+  for (const file of readdirSync3(partDir)) {
+    if (!file.endsWith(".json"))
+      continue;
+    try {
+      const filePath = join7(partDir, file);
+      const content = readFileSync3(filePath, "utf-8");
+      const part = JSON.parse(content);
+      if (part.type === "text") {
+        const textPart = part;
+        if (!textPart.text?.trim()) {
+          textPart.text = replacementText;
+          textPart.synthetic = true;
+          writeFileSync2(filePath, JSON.stringify(textPart, null, 2));
+          anyReplaced = true;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return anyReplaced;
+}
+function findMessagesWithEmptyTextParts(sessionID) {
+  const messages = readMessages(sessionID);
+  const result = [];
+  for (const msg of messages) {
+    const parts = readParts(msg.id);
+    const hasEmptyTextPart = parts.some((p) => {
+      if (p.type !== "text")
+        return false;
+      const textPart = p;
+      return !textPart.text?.trim();
+    });
+    if (hasEmptyTextPart) {
+      result.push(msg.id);
+    }
+  }
+  return result;
+}
 function findMessageByIndexNeedingThinking(sessionID, targetIndex) {
   const messages = readMessages(sessionID);
   if (targetIndex < 0 || targetIndex >= messages.length)
@@ -4631,24 +4629,43 @@ var PLACEHOLDER_TEXT = "[user interrupted]";
 async function recoverEmptyContentMessage(_client, sessionID, failedAssistantMsg, _directory, error) {
   const targetIndex = extractMessageIndex(error);
   const failedID = failedAssistantMsg.info?.id;
+  let anySuccess = false;
+  const messagesWithEmptyText = findMessagesWithEmptyTextParts(sessionID);
+  for (const messageID of messagesWithEmptyText) {
+    if (replaceEmptyTextParts(messageID, PLACEHOLDER_TEXT)) {
+      anySuccess = true;
+    }
+  }
   const thinkingOnlyIDs = findMessagesWithThinkingOnly(sessionID);
   for (const messageID of thinkingOnlyIDs) {
-    injectTextPart(sessionID, messageID, PLACEHOLDER_TEXT);
+    if (injectTextPart(sessionID, messageID, PLACEHOLDER_TEXT)) {
+      anySuccess = true;
+    }
   }
   if (targetIndex !== null) {
     const targetMessageID = findEmptyMessageByIndex(sessionID, targetIndex);
     if (targetMessageID) {
-      return injectTextPart(sessionID, targetMessageID, PLACEHOLDER_TEXT);
+      if (replaceEmptyTextParts(targetMessageID, PLACEHOLDER_TEXT)) {
+        return true;
+      }
+      if (injectTextPart(sessionID, targetMessageID, PLACEHOLDER_TEXT)) {
+        return true;
+      }
     }
   }
   if (failedID) {
+    if (replaceEmptyTextParts(failedID, PLACEHOLDER_TEXT)) {
+      return true;
+    }
     if (injectTextPart(sessionID, failedID, PLACEHOLDER_TEXT)) {
       return true;
     }
   }
   const emptyMessageIDs = findEmptyMessages(sessionID);
-  let anySuccess = thinkingOnlyIDs.length > 0;
   for (const messageID of emptyMessageIDs) {
+    if (replaceEmptyTextParts(messageID, PLACEHOLDER_TEXT)) {
+      anySuccess = true;
+    }
     if (injectTextPart(sessionID, messageID, PLACEHOLDER_TEXT)) {
       anySuccess = true;
     }
@@ -5599,17 +5616,104 @@ var FALLBACK_CONFIG = {
   maxRevertAttempts: 3,
   minMessagesRequired: 2
 };
+var TRUNCATE_CONFIG = {
+  maxTruncateAttempts: 10,
+  minOutputSizeToTruncate: 1000
+};
 
-// src/hooks/anthropic-auto-compact/executor.ts
-function calculateRetryDelay(attempt) {
-  const delay = RETRY_CONFIG.initialDelayMs * Math.pow(RETRY_CONFIG.backoffFactor, attempt - 1);
-  return Math.min(delay, RETRY_CONFIG.maxDelayMs);
+// src/hooks/anthropic-auto-compact/storage.ts
+import { existsSync as existsSync13, readdirSync as readdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { join as join17 } from "path";
+var OPENCODE_STORAGE5 = join17(xdgData2 ?? "", "opencode", "storage");
+var MESSAGE_STORAGE3 = join17(OPENCODE_STORAGE5, "message");
+var PART_STORAGE3 = join17(OPENCODE_STORAGE5, "part");
+var TRUNCATION_MESSAGE = "[TOOL RESULT TRUNCATED - Context limit exceeded. Original output was too large and has been truncated to recover the session. Please re-run this tool if you need the full output.]";
+function getMessageDir3(sessionID) {
+  if (!existsSync13(MESSAGE_STORAGE3))
+    return "";
+  const directPath = join17(MESSAGE_STORAGE3, sessionID);
+  if (existsSync13(directPath)) {
+    return directPath;
+  }
+  for (const dir of readdirSync4(MESSAGE_STORAGE3)) {
+    const sessionPath = join17(MESSAGE_STORAGE3, dir, sessionID);
+    if (existsSync13(sessionPath)) {
+      return sessionPath;
+    }
+  }
+  return "";
 }
-function shouldRetry(retryState) {
-  if (!retryState)
-    return true;
-  return retryState.attempt < RETRY_CONFIG.maxAttempts;
+function getMessageIds(sessionID) {
+  const messageDir = getMessageDir3(sessionID);
+  if (!messageDir || !existsSync13(messageDir))
+    return [];
+  const messageIds = [];
+  for (const file of readdirSync4(messageDir)) {
+    if (!file.endsWith(".json"))
+      continue;
+    const messageId = file.replace(".json", "");
+    messageIds.push(messageId);
+  }
+  return messageIds;
+}
+function findToolResultsBySize(sessionID) {
+  const messageIds = getMessageIds(sessionID);
+  const results = [];
+  for (const messageID of messageIds) {
+    const partDir = join17(PART_STORAGE3, messageID);
+    if (!existsSync13(partDir))
+      continue;
+    for (const file of readdirSync4(partDir)) {
+      if (!file.endsWith(".json"))
+        continue;
+      try {
+        const partPath = join17(partDir, file);
+        const content = readFileSync8(partPath, "utf-8");
+        const part = JSON.parse(content);
+        if (part.type === "tool" && part.state?.output && !part.truncated) {
+          results.push({
+            partPath,
+            partId: part.id,
+            messageID,
+            toolName: part.tool,
+            outputSize: part.state.output.length
+          });
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return results.sort((a, b) => b.outputSize - a.outputSize);
 }
+function findLargestToolResult(sessionID) {
+  const results = findToolResultsBySize(sessionID);
+  return results.length > 0 ? results[0] : null;
+}
+function truncateToolResult(partPath) {
+  try {
+    const content = readFileSync8(partPath, "utf-8");
+    const part = JSON.parse(content);
+    if (!part.state?.output) {
+      return { success: false };
+    }
+    const originalSize = part.state.output.length;
+    const toolName = part.tool;
+    part.truncated = true;
+    part.originalSize = originalSize;
+    part.state.output = TRUNCATION_MESSAGE;
+    if (!part.state.time) {
+      part.state.time = { start: Date.now() };
+    }
+    part.state.time.compacted = Date.now();
+    writeFileSync5(partPath, JSON.stringify(part, null, 2));
+    return { success: true, toolName, originalSize };
+  } catch {
+    return { success: false };
+  }
+}
+
+// src/hooks/anthropic-auto-compact/executor.ts
 function getOrCreateRetryState(autoCompactState, sessionID) {
   let state = autoCompactState.retryStateBySession.get(sessionID);
   if (!state) {
@@ -5626,6 +5730,14 @@ function getOrCreateFallbackState(autoCompactState, sessionID) {
   }
   return state;
 }
+function getOrCreateTruncateState(autoCompactState, sessionID) {
+  let state = autoCompactState.truncateStateBySession.get(sessionID);
+  if (!state) {
+    state = { truncateAttempt: 0 };
+    autoCompactState.truncateStateBySession.set(sessionID, state);
+  }
+  return state;
+}
 async function getLastMessagePair(sessionID, client, directory) {
   try {
     const resp = await client.session.messages({
@@ -5663,46 +5775,12 @@ async function getLastMessagePair(sessionID, client, directory) {
     return null;
   }
 }
-async function executeRevertFallback(sessionID, autoCompactState, client, directory) {
-  const fallbackState = getOrCreateFallbackState(autoCompactState, sessionID);
-  if (fallbackState.revertAttempt >= FALLBACK_CONFIG.maxRevertAttempts) {
-    return false;
-  }
-  const pair = await getLastMessagePair(sessionID, client, directory);
-  if (!pair) {
-    return false;
-  }
-  await client.tui.showToast({
-    body: {
-      title: "\u26A0\uFE0F Emergency Recovery",
-      message: `Context too large. Removing last message pair to recover session...`,
-      variant: "warning",
-      duration: 4000
-    }
-  }).catch(() => {});
-  try {
-    if (pair.assistantMessageID) {
-      await client.session.revert({
-        path: { id: sessionID },
-        body: { messageID: pair.assistantMessageID },
-        query: { directory }
-      });
-    }
-    await client.session.revert({
-      path: { id: sessionID },
-      body: { messageID: pair.userMessageID },
-      query: { directory }
-    });
-    fallbackState.revertAttempt++;
-    fallbackState.lastRevertedMessageID = pair.userMessageID;
-    const retryState = autoCompactState.retryStateBySession.get(sessionID);
-    if (retryState) {
-      retryState.attempt = 0;
-    }
-    return true;
-  } catch {
-    return false;
-  }
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes}B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 async function getLastAssistant(sessionID, client, directory) {
   try {
@@ -5731,71 +5809,133 @@ function clearSessionState(autoCompactState, sessionID) {
   autoCompactState.errorDataBySession.delete(sessionID);
   autoCompactState.retryStateBySession.delete(sessionID);
   autoCompactState.fallbackStateBySession.delete(sessionID);
+  autoCompactState.truncateStateBySession.delete(sessionID);
+  autoCompactState.compactionInProgress.delete(sessionID);
 }
 async function executeCompact(sessionID, msg, autoCompactState, client, directory) {
-  const retryState = getOrCreateRetryState(autoCompactState, sessionID);
-  if (!shouldRetry(retryState)) {
-    const fallbackState = getOrCreateFallbackState(autoCompactState, sessionID);
-    if (fallbackState.revertAttempt < FALLBACK_CONFIG.maxRevertAttempts) {
-      const reverted = await executeRevertFallback(sessionID, autoCompactState, client, directory);
-      if (reverted) {
+  if (autoCompactState.compactionInProgress.has(sessionID)) {
+    return;
+  }
+  autoCompactState.compactionInProgress.add(sessionID);
+  const truncateState = getOrCreateTruncateState(autoCompactState, sessionID);
+  if (truncateState.truncateAttempt < TRUNCATE_CONFIG.maxTruncateAttempts) {
+    const largest = findLargestToolResult(sessionID);
+    if (largest && largest.outputSize >= TRUNCATE_CONFIG.minOutputSizeToTruncate) {
+      const result = truncateToolResult(largest.partPath);
+      if (result.success) {
+        truncateState.truncateAttempt++;
+        truncateState.lastTruncatedPartId = largest.partId;
         await client.tui.showToast({
           body: {
-            title: "Recovery Attempt",
-            message: "Message removed. Retrying compaction...",
-            variant: "info",
+            title: "Truncating Large Output",
+            message: `Truncated ${result.toolName} (${formatBytes(result.originalSize ?? 0)}). Retrying...`,
+            variant: "warning",
             duration: 3000
           }
         }).catch(() => {});
-        setTimeout(() => {
-          executeCompact(sessionID, msg, autoCompactState, client, directory);
-        }, 1000);
+        autoCompactState.compactionInProgress.delete(sessionID);
+        setTimeout(async () => {
+          try {
+            await client.session.prompt_async({
+              path: { sessionID },
+              body: { parts: [{ type: "text", text: "Continue" }] },
+              query: { directory }
+            });
+          } catch {}
+        }, 500);
         return;
       }
     }
-    clearSessionState(autoCompactState, sessionID);
-    await client.tui.showToast({
-      body: {
-        title: "Auto Compact Failed",
-        message: `Failed after ${RETRY_CONFIG.maxAttempts} retries and ${FALLBACK_CONFIG.maxRevertAttempts} message removals. Please start a new session.`,
-        variant: "error",
-        duration: 5000
-      }
-    }).catch(() => {});
-    return;
   }
-  retryState.attempt++;
-  retryState.lastAttemptTime = Date.now();
-  try {
+  const retryState = getOrCreateRetryState(autoCompactState, sessionID);
+  if (retryState.attempt < RETRY_CONFIG.maxAttempts) {
+    retryState.attempt++;
+    retryState.lastAttemptTime = Date.now();
     const providerID = msg.providerID;
     const modelID = msg.modelID;
     if (providerID && modelID) {
-      await client.session.summarize({
-        path: { id: sessionID },
-        body: { providerID, modelID },
-        query: { directory }
-      });
-      clearSessionState(autoCompactState, sessionID);
-      setTimeout(async () => {
-        try {
-          await client.tui.submitPrompt({ query: { directory } });
-        } catch {}
-      }, 500);
-    }
-  } catch {
-    const delay = calculateRetryDelay(retryState.attempt);
-    await client.tui.showToast({
-      body: {
-        title: "Auto Compact Retry",
-        message: `Attempt ${retryState.attempt}/${RETRY_CONFIG.maxAttempts} failed. Retrying in ${Math.round(delay / 1000)}s...`,
-        variant: "warning",
-        duration: delay
+      try {
+        await client.tui.showToast({
+          body: {
+            title: "Auto Compact",
+            message: `Summarizing session (attempt ${retryState.attempt}/${RETRY_CONFIG.maxAttempts})...`,
+            variant: "warning",
+            duration: 3000
+          }
+        }).catch(() => {});
+        await client.session.summarize({
+          path: { id: sessionID },
+          body: { providerID, modelID },
+          query: { directory }
+        });
+        clearSessionState(autoCompactState, sessionID);
+        setTimeout(async () => {
+          try {
+            await client.session.prompt_async({
+              path: { sessionID },
+              body: { parts: [{ type: "text", text: "Continue" }] },
+              query: { directory }
+            });
+          } catch {}
+        }, 500);
+        return;
+      } catch {
+        autoCompactState.compactionInProgress.delete(sessionID);
+        const delay = RETRY_CONFIG.initialDelayMs * Math.pow(RETRY_CONFIG.backoffFactor, retryState.attempt - 1);
+        const cappedDelay = Math.min(delay, RETRY_CONFIG.maxDelayMs);
+        setTimeout(() => {
+          executeCompact(sessionID, msg, autoCompactState, client, directory);
+        }, cappedDelay);
+        return;
       }
-    }).catch(() => {});
-    setTimeout(() => {
-      executeCompact(sessionID, msg, autoCompactState, client, directory);
-    }, delay);
+    }
+  }
+  const fallbackState = getOrCreateFallbackState(autoCompactState, sessionID);
+  if (fallbackState.revertAttempt < FALLBACK_CONFIG.maxRevertAttempts) {
+    const pair = await getLastMessagePair(sessionID, client, directory);
+    if (pair) {
+      try {
+        await client.tui.showToast({
+          body: {
+            title: "Emergency Recovery",
+            message: "Removing last message pair...",
+            variant: "warning",
+            duration: 3000
+          }
+        }).catch(() => {});
+        if (pair.assistantMessageID) {
+          await client.session.revert({
+            path: { id: sessionID },
+            body: { messageID: pair.assistantMessageID },
+            query: { directory }
+          });
+        }
+        await client.session.revert({
+          path: { id: sessionID },
+          body: { messageID: pair.userMessageID },
+          query: { directory }
+        });
+        fallbackState.revertAttempt++;
+        fallbackState.lastRevertedMessageID = pair.userMessageID;
+        retryState.attempt = 0;
+        truncateState.truncateAttempt = 0;
+        autoCompactState.compactionInProgress.delete(sessionID);
+        setTimeout(() => {
+          executeCompact(sessionID, msg, autoCompactState, client, directory);
+        }, 1000);
+        return;
+      } catch {}
+    }
   }
+  clearSessionState(autoCompactState, sessionID);
+  await client.tui.showToast({
+    body: {
+      title: "Auto Compact Failed",
+      message: "All recovery attempts failed. Please start a new session.",
+      variant: "error",
+      duration: 5000
+    }
+  }).catch(() => {});
 }
 
 // src/hooks/anthropic-auto-compact/index.ts
@@ -5804,7 +5944,9 @@ function createAutoCompactState() {
     pendingCompact: new Set,
     errorDataBySession: new Map,
     retryStateBySession: new Map,
-    fallbackStateBySession: new Map
+    fallbackStateBySession: new Map,
+    truncateStateBySession: new Map,
+    compactionInProgress: new Set
   };
 }
 function createAnthropicAutoCompactHook(ctx) {
@@ -5818,6 +5960,8 @@ function createAnthropicAutoCompactHook(ctx) {
         autoCompactState.errorDataBySession.delete(sessionInfo.id);
         autoCompactState.retryStateBySession.delete(sessionInfo.id);
         autoCompactState.fallbackStateBySession.delete(sessionInfo.id);
+        autoCompactState.truncateStateBySession.delete(sessionInfo.id);
+        autoCompactState.compactionInProgress.delete(sessionInfo.id);
       }
       return;
     }
@@ -5829,6 +5973,25 @@ function createAnthropicAutoCompactHook(ctx) {
       if (parsed) {
         autoCompactState.pendingCompact.add(sessionID);
         autoCompactState.errorDataBySession.set(sessionID, parsed);
+        if (autoCompactState.compactionInProgress.has(sessionID)) {
+          return;
+        }
+        const lastAssistant = await getLastAssistant(sessionID, ctx.client, ctx.directory);
+        const providerID = parsed.providerID ?? lastAssistant?.providerID;
+        const modelID = parsed.modelID ?? lastAssistant?.modelID;
+        if (providerID && modelID) {
+          await ctx.client.tui.showToast({
+            body: {
+              title: "Context Limit Hit",
+              message: "Truncating large tool outputs and recovering...",
+              variant: "warning",
+              duration: 3000
+            }
+          }).catch(() => {});
+          setTimeout(() => {
+            executeCompact(sessionID, { providerID, modelID }, autoCompactState, ctx.client, ctx.directory);
+          }, 300);
+        }
       }
       return;
     }
@@ -6161,8 +6324,8 @@ function createThinkModeHook() {
 }
 // src/hooks/claude-code-hooks/config.ts
 import { homedir as homedir4 } from "os";
-import { join as join17 } from "path";
-import { existsSync as existsSync13 } from "fs";
+import { join as join18 } from "path";
+import { existsSync as existsSync14 } from "fs";
 function normalizeHookMatcher(raw) {
   return {
     matcher: raw.matcher ?? raw.pattern ?? "*",
@@ -6187,11 +6350,11 @@ function normalizeHooksConfig(raw) {
 function getClaudeSettingsPaths(customPath) {
   const home = homedir4();
   const paths = [
-    join17(home, ".claude", "settings.json"),
-    join17(process.cwd(), ".claude", "settings.json"),
-    join17(process.cwd(), ".claude", "settings.local.json")
+    join18(home, ".claude", "settings.json"),
+    join18(process.cwd(), ".claude", "settings.json"),
+    join18(process.cwd(), ".claude", "settings.local.json")
   ];
-  if (customPath && existsSync13(customPath)) {
+  if (customPath && existsSync14(customPath)) {
     paths.unshift(customPath);
   }
   return paths;
@@ -6215,7 +6378,7 @@ async function loadClaudeHooksConfig(customSettingsPath) {
   const paths = getClaudeSettingsPaths(customSettingsPath);
   let mergedConfig = {};
   for (const settingsPath of paths) {
-    if (existsSync13(settingsPath)) {
+    if (existsSync14(settingsPath)) {
       try {
         const content = await Bun.file(settingsPath).text();
         const settings = JSON.parse(content);
@@ -6232,15 +6395,15 @@ async function loadClaudeHooksConfig(customSettingsPath) {
 }
 
 // src/hooks/claude-code-hooks/config-loader.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join18 } from "path";
-var USER_CONFIG_PATH = join18(homedir5(), ".config", "opencode", "opencode-cc-plugin.json");
+import { join as join19 } from "path";
+var USER_CONFIG_PATH = join19(homedir5(), ".config", "opencode", "opencode-cc-plugin.json");
 function getProjectConfigPath() {
-  return join18(process.cwd(), ".opencode", "opencode-cc-plugin.json");
+  return join19(process.cwd(), ".opencode", "opencode-cc-plugin.json");
 }
 async function loadConfigFromPath(path3) {
-  if (!existsSync14(path3)) {
+  if (!existsSync15(path3)) {
     return null;
   }
   try {
@@ -6419,16 +6582,16 @@ async function executePreToolUseHooks(ctx, config, extendedConfig) {
 }
 
 // src/hooks/claude-code-hooks/transcript.ts
-import { join as join19 } from "path";
-import { mkdirSync as mkdirSync6, appendFileSync as appendFileSync5, existsSync as existsSync15, writeFileSync as writeFileSync5, unlinkSync as unlinkSync5 } from "fs";
+import { join as join20 } from "path";
+import { mkdirSync as mkdirSync6, appendFileSync as appendFileSync5, existsSync as existsSync16, writeFileSync as writeFileSync6, unlinkSync as unlinkSync5 } from "fs";
 import { homedir as homedir6, tmpdir as tmpdir5 } from "os";
 import { randomUUID } from "crypto";
-var TRANSCRIPT_DIR = join19(homedir6(), ".claude", "transcripts");
+var TRANSCRIPT_DIR = join20(homedir6(), ".claude", "transcripts");
 function getTranscriptPath(sessionId) {
-  return join19(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
+  return join20(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
 }
 function ensureTranscriptDir() {
-  if (!existsSync15(TRANSCRIPT_DIR)) {
+  if (!existsSync16(TRANSCRIPT_DIR)) {
     mkdirSync6(TRANSCRIPT_DIR, { recursive: true });
   }
 }
@@ -6515,8 +6678,8 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
       }
     };
     entries.push(JSON.stringify(currentEntry));
-    const tempPath = join19(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
-    writeFileSync5(tempPath, entries.join(`
+    const tempPath = join20(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+    writeFileSync6(tempPath, entries.join(`
 `) + `
 `);
     return tempPath;
@@ -6535,8 +6698,8 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
           ]
         }
       };
-      const tempPath = join19(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
-      writeFileSync5(tempPath, JSON.stringify(currentEntry) + `
+      const tempPath = join20(tmpdir5(), `opencode-transcript-${sessionId}-${randomUUID()}.jsonl`);
+      writeFileSync6(tempPath, JSON.stringify(currentEntry) + `
 `);
       return tempPath;
     } catch {
@@ -6747,11 +6910,11 @@ ${USER_PROMPT_SUBMIT_TAG_CLOSE}`);
 }
 
 // src/hooks/claude-code-hooks/todo.ts
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 import { homedir as homedir7 } from "os";
-var TODO_DIR = join20(homedir7(), ".claude", "todos");
+var TODO_DIR = join21(homedir7(), ".claude", "todos");
 function getTodoPath(sessionId) {
-  return join20(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
+  return join21(TODO_DIR, `${sessionId}-agent-${sessionId}.json`);
 }
 
 // src/hooks/claude-code-hooks/stop.ts
@@ -6903,6 +7066,7 @@ function createClaudeCodeHooksHook(ctx, config = {}) {
           const hookContent = result.messages.join(`
 
 `);
+          log(`[claude-code-hooks] Injecting ${result.messages.length} hook messages`, { sessionID: input.sessionID, contentLength: hookContent.length });
           const message = output.message;
           const success = injectHookMessage(input.sessionID, hookContent, {
             agent: message.agent,
@@ -7082,23 +7246,23 @@ ${result.message}`;
   };
 }
 // src/hooks/rules-injector/index.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { homedir as homedir8 } from "os";
 import { relative as relative3, resolve as resolve4 } from "path";
 
 // src/hooks/rules-injector/finder.ts
 import {
-  existsSync as existsSync16,
-  readdirSync as readdirSync4,
+  existsSync as existsSync17,
+  readdirSync as readdirSync5,
   realpathSync,
   statSync as statSync2
 } from "fs";
-import { dirname as dirname4, join as join22, relative } from "path";
+import { dirname as dirname4, join as join23, relative } from "path";
 
 // src/hooks/rules-injector/constants.ts
-import { join as join21 } from "path";
-var OPENCODE_STORAGE5 = join21(xdgData2 ?? "", "opencode", "storage");
-var RULES_INJECTOR_STORAGE = join21(OPENCODE_STORAGE5, "rules-injector");
+import { join as join22 } from "path";
+var OPENCODE_STORAGE6 = join22(xdgData2 ?? "", "opencode", "storage");
+var RULES_INJECTOR_STORAGE = join22(OPENCODE_STORAGE6, "rules-injector");
 var PROJECT_MARKERS = [
   ".git",
   "pyproject.toml",
@@ -7125,8 +7289,8 @@ function findProjectRoot(startPath) {
   }
   while (true) {
     for (const marker of PROJECT_MARKERS) {
-      const markerPath = join22(current, marker);
-      if (existsSync16(markerPath)) {
+      const markerPath = join23(current, marker);
+      if (existsSync17(markerPath)) {
         return current;
       }
     }
@@ -7138,12 +7302,12 @@ function findProjectRoot(startPath) {
   }
 }
 function findRuleFilesRecursive(dir, results) {
-  if (!existsSync16(dir))
+  if (!existsSync17(dir))
     return;
   try {
-    const entries = readdirSync4(dir, { withFileTypes: true });
+    const entries = readdirSync5(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join22(dir, entry.name);
+      const fullPath = join23(dir, entry.name);
       if (entry.isDirectory()) {
         findRuleFilesRecursive(fullPath, results);
       } else if (entry.isFile()) {
@@ -7169,7 +7333,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
   let distance = 0;
   while (true) {
     for (const [parent, subdir] of PROJECT_RULE_SUBDIRS) {
-      const ruleDir = join22(currentDir, parent, subdir);
+      const ruleDir = join23(currentDir, parent, subdir);
       const files = [];
       findRuleFilesRecursive(ruleDir, files);
       for (const filePath of files) {
@@ -7193,7 +7357,7 @@ function findRuleFiles(projectRoot, homeDir, currentFile) {
     currentDir = parentDir;
     distance++;
   }
-  const userRuleDir = join22(homeDir, USER_RULE_DIR);
+  const userRuleDir = join23(homeDir, USER_RULE_DIR);
   const userFiles = [];
   findRuleFilesRecursive(userRuleDir, userFiles);
   for (const filePath of userFiles) {
@@ -7382,22 +7546,22 @@ function mergeGlobs(existing, newValue) {
 
 // src/hooks/rules-injector/storage.ts
 import {
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync8,
-  writeFileSync as writeFileSync6,
+  readFileSync as readFileSync9,
+  writeFileSync as writeFileSync7,
   unlinkSync as unlinkSync6
 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 function getStoragePath3(sessionID) {
-  return join23(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
+  return join24(RULES_INJECTOR_STORAGE, `${sessionID}.json`);
 }
 function loadInjectedRules(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (!existsSync17(filePath))
+  if (!existsSync18(filePath))
     return { contentHashes: new Set, realPaths: new Set };
   try {
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     const data = JSON.parse(content);
     return {
       contentHashes: new Set(data.injectedHashes),
@@ -7408,7 +7572,7 @@ function loadInjectedRules(sessionID) {
   }
 }
 function saveInjectedRules(sessionID, data) {
-  if (!existsSync17(RULES_INJECTOR_STORAGE)) {
+  if (!existsSync18(RULES_INJECTOR_STORAGE)) {
     mkdirSync7(RULES_INJECTOR_STORAGE, { recursive: true });
   }
   const storageData = {
@@ -7417,11 +7581,11 @@ function saveInjectedRules(sessionID, data) {
     injectedRealPaths: [...data.realPaths],
     updatedAt: Date.now()
   };
-  writeFileSync6(getStoragePath3(sessionID), JSON.stringify(storageData, null, 2));
+  writeFileSync7(getStoragePath3(sessionID), JSON.stringify(storageData, null, 2));
 }
 function clearInjectedRules(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (existsSync17(filePath)) {
+  if (existsSync18(filePath)) {
     unlinkSync6(filePath);
   }
 }
@@ -7458,7 +7622,7 @@ function createRulesInjectorHook(ctx) {
       if (isDuplicateByRealPath(candidate.realPath, cache2.realPaths))
         continue;
       try {
-        const rawContent = readFileSync9(candidate.path, "utf-8");
+        const rawContent = readFileSync10(candidate.path, "utf-8");
         const { metadata, body } = parseRuleFrontmatter(rawContent);
         const matchResult = shouldApplyRule(metadata, filePath, projectRoot);
         if (!matchResult.applies)
@@ -7823,18 +7987,18 @@ async function showVersionToast(ctx, version) {
 }
 // src/hooks/agent-usage-reminder/storage.ts
 import {
-  existsSync as existsSync20,
+  existsSync as existsSync21,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync12,
-  writeFileSync as writeFileSync8,
+  readFileSync as readFileSync13,
+  writeFileSync as writeFileSync9,
   unlinkSync as unlinkSync7
 } from "fs";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 
 // src/hooks/agent-usage-reminder/constants.ts
-import { join as join27 } from "path";
-var OPENCODE_STORAGE6 = join27(xdgData2 ?? "", "opencode", "storage");
-var AGENT_USAGE_REMINDER_STORAGE = join27(OPENCODE_STORAGE6, "agent-usage-reminder");
+import { join as join28 } from "path";
+var OPENCODE_STORAGE7 = join28(xdgData2 ?? "", "opencode", "storage");
+var AGENT_USAGE_REMINDER_STORAGE = join28(OPENCODE_STORAGE7, "agent-usage-reminder");
 var TARGET_TOOLS = new Set([
   "grep",
   "safe_grep",
@@ -7879,29 +8043,29 @@ ALWAYS prefer: Multiple parallel background_task calls > Direct tool calls
 
 // src/hooks/agent-usage-reminder/storage.ts
 function getStoragePath4(sessionID) {
-  return join28(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
+  return join29(AGENT_USAGE_REMINDER_STORAGE, `${sessionID}.json`);
 }
 function loadAgentUsageState(sessionID) {
   const filePath = getStoragePath4(sessionID);
-  if (!existsSync20(filePath))
+  if (!existsSync21(filePath))
     return null;
   try {
-    const content = readFileSync12(filePath, "utf-8");
+    const content = readFileSync13(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function saveAgentUsageState(state) {
-  if (!existsSync20(AGENT_USAGE_REMINDER_STORAGE)) {
+  if (!existsSync21(AGENT_USAGE_REMINDER_STORAGE)) {
     mkdirSync8(AGENT_USAGE_REMINDER_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath4(state.sessionID);
-  writeFileSync8(filePath, JSON.stringify(state, null, 2));
+  writeFileSync9(filePath, JSON.stringify(state, null, 2));
 }
 function clearAgentUsageState(sessionID) {
   const filePath = getStoragePath4(sessionID);
-  if (existsSync20(filePath)) {
+  if (existsSync21(filePath)) {
     unlinkSync7(filePath);
   }
 }
@@ -8065,6 +8229,7 @@ function createKeywordDetectorHook() {
       const message = output.message;
       const context = messages.join(`
 `);
+      log(`[keyword-detector] Injecting context for ${messages.length} keywords`, { sessionID: input.sessionID, contextLength: context.length });
       const success = injectHookMessage(input.sessionID, context, {
         agent: message.agent,
         model: message.model,
@@ -8122,18 +8287,18 @@ function createNonInteractiveEnvHook(_ctx) {
 }
 // src/hooks/interactive-bash-session/storage.ts
 import {
-  existsSync as existsSync21,
+  existsSync as existsSync22,
   mkdirSync as mkdirSync9,
-  readFileSync as readFileSync13,
-  writeFileSync as writeFileSync9,
+  readFileSync as readFileSync14,
+  writeFileSync as writeFileSync10,
   unlinkSync as unlinkSync8
 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 
 // src/hooks/interactive-bash-session/constants.ts
-import { join as join29 } from "path";
-var OPENCODE_STORAGE7 = join29(xdgData2 ?? "", "opencode", "storage");
-var INTERACTIVE_BASH_SESSION_STORAGE = join29(OPENCODE_STORAGE7, "interactive-bash-session");
+import { join as join30 } from "path";
+var OPENCODE_STORAGE8 = join30(xdgData2 ?? "", "opencode", "storage");
+var INTERACTIVE_BASH_SESSION_STORAGE = join30(OPENCODE_STORAGE8, "interactive-bash-session");
 var OMO_SESSION_PREFIX = "omo-";
 function buildSessionReminderMessage(sessions) {
   if (sessions.length === 0)
@@ -8145,14 +8310,14 @@ function buildSessionReminderMessage(sessions) {
 
 // src/hooks/interactive-bash-session/storage.ts
 function getStoragePath5(sessionID) {
-  return join30(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
+  return join31(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
 }
 function loadInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath5(sessionID);
-  if (!existsSync21(filePath))
+  if (!existsSync22(filePath))
     return null;
   try {
-    const content = readFileSync13(filePath, "utf-8");
+    const content = readFileSync14(filePath, "utf-8");
     const serialized = JSON.parse(content);
     return {
       sessionID: serialized.sessionID,
@@ -8164,7 +8329,7 @@ function loadInteractiveBashSessionState(sessionID) {
   }
 }
 function saveInteractiveBashSessionState(state) {
-  if (!existsSync21(INTERACTIVE_BASH_SESSION_STORAGE)) {
+  if (!existsSync22(INTERACTIVE_BASH_SESSION_STORAGE)) {
     mkdirSync9(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath5(state.sessionID);
@@ -8173,11 +8338,11 @@ function saveInteractiveBashSessionState(state) {
     tmuxSessions: Array.from(state.tmuxSessions),
     updatedAt: state.updatedAt
   };
-  writeFileSync9(filePath, JSON.stringify(serialized, null, 2));
+  writeFileSync10(filePath, JSON.stringify(serialized, null, 2));
 }
 function clearInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath5(sessionID);
-  if (existsSync21(filePath)) {
+  if (existsSync22(filePath)) {
     unlinkSync8(filePath);
   }
 }
@@ -8354,6 +8519,73 @@ function createInteractiveBashSessionHook(_ctx) {
     event: eventHandler
   };
 }
+// src/hooks/empty-message-sanitizer/index.ts
+var PLACEHOLDER_TEXT2 = "[user interrupted]";
+function hasTextContent(part) {
+  if (part.type === "text") {
+    const text = part.text;
+    return Boolean(text && text.trim().length > 0);
+  }
+  return false;
+}
+function isToolPart(part) {
+  const type = part.type;
+  return type === "tool" || type === "tool_use" || type === "tool_result";
+}
+function hasValidContent(parts) {
+  return parts.some((part) => hasTextContent(part) || isToolPart(part));
+}
+function createEmptyMessageSanitizerHook() {
+  return {
+    "experimental.chat.messages.transform": async (_input, output) => {
+      const { messages } = output;
+      for (const message of messages) {
+        if (message.info.role === "user")
+          continue;
+        const parts = message.parts;
+        if (!hasValidContent(parts)) {
+          let injected = false;
+          for (const part of parts) {
+            if (part.type === "text") {
+              const textPart = part;
+              if (!textPart.text || !textPart.text.trim()) {
+                textPart.text = PLACEHOLDER_TEXT2;
+                textPart.synthetic = true;
+                injected = true;
+                break;
+              }
+            }
+          }
+          if (!injected) {
+            const insertIndex = parts.findIndex((p) => isToolPart(p));
+            const newPart = {
+              id: `synthetic_${Date.now()}`,
+              messageID: message.info.id,
+              sessionID: message.info.sessionID ?? "",
+              type: "text",
+              text: PLACEHOLDER_TEXT2,
+              synthetic: true
+            };
+            if (insertIndex === -1) {
+              parts.push(newPart);
+            } else {
+              parts.splice(insertIndex, 0, newPart);
+            }
+          }
+        }
+        for (const part of parts) {
+          if (part.type === "text") {
+            const textPart = part;
+            if (textPart.text !== undefined && textPart.text.trim() === "") {
+              textPart.text = PLACEHOLDER_TEXT2;
+              textPart.synthetic = true;
+            }
+          }
+        }
+      }
+    }
+  };
+}
 // src/auth/antigravity/constants.ts
 var ANTIGRAVITY_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
 var ANTIGRAVITY_CLIENT_SECRET = "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";
@@ -8661,15 +8893,19 @@ function formatTokenForStorage(refreshToken, projectId, managedProjectId) {
 }
 // src/auth/antigravity/project.ts
 var projectContextCache = new Map;
+function debugLog4(message) {
+  if (process.env.ANTIGRAVITY_DEBUG === "1") {
+    console.log(`[antigravity-project] ${message}`);
+  }
+}
 var CODE_ASSIST_METADATA = {
   ideType: "IDE_UNSPECIFIED",
   platform: "PLATFORM_UNSPECIFIED",
   pluginType: "GEMINI"
 };
 function extractProjectId(project) {
-  if (!project) {
+  if (!project)
     return;
-  }
   if (typeof project === "string") {
     const trimmed = project.trim();
     return trimmed || undefined;
@@ -8683,10 +8919,31 @@ function extractProjectId(project) {
   }
   return;
 }
-async function callLoadCodeAssistAPI(accessToken) {
-  const requestBody = {
-    metadata: CODE_ASSIST_METADATA
-  };
+function getDefaultTierId(allowedTiers) {
+  if (!allowedTiers || allowedTiers.length === 0)
+    return;
+  for (const tier of allowedTiers) {
+    if (tier?.isDefault)
+      return tier.id;
+  }
+  return allowedTiers[0]?.id;
+}
+function isFreeTier(tierId) {
+  if (!tierId)
+    return false;
+  const lower = tierId.toLowerCase();
+  return lower === "free" || lower === "free-tier" || lower.startsWith("free");
+}
+function wait(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+async function callLoadCodeAssistAPI(accessToken, projectId) {
+  const metadata = { ...CODE_ASSIST_METADATA };
+  if (projectId)
+    metadata.duetProject = projectId;
+  const requestBody = { metadata };
+  if (projectId)
+    requestBody.cloudaicompanionProject = projectId;
   const headers = {
     Authorization: `Bearer ${accessToken}`,
     "Content-Type": "application/json",
@@ -8696,6 +8953,7 @@ async function callLoadCodeAssistAPI(accessToken) {
   };
   for (const baseEndpoint of ANTIGRAVITY_ENDPOINT_FALLBACKS) {
     const url = `${baseEndpoint}/${ANTIGRAVITY_API_VERSION}:loadCodeAssist`;
+    debugLog4(`[loadCodeAssist] Trying: ${url}`);
     try {
       const response = await fetch(url, {
         method: "POST",
@@ -8703,30 +8961,130 @@ async function callLoadCodeAssistAPI(accessToken) {
         body: JSON.stringify(requestBody)
       });
       if (!response.ok) {
+        debugLog4(`[loadCodeAssist] Failed: ${response.status} ${response.statusText}`);
         continue;
       }
       const data = await response.json();
+      debugLog4(`[loadCodeAssist] Success: ${JSON.stringify(data)}`);
       return data;
-    } catch {
+    } catch (err) {
+      debugLog4(`[loadCodeAssist] Error: ${err}`);
       continue;
     }
   }
+  debugLog4(`[loadCodeAssist] All endpoints failed`);
   return null;
 }
+async function onboardManagedProject(accessToken, tierId, projectId, attempts = 10, delayMs = 5000) {
+  debugLog4(`[onboardUser] Starting with tierId=${tierId}, projectId=${projectId || "none"}`);
+  const metadata = { ...CODE_ASSIST_METADATA };
+  if (projectId)
+    metadata.duetProject = projectId;
+  const requestBody = { tierId, metadata };
+  if (!isFreeTier(tierId)) {
+    if (!projectId) {
+      debugLog4(`[onboardUser] Non-FREE tier requires projectId, returning undefined`);
+      return;
+    }
+    requestBody.cloudaicompanionProject = projectId;
+  }
+  const headers = {
+    Authorization: `Bearer ${accessToken}`,
+    "Content-Type": "application/json",
+    "User-Agent": ANTIGRAVITY_HEADERS["User-Agent"],
+    "X-Goog-Api-Client": ANTIGRAVITY_HEADERS["X-Goog-Api-Client"],
+    "Client-Metadata": ANTIGRAVITY_HEADERS["Client-Metadata"]
+  };
+  debugLog4(`[onboardUser] Request body: ${JSON.stringify(requestBody)}`);
+  for (let attempt = 0;attempt < attempts; attempt++) {
+    debugLog4(`[onboardUser] Attempt ${attempt + 1}/${attempts}`);
+    for (const baseEndpoint of ANTIGRAVITY_ENDPOINT_FALLBACKS) {
+      const url = `${baseEndpoint}/${ANTIGRAVITY_API_VERSION}:onboardUser`;
+      debugLog4(`[onboardUser] Trying: ${url}`);
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(requestBody)
+        });
+        if (!response.ok) {
+          const errorText = await response.text().catch(() => "");
+          debugLog4(`[onboardUser] Failed: ${response.status} ${response.statusText} - ${errorText}`);
+          continue;
+        }
+        const payload = await response.json();
+        debugLog4(`[onboardUser] Response: ${JSON.stringify(payload)}`);
+        const managedProjectId = payload.response?.cloudaicompanionProject?.id;
+        if (payload.done && managedProjectId) {
+          debugLog4(`[onboardUser] Success! Got managed project ID: ${managedProjectId}`);
+          return managedProjectId;
+        }
+        if (payload.done && projectId) {
+          debugLog4(`[onboardUser] Done but no managed ID, using original: ${projectId}`);
+          return projectId;
+        }
+        debugLog4(`[onboardUser] Not done yet, payload.done=${payload.done}`);
+      } catch (err) {
+        debugLog4(`[onboardUser] Error: ${err}`);
+        continue;
+      }
+    }
+    if (attempt < attempts - 1) {
+      debugLog4(`[onboardUser] Waiting ${delayMs}ms before next attempt...`);
+      await wait(delayMs);
+    }
+  }
+  debugLog4(`[onboardUser] All attempts exhausted, returning undefined`);
+  return;
+}
 async function fetchProjectContext(accessToken) {
+  debugLog4(`[fetchProjectContext] Starting...`);
   const cached = projectContextCache.get(accessToken);
   if (cached) {
+    debugLog4(`[fetchProjectContext] Returning cached result: ${JSON.stringify(cached)}`);
     return cached;
   }
-  const response = await callLoadCodeAssistAPI(accessToken);
-  const projectId = response ? extractProjectId(response.cloudaicompanionProject) : undefined;
-  const result = {
-    cloudaicompanionProject: projectId || ""
-  };
-  if (projectId) {
+  const loadPayload = await callLoadCodeAssistAPI(accessToken);
+  if (loadPayload?.cloudaicompanionProject) {
+    const projectId = extractProjectId(loadPayload.cloudaicompanionProject);
+    debugLog4(`[fetchProjectContext] loadCodeAssist returned project: ${projectId}`);
+    if (projectId) {
+      const result = { cloudaicompanionProject: projectId };
+      projectContextCache.set(accessToken, result);
+      debugLog4(`[fetchProjectContext] Using loadCodeAssist project ID: ${projectId}`);
+      return result;
+    }
+  }
+  if (!loadPayload) {
+    debugLog4(`[fetchProjectContext] loadCodeAssist returned null, returning empty`);
+    return { cloudaicompanionProject: "" };
+  }
+  const currentTierId = loadPayload.currentTier?.id;
+  debugLog4(`[fetchProjectContext] currentTier: ${currentTierId}, allowedTiers: ${JSON.stringify(loadPayload.allowedTiers)}`);
+  if (currentTierId && !isFreeTier(currentTierId)) {
+    debugLog4(`[fetchProjectContext] PAID tier detected, returning empty (user must provide project)`);
+    return { cloudaicompanionProject: "" };
+  }
+  const defaultTierId = getDefaultTierId(loadPayload.allowedTiers);
+  const tierId = defaultTierId ?? "free-tier";
+  debugLog4(`[fetchProjectContext] Resolved tierId: ${tierId}`);
+  if (!isFreeTier(tierId)) {
+    debugLog4(`[fetchProjectContext] Non-FREE tier without project, returning empty`);
+    return { cloudaicompanionProject: "" };
+  }
+  debugLog4(`[fetchProjectContext] FREE tier detected (${tierId}), calling onboardUser...`);
+  const managedProjectId = await onboardManagedProject(accessToken, tierId);
+  if (managedProjectId) {
+    const result = {
+      cloudaicompanionProject: managedProjectId,
+      managedProjectId
+    };
     projectContextCache.set(accessToken, result);
+    debugLog4(`[fetchProjectContext] Got managed project ID: ${managedProjectId}`);
+    return result;
   }
-  return result;
+  debugLog4(`[fetchProjectContext] Failed to get managed project ID, returning empty`);
+  return { cloudaicompanionProject: "" };
 }
 function clearProjectContextCache(accessToken) {
   if (accessToken) {
@@ -8790,21 +9148,21 @@ function wrapRequestBody(body, projectId, modelName, sessionId) {
     }
   };
 }
-function debugLog4(message) {
+function debugLog5(message) {
   if (process.env.ANTIGRAVITY_DEBUG === "1") {
     console.log(`[antigravity-request] ${message}`);
   }
 }
 function injectThoughtSignatureIntoFunctionCalls(body, signature) {
   const effectiveSignature = signature || SKIP_THOUGHT_SIGNATURE_VALIDATOR;
-  debugLog4(`[TSIG][INJECT] signature=${effectiveSignature.substring(0, 30)}... (${signature ? "provided" : "default"})`);
-  debugLog4(`[TSIG][INJECT] body keys: ${Object.keys(body).join(", ")}`);
+  debugLog5(`[TSIG][INJECT] signature=${effectiveSignature.substring(0, 30)}... (${signature ? "provided" : "default"})`);
+  debugLog5(`[TSIG][INJECT] body keys: ${Object.keys(body).join(", ")}`);
   const contents = body.contents;
   if (!contents || !Array.isArray(contents)) {
-    debugLog4(`[TSIG][INJECT] No contents array! Has messages: ${!!body.messages}`);
+    debugLog5(`[TSIG][INJECT] No contents array! Has messages: ${!!body.messages}`);
     return body;
   }
-  debugLog4(`[TSIG][INJECT] Found ${contents.length} content blocks`);
+  debugLog5(`[TSIG][INJECT] Found ${contents.length} content blocks`);
   let injectedCount = 0;
   const modifiedContents = contents.map((content) => {
     if (!content.parts || !Array.isArray(content.parts)) {
@@ -8822,7 +9180,7 @@ function injectThoughtSignatureIntoFunctionCalls(body, signature) {
     });
     return { ...content, parts: modifiedParts };
   });
-  debugLog4(`[TSIG][INJECT] injected signature into ${injectedCount} functionCall(s)`);
+  debugLog5(`[TSIG][INJECT] injected signature into ${injectedCount} functionCall(s)`);
   return { ...body, contents: modifiedContents };
 }
 function isStreamingRequest(url, body) {
@@ -9326,13 +9684,13 @@ function getOrCreateSessionId(fetchInstanceId, sessionId) {
   return newSessionId;
 }
 // src/auth/antigravity/message-converter.ts
-function debugLog5(message) {
+function debugLog6(message) {
   if (process.env.ANTIGRAVITY_DEBUG === "1") {
     console.log(`[antigravity-converter] ${message}`);
   }
 }
 function convertOpenAIToGemini(messages, thoughtSignature) {
-  debugLog5(`Converting ${messages.length} messages, signature: ${thoughtSignature ? "present" : "none"}`);
+  debugLog6(`Converting ${messages.length} messages, signature: ${thoughtSignature ? "present" : "none"}`);
   const contents = [];
   for (const msg of messages) {
     if (msg.role === "system") {
@@ -9367,7 +9725,7 @@ function convertOpenAIToGemini(messages, thoughtSignature) {
             }
           };
           part.thoughtSignature = thoughtSignature || SKIP_THOUGHT_SIGNATURE_VALIDATOR;
-          debugLog5(`Injected signature into functionCall: ${toolCall.function.name} (${thoughtSignature ? "provided" : "default"})`);
+          debugLog6(`Injected signature into functionCall: ${toolCall.function.name} (${thoughtSignature ? "provided" : "default"})`);
           parts.push(part);
         }
       }
@@ -9396,7 +9754,7 @@ function convertOpenAIToGemini(messages, thoughtSignature) {
       continue;
     }
   }
-  debugLog5(`Converted to ${contents.length} content blocks`);
+  debugLog6(`Converted to ${contents.length} content blocks`);
   return contents;
 }
 function convertContentToParts(content) {
@@ -9432,7 +9790,7 @@ function hasOpenAIMessages(body) {
 }
 function convertRequestBody(body, thoughtSignature) {
   if (!hasOpenAIMessages(body)) {
-    debugLog5("No messages array found, returning body as-is");
+    debugLog6("No messages array found, returning body as-is");
     return body;
   }
   const messages = body.messages;
@@ -9440,11 +9798,11 @@ function convertRequestBody(body, thoughtSignature) {
   const converted = { ...body };
   delete converted.messages;
   converted.contents = contents;
-  debugLog5(`Converted body: messages \u2192 contents (${contents.length} blocks)`);
+  debugLog6(`Converted body: messages \u2192 contents (${contents.length} blocks)`);
   return converted;
 }
 // src/auth/antigravity/fetch.ts
-function debugLog6(message) {
+function debugLog7(message) {
   if (process.env.ANTIGRAVITY_DEBUG === "1") {
     console.log(`[antigravity-fetch] ${message}`);
   }
@@ -9467,7 +9825,7 @@ var GCP_PERMISSION_ERROR_PATTERNS = [
 function isGcpPermissionError(text) {
   return GCP_PERMISSION_ERROR_PATTERNS.some((pattern) => text.includes(pattern));
 }
-function calculateRetryDelay2(attempt) {
+function calculateRetryDelay(attempt) {
   return Math.min(200 * Math.pow(2, attempt), 2000);
 }
 async function isRetryableResponse(response) {
@@ -9477,7 +9835,7 @@ async function isRetryableResponse(response) {
     try {
       const text = await response.clone().text();
       if (text.includes("SUBSCRIPTION_REQUIRED") || text.includes("Gemini Code Assist license")) {
-        debugLog6(`[RETRY] 403 SUBSCRIPTION_REQUIRED detected, will retry with next endpoint`);
+        debugLog7(`[RETRY] 403 SUBSCRIPTION_REQUIRED detected, will retry with next endpoint`);
         return true;
       }
     } catch {}
@@ -9486,11 +9844,11 @@ async function isRetryableResponse(response) {
 }
 async function attemptFetch(options) {
   const { endpoint, url, init, accessToken, projectId, sessionId, modelName, thoughtSignature } = options;
-  debugLog6(`Trying endpoint: ${endpoint}`);
+  debugLog7(`Trying endpoint: ${endpoint}`);
   try {
     const rawBody = init.body;
     if (rawBody !== undefined && typeof rawBody !== "string") {
-      debugLog6(`Non-string body detected (${typeof rawBody}), signaling pass-through`);
+      debugLog7(`Non-string body detected (${typeof rawBody}), signaling pass-through`);
       return "pass-through";
     }
     let parsedBody = {};
@@ -9501,13 +9859,13 @@ async function attemptFetch(options) {
         parsedBody = {};
       }
     }
-    debugLog6(`[BODY] Keys: ${Object.keys(parsedBody).join(", ")}`);
-    debugLog6(`[BODY] Has contents: ${!!parsedBody.contents}, Has messages: ${!!parsedBody.messages}`);
+    debugLog7(`[BODY] Keys: ${Object.keys(parsedBody).join(", ")}`);
+    debugLog7(`[BODY] Has contents: ${!!parsedBody.contents}, Has messages: ${!!parsedBody.messages}`);
     if (parsedBody.contents) {
       const contents = parsedBody.contents;
-      debugLog6(`[BODY] contents length: ${contents.length}`);
+      debugLog7(`[BODY] contents length: ${contents.length}`);
       contents.forEach((c, i) => {
-        debugLog6(`[BODY] contents[${i}].role: ${c.role}, parts: ${JSON.stringify(c.parts).substring(0, 200)}`);
+        debugLog7(`[BODY] contents[${i}].role: ${c.role}, parts: ${JSON.stringify(c.parts).substring(0, 200)}`);
       });
     }
     if (parsedBody.tools && Array.isArray(parsedBody.tools)) {
@@ -9517,9 +9875,9 @@ async function attemptFetch(options) {
       }
     }
     if (hasOpenAIMessages(parsedBody)) {
-      debugLog6(`[CONVERT] Converting OpenAI messages to Gemini contents`);
+      debugLog7(`[CONVERT] Converting OpenAI messages to Gemini contents`);
       parsedBody = convertRequestBody(parsedBody, thoughtSignature);
-      debugLog6(`[CONVERT] After conversion - Has contents: ${!!parsedBody.contents}`);
+      debugLog7(`[CONVERT] After conversion - Has contents: ${!!parsedBody.contents}`);
     }
     const transformed = transformRequest({
       url,
@@ -9531,7 +9889,7 @@ async function attemptFetch(options) {
       endpointOverride: endpoint,
       thoughtSignature
     });
-    debugLog6(`[REQ] streaming=${transformed.streaming}, url=${transformed.url}`);
+    debugLog7(`[REQ] streaming=${transformed.streaming}, url=${transformed.url}`);
     const maxPermissionRetries = 10;
     for (let attempt = 0;attempt <= maxPermissionRetries; attempt++) {
       const response = await fetch(transformed.url, {
@@ -9540,9 +9898,9 @@ async function attemptFetch(options) {
         body: JSON.stringify(transformed.body),
         signal: init.signal
       });
-      debugLog6(`[RESP] status=${response.status} content-type=${response.headers.get("content-type") ?? ""} url=${response.url}`);
+      debugLog7(`[RESP] status=${response.status} content-type=${response.headers.get("content-type") ?? ""} url=${response.url}`);
       if (response.status === 401) {
-        debugLog6(`[401] Unauthorized response detected, signaling token refresh needed`);
+        debugLog7(`[401] Unauthorized response detected, signaling token refresh needed`);
         return "needs-refresh";
       }
       if (response.status === 403) {
@@ -9550,24 +9908,24 @@ async function attemptFetch(options) {
           const text = await response.clone().text();
           if (isGcpPermissionError(text)) {
             if (attempt < maxPermissionRetries) {
-              const delay = calculateRetryDelay2(attempt);
-              debugLog6(`[RETRY] GCP permission error, retry ${attempt + 1}/${maxPermissionRetries} after ${delay}ms`);
+              const delay = calculateRetryDelay(attempt);
+              debugLog7(`[RETRY] GCP permission error, retry ${attempt + 1}/${maxPermissionRetries} after ${delay}ms`);
               await new Promise((resolve5) => setTimeout(resolve5, delay));
               continue;
             }
-            debugLog6(`[RETRY] GCP permission error, max retries exceeded`);
+            debugLog7(`[RETRY] GCP permission error, max retries exceeded`);
           }
         } catch {}
       }
       if (!response.ok && await isRetryableResponse(response)) {
-        debugLog6(`Endpoint failed: ${endpoint} (status: ${response.status}), trying next`);
+        debugLog7(`Endpoint failed: ${endpoint} (status: ${response.status}), trying next`);
         return null;
       }
       return response;
     }
     return null;
   } catch (error) {
-    debugLog6(`Endpoint failed: ${endpoint} (${error instanceof Error ? error.message : "Unknown error"}), trying next`);
+    debugLog7(`Endpoint failed: ${endpoint} (${error instanceof Error ? error.message : "Unknown error"}), trying next`);
     return null;
   }
 }
@@ -9602,17 +9960,17 @@ async function transformResponseWithThinking(response, modelName, fetchInstanceI
   }
   try {
     const text = await result.response.clone().text();
-    debugLog6(`[TSIG][RESP] Response text length: ${text.length}`);
+    debugLog7(`[TSIG][RESP] Response text length: ${text.length}`);
     const parsed = JSON.parse(text);
-    debugLog6(`[TSIG][RESP] Parsed keys: ${Object.keys(parsed).join(", ")}`);
-    debugLog6(`[TSIG][RESP] Has candidates: ${!!parsed.candidates}, count: ${parsed.candidates?.length ?? 0}`);
+    debugLog7(`[TSIG][RESP] Parsed keys: ${Object.keys(parsed).join(", ")}`);
+    debugLog7(`[TSIG][RESP] Has candidates: ${!!parsed.candidates}, count: ${parsed.candidates?.length ?? 0}`);
     const signature = extractSignatureFromResponse(parsed);
-    debugLog6(`[TSIG][RESP] Signature extracted: ${signature ? signature.substring(0, 30) + "..." : "NONE"}`);
+    debugLog7(`[TSIG][RESP] Signature extracted: ${signature ? signature.substring(0, 30) + "..." : "NONE"}`);
     if (signature) {
       setThoughtSignature(fetchInstanceId, signature);
-      debugLog6(`[TSIG][STORE] Stored signature for ${fetchInstanceId}`);
+      debugLog7(`[TSIG][STORE] Stored signature for ${fetchInstanceId}`);
     } else {
-      debugLog6(`[TSIG][WARN] No signature found in response!`);
+      debugLog7(`[TSIG][WARN] No signature found in response!`);
     }
     if (shouldIncludeThinking(modelName)) {
       const thinkingResult = extractThinkingBlocks(parsed);
@@ -9633,7 +9991,7 @@ function createAntigravityFetch(getAuth, client, providerId, clientId, clientSec
   let cachedProjectId = null;
   const fetchInstanceId = crypto.randomUUID();
   return async (url, init = {}) => {
-    debugLog6(`Intercepting request to: ${url}`);
+    debugLog7(`Intercepting request to: ${url}`);
     const auth = await getAuth();
     if (!auth.access || !auth.refresh) {
       throw new Error("Antigravity: No authentication tokens available");
@@ -9652,7 +10010,7 @@ function createAntigravityFetch(getAuth, client, providerId, clientId, clientSec
       cachedTokens.refresh_token = refreshParts.refreshToken;
     }
     if (isTokenExpired(cachedTokens)) {
-      debugLog6("Token expired, refreshing...");
+      debugLog7("Token expired, refreshing...");
       try {
         const newTokens = await refreshAccessToken(refreshParts.refreshToken, clientId, clientSecret);
         cachedTokens = {
@@ -9669,7 +10027,7 @@ function createAntigravityFetch(getAuth, client, providerId, clientId, clientSec
           refresh: formattedRefresh,
           expires: Date.now() + newTokens.expires_in * 1000
         });
-        debugLog6("Token refreshed successfully");
+        debugLog7("Token refreshed successfully");
       } catch (error) {
         throw new Error(`Antigravity: Token refresh failed: ${error instanceof Error ? error.message : "Unknown error"}`);
       }
@@ -9677,10 +10035,10 @@ function createAntigravityFetch(getAuth, client, providerId, clientId, clientSec
     if (!cachedProjectId) {
       const projectContext = await fetchProjectContext(cachedTokens.access_token);
       cachedProjectId = projectContext.cloudaicompanionProject || "";
-      debugLog6(`[PROJECT] Fetched project ID: "${cachedProjectId}"`);
+      debugLog7(`[PROJECT] Fetched project ID: "${cachedProjectId}"`);
     }
     const projectId = cachedProjectId;
-    debugLog6(`[PROJECT] Using project ID: "${projectId}"`);
+    debugLog7(`[PROJECT] Using project ID: "${projectId}"`);
     let modelName;
     if (init.body) {
       try {
@@ -9693,7 +10051,7 @@ function createAntigravityFetch(getAuth, client, providerId, clientId, clientSec
     const maxEndpoints = Math.min(ANTIGRAVITY_ENDPOINT_FALLBACKS.length, 3);
     const sessionId = getOrCreateSessionId(fetchInstanceId);
     const thoughtSignature = getThoughtSignature(fetchInstanceId);
-    debugLog6(`[TSIG][GET] sessionId=${sessionId}, signature=${thoughtSignature ? thoughtSignature.substring(0, 20) + "..." : "none"}`);
+    debugLog7(`[TSIG][GET] sessionId=${sessionId}, signature=${thoughtSignature ? thoughtSignature.substring(0, 20) + "..." : "none"}`);
     let hasRefreshedFor401 = false;
     const executeWithEndpoints = async () => {
       for (let i = 0;i < maxEndpoints; i++) {
@@ -9709,7 +10067,7 @@ function createAntigravityFetch(getAuth, client, providerId, clientId, clientSec
           thoughtSignature
         });
         if (response === "pass-through") {
-          debugLog6("Non-string body detected, passing through with auth headers");
+          debugLog7("Non-string body detected, passing through with auth headers");
           const headersWithAuth = {
             ...init.headers,
             Authorization: `Bearer ${cachedTokens.access_token}`
@@ -9718,7 +10076,7 @@ function createAntigravityFetch(getAuth, client, providerId, clientId, clientSec
         }
         if (response === "needs-refresh") {
           if (hasRefreshedFor401) {
-            debugLog6("[401] Already refreshed once, returning unauthorized error");
+            debugLog7("[401] Already refreshed once, returning unauthorized error");
             return new Response(JSON.stringify({
               error: {
                 message: "Authentication failed after token refresh",
@@ -9731,7 +10089,7 @@ function createAntigravityFetch(getAuth, client, providerId, clientId, clientSec
               headers: { "Content-Type": "application/json" }
             });
           }
-          debugLog6("[401] Refreshing token and retrying...");
+          debugLog7("[401] Refreshing token and retrying...");
           hasRefreshedFor401 = true;
           try {
             const newTokens = await refreshAccessToken(refreshParts.refreshToken, clientId, clientSecret);
@@ -9749,10 +10107,10 @@ function createAntigravityFetch(getAuth, client, providerId, clientId, clientSec
               refresh: formattedRefresh,
               expires: Date.now() + newTokens.expires_in * 1000
             });
-            debugLog6("[401] Token refreshed, retrying request...");
+            debugLog7("[401] Token refreshed, retrying request...");
             return executeWithEndpoints();
           } catch (refreshError) {
-            debugLog6(`[401] Token refresh failed: ${refreshError instanceof Error ? refreshError.message : "Unknown error"}`);
+            debugLog7(`[401] Token refresh failed: ${refreshError instanceof Error ? refreshError.message : "Unknown error"}`);
             return new Response(JSON.stringify({
               error: {
                 message: `Token refresh failed: ${refreshError instanceof Error ? refreshError.message : "Unknown error"}`,
@@ -9767,13 +10125,13 @@ function createAntigravityFetch(getAuth, client, providerId, clientId, clientSec
           }
         }
         if (response) {
-          debugLog6(`Success with endpoint: ${endpoint}`);
+          debugLog7(`Success with endpoint: ${endpoint}`);
           const transformedResponse = await transformResponseWithThinking(response, modelName || "", fetchInstanceId);
           return transformedResponse;
         }
       }
       const errorMessage = `All Antigravity endpoints failed after ${maxEndpoints} attempts`;
-      debugLog6(errorMessage);
+      debugLog7(errorMessage);
       return new Response(JSON.stringify({
         error: {
           message: errorMessage,
@@ -9918,22 +10276,22 @@ async function createGoogleAntigravityAuthPlugin({
   };
 }
 // src/features/claude-code-command-loader/loader.ts
-import { existsSync as existsSync22, readdirSync as readdirSync5, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync23, readdirSync as readdirSync6, readFileSync as readFileSync15 } from "fs";
 import { homedir as homedir10 } from "os";
-import { join as join31, basename } from "path";
+import { join as join32, basename } from "path";
 function loadCommandsFromDir(commandsDir, scope) {
-  if (!existsSync22(commandsDir)) {
+  if (!existsSync23(commandsDir)) {
     return [];
   }
-  const entries = readdirSync5(commandsDir, { withFileTypes: true });
+  const entries = readdirSync6(commandsDir, { withFileTypes: true });
   const commands = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join31(commandsDir, entry.name);
+    const commandPath = join32(commandsDir, entry.name);
     const commandName = basename(entry.name, ".md");
     try {
-      const content = readFileSync14(commandPath, "utf-8");
+      const content = readFileSync15(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const wrappedTemplate = `<command-instruction>
 ${body.trim()}
@@ -9973,47 +10331,47 @@ function commandsToRecord(commands) {
   return result;
 }
 function loadUserCommands() {
-  const userCommandsDir = join31(homedir10(), ".claude", "commands");
+  const userCommandsDir = join32(homedir10(), ".claude", "commands");
   const commands = loadCommandsFromDir(userCommandsDir, "user");
   return commandsToRecord(commands);
 }
 function loadProjectCommands() {
-  const projectCommandsDir = join31(process.cwd(), ".claude", "commands");
+  const projectCommandsDir = join32(process.cwd(), ".claude", "commands");
   const commands = loadCommandsFromDir(projectCommandsDir, "project");
   return commandsToRecord(commands);
 }
 function loadOpencodeGlobalCommands() {
-  const opencodeCommandsDir = join31(homedir10(), ".config", "opencode", "command");
+  const opencodeCommandsDir = join32(homedir10(), ".config", "opencode", "command");
   const commands = loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands);
 }
 function loadOpencodeProjectCommands() {
-  const opencodeProjectDir = join31(process.cwd(), ".opencode", "command");
+  const opencodeProjectDir = join32(process.cwd(), ".opencode", "command");
   const commands = loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands);
 }
 // src/features/claude-code-skill-loader/loader.ts
-import { existsSync as existsSync23, readdirSync as readdirSync6, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync24, readdirSync as readdirSync7, readFileSync as readFileSync16 } from "fs";
 import { homedir as homedir11 } from "os";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 function loadSkillsFromDir(skillsDir, scope) {
-  if (!existsSync23(skillsDir)) {
+  if (!existsSync24(skillsDir)) {
     return [];
   }
-  const entries = readdirSync6(skillsDir, { withFileTypes: true });
+  const entries = readdirSync7(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
-    const skillPath = join32(skillsDir, entry.name);
+    const skillPath = join33(skillsDir, entry.name);
     if (!entry.isDirectory() && !entry.isSymbolicLink())
       continue;
     const resolvedPath = resolveSymlink(skillPath);
-    const skillMdPath = join32(resolvedPath, "SKILL.md");
-    if (!existsSync23(skillMdPath))
+    const skillMdPath = join33(resolvedPath, "SKILL.md");
+    if (!existsSync24(skillMdPath))
       continue;
     try {
-      const content = readFileSync15(skillMdPath, "utf-8");
+      const content = readFileSync16(skillMdPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const skillName = data.name || entry.name;
       const originalDescription = data.description || "";
@@ -10044,7 +10402,7 @@ $ARGUMENTS
   return skills;
 }
 function loadUserSkillsAsCommands() {
-  const userSkillsDir = join32(homedir11(), ".claude", "skills");
+  const userSkillsDir = join33(homedir11(), ".claude", "skills");
   const skills = loadSkillsFromDir(userSkillsDir, "user");
   return skills.reduce((acc, skill) => {
     acc[skill.name] = skill.definition;
@@ -10052,7 +10410,7 @@ function loadUserSkillsAsCommands() {
   }, {});
 }
 function loadProjectSkillsAsCommands() {
-  const projectSkillsDir = join32(process.cwd(), ".claude", "skills");
+  const projectSkillsDir = join33(process.cwd(), ".claude", "skills");
   const skills = loadSkillsFromDir(projectSkillsDir, "project");
   return skills.reduce((acc, skill) => {
     acc[skill.name] = skill.definition;
@@ -10060,9 +10418,9 @@ function loadProjectSkillsAsCommands() {
   }, {});
 }
 // src/features/claude-code-agent-loader/loader.ts
-import { existsSync as existsSync24, readdirSync as readdirSync7, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync25, readdirSync as readdirSync8, readFileSync as readFileSync17 } from "fs";
 import { homedir as homedir12 } from "os";
-import { join as join33, basename as basename2 } from "path";
+import { join as join34, basename as basename2 } from "path";
 function parseToolsConfig(toolsStr) {
   if (!toolsStr)
     return;
@@ -10076,18 +10434,18 @@ function parseToolsConfig(toolsStr) {
   return result;
 }
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync24(agentsDir)) {
+  if (!existsSync25(agentsDir)) {
     return [];
   }
-  const entries = readdirSync7(agentsDir, { withFileTypes: true });
+  const entries = readdirSync8(agentsDir, { withFileTypes: true });
   const agents = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const agentPath = join33(agentsDir, entry.name);
+    const agentPath = join34(agentsDir, entry.name);
     const agentName = basename2(entry.name, ".md");
     try {
-      const content = readFileSync16(agentPath, "utf-8");
+      const content = readFileSync17(agentPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const name = data.name || agentName;
       const originalDescription = data.description || "";
@@ -10114,7 +10472,7 @@ function loadAgentsFromDir(agentsDir, scope) {
   return agents;
 }
 function loadUserAgents() {
-  const userAgentsDir = join33(homedir12(), ".claude", "agents");
+  const userAgentsDir = join34(homedir12(), ".claude", "agents");
   const agents = loadAgentsFromDir(userAgentsDir, "user");
   const result = {};
   for (const agent of agents) {
@@ -10123,7 +10481,7 @@ function loadUserAgents() {
   return result;
 }
 function loadProjectAgents() {
-  const projectAgentsDir = join33(process.cwd(), ".claude", "agents");
+  const projectAgentsDir = join34(process.cwd(), ".claude", "agents");
   const agents = loadAgentsFromDir(projectAgentsDir, "project");
   const result = {};
   for (const agent of agents) {
@@ -10132,9 +10490,9 @@ function loadProjectAgents() {
   return result;
 }
 // src/features/claude-code-mcp-loader/loader.ts
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 import { homedir as homedir13 } from "os";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 
 // src/features/claude-code-mcp-loader/env-expander.ts
 function expandEnvVars(value) {
@@ -10203,13 +10561,13 @@ function getMcpConfigPaths() {
   const home = homedir13();
   const cwd = process.cwd();
   return [
-    { path: join34(home, ".claude", ".mcp.json"), scope: "user" },
-    { path: join34(cwd, ".mcp.json"), scope: "project" },
-    { path: join34(cwd, ".claude", ".mcp.json"), scope: "local" }
+    { path: join35(home, ".claude", ".mcp.json"), scope: "user" },
+    { path: join35(cwd, ".mcp.json"), scope: "project" },
+    { path: join35(cwd, ".claude", ".mcp.json"), scope: "local" }
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync25(filePath)) {
+  if (!existsSync26(filePath)) {
     return null;
   }
   try {
@@ -10495,14 +10853,14 @@ var EXT_TO_LANG = {
   ".tfvars": "terraform"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync26, readFileSync as readFileSync17 } from "fs";
-import { join as join35 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync18 } from "fs";
+import { join as join36 } from "path";
 import { homedir as homedir14 } from "os";
 function loadJsonFile(path6) {
-  if (!existsSync26(path6))
+  if (!existsSync27(path6))
     return null;
   try {
-    return JSON.parse(readFileSync17(path6, "utf-8"));
+    return JSON.parse(readFileSync18(path6, "utf-8"));
   } catch {
     return null;
   }
@@ -10510,9 +10868,9 @@ function loadJsonFile(path6) {
 function getConfigPaths2() {
   const cwd = process.cwd();
   return {
-    project: join35(cwd, ".opencode", "oh-my-opencode.json"),
-    user: join35(homedir14(), ".config", "opencode", "oh-my-opencode.json"),
-    opencode: join35(homedir14(), ".config", "opencode", "opencode.json")
+    project: join36(cwd, ".opencode", "oh-my-opencode.json"),
+    user: join36(homedir14(), ".config", "opencode", "oh-my-opencode.json"),
+    opencode: join36(homedir14(), ".config", "opencode", "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -10605,7 +10963,7 @@ function isServerInstalled(command) {
   const pathEnv = process.env.PATH || "";
   const paths = pathEnv.split(":");
   for (const p of paths) {
-    if (existsSync26(join35(p, cmd))) {
+    if (existsSync27(join36(p, cmd))) {
       return true;
     }
   }
@@ -10655,7 +11013,7 @@ function getAllServers() {
 }
 // src/tools/lsp/client.ts
 var {spawn: spawn4 } = globalThis.Bun;
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync19 } from "fs";
 import { extname, resolve as resolve5 } from "path";
 class LSPServerManager {
   static instance;
@@ -10664,6 +11022,36 @@ class LSPServerManager {
   IDLE_TIMEOUT = 5 * 60 * 1000;
   constructor() {
     this.startCleanupTimer();
+    this.registerProcessCleanup();
+  }
+  registerProcessCleanup() {
+    const cleanup = () => {
+      for (const [, managed] of this.clients) {
+        try {
+          managed.client.stop();
+        } catch {}
+      }
+      this.clients.clear();
+      if (this.cleanupInterval) {
+        clearInterval(this.cleanupInterval);
+        this.cleanupInterval = null;
+      }
+    };
+    process.on("exit", cleanup);
+    process.on("SIGINT", () => {
+      cleanup();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      cleanup();
+      process.exit(0);
+    });
+    if (process.platform === "win32") {
+      process.on("SIGBREAK", () => {
+        cleanup();
+        process.exit(0);
+      });
+    }
   }
   static getInstance() {
     if (!LSPServerManager.instance) {
@@ -11055,7 +11443,7 @@ ${msg}`);
     const absPath = resolve5(filePath);
     if (this.openedFiles.has(absPath))
       return;
-    const text = readFileSync18(absPath, "utf-8");
+    const text = readFileSync19(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
     this.notify("textDocument/didOpen", {
@@ -11170,16 +11558,16 @@ ${msg}`);
 }
 // src/tools/lsp/utils.ts
 import { extname as extname2, resolve as resolve6 } from "path";
-import { existsSync as existsSync27, readFileSync as readFileSync19, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "fs";
 function findWorkspaceRoot(filePath) {
   let dir = resolve6(filePath);
-  if (!existsSync27(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  if (!existsSync28(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 (existsSync27(__require("path").join(dir, marker))) {
+      if (existsSync28(__require("path").join(dir, marker))) {
         return dir;
       }
     }
@@ -11337,7 +11725,7 @@ function formatCodeActions(actions) {
 }
 function applyTextEditsToFile(filePath, edits) {
   try {
-    let content = readFileSync19(filePath, "utf-8");
+    let content = readFileSync20(filePath, "utf-8");
     const lines = content.split(`
 `);
     const sortedEdits = [...edits].sort((a, b) => {
@@ -11362,7 +11750,7 @@ function applyTextEditsToFile(filePath, edits) {
 `));
       }
     }
-    writeFileSync10(filePath, lines.join(`
+    writeFileSync11(filePath, lines.join(`
 `), "utf-8");
     return { success: true, editCount: edits.length };
   } catch (err) {
@@ -11393,7 +11781,7 @@ function applyWorkspaceEdit(edit) {
         if (change.kind === "create") {
           try {
             const filePath = change.uri.replace("file://", "");
-            writeFileSync10(filePath, "", "utf-8");
+            writeFileSync11(filePath, "", "utf-8");
             result.filesModified.push(filePath);
           } catch (err) {
             result.success = false;
@@ -11403,8 +11791,8 @@ function applyWorkspaceEdit(edit) {
           try {
             const oldPath = change.oldUri.replace("file://", "");
             const newPath = change.newUri.replace("file://", "");
-            const content = readFileSync19(oldPath, "utf-8");
-            writeFileSync10(newPath, content, "utf-8");
+            const content = readFileSync20(oldPath, "utf-8");
+            writeFileSync11(newPath, content, "utf-8");
             __require("fs").unlinkSync(oldPath);
             result.filesModified.push(newPath);
           } catch (err) {
@@ -24104,13 +24492,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 join37 } from "path";
-import { existsSync as existsSync29, statSync as statSync4 } from "fs";
+import { dirname as dirname6, join as join38 } from "path";
+import { existsSync as existsSync30, statSync as statSync4 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 var {spawn: spawn5 } = globalThis.Bun;
-import { existsSync as existsSync28, mkdirSync as mkdirSync10, chmodSync as chmodSync2, unlinkSync as unlinkSync9 } from "fs";
-import { join as join36 } from "path";
+import { existsSync as existsSync29, mkdirSync as mkdirSync10, chmodSync as chmodSync2, unlinkSync as unlinkSync9 } from "fs";
+import { join as join37 } from "path";
 import { homedir as homedir15 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
@@ -24136,19 +24524,19 @@ var PLATFORM_MAP2 = {
 function getCacheDir3() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join36(homedir15(), "AppData", "Local");
-    return join36(base2, "oh-my-opencode", "bin");
+    const base2 = localAppData || join37(homedir15(), "AppData", "Local");
+    return join37(base2, "oh-my-opencode", "bin");
   }
   const xdgCache2 = process.env.XDG_CACHE_HOME;
-  const base = xdgCache2 || join36(homedir15(), ".cache");
-  return join36(base, "oh-my-opencode", "bin");
+  const base = xdgCache2 || join37(homedir15(), ".cache");
+  return join37(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
   return process.platform === "win32" ? "sg.exe" : "sg";
 }
 function getCachedBinaryPath2() {
-  const binaryPath = join36(getCacheDir3(), getBinaryName3());
-  return existsSync28(binaryPath) ? binaryPath : null;
+  const binaryPath = join37(getCacheDir3(), getBinaryName3());
+  return existsSync29(binaryPath) ? binaryPath : null;
 }
 async function extractZip2(archivePath, destDir) {
   const proc = process.platform === "win32" ? spawn5([
@@ -24174,8 +24562,8 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   }
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
-  const binaryPath = join36(cacheDir, binaryName);
-  if (existsSync28(binaryPath)) {
+  const binaryPath = join37(cacheDir, binaryName);
+  if (existsSync29(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os4 } = platformInfo;
@@ -24183,21 +24571,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 (!existsSync28(cacheDir)) {
+    if (!existsSync29(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 = join36(cacheDir, assetName);
+    const archivePath = join37(cacheDir, assetName);
     const arrayBuffer = await response2.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip2(archivePath, cacheDir);
-    if (existsSync28(archivePath)) {
+    if (existsSync29(archivePath)) {
       unlinkSync9(archivePath);
     }
-    if (process.platform !== "win32" && existsSync28(binaryPath)) {
+    if (process.platform !== "win32" && existsSync29(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -24248,8 +24636,8 @@ function findSgCliPathSync() {
     const require2 = createRequire4(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDir = dirname6(cliPkgPath);
-    const sgPath = join37(cliDir, binaryName);
-    if (existsSync29(sgPath) && isValidBinary(sgPath)) {
+    const sgPath = join38(cliDir, binaryName);
+    if (existsSync30(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -24260,8 +24648,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 = join37(pkgDir, astGrepName);
-      if (existsSync29(binaryPath) && isValidBinary(binaryPath)) {
+      const binaryPath = join38(pkgDir, astGrepName);
+      if (existsSync30(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -24269,7 +24657,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path6 of homebrewPaths) {
-      if (existsSync29(path6) && isValidBinary(path6)) {
+      if (existsSync30(path6) && isValidBinary(path6)) {
         return path6;
       }
     }
@@ -24325,11 +24713,11 @@ var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn6 } = globalThis.Bun;
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync30(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync31(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -24337,7 +24725,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync30(syncPath)) {
+    if (syncPath && existsSync31(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -24371,7 +24759,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync30(cliPath) && cliPath !== "sg") {
+  if (!existsSync31(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -24635,24 +25023,24 @@ var ast_grep_replace = tool({
 var {spawn: spawn7 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
-import { existsSync as existsSync32 } from "fs";
-import { join as join39, dirname as dirname7 } from "path";
+import { existsSync as existsSync33 } from "fs";
+import { join as join40, dirname as dirname7 } from "path";
 import { spawnSync } from "child_process";
 
 // src/tools/grep/downloader.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync11, chmodSync as chmodSync3, unlinkSync as unlinkSync10, readdirSync as readdirSync8 } from "fs";
-import { join as join38 } from "path";
+import { existsSync as existsSync32, mkdirSync as mkdirSync11, chmodSync as chmodSync3, unlinkSync as unlinkSync10, readdirSync as readdirSync9 } from "fs";
+import { join as join39 } from "path";
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join38(homeDir, ".cache", "oh-my-opencode", "bin");
+  return join39(homeDir, ".cache", "oh-my-opencode", "bin");
 }
 function getRgPath() {
   const isWindows2 = process.platform === "win32";
-  return join38(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
+  return join39(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
 }
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
-  return existsSync31(rgPath) ? rgPath : null;
+  return existsSync32(rgPath) ? rgPath : null;
 }
 
 // src/tools/grep/constants.ts
@@ -24675,13 +25063,13 @@ function getOpenCodeBundledRg() {
   const isWindows2 = process.platform === "win32";
   const rgName = isWindows2 ? "rg.exe" : "rg";
   const candidates = [
-    join39(execDir, rgName),
-    join39(execDir, "bin", rgName),
-    join39(execDir, "..", "bin", rgName),
-    join39(execDir, "..", "libexec", rgName)
+    join40(execDir, rgName),
+    join40(execDir, "bin", rgName),
+    join40(execDir, "..", "bin", rgName),
+    join40(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync32(candidate)) {
+    if (existsSync33(candidate)) {
       return candidate;
     }
   }
@@ -25084,22 +25472,22 @@ var glob = tool({
   }
 });
 // src/tools/slashcommand/tools.ts
-import { existsSync as existsSync33, readdirSync as readdirSync9, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync34, readdirSync as readdirSync10, readFileSync as readFileSync21 } from "fs";
 import { homedir as homedir16 } from "os";
-import { join as join40, basename as basename3, dirname as dirname8 } from "path";
+import { join as join41, basename as basename3, dirname as dirname8 } from "path";
 function discoverCommandsFromDir(commandsDir, scope) {
-  if (!existsSync33(commandsDir)) {
+  if (!existsSync34(commandsDir)) {
     return [];
   }
-  const entries = readdirSync9(commandsDir, { withFileTypes: true });
+  const entries = readdirSync10(commandsDir, { withFileTypes: true });
   const commands = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
-    const commandPath = join40(commandsDir, entry.name);
+    const commandPath = join41(commandsDir, entry.name);
     const commandName = basename3(entry.name, ".md");
     try {
-      const content = readFileSync20(commandPath, "utf-8");
+      const content = readFileSync21(commandPath, "utf-8");
       const { data, body } = parseFrontmatter(content);
       const isOpencodeSource = scope === "opencode" || scope === "opencode-project";
       const metadata = {
@@ -25124,10 +25512,10 @@ function discoverCommandsFromDir(commandsDir, scope) {
   return commands;
 }
 function discoverCommandsSync() {
-  const userCommandsDir = join40(homedir16(), ".claude", "commands");
-  const projectCommandsDir = join40(process.cwd(), ".claude", "commands");
-  const opencodeGlobalDir = join40(homedir16(), ".config", "opencode", "command");
-  const opencodeProjectDir = join40(process.cwd(), ".opencode", "command");
+  const userCommandsDir = join41(homedir16(), ".claude", "commands");
+  const projectCommandsDir = join41(process.cwd(), ".claude", "commands");
+  const opencodeGlobalDir = join41(homedir16(), ".config", "opencode", "command");
+  const opencodeProjectDir = join41(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode");
   const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project");
@@ -25259,9 +25647,9 @@ var SkillFrontmatterSchema = exports_external.object({
   metadata: exports_external.record(exports_external.string(), exports_external.string()).optional()
 });
 // src/tools/skill/tools.ts
-import { existsSync as existsSync34, readdirSync as readdirSync10, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync35, readdirSync as readdirSync11, readFileSync as readFileSync22 } from "fs";
 import { homedir as homedir17 } from "os";
-import { join as join41, basename as basename4 } from "path";
+import { join as join42, basename as basename4 } from "path";
 function parseSkillFrontmatter(data) {
   return {
     name: typeof data.name === "string" ? data.name : "",
@@ -25272,22 +25660,22 @@ function parseSkillFrontmatter(data) {
   };
 }
 function discoverSkillsFromDir(skillsDir, scope) {
-  if (!existsSync34(skillsDir)) {
+  if (!existsSync35(skillsDir)) {
     return [];
   }
-  const entries = readdirSync10(skillsDir, { withFileTypes: true });
+  const entries = readdirSync11(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
-    const skillPath = join41(skillsDir, entry.name);
+    const skillPath = join42(skillsDir, entry.name);
     if (entry.isDirectory() || entry.isSymbolicLink()) {
       const resolvedPath = resolveSymlink(skillPath);
-      const skillMdPath = join41(resolvedPath, "SKILL.md");
-      if (!existsSync34(skillMdPath))
+      const skillMdPath = join42(resolvedPath, "SKILL.md");
+      if (!existsSync35(skillMdPath))
         continue;
       try {
-        const content = readFileSync21(skillMdPath, "utf-8");
+        const content = readFileSync22(skillMdPath, "utf-8");
         const { data } = parseFrontmatter(content);
         skills.push({
           name: data.name || entry.name,
@@ -25302,8 +25690,8 @@ function discoverSkillsFromDir(skillsDir, scope) {
   return skills;
 }
 function discoverSkillsSync() {
-  const userSkillsDir = join41(homedir17(), ".claude", "skills");
-  const projectSkillsDir = join41(process.cwd(), ".claude", "skills");
+  const userSkillsDir = join42(homedir17(), ".claude", "skills");
+  const projectSkillsDir = join42(process.cwd(), ".claude", "skills");
   const userSkills = discoverSkillsFromDir(userSkillsDir, "user");
   const projectSkills = discoverSkillsFromDir(projectSkillsDir, "project");
   return [...projectSkills, ...userSkills];
@@ -25313,12 +25701,12 @@ var skillListForDescription = availableSkills.map((s) => `- ${s.name}: ${s.descr
 `);
 async function parseSkillMd(skillPath) {
   const resolvedPath = resolveSymlink(skillPath);
-  const skillMdPath = join41(resolvedPath, "SKILL.md");
-  if (!existsSync34(skillMdPath)) {
+  const skillMdPath = join42(resolvedPath, "SKILL.md");
+  if (!existsSync35(skillMdPath)) {
     return null;
   }
   try {
-    let content = readFileSync21(skillMdPath, "utf-8");
+    let content = readFileSync22(skillMdPath, "utf-8");
     content = await resolveCommandsInText(content);
     const { data, body } = parseFrontmatter(content);
     const frontmatter2 = parseSkillFrontmatter(data);
@@ -25329,12 +25717,12 @@ async function parseSkillMd(skillPath) {
       allowedTools: frontmatter2["allowed-tools"],
       metadata: frontmatter2.metadata
     };
-    const referencesDir = join41(resolvedPath, "references");
-    const scriptsDir = join41(resolvedPath, "scripts");
-    const assetsDir = join41(resolvedPath, "assets");
-    const references = existsSync34(referencesDir) ? readdirSync10(referencesDir).filter((f) => !f.startsWith(".")) : [];
-    const scripts = existsSync34(scriptsDir) ? readdirSync10(scriptsDir).filter((f) => !f.startsWith(".") && !f.startsWith("__")) : [];
-    const assets = existsSync34(assetsDir) ? readdirSync10(assetsDir).filter((f) => !f.startsWith(".")) : [];
+    const referencesDir = join42(resolvedPath, "references");
+    const scriptsDir = join42(resolvedPath, "scripts");
+    const assetsDir = join42(resolvedPath, "assets");
+    const references = existsSync35(referencesDir) ? readdirSync11(referencesDir).filter((f) => !f.startsWith(".")) : [];
+    const scripts = existsSync35(scriptsDir) ? readdirSync11(scriptsDir).filter((f) => !f.startsWith(".") && !f.startsWith("__")) : [];
+    const assets = existsSync35(assetsDir) ? readdirSync11(assetsDir).filter((f) => !f.startsWith(".")) : [];
     return {
       name: metadata.name,
       path: resolvedPath,
@@ -25350,15 +25738,15 @@ async function parseSkillMd(skillPath) {
   }
 }
 async function discoverSkillsFromDirAsync(skillsDir) {
-  if (!existsSync34(skillsDir)) {
+  if (!existsSync35(skillsDir)) {
     return [];
   }
-  const entries = readdirSync10(skillsDir, { withFileTypes: true });
+  const entries = readdirSync11(skillsDir, { withFileTypes: true });
   const skills = [];
   for (const entry of entries) {
     if (entry.name.startsWith("."))
       continue;
-    const skillPath = join41(skillsDir, entry.name);
+    const skillPath = join42(skillsDir, entry.name);
     if (entry.isDirectory() || entry.isSymbolicLink()) {
       const skillInfo = await parseSkillMd(skillPath);
       if (skillInfo) {
@@ -25369,8 +25757,8 @@ async function discoverSkillsFromDirAsync(skillsDir) {
   return skills;
 }
 async function discoverSkills() {
-  const userSkillsDir = join41(homedir17(), ".claude", "skills");
-  const projectSkillsDir = join41(process.cwd(), ".claude", "skills");
+  const userSkillsDir = join42(homedir17(), ".claude", "skills");
+  const projectSkillsDir = join42(process.cwd(), ".claude", "skills");
   const userSkills = await discoverSkillsFromDirAsync(userSkillsDir);
   const projectSkills = await discoverSkillsFromDirAsync(projectSkillsDir);
   return [...projectSkills, ...userSkills];
@@ -25399,9 +25787,9 @@ async function loadSkillWithReferences(skill, includeRefs) {
   const referencesLoaded = [];
   if (includeRefs && skill.references.length > 0) {
     for (const ref of skill.references) {
-      const refPath = join41(skill.path, "references", ref);
+      const refPath = join42(skill.path, "references", ref);
       try {
-        let content = readFileSync21(refPath, "utf-8");
+        let content = readFileSync22(refPath, "utf-8");
         content = await resolveCommandsInText(content);
         referencesLoaded.push({ path: ref, content });
       } catch {}
@@ -25673,12 +26061,15 @@ Arguments:
 - timeout: Max wait time in ms when blocking (default: 60000, max: 600000)
 
 The system automatically notifies when background tasks complete. You typically don't need block=true.`;
-var BACKGROUND_CANCEL_DESCRIPTION = `Cancel a running background task.
+var BACKGROUND_CANCEL_DESCRIPTION = `Cancel running background task(s).
 
 Only works for tasks with status "running". Aborts the background session and marks the task as cancelled.
 
 Arguments:
-- taskId: Required task ID to cancel.`;
+- taskId: Task ID to cancel (optional if all=true)
+- all: Set to true to cancel ALL running background tasks at once (default: false)
+
+**Cleanup Before Answer**: When you have gathered sufficient information and are ready to provide your final answer to the user, use \`all=true\` to cancel ALL running background tasks first, then deliver your response. This conserves resources and ensures clean workflow completion.`;
 
 // src/tools/background-task/tools.ts
 function formatDuration(start, end) {
@@ -25893,10 +26284,35 @@ function createBackgroundCancel(manager, client2) {
   return tool({
     description: BACKGROUND_CANCEL_DESCRIPTION,
     args: {
-      taskId: tool.schema.string().describe("Task ID to cancel")
+      taskId: tool.schema.string().optional().describe("Task ID to cancel (required if all=false)"),
+      all: tool.schema.boolean().optional().describe("Cancel all running background tasks (default: false)")
     },
-    async execute(args) {
+    async execute(args, toolContext) {
       try {
+        const cancelAll = args.all === true;
+        if (!cancelAll && !args.taskId) {
+          return `\u274C Invalid arguments: Either provide a taskId or set all=true to cancel all running tasks.`;
+        }
+        if (cancelAll) {
+          const tasks = manager.getTasksByParentSession(toolContext.sessionID);
+          const runningTasks = tasks.filter((t) => t.status === "running");
+          if (runningTasks.length === 0) {
+            return `\u2705 No running background tasks to cancel.`;
+          }
+          const results = [];
+          for (const task2 of runningTasks) {
+            client2.session.abort({
+              path: { id: task2.sessionID }
+            }).catch(() => {});
+            task2.status = "cancelled";
+            task2.completedAt = new Date;
+            results.push(`- ${task2.id}: ${task2.description}`);
+          }
+          return `\u2705 Cancelled ${runningTasks.length} background task(s):
+
+${results.join(`
+`)}`;
+        }
         const task = manager.getTask(args.taskId);
         if (!task) {
           return `\u274C Task not found: ${args.taskId}`;
@@ -26197,17 +26613,17 @@ var builtinTools = {
   skill
 };
 // src/features/background-agent/manager.ts
-import { existsSync as existsSync35, readdirSync as readdirSync11 } from "fs";
-import { join as join42 } from "path";
-function getMessageDir3(sessionID) {
-  if (!existsSync35(MESSAGE_STORAGE))
+import { existsSync as existsSync36, readdirSync as readdirSync12 } from "fs";
+import { join as join43 } from "path";
+function getMessageDir4(sessionID) {
+  if (!existsSync36(MESSAGE_STORAGE))
     return null;
-  const directPath = join42(MESSAGE_STORAGE, sessionID);
-  if (existsSync35(directPath))
+  const directPath = join43(MESSAGE_STORAGE, sessionID);
+  if (existsSync36(directPath))
     return directPath;
-  for (const dir of readdirSync11(MESSAGE_STORAGE)) {
-    const sessionPath = join42(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync35(sessionPath))
+  for (const dir of readdirSync12(MESSAGE_STORAGE)) {
+    const sessionPath = join43(MESSAGE_STORAGE, dir, sessionID);
+    if (existsSync36(sessionPath))
       return sessionPath;
   }
   return null;
@@ -26431,7 +26847,7 @@ class BackgroundManager {
     log("[background-agent] Sending notification to parent session:", { parentSessionID: task.parentSessionID });
     setTimeout(async () => {
       try {
-        const messageDir = getMessageDir3(task.parentSessionID);
+        const messageDir = getMessageDir4(task.parentSessionID);
         const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
         await this.client.session.prompt({
           path: { id: task.parentSessionID },
@@ -26627,7 +27043,8 @@ var HookNameSchema = exports_external.enum([
   "keyword-detector",
   "agent-usage-reminder",
   "non-interactive-env",
-  "interactive-bash-session"
+  "interactive-bash-session",
+  "empty-message-sanitizer"
 ]);
 var AgentOverrideConfigSchema = exports_external.object({
   model: exports_external.string().optional(),
@@ -26795,13 +27212,14 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const agentUsageReminder = isHookEnabled("agent-usage-reminder") ? createAgentUsageReminderHook(ctx) : null;
   const nonInteractiveEnv = isHookEnabled("non-interactive-env") ? createNonInteractiveEnvHook(ctx) : null;
   const interactiveBashSession = isHookEnabled("interactive-bash-session") ? createInteractiveBashSessionHook(ctx) : null;
+  const emptyMessageSanitizer = isHookEnabled("empty-message-sanitizer") ? createEmptyMessageSanitizerHook() : null;
   updateTerminalTitle({ sessionId: "main" });
   const backgroundManager = new BackgroundManager(ctx);
   const backgroundNotificationHook = isHookEnabled("background-notification") ? createBackgroundNotificationHook(backgroundManager) : null;
   const backgroundTools = createBackgroundTools(backgroundManager, ctx.client);
   const callOmoAgent = createCallOmoAgent(ctx, backgroundManager);
   const lookAt = createLookAt(ctx);
-  const googleAuthHooks = pluginConfig.google_auth ? await createGoogleAntigravityAuthPlugin(ctx) : null;
+  const googleAuthHooks = pluginConfig.google_auth !== false ? await createGoogleAntigravityAuthPlugin(ctx) : null;
   const tmuxAvailable = await getTmuxPath();
   return {
     ...googleAuthHooks ? { auth: googleAuthHooks.auth } : {},
@@ -26816,6 +27234,9 @@ var OhMyOpenCodePlugin = async (ctx) => {
       await claudeCodeHooks["chat.message"]?.(input, output);
       await keywordDetector?.["chat.message"]?.(input, output);
     },
+    "experimental.chat.messages.transform": async (input, output) => {
+      await emptyMessageSanitizer?.["experimental.chat.messages.transform"]?.(input, output);
+    },
     config: async (config3) => {
       const builtinAgents = createBuiltinAgents(pluginConfig.disabled_agents, pluginConfig.agents, ctx.directory);
       const userAgents = pluginConfig.claude_code?.agents ?? true ? loadUserAgents() : {};