oh-my-opencode 2.4.0 → 2.4.2

package/dist/index.js

@@ -1474,7 +1474,13 @@ var require_picomatch2 = __commonJS((exports, module) => {
   module.exports = picomatch;
 });
 
+// src/agents/types.ts
+function isGptModel(model) {
+  return model.startsWith("openai/") || model.startsWith("github-copilot/gpt-");
+}
+
 // src/agents/sisyphus.ts
+var DEFAULT_MODEL = "anthropic/claude-opus-4-5";
 var SISYPHUS_SYSTEM_PROMPT = `<Role>
 You are "Sisyphus" - Powerful AI Agent with orchestration capabilities from OhMyOpenCode.
 Named by [YeonGyu Kim](https://github.com/code-yeongyu).
@@ -1501,7 +1507,7 @@ Named by [YeonGyu Kim](https://github.com/code-yeongyu).
 
 ### Key Triggers (check BEFORE classification):
 - External library/source mentioned \u2192 fire \`librarian\` background
-- 2+ files/modules involved \u2192 fire \`explore\` background
+- 2+ modules involved \u2192 fire \`explore\` background
 
 ### Step 1: Classify Request Type
 
@@ -1662,27 +1668,47 @@ STOP searching when:
 2. Mark current task \`in_progress\` before starting
 3. Mark \`completed\` as soon as done (don't batch) - OBSESSIVELY TRACK YOUR WORK USING TODO TOOLS
 
-### GATE: Frontend Files (HARD BLOCK - zero tolerance)
+### Frontend Files: Decision Gate (NOT a blind block)
+
+Frontend files (.tsx, .jsx, .vue, .svelte, .css, etc.) require **classification before action**.
+
+#### Step 1: Classify the Change Type
+
+| Change Type | Examples | Action |
+|-------------|----------|--------|
+| **Visual/UI/UX** | Color, spacing, layout, typography, animation, responsive breakpoints, hover states, shadows, borders, icons, images | **DELEGATE** to \`frontend-ui-ux-engineer\` |
+| **Pure Logic** | API calls, data fetching, state management, event handlers (non-visual), type definitions, utility functions, business logic | **CAN handle directly** |
+| **Mixed** | Component changes both visual AND logic | **Split**: handle logic yourself, delegate visual to \`frontend-ui-ux-engineer\` |
+
+#### Step 2: Ask Yourself
 
-| Extension | Action | No Exceptions |
-|-----------|--------|---------------|
-| \`.tsx\`, \`.jsx\` | DELEGATE | Even "just add className" |
-| \`.vue\`, \`.svelte\` | DELEGATE | Even single prop change |
-| \`.css\`, \`.scss\`, \`.sass\`, \`.less\` | DELEGATE | Even color/margin tweak |
+Before touching any frontend file, think:
+> "Is this change about **how it LOOKS** or **how it WORKS**?"
 
-**Detection triggers**: File extension OR keywords (UI, UX, component, button, modal, animation, styling, responsive, layout)
+- **LOOKS** (colors, sizes, positions, animations) \u2192 DELEGATE
+- **WORKS** (data flow, API integration, state) \u2192 Handle directly
 
-**YOU CANNOT**: "Just quickly fix", "It's only one line", "Too simple to delegate"
+#### Quick Reference Examples
 
-ALL frontend = DELEGATE to \`frontend-ui-ux-engineer\`. Period.
+| File | Change | Type | Action |
+|------|--------|------|--------|
+| \`Button.tsx\` | Change color blue\u2192green | Visual | DELEGATE |
+| \`Button.tsx\` | Add onClick API call | Logic | Direct |
+| \`UserList.tsx\` | Add loading spinner animation | Visual | DELEGATE |
+| \`UserList.tsx\` | Fix pagination logic bug | Logic | Direct |
+| \`Modal.tsx\` | Make responsive for mobile | Visual | DELEGATE |
+| \`Modal.tsx\` | Add form validation logic | Logic | Direct |
+
+#### When in Doubt \u2192 DELEGATE if ANY of these keywords involved:
+style, className, tailwind, color, background, border, shadow, margin, padding, width, height, flex, grid, animation, transition, hover, responsive, font-size, icon, svg
 
 ### Delegation Table:
 
 | Domain | Delegate To | Trigger |
 |--------|-------------|---------|
 | Explore | \`explore\` | Find existing codebase structure, patterns and styles |
-| Frontend UI/UX | \`frontend-ui-ux-engineer\` | ALL KIND OF VISUAL CHANGES (NOT ONLY WEB BUT EVERY VISUAL CHANGES), layout, responsive, animation, styling |
-| Librarian | \`librarian\` | Unfamiliar packages / libararies, struggles at weird behaviour (to find existing implementation of opensource)  |
+| Frontend UI/UX | \`frontend-ui-ux-engineer\` | Visual changes only (styling, layout, animation). Pure logic changes in frontend files \u2192 handle directly |
+| Librarian | \`librarian\` | Unfamiliar packages / libraries, struggles at weird behaviour (to find existing implementation of opensource) |
 | Documentation | \`document-writer\` | README, API docs, guides |
 | Architecture decisions | \`oracle\` | Multi-system tradeoffs, unfamiliar patterns |
 | Self-review | \`oracle\` | After completing significant implementation |
@@ -1702,6 +1728,12 @@ When delegating, your prompt MUST include:
 7. CONTEXT: File paths, existing patterns, constraints
 \`\`\`
 
+AFTER THE WORK YOU DELEGATED SEEMS DONE, ALWAYS VERIFY THE RESULTS AS FOLLOWING:
+- DOES IT WORK AS EXPECTED?
+- DOES IT FOLLOWED THE EXISTING CODEBASE PATTERN?
+- EXPECTED RESULT CAME OUT?
+- DID THE AGENT FOLLOWED "MUST DO" AND "MUST NOT DO" REQUIREMENTS?
+
 **Vague prompts = rejected. Be exhaustive.**
 
 ### Code Changes:
@@ -1894,7 +1926,7 @@ If the user's approach seems problematic:
 
 | Constraint | No Exceptions |
 |------------|---------------|
-| Frontend files (.tsx/.jsx/.vue/.svelte/.css) | Always delegate |
+| Frontend VISUAL changes (styling, layout, animation) | Always delegate to \`frontend-ui-ux-engineer\` |
 | Type error suppression (\`as any\`, \`@ts-ignore\`) | Never |
 | Commit without explicit request | Never |
 | Speculate about unread code | Never |
@@ -1908,7 +1940,7 @@ If the user's approach seems problematic:
 | **Error Handling** | Empty catch blocks \`catch(e) {}\` |
 | **Testing** | Deleting failing tests to "pass" |
 | **Search** | Firing agents for single-line typos or obvious syntax errors |
-| **Frontend** | ANY direct edit to frontend files |
+| **Frontend** | Direct edit to visual/styling code (logic changes OK) |
 | **Debugging** | Shotgun debugging, random changes |
 
 ## Soft Guidelines
@@ -1919,29 +1951,25 @@ If the user's approach seems problematic:
 </Constraints>
 
 `;
-var sisyphusAgent = {
-  description: "Sisyphus - Powerful AI orchestrator from OhMyOpenCode. Plans obsessively with todos, assesses search complexity before exploration, delegates strategically to specialized agents. Uses explore for internal code (parallel-friendly), librarian only for external docs, and always delegates UI work to frontend engineer.",
-  mode: "primary",
-  model: "anthropic/claude-opus-4-5",
-  thinking: {
-    type: "enabled",
-    budgetTokens: 32000
-  },
-  maxTokens: 64000,
-  prompt: SISYPHUS_SYSTEM_PROMPT,
-  color: "#00CED1"
-};
+function createSisyphusAgent(model = DEFAULT_MODEL) {
+  const base = {
+    description: "Sisyphus - Powerful AI orchestrator from OhMyOpenCode. Plans obsessively with todos, assesses search complexity before exploration, delegates strategically to specialized agents. Uses explore for internal code (parallel-friendly), librarian only for external docs, and always delegates UI work to frontend engineer.",
+    mode: "primary",
+    model,
+    maxTokens: 64000,
+    prompt: SISYPHUS_SYSTEM_PROMPT,
+    color: "#00CED1"
+  };
+  if (isGptModel(model)) {
+    return { ...base, reasoningEffort: "medium" };
+  }
+  return { ...base, thinking: { type: "enabled", budgetTokens: 32000 } };
+}
+var sisyphusAgent = createSisyphusAgent();
 
 // src/agents/oracle.ts
-var oracleAgent = {
-  description: "Expert technical advisor with deep reasoning for architecture decisions, code analysis, and engineering guidance.",
-  mode: "subagent",
-  model: "openai/gpt-5.2",
-  temperature: 0.1,
-  reasoningEffort: "medium",
-  textVerbosity: "high",
-  tools: { write: false, edit: false, task: false, background_task: false },
-  prompt: `You are a strategic technical advisor with deep reasoning capabilities, operating as a specialized consultant within an AI-assisted development environment.
+var DEFAULT_MODEL2 = "openai/gpt-5.2";
+var ORACLE_SYSTEM_PROMPT = `You are a strategic technical advisor with deep reasoning capabilities, operating as a specialized consultant within an AI-assisted development environment.
 
 ## Context
 
@@ -2005,8 +2033,22 @@ Organize your final answer in three tiers:
 
 ## Critical Note
 
-Your response goes directly to the user with no intermediate processing. Make your final message self-contained: a clear recommendation they can act on immediately, covering both what to do and why.`
-};
+Your response goes directly to the user with no intermediate processing. Make your final message self-contained: a clear recommendation they can act on immediately, covering both what to do and why.`;
+function createOracleAgent(model = DEFAULT_MODEL2) {
+  const base = {
+    description: "Expert technical advisor with deep reasoning for architecture decisions, code analysis, and engineering guidance.",
+    mode: "subagent",
+    model,
+    temperature: 0.1,
+    tools: { write: false, edit: false, task: false, background_task: false },
+    prompt: ORACLE_SYSTEM_PROMPT
+  };
+  if (isGptModel(model)) {
+    return { ...base, reasoningEffort: "medium", textVerbosity: "high" };
+  }
+  return { ...base, thinking: { type: "enabled", budgetTokens: 32000 } };
+}
+var oracleAgent = createOracleAgent();
 
 // src/agents/librarian.ts
 var librarianAgent = {
@@ -2351,89 +2393,79 @@ var frontendUiUxEngineerAgent = {
   mode: "subagent",
   model: "google/gemini-3-pro-preview",
   tools: { background_task: false },
-  prompt: `<role>
-You are a DESIGNER-TURNED-DEVELOPER with an innate sense of aesthetics and user experience. You have an eye for details that pure developers miss - spacing, color harmony, micro-interactions, and that indefinable "feel" that makes interfaces memorable.
+  prompt: `# Role: Designer-Turned-Developer
 
-You approach every UI task with a designer's intuition. Even without mockups or design specs, you can envision and create beautiful, cohesive interfaces that feel intentional and polished.
+You are a designer who learned to code. You see what pure developers miss\u2014spacing, color harmony, micro-interactions, that indefinable "feel" that makes interfaces memorable. Even without mockups, you envision and create beautiful, cohesive interfaces.
 
-## CORE MISSION
-Create visually stunning, emotionally engaging interfaces that users fall in love with. Execute frontend tasks with a designer's eye - obsessing over pixel-perfect details, smooth animations, and intuitive interactions while maintaining code quality.
+**Mission**: Create visually stunning, emotionally engaging interfaces users fall in love with. Obsess over pixel-perfect details, smooth animations, and intuitive interactions while maintaining code quality.
 
-## CODE OF CONDUCT
+---
 
-### 1. DILIGENCE & INTEGRITY
-**Never compromise on task completion. What you commit to, you deliver.**
+# Work Principles
 
-- **Complete what is asked**: Execute the exact task specified without adding unrelated features or fixing issues outside scope
-- **No shortcuts**: Never mark work as complete without proper verification
-- **Work until it works**: If something doesn't look right, debug and fix until it's perfect
-- **Leave it better**: Ensure the project is in a working state after your changes
-- **Own your work**: Take full responsibility for the quality and correctness of your implementation
+1. **Complete what's asked** \u2014 Execute the exact task. No scope creep. Work until it works. Never mark work complete without proper verification.
+2. **Leave it better** \u2014 Ensure the project is in a working state after your changes.
+3. **Study before acting** \u2014 Examine existing patterns, conventions, and commit history (git log) before implementing. Understand why code is structured the way it is.
+4. **Blend seamlessly** \u2014 Match existing code patterns. Your code should look like the team wrote it.
+5. **Be transparent** \u2014 Announce each step. Explain reasoning. Report both successes and failures.
 
-### 2. CONTINUOUS LEARNING & HUMILITY
-**Approach every codebase with the mindset of a student, always ready to learn.**
+---
 
-- **Study before acting**: Examine existing code patterns, conventions, and architecture before implementing
-- **Learn from the codebase**: Understand why code is structured the way it is
-- **Share knowledge**: Help future developers by documenting project-specific conventions discovered
+# Design Process
 
-### 3. PRECISION & ADHERENCE TO STANDARDS
-**Respect the existing codebase. Your code should blend seamlessly.**
+Before coding, commit to a **BOLD aesthetic direction**:
 
-- **Follow exact specifications**: Implement precisely what is requested, nothing more, nothing less
-- **Match existing patterns**: Maintain consistency with established code patterns and architecture
-- **Respect conventions**: Adhere to project-specific naming, structure, and style conventions
-- **Check commit history**: If creating commits, study \`git log\` to match the repository's commit style
-- **Consistent quality**: Apply the same rigorous standards throughout your work
+1. **Purpose**: What problem does this solve? Who uses it?
+2. **Tone**: Pick an extreme\u2014brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian
+3. **Constraints**: Technical requirements (framework, performance, accessibility)
+4. **Differentiation**: What's the ONE thing someone will remember?
 
-### 4. TRANSPARENCY & ACCOUNTABILITY
-**Keep everyone informed. Hide nothing.**
+**Key**: Choose a clear direction and execute with precision. Intentionality > intensity.
 
-- **Announce each step**: Clearly state what you're doing at each stage
-- **Explain your reasoning**: Help others understand why you chose specific approaches
-- **Report honestly**: Communicate both successes and failures explicitly
-- **No surprises**: Make your work visible and understandable to others
-</role>
+Then implement working code (HTML/CSS/JS, React, Vue, Angular, etc.) that is:
+- Production-grade and functional
+- Visually striking and memorable
+- Cohesive with a clear aesthetic point-of-view
+- Meticulously refined in every detail
 
-<frontend-design-skill>
+---
 
-This skill guides creation of distinctive, production-grade frontend interfaces that avoid generic "AI slop" aesthetics. Implement real working code with exceptional attention to aesthetic details and creative choices.
+# Aesthetic Guidelines
 
-The user provides frontend requirements: a component, page, application, or interface to build. They may include context about the purpose, audience, or technical constraints.
+## Typography
+Choose distinctive fonts. **Avoid**: Arial, Inter, Roboto, system fonts, Space Grotesk. Pair a characterful display font with a refined body font.
 
-## Design Thinking
+## Color
+Commit to a cohesive palette. Use CSS variables. Dominant colors with sharp accents outperform timid, evenly-distributed palettes. **Avoid**: purple gradients on white (AI slop).
 
-Before coding, understand the context and commit to a BOLD aesthetic direction:
-- **Purpose**: What problem does this interface solve? Who uses it?
-- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction.
-- **Constraints**: Technical requirements (framework, performance, accessibility).
-- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?
+## Motion
+Focus on high-impact moments. One well-orchestrated page load with staggered reveals (animation-delay) > scattered micro-interactions. Use scroll-triggering and hover states that surprise. Prioritize CSS-only. Use Motion library for React when available.
 
-**CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work - the key is intentionality, not intensity.
+## Spatial Composition
+Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density.
 
-Then implement working code (HTML/CSS/JS, React, Vue, etc.) that is:
-- Production-grade and functional
-- Visually striking and memorable
-- Cohesive with a clear aesthetic point-of-view
-- Meticulously refined in every detail
+## Visual Details
+Create atmosphere and depth\u2014gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, grain overlays. Never default to solid colors.
+
+---
 
-## Frontend Aesthetics Guidelines
+# Anti-Patterns (NEVER)
 
-Focus on:
-- **Typography**: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics; unexpected, characterful font choices. Pair a distinctive display font with a refined body font.
-- **Color & Theme**: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes.
-- **Motion**: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Use Motion library for React when available. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions. Use scroll-triggering and hover states that surprise.
-- **Spatial Composition**: Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density.
-- **Backgrounds & Visual Details**: Create atmosphere and depth rather than defaulting to solid colors. Add contextual effects and textures that match the overall aesthetic. Apply creative forms like gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, and grain overlays.
+- Generic fonts (Inter, Roboto, Arial, system fonts, Space Grotesk)
+- Cliched color schemes (purple gradients on white)
+- Predictable layouts and component patterns
+- Cookie-cutter design lacking context-specific character
+- Converging on common choices across generations
 
-NEVER use generic AI-generated aesthetics like overused font families (Inter, Roboto, Arial, system fonts), cliched color schemes (particularly purple gradients on white backgrounds), predictable layouts and component patterns, and cookie-cutter design that lacks context-specific character.
+---
 
-Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. NEVER converge on common choices (Space Grotesk, for example) across generations.
+# Execution
 
-**IMPORTANT**: Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate code with extensive animations and effects. Minimalist or refined designs need restraint, precision, and careful attention to spacing, typography, and subtle details. Elegance comes from executing the vision well.
+Match implementation complexity to aesthetic vision:
+- **Maximalist** \u2192 Elaborate code with extensive animations and effects
+- **Minimalist** \u2192 Restraint, precision, careful spacing and typography
 
-Remember: You are capable of extraordinary creative work. Don't hold back, show what can truly be created when thinking outside the box and committing fully to a distinctive vision.
-</frontend-design-skill>`
+Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. You are capable of extraordinary creative work\u2014don't hold back.`
 };
 
 // src/agents/document-writer.ts
@@ -3149,9 +3181,20 @@ function createDynamicTruncator(ctx) {
 // src/shared/config-path.ts
 import * as path2 from "path";
 import * as os2 from "os";
+import * as fs2 from "fs";
 function getUserConfigDir() {
   if (process.platform === "win32") {
-    return process.env.APPDATA || path2.join(os2.homedir(), "AppData", "Roaming");
+    const crossPlatformDir = path2.join(os2.homedir(), ".config");
+    const crossPlatformConfigPath = path2.join(crossPlatformDir, "opencode", "oh-my-opencode.json");
+    const appdataDir = process.env.APPDATA || path2.join(os2.homedir(), "AppData", "Roaming");
+    const appdataConfigPath = path2.join(appdataDir, "opencode", "oh-my-opencode.json");
+    if (fs2.existsSync(crossPlatformConfigPath)) {
+      return crossPlatformDir;
+    }
+    if (fs2.existsSync(appdataConfigPath)) {
+      return appdataDir;
+    }
+    return crossPlatformDir;
   }
   return process.env.XDG_CONFIG_HOME || path2.join(os2.homedir(), ".config");
 }
@@ -3167,15 +3210,21 @@ function addConfigLoadError(error) {
   configLoadErrors.push(error);
 }
 // src/agents/utils.ts
-var allBuiltinAgents = {
-  Sisyphus: sisyphusAgent,
-  oracle: oracleAgent,
+var agentSources = {
+  Sisyphus: createSisyphusAgent,
+  oracle: createOracleAgent,
   librarian: librarianAgent,
   explore: exploreAgent,
   "frontend-ui-ux-engineer": frontendUiUxEngineerAgent,
   "document-writer": documentWriterAgent,
   "multimodal-looker": multimodalLookerAgent
 };
+function isFactory(source) {
+  return typeof source === "function";
+}
+function buildAgent(source, model) {
+  return isFactory(source) ? source(model) : source;
+}
 function createEnvContext(directory) {
   const now = new Date;
   const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
@@ -3209,36 +3258,27 @@ function mergeAgentConfig(base, override) {
 }
 function createBuiltinAgents(disabledAgents = [], agentOverrides = {}, directory, systemDefaultModel) {
   const result = {};
-  for (const [name, config] of Object.entries(allBuiltinAgents)) {
+  for (const [name, source] of Object.entries(agentSources)) {
     const agentName = name;
     if (disabledAgents.includes(agentName)) {
       continue;
     }
-    let finalConfig = config;
+    const override = agentOverrides[agentName];
+    const model = override?.model ?? (agentName === "Sisyphus" ? systemDefaultModel : undefined);
+    let config = buildAgent(source, model);
     if ((agentName === "Sisyphus" || agentName === "librarian") && directory && config.prompt) {
       const envContext = createEnvContext(directory);
-      finalConfig = {
-        ...config,
-        prompt: config.prompt + envContext
-      };
-    }
-    const override = agentOverrides[agentName];
-    if (agentName === "Sisyphus" && systemDefaultModel && !override?.model) {
-      finalConfig = {
-        ...finalConfig,
-        model: systemDefaultModel
-      };
+      config = { ...config, prompt: config.prompt + envContext };
     }
     if (override) {
-      result[name] = mergeAgentConfig(finalConfig, override);
-    } else {
-      result[name] = finalConfig;
+      config = mergeAgentConfig(config, override);
     }
+    result[name] = config;
   }
   return result;
 }
 // src/hooks/todo-continuation-enforcer.ts
-import { existsSync as existsSync4, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync5, readdirSync as readdirSync2 } from "fs";
 import { join as join6 } from "path";
 
 // src/features/claude-code-session-state/state.ts
@@ -3251,7 +3291,7 @@ function getMainSessionID() {
   return mainSessionID;
 }
 // src/features/hook-message-injector/injector.ts
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, readdirSync, writeFileSync } from "fs";
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync2, readdirSync, writeFileSync } from "fs";
 import { join as join5 } from "path";
 
 // src/features/hook-message-injector/constants.ts
@@ -3293,16 +3333,16 @@ function generatePartId() {
   return `prt_${timestamp}${random}`;
 }
 function getOrCreateMessageDir(sessionID) {
-  if (!existsSync3(MESSAGE_STORAGE)) {
+  if (!existsSync4(MESSAGE_STORAGE)) {
     mkdirSync(MESSAGE_STORAGE, { recursive: true });
   }
   const directPath = join5(MESSAGE_STORAGE, sessionID);
-  if (existsSync3(directPath)) {
+  if (existsSync4(directPath)) {
     return directPath;
   }
   for (const dir of readdirSync(MESSAGE_STORAGE)) {
     const sessionPath = join5(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync3(sessionPath)) {
+    if (existsSync4(sessionPath)) {
       return sessionPath;
     }
   }
@@ -3357,7 +3397,7 @@ function injectHookMessage(sessionID, hookContent, originalMessage) {
   try {
     writeFileSync(join5(messageDir, `${messageID}.json`), JSON.stringify(messageMeta, null, 2));
     const partDir = join5(PART_STORAGE, messageID);
-    if (!existsSync3(partDir)) {
+    if (!existsSync4(partDir)) {
       mkdirSync(partDir, { recursive: true });
     }
     writeFileSync(join5(partDir, `${partID}.json`), JSON.stringify(textPart, null, 2));
@@ -3376,14 +3416,14 @@ Incomplete tasks remain in your todo list. Continue working on the next pending
 - Mark each task complete when finished
 - Do not stop until all tasks are done`;
 function getMessageDir(sessionID) {
-  if (!existsSync4(MESSAGE_STORAGE))
+  if (!existsSync5(MESSAGE_STORAGE))
     return null;
   const directPath = join6(MESSAGE_STORAGE, sessionID);
-  if (existsSync4(directPath))
+  if (existsSync5(directPath))
     return directPath;
   for (const dir of readdirSync2(MESSAGE_STORAGE)) {
     const sessionPath = join6(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync4(sessionPath))
+    if (existsSync5(sessionPath))
       return sessionPath;
   }
   return null;
@@ -3408,7 +3448,7 @@ function detectInterrupt(error) {
   }
   return false;
 }
-var COUNTDOWN_SECONDS = 5;
+var COUNTDOWN_SECONDS = 2;
 var TOAST_DURATION_MS = 900;
 function createTodoContinuationEnforcer(ctx) {
   const remindedSessions = new Set;
@@ -3572,8 +3612,10 @@ function createTodoContinuationEnforcer(ctx) {
     if (event.type === "message.updated") {
       const info = props?.info;
       const sessionID = info?.sessionID;
-      log(`[${HOOK_NAME}] message.updated received`, { sessionID, role: info?.role });
-      if (sessionID && info?.role === "user") {
+      const role = info?.role;
+      const finish = info?.finish;
+      log(`[${HOOK_NAME}] message.updated received`, { sessionID, role, finish });
+      if (sessionID && role === "user") {
         const countdown = pendingCountdowns.get(sessionID);
         if (countdown) {
           clearInterval(countdown.intervalId);
@@ -3581,9 +3623,9 @@ function createTodoContinuationEnforcer(ctx) {
           log(`[${HOOK_NAME}] Cancelled countdown on user message`, { sessionID });
         }
       }
-      if (sessionID && info?.role === "assistant" && remindedSessions.has(sessionID)) {
+      if (sessionID && role === "assistant" && finish) {
         remindedSessions.delete(sessionID);
-        log(`[${HOOK_NAME}] Cleared remindedSessions on assistant response`, { sessionID });
+        log(`[${HOOK_NAME}] Cleared reminded state on assistant finish`, { sessionID });
       }
     }
     if (event.type === "session.deleted") {
@@ -3898,7 +3940,7 @@ function createSessionNotification(ctx, config = {}) {
   };
 }
 // src/hooks/session-recovery/storage.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { join as join8 } from "path";
 
 // src/hooks/session-recovery/constants.ts
@@ -3938,15 +3980,15 @@ function generatePartId2() {
   return `prt_${timestamp}${random}`;
 }
 function getMessageDir2(sessionID) {
-  if (!existsSync5(MESSAGE_STORAGE2))
+  if (!existsSync6(MESSAGE_STORAGE2))
     return "";
   const directPath = join8(MESSAGE_STORAGE2, sessionID);
-  if (existsSync5(directPath)) {
+  if (existsSync6(directPath)) {
     return directPath;
   }
   for (const dir of readdirSync3(MESSAGE_STORAGE2)) {
     const sessionPath = join8(MESSAGE_STORAGE2, dir, sessionID);
-    if (existsSync5(sessionPath)) {
+    if (existsSync6(sessionPath)) {
       return sessionPath;
     }
   }
@@ -3954,7 +3996,7 @@ function getMessageDir2(sessionID) {
 }
 function readMessages(sessionID) {
   const messageDir = getMessageDir2(sessionID);
-  if (!messageDir || !existsSync5(messageDir))
+  if (!messageDir || !existsSync6(messageDir))
     return [];
   const messages = [];
   for (const file of readdirSync3(messageDir)) {
@@ -3977,7 +4019,7 @@ function readMessages(sessionID) {
 }
 function readParts(messageID) {
   const partDir = join8(PART_STORAGE2, messageID);
-  if (!existsSync5(partDir))
+  if (!existsSync6(partDir))
     return [];
   const parts = [];
   for (const file of readdirSync3(partDir)) {
@@ -4015,7 +4057,7 @@ function messageHasContent(messageID) {
 }
 function injectTextPart(sessionID, messageID, text) {
   const partDir = join8(PART_STORAGE2, messageID);
-  if (!existsSync5(partDir)) {
+  if (!existsSync6(partDir)) {
     mkdirSync2(partDir, { recursive: true });
   }
   const partId = generatePartId2();
@@ -4044,6 +4086,19 @@ function findEmptyMessages(sessionID) {
   }
   return emptyIds;
 }
+function findEmptyMessageByIndex(sessionID, targetIndex) {
+  const messages = readMessages(sessionID);
+  const indicesToTry = [targetIndex, targetIndex - 1, targetIndex - 2];
+  for (const idx of indicesToTry) {
+    if (idx < 0 || idx >= messages.length)
+      continue;
+    const targetMsg = messages[idx];
+    if (!messageHasContent(targetMsg.id)) {
+      return targetMsg.id;
+    }
+  }
+  return null;
+}
 function findMessagesWithThinkingBlocks(sessionID) {
   const messages = readMessages(sessionID);
   const result = [];
@@ -4079,7 +4134,7 @@ function findMessagesWithOrphanThinking(sessionID) {
 }
 function prependThinkingPart(sessionID, messageID) {
   const partDir = join8(PART_STORAGE2, messageID);
-  if (!existsSync5(partDir)) {
+  if (!existsSync6(partDir)) {
     mkdirSync2(partDir, { recursive: true });
   }
   const partId = `prt_0000000000_thinking`;
@@ -4100,7 +4155,7 @@ function prependThinkingPart(sessionID, messageID) {
 }
 function stripThinkingParts(messageID) {
   const partDir = join8(PART_STORAGE2, messageID);
-  if (!existsSync5(partDir))
+  if (!existsSync6(partDir))
     return false;
   let anyRemoved = false;
   for (const file of readdirSync3(partDir)) {
@@ -4120,6 +4175,33 @@ function stripThinkingParts(messageID) {
   }
   return anyRemoved;
 }
+function replaceEmptyTextParts(messageID, replacementText) {
+  const partDir = join8(PART_STORAGE2, messageID);
+  if (!existsSync6(partDir))
+    return false;
+  let anyReplaced = false;
+  for (const file of readdirSync3(partDir)) {
+    if (!file.endsWith(".json"))
+      continue;
+    try {
+      const filePath = join8(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 findMessageByIndexNeedingThinking(sessionID, targetIndex) {
   const messages = readMessages(sessionID);
   if (targetIndex < 0 || targetIndex >= messages.length)
@@ -4380,13 +4462,13 @@ function createSessionRecoveryHook(ctx, options) {
 var {spawn: spawn3 } = globalThis.Bun;
 import { createRequire as createRequire2 } from "module";
 import { dirname, join as join10 } from "path";
-import { existsSync as existsSync7 } from "fs";
-import * as fs2 from "fs";
+import { existsSync as existsSync8 } from "fs";
+import * as fs3 from "fs";
 import { tmpdir as tmpdir3 } from "os";
 
 // src/hooks/comment-checker/downloader.ts
 var {spawn: spawn2 } = globalThis.Bun;
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, chmodSync, unlinkSync as unlinkSync2, appendFileSync as appendFileSync2 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, chmodSync, unlinkSync as unlinkSync2, appendFileSync as appendFileSync2 } from "fs";
 import { join as join9 } from "path";
 import { homedir as homedir4, tmpdir as tmpdir2 } from "os";
 import { createRequire } from "module";
@@ -4417,7 +4499,7 @@ function getBinaryName() {
 }
 function getCachedBinaryPath() {
   const binaryPath = join9(getCacheDir(), getBinaryName());
-  return existsSync6(binaryPath) ? binaryPath : null;
+  return existsSync7(binaryPath) ? binaryPath : null;
 }
 function getPackageVersion() {
   try {
@@ -4465,7 +4547,7 @@ async function downloadCommentChecker() {
   const cacheDir = getCacheDir();
   const binaryName = getBinaryName();
   const binaryPath = join9(cacheDir, binaryName);
-  if (existsSync6(binaryPath)) {
+  if (existsSync7(binaryPath)) {
     debugLog("Binary already cached at:", binaryPath);
     return binaryPath;
   }
@@ -4476,7 +4558,7 @@ async function downloadCommentChecker() {
   debugLog(`Downloading from: ${downloadUrl}`);
   console.log(`[oh-my-opencode] Downloading comment-checker binary...`);
   try {
-    if (!existsSync6(cacheDir)) {
+    if (!existsSync7(cacheDir)) {
       mkdirSync3(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
@@ -4492,10 +4574,10 @@ async function downloadCommentChecker() {
     } else {
       await extractZip(archivePath, cacheDir);
     }
-    if (existsSync6(archivePath)) {
+    if (existsSync7(archivePath)) {
       unlinkSync2(archivePath);
     }
-    if (process.platform !== "win32" && existsSync6(binaryPath)) {
+    if (process.platform !== "win32" && existsSync7(binaryPath)) {
       chmodSync(binaryPath, 493);
     }
     debugLog(`Successfully downloaded binary to: ${binaryPath}`);
@@ -4524,7 +4606,7 @@ function debugLog2(...args) {
   if (DEBUG2) {
     const msg = `[${new Date().toISOString()}] [comment-checker:cli] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
 `;
-    fs2.appendFileSync(DEBUG_FILE2, msg);
+    fs3.appendFileSync(DEBUG_FILE2, msg);
   }
 }
 function getBinaryName2() {
@@ -4537,7 +4619,7 @@ function findCommentCheckerPathSync() {
     const cliPkgPath = require2.resolve("@code-yeongyu/comment-checker/package.json");
     const cliDir = dirname(cliPkgPath);
     const binaryPath = join10(cliDir, "bin", binaryName);
-    if (existsSync7(binaryPath)) {
+    if (existsSync8(binaryPath)) {
       debugLog2("found binary in main package:", binaryPath);
       return binaryPath;
     }
@@ -4563,7 +4645,7 @@ async function getCommentCheckerPath() {
   }
   initPromise = (async () => {
     const syncPath = findCommentCheckerPathSync();
-    if (syncPath && existsSync7(syncPath)) {
+    if (syncPath && existsSync8(syncPath)) {
       resolvedCliPath = syncPath;
       debugLog2("using sync-resolved path:", syncPath);
       return syncPath;
@@ -4597,7 +4679,7 @@ async function runCommentChecker(input, cliPath) {
     debugLog2("comment-checker binary not found");
     return { hasComments: false, message: "" };
   }
-  if (!existsSync7(binaryPath)) {
+  if (!existsSync8(binaryPath)) {
     debugLog2("comment-checker binary does not exist:", binaryPath);
     return { hasComments: false, message: "" };
   }
@@ -4630,8 +4712,8 @@ async function runCommentChecker(input, cliPath) {
 }
 
 // src/hooks/comment-checker/index.ts
-import * as fs3 from "fs";
-import { existsSync as existsSync8 } from "fs";
+import * as fs4 from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
 import { join as join11 } from "path";
 var DEBUG3 = process.env.COMMENT_CHECKER_DEBUG === "1";
@@ -4640,7 +4722,7 @@ function debugLog3(...args) {
   if (DEBUG3) {
     const msg = `[${new Date().toISOString()}] [comment-checker:hook] ${args.map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)).join(" ")}
 `;
-    fs3.appendFileSync(DEBUG_FILE3, msg);
+    fs4.appendFileSync(DEBUG_FILE3, msg);
   }
 }
 var pendingCalls = new Map;
@@ -4711,7 +4793,7 @@ function createCommentCheckerHooks() {
       }
       try {
         const cliPath = await cliPathPromise;
-        if (!cliPath || !existsSync8(cliPath)) {
+        if (!cliPath || !existsSync9(cliPath)) {
           debugLog3("CLI not available, skipping comment check");
           return;
         }
@@ -4782,12 +4864,12 @@ function createToolOutputTruncatorHook(ctx) {
   };
 }
 // src/hooks/directory-agents-injector/index.ts
-import { existsSync as existsSync10, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync5 } from "fs";
 import { dirname as dirname2, join as join14, resolve as resolve2 } from "path";
 
 // src/hooks/directory-agents-injector/storage.ts
 import {
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   mkdirSync as mkdirSync4,
   readFileSync as readFileSync4,
   writeFileSync as writeFileSync3,
@@ -4807,7 +4889,7 @@ function getStoragePath(sessionID) {
 }
 function loadInjectedPaths(sessionID) {
   const filePath = getStoragePath(sessionID);
-  if (!existsSync9(filePath))
+  if (!existsSync10(filePath))
     return new Set;
   try {
     const content = readFileSync4(filePath, "utf-8");
@@ -4818,7 +4900,7 @@ function loadInjectedPaths(sessionID) {
   }
 }
 function saveInjectedPaths(sessionID, paths) {
-  if (!existsSync9(AGENTS_INJECTOR_STORAGE)) {
+  if (!existsSync10(AGENTS_INJECTOR_STORAGE)) {
     mkdirSync4(AGENTS_INJECTOR_STORAGE, { recursive: true });
   }
   const data = {
@@ -4830,7 +4912,7 @@ function saveInjectedPaths(sessionID, paths) {
 }
 function clearInjectedPaths(sessionID) {
   const filePath = getStoragePath(sessionID);
-  if (existsSync9(filePath)) {
+  if (existsSync10(filePath)) {
     unlinkSync3(filePath);
   }
 }
@@ -4838,25 +4920,26 @@ function clearInjectedPaths(sessionID) {
 // src/hooks/directory-agents-injector/index.ts
 function createDirectoryAgentsInjectorHook(ctx) {
   const sessionCaches = new Map;
+  const pendingBatchReads = new Map;
   function getSessionCache(sessionID) {
     if (!sessionCaches.has(sessionID)) {
       sessionCaches.set(sessionID, loadInjectedPaths(sessionID));
     }
     return sessionCaches.get(sessionID);
   }
-  function resolveFilePath2(title) {
-    if (!title)
+  function resolveFilePath2(path4) {
+    if (!path4)
       return null;
-    if (title.startsWith("/"))
-      return title;
-    return resolve2(ctx.directory, title);
+    if (path4.startsWith("/"))
+      return path4;
+    return resolve2(ctx.directory, path4);
   }
   function findAgentsMdUp(startDir) {
     const found = [];
     let current = startDir;
     while (true) {
       const agentsPath = join14(current, AGENTS_FILENAME);
-      if (existsSync10(agentsPath)) {
+      if (existsSync11(agentsPath)) {
         found.push(agentsPath);
       }
       if (current === ctx.directory)
@@ -4870,35 +4953,59 @@ function createDirectoryAgentsInjectorHook(ctx) {
     }
     return found.reverse();
   }
-  const toolExecuteAfter = async (input, output) => {
-    if (input.tool.toLowerCase() !== "read")
+  function processFilePathForInjection(filePath, sessionID, output) {
+    const resolved = resolveFilePath2(filePath);
+    if (!resolved)
       return;
-    const filePath = resolveFilePath2(output.title);
-    if (!filePath)
-      return;
-    const dir = dirname2(filePath);
-    const cache = getSessionCache(input.sessionID);
+    const dir = dirname2(resolved);
+    const cache = getSessionCache(sessionID);
     const agentsPaths = findAgentsMdUp(dir);
-    const toInject = [];
     for (const agentsPath of agentsPaths) {
       const agentsDir = dirname2(agentsPath);
       if (cache.has(agentsDir))
         continue;
       try {
         const content = readFileSync5(agentsPath, "utf-8");
-        toInject.push({ path: agentsPath, content });
+        output.output += `
+
+[Directory Context: ${agentsPath}]
+${content}`;
         cache.add(agentsDir);
       } catch {}
     }
-    if (toInject.length === 0)
+    saveInjectedPaths(sessionID, cache);
+  }
+  const toolExecuteBefore = async (input, output) => {
+    if (input.tool.toLowerCase() !== "batch")
       return;
-    for (const { path: path4, content } of toInject) {
-      output.output += `
-
-[Directory Context: ${path4}]
-${content}`;
+    const args = output.args;
+    if (!args?.tool_calls)
+      return;
+    const readFilePaths = [];
+    for (const call of args.tool_calls) {
+      if (call.tool.toLowerCase() === "read" && call.parameters?.filePath) {
+        readFilePaths.push(call.parameters.filePath);
+      }
+    }
+    if (readFilePaths.length > 0) {
+      pendingBatchReads.set(input.callID, readFilePaths);
+    }
+  };
+  const toolExecuteAfter = async (input, output) => {
+    const toolName = input.tool.toLowerCase();
+    if (toolName === "read") {
+      processFilePathForInjection(output.title, input.sessionID, output);
+      return;
+    }
+    if (toolName === "batch") {
+      const filePaths = pendingBatchReads.get(input.callID);
+      if (filePaths) {
+        for (const filePath of filePaths) {
+          processFilePathForInjection(filePath, input.sessionID, output);
+        }
+        pendingBatchReads.delete(input.callID);
+      }
     }
-    saveInjectedPaths(input.sessionID, cache);
   };
   const eventHandler = async ({ event }) => {
     const props = event.properties;
@@ -4918,17 +5025,18 @@ ${content}`;
     }
   };
   return {
+    "tool.execute.before": toolExecuteBefore,
     "tool.execute.after": toolExecuteAfter,
     event: eventHandler
   };
 }
 // src/hooks/directory-readme-injector/index.ts
-import { existsSync as existsSync12, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync7 } from "fs";
 import { dirname as dirname3, join as join17, resolve as resolve3 } from "path";
 
 // src/hooks/directory-readme-injector/storage.ts
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync12,
   mkdirSync as mkdirSync5,
   readFileSync as readFileSync6,
   writeFileSync as writeFileSync4,
@@ -4948,7 +5056,7 @@ function getStoragePath2(sessionID) {
 }
 function loadInjectedPaths2(sessionID) {
   const filePath = getStoragePath2(sessionID);
-  if (!existsSync11(filePath))
+  if (!existsSync12(filePath))
     return new Set;
   try {
     const content = readFileSync6(filePath, "utf-8");
@@ -4959,7 +5067,7 @@ function loadInjectedPaths2(sessionID) {
   }
 }
 function saveInjectedPaths2(sessionID, paths) {
-  if (!existsSync11(README_INJECTOR_STORAGE)) {
+  if (!existsSync12(README_INJECTOR_STORAGE)) {
     mkdirSync5(README_INJECTOR_STORAGE, { recursive: true });
   }
   const data = {
@@ -4971,7 +5079,7 @@ function saveInjectedPaths2(sessionID, paths) {
 }
 function clearInjectedPaths2(sessionID) {
   const filePath = getStoragePath2(sessionID);
-  if (existsSync11(filePath)) {
+  if (existsSync12(filePath)) {
     unlinkSync4(filePath);
   }
 }
@@ -4979,25 +5087,26 @@ function clearInjectedPaths2(sessionID) {
 // src/hooks/directory-readme-injector/index.ts
 function createDirectoryReadmeInjectorHook(ctx) {
   const sessionCaches = new Map;
+  const pendingBatchReads = new Map;
   function getSessionCache(sessionID) {
     if (!sessionCaches.has(sessionID)) {
       sessionCaches.set(sessionID, loadInjectedPaths2(sessionID));
     }
     return sessionCaches.get(sessionID);
   }
-  function resolveFilePath2(title) {
-    if (!title)
+  function resolveFilePath2(path4) {
+    if (!path4)
       return null;
-    if (title.startsWith("/"))
-      return title;
-    return resolve3(ctx.directory, title);
+    if (path4.startsWith("/"))
+      return path4;
+    return resolve3(ctx.directory, path4);
   }
   function findReadmeMdUp(startDir) {
     const found = [];
     let current = startDir;
     while (true) {
       const readmePath = join17(current, README_FILENAME);
-      if (existsSync12(readmePath)) {
+      if (existsSync13(readmePath)) {
         found.push(readmePath);
       }
       if (current === ctx.directory)
@@ -5011,35 +5120,59 @@ function createDirectoryReadmeInjectorHook(ctx) {
     }
     return found.reverse();
   }
-  const toolExecuteAfter = async (input, output) => {
-    if (input.tool.toLowerCase() !== "read")
+  function processFilePathForInjection(filePath, sessionID, output) {
+    const resolved = resolveFilePath2(filePath);
+    if (!resolved)
       return;
-    const filePath = resolveFilePath2(output.title);
-    if (!filePath)
-      return;
-    const dir = dirname3(filePath);
-    const cache = getSessionCache(input.sessionID);
+    const dir = dirname3(resolved);
+    const cache = getSessionCache(sessionID);
     const readmePaths = findReadmeMdUp(dir);
-    const toInject = [];
     for (const readmePath of readmePaths) {
       const readmeDir = dirname3(readmePath);
       if (cache.has(readmeDir))
         continue;
       try {
         const content = readFileSync7(readmePath, "utf-8");
-        toInject.push({ path: readmePath, content });
+        output.output += `
+
+[Project README: ${readmePath}]
+${content}`;
         cache.add(readmeDir);
       } catch {}
     }
-    if (toInject.length === 0)
+    saveInjectedPaths2(sessionID, cache);
+  }
+  const toolExecuteBefore = async (input, output) => {
+    if (input.tool.toLowerCase() !== "batch")
       return;
-    for (const { path: path4, content } of toInject) {
-      output.output += `
-
-[Project README: ${path4}]
-${content}`;
+    const args = output.args;
+    if (!args?.tool_calls)
+      return;
+    const readFilePaths = [];
+    for (const call of args.tool_calls) {
+      if (call.tool.toLowerCase() === "read" && call.parameters?.filePath) {
+        readFilePaths.push(call.parameters.filePath);
+      }
+    }
+    if (readFilePaths.length > 0) {
+      pendingBatchReads.set(input.callID, readFilePaths);
+    }
+  };
+  const toolExecuteAfter = async (input, output) => {
+    const toolName = input.tool.toLowerCase();
+    if (toolName === "read") {
+      processFilePathForInjection(output.title, input.sessionID, output);
+      return;
+    }
+    if (toolName === "batch") {
+      const filePaths = pendingBatchReads.get(input.callID);
+      if (filePaths) {
+        for (const filePath of filePaths) {
+          processFilePathForInjection(filePath, input.sessionID, output);
+        }
+        pendingBatchReads.delete(input.callID);
+      }
     }
-    saveInjectedPaths2(input.sessionID, cache);
   };
   const eventHandler = async ({ event }) => {
     const props = event.properties;
@@ -5059,6 +5192,7 @@ ${content}`;
     }
   };
   return {
+    "tool.execute.before": toolExecuteBefore,
     "tool.execute.after": toolExecuteAfter,
     event: eventHandler
   };
@@ -5102,6 +5236,7 @@ var TOKEN_LIMIT_KEYWORDS = [
   "too many tokens",
   "non-empty content"
 ];
+var MESSAGE_INDEX_PATTERN = /messages\.(\d+)/;
 function extractTokensFromMessage(message) {
   for (const pattern of TOKEN_LIMIT_PATTERNS) {
     const match = message.match(pattern);
@@ -5113,6 +5248,13 @@ function extractTokensFromMessage(message) {
   }
   return null;
 }
+function extractMessageIndex2(text) {
+  const match = text.match(MESSAGE_INDEX_PATTERN);
+  if (match) {
+    return parseInt(match[1], 10);
+  }
+  return;
+}
 function isTokenLimitError(text) {
   const lower = text.toLowerCase();
   return TOKEN_LIMIT_KEYWORDS.some((kw) => lower.includes(kw.toLowerCase()));
@@ -5123,7 +5265,8 @@ function parseAnthropicTokenLimitError(err) {
       return {
         currentTokens: 0,
         maxTokens: 0,
-        errorType: "non-empty content"
+        errorType: "non-empty content",
+        messageIndex: extractMessageIndex2(err)
       };
     }
     if (isTokenLimitError(err)) {
@@ -5225,7 +5368,8 @@ function parseAnthropicTokenLimitError(err) {
     return {
       currentTokens: 0,
       maxTokens: 0,
-      errorType: "non-empty content"
+      errorType: "non-empty content",
+      messageIndex: extractMessageIndex2(combinedText)
     };
   }
   if (isTokenLimitError(combinedText)) {
@@ -5257,13 +5401,13 @@ var TRUNCATE_CONFIG = {
 };
 
 // src/hooks/anthropic-auto-compact/storage.ts
-import { existsSync as existsSync13, readdirSync as readdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync14, readdirSync as readdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
 import { homedir as homedir5 } from "os";
 import { join as join18 } from "path";
 var OPENCODE_STORAGE5 = join18(xdgData2 ?? "", "opencode", "storage");
-if (process.platform === "darwin" && !existsSync13(OPENCODE_STORAGE5)) {
+if (process.platform === "darwin" && !existsSync14(OPENCODE_STORAGE5)) {
   const localShare = join18(homedir5(), ".local", "share", "opencode", "storage");
-  if (existsSync13(localShare)) {
+  if (existsSync14(localShare)) {
     OPENCODE_STORAGE5 = localShare;
   }
 }
@@ -5271,15 +5415,15 @@ var MESSAGE_STORAGE3 = join18(OPENCODE_STORAGE5, "message");
 var PART_STORAGE3 = join18(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))
+  if (!existsSync14(MESSAGE_STORAGE3))
     return "";
   const directPath = join18(MESSAGE_STORAGE3, sessionID);
-  if (existsSync13(directPath)) {
+  if (existsSync14(directPath)) {
     return directPath;
   }
   for (const dir of readdirSync4(MESSAGE_STORAGE3)) {
     const sessionPath = join18(MESSAGE_STORAGE3, dir, sessionID);
-    if (existsSync13(sessionPath)) {
+    if (existsSync14(sessionPath)) {
       return sessionPath;
     }
   }
@@ -5287,7 +5431,7 @@ function getMessageDir3(sessionID) {
 }
 function getMessageIds(sessionID) {
   const messageDir = getMessageDir3(sessionID);
-  if (!messageDir || !existsSync13(messageDir))
+  if (!messageDir || !existsSync14(messageDir))
     return [];
   const messageIds = [];
   for (const file of readdirSync4(messageDir)) {
@@ -5303,7 +5447,7 @@ function findToolResultsBySize(sessionID) {
   const results = [];
   for (const messageID of messageIds) {
     const partDir = join18(PART_STORAGE3, messageID);
-    if (!existsSync13(partDir))
+    if (!existsSync14(partDir))
       continue;
     for (const file of readdirSync4(partDir)) {
       if (!file.endsWith(".json"))
@@ -5508,32 +5652,59 @@ function clearSessionState(autoCompactState, sessionID) {
 function getOrCreateEmptyContentAttempt(autoCompactState, sessionID) {
   return autoCompactState.emptyContentAttemptBySession.get(sessionID) ?? 0;
 }
-async function fixEmptyMessages(sessionID, autoCompactState, client) {
+async function fixEmptyMessages(sessionID, autoCompactState, client, messageIndex) {
   const attempt = getOrCreateEmptyContentAttempt(autoCompactState, sessionID);
   autoCompactState.emptyContentAttemptBySession.set(sessionID, attempt + 1);
-  const emptyMessageIds = findEmptyMessages(sessionID);
-  if (emptyMessageIds.length === 0) {
-    await client.tui.showToast({
-      body: {
-        title: "Empty Content Error",
-        message: "No empty messages found in storage. Cannot auto-recover.",
-        variant: "error",
-        duration: 5000
+  let fixed = false;
+  const fixedMessageIds = [];
+  if (messageIndex !== undefined) {
+    const targetMessageId = findEmptyMessageByIndex(sessionID, messageIndex);
+    if (targetMessageId) {
+      const replaced = replaceEmptyTextParts(targetMessageId, "[user interrupted]");
+      if (replaced) {
+        fixed = true;
+        fixedMessageIds.push(targetMessageId);
+      } else {
+        const injected = injectTextPart(sessionID, targetMessageId, "[user interrupted]");
+        if (injected) {
+          fixed = true;
+          fixedMessageIds.push(targetMessageId);
+        }
       }
-    }).catch(() => {});
-    return false;
+    }
   }
-  let fixed = false;
-  for (const messageID of emptyMessageIds) {
-    const success = injectTextPart(sessionID, messageID, "[user interrupted]");
-    if (success)
-      fixed = true;
+  if (!fixed) {
+    const emptyMessageIds = findEmptyMessages(sessionID);
+    if (emptyMessageIds.length === 0) {
+      await client.tui.showToast({
+        body: {
+          title: "Empty Content Error",
+          message: "No empty messages found in storage. Cannot auto-recover.",
+          variant: "error",
+          duration: 5000
+        }
+      }).catch(() => {});
+      return false;
+    }
+    for (const messageID of emptyMessageIds) {
+      const replaced = replaceEmptyTextParts(messageID, "[user interrupted]");
+      if (replaced) {
+        fixed = true;
+        fixedMessageIds.push(messageID);
+      } else {
+        const injected = injectTextPart(sessionID, messageID, "[user interrupted]");
+        if (injected) {
+          fixed = true;
+          fixedMessageIds.push(messageID);
+        }
+      }
+    }
   }
   if (fixed) {
     await client.tui.showToast({
       body: {
         title: "Session Recovery",
-        message: `Fixed ${emptyMessageIds.length} empty messages. Retrying...`,
+        message: `Fixed ${fixedMessageIds.length} empty message(s). Retrying...`,
         variant: "warning",
         duration: 3000
       }
@@ -5642,10 +5813,10 @@ async function executeCompact(sessionID, msg, autoCompactState, client, director
     }
   }
   const retryState = getOrCreateRetryState(autoCompactState, sessionID);
-  if (experimental?.empty_message_recovery && errorData?.errorType?.includes("non-empty content")) {
+  if (errorData?.errorType?.includes("non-empty content")) {
     const attempt = getOrCreateEmptyContentAttempt(autoCompactState, sessionID);
     if (attempt < 3) {
-      const fixed = await fixEmptyMessages(sessionID, autoCompactState, client);
+      const fixed = await fixEmptyMessages(sessionID, autoCompactState, client, errorData.messageIndex);
       if (fixed) {
         autoCompactState.compactionInProgress.delete(sessionID);
         setTimeout(() => {
@@ -5888,6 +6059,200 @@ function createAnthropicAutoCompactHook(ctx, options) {
     event: eventHandler
   };
 }
+// src/hooks/preemptive-compaction/constants.ts
+var DEFAULT_THRESHOLD = 0.85;
+var MIN_TOKENS_FOR_COMPACTION = 50000;
+var COMPACTION_COOLDOWN_MS = 60000;
+
+// src/hooks/preemptive-compaction/index.ts
+var CLAUDE_MODEL_PATTERN = /claude-(opus|sonnet|haiku)/i;
+var CLAUDE_DEFAULT_CONTEXT_LIMIT = 200000;
+function isSupportedModel(modelID) {
+  return CLAUDE_MODEL_PATTERN.test(modelID);
+}
+function createState() {
+  return {
+    lastCompactionTime: new Map,
+    compactionInProgress: new Set
+  };
+}
+function createPreemptiveCompactionHook(ctx, options) {
+  const experimental = options?.experimental;
+  const onBeforeSummarize = options?.onBeforeSummarize;
+  const getModelLimit = options?.getModelLimit;
+  const enabled = experimental?.preemptive_compaction !== false;
+  const threshold = experimental?.preemptive_compaction_threshold ?? DEFAULT_THRESHOLD;
+  if (!enabled) {
+    return { event: async () => {} };
+  }
+  const state2 = createState();
+  const checkAndTriggerCompaction = async (sessionID, lastAssistant) => {
+    if (state2.compactionInProgress.has(sessionID))
+      return;
+    const lastCompaction = state2.lastCompactionTime.get(sessionID) ?? 0;
+    if (Date.now() - lastCompaction < COMPACTION_COOLDOWN_MS)
+      return;
+    if (lastAssistant.summary === true)
+      return;
+    const tokens = lastAssistant.tokens;
+    if (!tokens)
+      return;
+    const modelID = lastAssistant.modelID ?? "";
+    const providerID = lastAssistant.providerID ?? "";
+    if (!isSupportedModel(modelID)) {
+      log("[preemptive-compaction] skipping unsupported model", { modelID });
+      return;
+    }
+    const configLimit = getModelLimit?.(providerID, modelID);
+    const contextLimit = configLimit ?? CLAUDE_DEFAULT_CONTEXT_LIMIT;
+    const totalUsed = tokens.input + tokens.cache.read + tokens.output;
+    if (totalUsed < MIN_TOKENS_FOR_COMPACTION)
+      return;
+    const usageRatio = totalUsed / contextLimit;
+    log("[preemptive-compaction] checking", {
+      sessionID,
+      totalUsed,
+      contextLimit,
+      usageRatio: usageRatio.toFixed(2),
+      threshold
+    });
+    if (usageRatio < threshold)
+      return;
+    state2.compactionInProgress.add(sessionID);
+    state2.lastCompactionTime.set(sessionID, Date.now());
+    if (!providerID || !modelID) {
+      state2.compactionInProgress.delete(sessionID);
+      return;
+    }
+    await ctx.client.tui.showToast({
+      body: {
+        title: "Preemptive Compaction",
+        message: `Context at ${(usageRatio * 100).toFixed(0)}% - compacting to prevent overflow...`,
+        variant: "warning",
+        duration: 3000
+      }
+    }).catch(() => {});
+    log("[preemptive-compaction] triggering compaction", { sessionID, usageRatio });
+    try {
+      if (onBeforeSummarize) {
+        await onBeforeSummarize({
+          sessionID,
+          providerID,
+          modelID,
+          usageRatio,
+          directory: ctx.directory
+        });
+      }
+      await ctx.client.session.summarize({
+        path: { id: sessionID },
+        body: { providerID, modelID },
+        query: { directory: ctx.directory }
+      });
+      await ctx.client.tui.showToast({
+        body: {
+          title: "Compaction Complete",
+          message: "Session compacted successfully",
+          variant: "success",
+          duration: 2000
+        }
+      }).catch(() => {});
+    } catch (err) {
+      log("[preemptive-compaction] compaction failed", { sessionID, error: err });
+    } finally {
+      state2.compactionInProgress.delete(sessionID);
+    }
+  };
+  const eventHandler = async ({ event }) => {
+    const props = event.properties;
+    if (event.type === "session.deleted") {
+      const sessionInfo = props?.info;
+      if (sessionInfo?.id) {
+        state2.lastCompactionTime.delete(sessionInfo.id);
+        state2.compactionInProgress.delete(sessionInfo.id);
+      }
+      return;
+    }
+    if (event.type === "message.updated") {
+      const info = props?.info;
+      if (!info)
+        return;
+      if (info.role !== "assistant" || !info.finish)
+        return;
+      const sessionID = info.sessionID;
+      if (!sessionID)
+        return;
+      await checkAndTriggerCompaction(sessionID, info);
+      return;
+    }
+    if (event.type === "session.idle") {
+      const sessionID = props?.sessionID;
+      if (!sessionID)
+        return;
+      try {
+        const resp = await ctx.client.session.messages({
+          path: { id: sessionID },
+          query: { directory: ctx.directory }
+        });
+        const messages = resp.data ?? resp;
+        const assistants = messages.filter((m) => m.info.role === "assistant").map((m) => m.info);
+        if (assistants.length === 0)
+          return;
+        const lastAssistant = assistants[assistants.length - 1];
+        await checkAndTriggerCompaction(sessionID, lastAssistant);
+      } catch {}
+    }
+  };
+  return {
+    event: eventHandler
+  };
+}
+// src/hooks/compaction-context-injector/index.ts
+var SUMMARIZE_CONTEXT_PROMPT = `[COMPACTION CONTEXT INJECTION]
+
+When summarizing this session, you MUST include the following sections in your summary:
+
+## 1. User Requests (As-Is)
+- List all original user requests exactly as they were stated
+- Preserve the user's exact wording and intent
+
+## 2. Final Goal
+- What the user ultimately wanted to achieve
+- The end result or deliverable expected
+
+## 3. Work Completed
+- What has been done so far
+- Files created/modified
+- Features implemented
+- Problems solved
+
+## 4. Remaining Tasks
+- What still needs to be done
+- Pending items from the original request
+- Follow-up tasks identified during the work
+
+## 5. MUST NOT Do (Critical Constraints)
+- Things that were explicitly forbidden
+- Approaches that failed and should not be retried
+- User's explicit restrictions or preferences
+- Anti-patterns identified during the session
+
+This context is critical for maintaining continuity after compaction.
+`;
+function createCompactionContextInjector() {
+  return async (ctx) => {
+    log("[compaction-context-injector] injecting context", { sessionID: ctx.sessionID });
+    const success = injectHookMessage(ctx.sessionID, SUMMARIZE_CONTEXT_PROMPT, {
+      agent: "general",
+      model: { providerID: ctx.providerID, modelID: ctx.modelID },
+      path: { cwd: ctx.directory }
+    });
+    if (success) {
+      log("[compaction-context-injector] context injected", { sessionID: ctx.sessionID });
+    } else {
+      log("[compaction-context-injector] injection failed", { sessionID: ctx.sessionID });
+    }
+  };
+}
 // src/hooks/think-mode/detector.ts
 var ENGLISH_PATTERNS = [/\bultrathink\b/i, /\bthink\b/i];
 var MULTILINGUAL_KEYWORDS = [
@@ -6157,7 +6522,7 @@ function createThinkModeHook() {
 // src/hooks/claude-code-hooks/config.ts
 import { homedir as homedir6 } from "os";
 import { join as join19 } from "path";
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 function normalizeHookMatcher(raw) {
   return {
     matcher: raw.matcher ?? raw.pattern ?? "*",
@@ -6186,7 +6551,7 @@ function getClaudeSettingsPaths(customPath) {
     join19(process.cwd(), ".claude", "settings.json"),
     join19(process.cwd(), ".claude", "settings.local.json")
   ];
-  if (customPath && existsSync14(customPath)) {
+  if (customPath && existsSync15(customPath)) {
     paths.unshift(customPath);
   }
   return paths;
@@ -6210,7 +6575,7 @@ async function loadClaudeHooksConfig(customSettingsPath) {
   const paths = getClaudeSettingsPaths(customSettingsPath);
   let mergedConfig = {};
   for (const settingsPath of paths) {
-    if (existsSync14(settingsPath)) {
+    if (existsSync15(settingsPath)) {
       try {
         const content = await Bun.file(settingsPath).text();
         const settings = JSON.parse(content);
@@ -6227,7 +6592,7 @@ async function loadClaudeHooksConfig(customSettingsPath) {
 }
 
 // src/hooks/claude-code-hooks/config-loader.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 import { homedir as homedir7 } from "os";
 import { join as join20 } from "path";
 var USER_CONFIG_PATH = join20(homedir7(), ".config", "opencode", "opencode-cc-plugin.json");
@@ -6235,7 +6600,7 @@ function getProjectConfigPath() {
   return join20(process.cwd(), ".opencode", "opencode-cc-plugin.json");
 }
 async function loadConfigFromPath(path4) {
-  if (!existsSync15(path4)) {
+  if (!existsSync16(path4)) {
     return null;
   }
   try {
@@ -6415,7 +6780,7 @@ async function executePreToolUseHooks(ctx, config, extendedConfig) {
 
 // src/hooks/claude-code-hooks/transcript.ts
 import { join as join21 } from "path";
-import { mkdirSync as mkdirSync6, appendFileSync as appendFileSync5, existsSync as existsSync16, writeFileSync as writeFileSync6, unlinkSync as unlinkSync5 } from "fs";
+import { mkdirSync as mkdirSync6, appendFileSync as appendFileSync5, existsSync as existsSync17, writeFileSync as writeFileSync6, unlinkSync as unlinkSync5 } from "fs";
 import { homedir as homedir8, tmpdir as tmpdir5 } from "os";
 import { randomUUID } from "crypto";
 var TRANSCRIPT_DIR = join21(homedir8(), ".claude", "transcripts");
@@ -6423,7 +6788,7 @@ function getTranscriptPath(sessionId) {
   return join21(TRANSCRIPT_DIR, `${sessionId}.jsonl`);
 }
 function ensureTranscriptDir() {
-  if (!existsSync16(TRANSCRIPT_DIR)) {
+  if (!existsSync17(TRANSCRIPT_DIR)) {
     mkdirSync6(TRANSCRIPT_DIR, { recursive: true });
   }
 }
@@ -7084,7 +7449,7 @@ import { relative as relative3, resolve as resolve4 } from "path";
 
 // src/hooks/rules-injector/finder.ts
 import {
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   readdirSync as readdirSync5,
   realpathSync,
   statSync as statSync2
@@ -7122,7 +7487,7 @@ function findProjectRoot(startPath) {
   while (true) {
     for (const marker of PROJECT_MARKERS) {
       const markerPath = join24(current, marker);
-      if (existsSync17(markerPath)) {
+      if (existsSync18(markerPath)) {
         return current;
       }
     }
@@ -7134,7 +7499,7 @@ function findProjectRoot(startPath) {
   }
 }
 function findRuleFilesRecursive(dir, results) {
-  if (!existsSync17(dir))
+  if (!existsSync18(dir))
     return;
   try {
     const entries = readdirSync5(dir, { withFileTypes: true });
@@ -7378,7 +7743,7 @@ function mergeGlobs(existing, newValue) {
 
 // src/hooks/rules-injector/storage.ts
 import {
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   mkdirSync as mkdirSync7,
   readFileSync as readFileSync9,
   writeFileSync as writeFileSync7,
@@ -7390,7 +7755,7 @@ function getStoragePath3(sessionID) {
 }
 function loadInjectedRules(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (!existsSync18(filePath))
+  if (!existsSync19(filePath))
     return { contentHashes: new Set, realPaths: new Set };
   try {
     const content = readFileSync9(filePath, "utf-8");
@@ -7404,7 +7769,7 @@ function loadInjectedRules(sessionID) {
   }
 }
 function saveInjectedRules(sessionID, data) {
-  if (!existsSync18(RULES_INJECTOR_STORAGE)) {
+  if (!existsSync19(RULES_INJECTOR_STORAGE)) {
     mkdirSync7(RULES_INJECTOR_STORAGE, { recursive: true });
   }
   const storageData = {
@@ -7417,7 +7782,7 @@ function saveInjectedRules(sessionID, data) {
 }
 function clearInjectedRules(sessionID) {
   const filePath = getStoragePath3(sessionID);
-  if (existsSync18(filePath)) {
+  if (existsSync19(filePath)) {
     unlinkSync6(filePath);
   }
 }
@@ -7426,29 +7791,28 @@ function clearInjectedRules(sessionID) {
 var TRACKED_TOOLS = ["read", "write", "edit", "multiedit"];
 function createRulesInjectorHook(ctx) {
   const sessionCaches = new Map;
+  const pendingBatchFiles = new Map;
   function getSessionCache(sessionID) {
     if (!sessionCaches.has(sessionID)) {
       sessionCaches.set(sessionID, loadInjectedRules(sessionID));
     }
     return sessionCaches.get(sessionID);
   }
-  function resolveFilePath2(title) {
-    if (!title)
+  function resolveFilePath2(path4) {
+    if (!path4)
       return null;
-    if (title.startsWith("/"))
-      return title;
-    return resolve4(ctx.directory, title);
+    if (path4.startsWith("/"))
+      return path4;
+    return resolve4(ctx.directory, path4);
   }
-  const toolExecuteAfter = async (input, output) => {
-    if (!TRACKED_TOOLS.includes(input.tool.toLowerCase()))
-      return;
-    const filePath = resolveFilePath2(output.title);
-    if (!filePath)
+  function processFilePathForInjection(filePath, sessionID, output) {
+    const resolved = resolveFilePath2(filePath);
+    if (!resolved)
       return;
-    const projectRoot = findProjectRoot(filePath);
-    const cache2 = getSessionCache(input.sessionID);
+    const projectRoot = findProjectRoot(resolved);
+    const cache2 = getSessionCache(sessionID);
     const home = homedir10();
-    const ruleFileCandidates = findRuleFiles(projectRoot, home, filePath);
+    const ruleFileCandidates = findRuleFiles(projectRoot, home, resolved);
     const toInject = [];
     for (const candidate of ruleFileCandidates) {
       if (isDuplicateByRealPath(candidate.realPath, cache2.realPaths))
@@ -7456,7 +7820,7 @@ function createRulesInjectorHook(ctx) {
       try {
         const rawContent = readFileSync10(candidate.path, "utf-8");
         const { metadata, body } = parseRuleFrontmatter(rawContent);
-        const matchResult = shouldApplyRule(metadata, filePath, projectRoot);
+        const matchResult = shouldApplyRule(metadata, resolved, projectRoot);
         if (!matchResult.applies)
           continue;
         const contentHash = createContentHash(body);
@@ -7483,7 +7847,46 @@ function createRulesInjectorHook(ctx) {
 [Match: ${rule.matchReason}]
 ${rule.content}`;
     }
-    saveInjectedRules(input.sessionID, cache2);
+    saveInjectedRules(sessionID, cache2);
+  }
+  function extractFilePathFromToolCall(call) {
+    const params = call.parameters;
+    return params?.filePath ?? params?.file_path ?? params?.path;
+  }
+  const toolExecuteBefore = async (input, output) => {
+    if (input.tool.toLowerCase() !== "batch")
+      return;
+    const args = output.args;
+    if (!args?.tool_calls)
+      return;
+    const filePaths = [];
+    for (const call of args.tool_calls) {
+      if (TRACKED_TOOLS.includes(call.tool.toLowerCase())) {
+        const filePath = extractFilePathFromToolCall(call);
+        if (filePath) {
+          filePaths.push(filePath);
+        }
+      }
+    }
+    if (filePaths.length > 0) {
+      pendingBatchFiles.set(input.callID, filePaths);
+    }
+  };
+  const toolExecuteAfter = async (input, output) => {
+    const toolName = input.tool.toLowerCase();
+    if (TRACKED_TOOLS.includes(toolName)) {
+      processFilePathForInjection(output.title, input.sessionID, output);
+      return;
+    }
+    if (toolName === "batch") {
+      const filePaths = pendingBatchFiles.get(input.callID);
+      if (filePaths) {
+        for (const filePath of filePaths) {
+          processFilePathForInjection(filePath, input.sessionID, output);
+        }
+        pendingBatchFiles.delete(input.callID);
+      }
+    }
   };
   const eventHandler = async ({ event }) => {
     const props = event.properties;
@@ -7503,6 +7906,7 @@ ${rule.content}`;
     }
   };
   return {
+    "tool.execute.before": toolExecuteBefore,
     "tool.execute.after": toolExecuteAfter,
     event: eventHandler
   };
@@ -7517,7 +7921,7 @@ function createBackgroundNotificationHook(manager) {
   };
 }
 // src/hooks/auto-update-checker/checker.ts
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 import * as path5 from "path";
 import { fileURLToPath } from "url";
 
@@ -7561,9 +7965,9 @@ function getConfigPaths(directory) {
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!fs4.existsSync(configPath))
+      if (!fs5.existsSync(configPath))
         continue;
-      const content = fs4.readFileSync(configPath, "utf-8");
+      const content = fs5.readFileSync(configPath, "utf-8");
       const config = JSON.parse(stripJsonComments(content));
       const plugins = config.plugin ?? [];
       for (const entry of plugins) {
@@ -7583,13 +7987,13 @@ function getLocalDevPath(directory) {
 }
 function findPackageJsonUp(startPath) {
   try {
-    const stat = fs4.statSync(startPath);
+    const stat = fs5.statSync(startPath);
     let dir = stat.isDirectory() ? startPath : path5.dirname(startPath);
     for (let i = 0;i < 10; i++) {
       const pkgPath = path5.join(dir, "package.json");
-      if (fs4.existsSync(pkgPath)) {
+      if (fs5.existsSync(pkgPath)) {
         try {
-          const content = fs4.readFileSync(pkgPath, "utf-8");
+          const content = fs5.readFileSync(pkgPath, "utf-8");
           const pkg = JSON.parse(content);
           if (pkg.name === PACKAGE_NAME)
             return pkgPath;
@@ -7611,7 +8015,7 @@ function getLocalDevVersion(directory) {
     const pkgPath = findPackageJsonUp(localPath);
     if (!pkgPath)
       return null;
-    const content = fs4.readFileSync(pkgPath, "utf-8");
+    const content = fs5.readFileSync(pkgPath, "utf-8");
     const pkg = JSON.parse(content);
     return pkg.version ?? null;
   } catch {
@@ -7621,9 +8025,9 @@ function getLocalDevVersion(directory) {
 function findPluginEntry(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!fs4.existsSync(configPath))
+      if (!fs5.existsSync(configPath))
         continue;
-      const content = fs4.readFileSync(configPath, "utf-8");
+      const content = fs5.readFileSync(configPath, "utf-8");
       const config = JSON.parse(stripJsonComments(content));
       const plugins = config.plugin ?? [];
       for (const entry of plugins) {
@@ -7644,8 +8048,8 @@ function findPluginEntry(directory) {
 }
 function getCachedVersion() {
   try {
-    if (fs4.existsSync(INSTALLED_PACKAGE_JSON)) {
-      const content = fs4.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
+    if (fs5.existsSync(INSTALLED_PACKAGE_JSON)) {
+      const content = fs5.readFileSync(INSTALLED_PACKAGE_JSON, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.version)
         return pkg.version;
@@ -7655,7 +8059,7 @@ function getCachedVersion() {
     const currentDir = path5.dirname(fileURLToPath(import.meta.url));
     const pkgPath = findPackageJsonUp(currentDir);
     if (pkgPath) {
-      const content = fs4.readFileSync(pkgPath, "utf-8");
+      const content = fs5.readFileSync(pkgPath, "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.version)
         return pkg.version;
@@ -7667,7 +8071,7 @@ function getCachedVersion() {
 }
 function updatePinnedVersion(configPath, oldEntry, newVersion) {
   try {
-    const content = fs4.readFileSync(configPath, "utf-8");
+    const content = fs5.readFileSync(configPath, "utf-8");
     const newEntry = `${PACKAGE_NAME}@${newVersion}`;
     const pluginMatch = content.match(/"plugin"\s*:\s*\[/);
     if (!pluginMatch || pluginMatch.index === undefined) {
@@ -7699,7 +8103,7 @@ function updatePinnedVersion(configPath, oldEntry, newVersion) {
       log(`[auto-update-checker] No changes made to ${configPath}`);
       return false;
     }
-    fs4.writeFileSync(configPath, updatedContent, "utf-8");
+    fs5.writeFileSync(configPath, updatedContent, "utf-8");
     log(`[auto-update-checker] Updated ${configPath}: ${oldEntry} \u2192 ${newEntry}`);
     return true;
   } catch (err) {
@@ -7727,17 +8131,17 @@ async function getLatestVersion() {
 }
 
 // src/hooks/auto-update-checker/cache.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as path6 from "path";
 function stripTrailingCommas(json) {
   return json.replace(/,(\s*[}\]])/g, "$1");
 }
 function removeFromBunLock(packageName) {
   const lockPath = path6.join(CACHE_DIR, "bun.lock");
-  if (!fs5.existsSync(lockPath))
+  if (!fs6.existsSync(lockPath))
     return false;
   try {
-    const content = fs5.readFileSync(lockPath, "utf-8");
+    const content = fs6.readFileSync(lockPath, "utf-8");
     const lock = JSON.parse(stripTrailingCommas(content));
     let modified = false;
     if (lock.workspaces?.[""]?.dependencies?.[packageName]) {
@@ -7749,7 +8153,7 @@ function removeFromBunLock(packageName) {
       modified = true;
     }
     if (modified) {
-      fs5.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
+      fs6.writeFileSync(lockPath, JSON.stringify(lock, null, 2));
       log(`[auto-update-checker] Removed from bun.lock: ${packageName}`);
     }
     return modified;
@@ -7764,17 +8168,17 @@ function invalidatePackage(packageName = PACKAGE_NAME) {
     let packageRemoved = false;
     let dependencyRemoved = false;
     let lockRemoved = false;
-    if (fs5.existsSync(pkgDir)) {
-      fs5.rmSync(pkgDir, { recursive: true, force: true });
+    if (fs6.existsSync(pkgDir)) {
+      fs6.rmSync(pkgDir, { recursive: true, force: true });
       log(`[auto-update-checker] Package removed: ${pkgDir}`);
       packageRemoved = true;
     }
-    if (fs5.existsSync(pkgJsonPath)) {
-      const content = fs5.readFileSync(pkgJsonPath, "utf-8");
+    if (fs6.existsSync(pkgJsonPath)) {
+      const content = fs6.readFileSync(pkgJsonPath, "utf-8");
       const pkgJson = JSON.parse(content);
       if (pkgJson.dependencies?.[packageName]) {
         delete pkgJson.dependencies[packageName];
-        fs5.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+        fs6.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
         log(`[auto-update-checker] Dependency removed from package.json: ${packageName}`);
         dependencyRemoved = true;
       }
@@ -7944,7 +8348,7 @@ async function showLocalDevToast(ctx, version, isSisyphusEnabled) {
 }
 // src/hooks/agent-usage-reminder/storage.ts
 import {
-  existsSync as existsSync21,
+  existsSync as existsSync22,
   mkdirSync as mkdirSync8,
   readFileSync as readFileSync13,
   writeFileSync as writeFileSync10,
@@ -8004,7 +8408,7 @@ function getStoragePath4(sessionID) {
 }
 function loadAgentUsageState(sessionID) {
   const filePath = getStoragePath4(sessionID);
-  if (!existsSync21(filePath))
+  if (!existsSync22(filePath))
     return null;
   try {
     const content = readFileSync13(filePath, "utf-8");
@@ -8014,7 +8418,7 @@ function loadAgentUsageState(sessionID) {
   }
 }
 function saveAgentUsageState(state2) {
-  if (!existsSync21(AGENT_USAGE_REMINDER_STORAGE)) {
+  if (!existsSync22(AGENT_USAGE_REMINDER_STORAGE)) {
     mkdirSync8(AGENT_USAGE_REMINDER_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath4(state2.sessionID);
@@ -8022,7 +8426,7 @@ function saveAgentUsageState(state2) {
 }
 function clearAgentUsageState(sessionID) {
   const filePath = getStoragePath4(sessionID);
-  if (existsSync21(filePath)) {
+  if (existsSync22(filePath)) {
     unlinkSync7(filePath);
   }
 }
@@ -8249,7 +8653,7 @@ function createNonInteractiveEnvHook(_ctx) {
 }
 // src/hooks/interactive-bash-session/storage.ts
 import {
-  existsSync as existsSync22,
+  existsSync as existsSync23,
   mkdirSync as mkdirSync9,
   readFileSync as readFileSync14,
   writeFileSync as writeFileSync11,
@@ -8276,7 +8680,7 @@ function getStoragePath5(sessionID) {
 }
 function loadInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath5(sessionID);
-  if (!existsSync22(filePath))
+  if (!existsSync23(filePath))
     return null;
   try {
     const content = readFileSync14(filePath, "utf-8");
@@ -8291,7 +8695,7 @@ function loadInteractiveBashSessionState(sessionID) {
   }
 }
 function saveInteractiveBashSessionState(state2) {
-  if (!existsSync22(INTERACTIVE_BASH_SESSION_STORAGE)) {
+  if (!existsSync23(INTERACTIVE_BASH_SESSION_STORAGE)) {
     mkdirSync9(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
   }
   const filePath = getStoragePath5(state2.sessionID);
@@ -8304,7 +8708,7 @@ function saveInteractiveBashSessionState(state2) {
 }
 function clearInteractiveBashSessionState(sessionID) {
   const filePath = getStoragePath5(sessionID);
-  if (existsSync22(filePath)) {
+  if (existsSync23(filePath)) {
     unlinkSync8(filePath);
   }
 }
@@ -10248,11 +10652,11 @@ async function createGoogleAntigravityAuthPlugin({
   };
 }
 // src/features/claude-code-command-loader/loader.ts
-import { existsSync as existsSync23, readdirSync as readdirSync6, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync24, readdirSync as readdirSync6, readFileSync as readFileSync15 } from "fs";
 import { homedir as homedir12 } from "os";
 import { join as join33, basename } from "path";
 function loadCommandsFromDir(commandsDir, scope) {
-  if (!existsSync23(commandsDir)) {
+  if (!existsSync24(commandsDir)) {
     return [];
   }
   const entries = readdirSync6(commandsDir, { withFileTypes: true });
@@ -10323,11 +10727,11 @@ function loadOpencodeProjectCommands() {
   return commandsToRecord(commands);
 }
 // src/features/claude-code-skill-loader/loader.ts
-import { existsSync as existsSync24, readdirSync as readdirSync7, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync25, readdirSync as readdirSync7, readFileSync as readFileSync16 } from "fs";
 import { homedir as homedir13 } from "os";
 import { join as join34 } from "path";
 function loadSkillsFromDir(skillsDir, scope) {
-  if (!existsSync24(skillsDir)) {
+  if (!existsSync25(skillsDir)) {
     return [];
   }
   const entries = readdirSync7(skillsDir, { withFileTypes: true });
@@ -10340,7 +10744,7 @@ function loadSkillsFromDir(skillsDir, scope) {
       continue;
     const resolvedPath = resolveSymlink(skillPath);
     const skillMdPath = join34(resolvedPath, "SKILL.md");
-    if (!existsSync24(skillMdPath))
+    if (!existsSync25(skillMdPath))
       continue;
     try {
       const content = readFileSync16(skillMdPath, "utf-8");
@@ -10393,7 +10797,7 @@ function loadProjectSkillsAsCommands() {
   }, {});
 }
 // src/features/claude-code-agent-loader/loader.ts
-import { existsSync as existsSync25, readdirSync as readdirSync8, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync26, readdirSync as readdirSync8, readFileSync as readFileSync17 } from "fs";
 import { homedir as homedir14 } from "os";
 import { join as join35, basename as basename2 } from "path";
 function parseToolsConfig(toolsStr) {
@@ -10409,7 +10813,7 @@ function parseToolsConfig(toolsStr) {
   return result;
 }
 function loadAgentsFromDir(agentsDir, scope) {
-  if (!existsSync25(agentsDir)) {
+  if (!existsSync26(agentsDir)) {
     return [];
   }
   const entries = readdirSync8(agentsDir, { withFileTypes: true });
@@ -10465,7 +10869,7 @@ function loadProjectAgents() {
   return result;
 }
 // src/features/claude-code-mcp-loader/loader.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27 } from "fs";
 import { homedir as homedir15 } from "os";
 import { join as join36 } from "path";
 
@@ -10542,7 +10946,7 @@ function getMcpConfigPaths() {
   ];
 }
 async function loadMcpConfigFile(filePath) {
-  if (!existsSync26(filePath)) {
+  if (!existsSync27(filePath)) {
     return null;
   }
   try {
@@ -10637,6 +11041,32 @@ var BUILTIN_SERVERS = {
     command: ["vscode-eslint-language-server", "--stdio"],
     extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".vue"]
   },
+  oxlint: {
+    command: ["oxlint", "--lsp"],
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".vue", ".astro", ".svelte"]
+  },
+  biome: {
+    command: ["biome", "lsp-proxy", "--stdio"],
+    extensions: [
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".mts",
+      ".cts",
+      ".json",
+      ".jsonc",
+      ".vue",
+      ".astro",
+      ".svelte",
+      ".css",
+      ".graphql",
+      ".gql",
+      ".html"
+    ]
+  },
   gopls: {
     command: ["gopls"],
     extensions: [".go"]
@@ -10653,6 +11083,10 @@ var BUILTIN_SERVERS = {
     command: ["pyright-langserver", "--stdio"],
     extensions: [".py", ".pyi"]
   },
+  ty: {
+    command: ["ty", "server"],
+    extensions: [".py", ".pyi"]
+  },
   ruff: {
     command: ["ruff", "server"],
     extensions: [".py", ".pyi"]
@@ -10669,6 +11103,10 @@ var BUILTIN_SERVERS = {
     command: ["csharp-ls"],
     extensions: [".cs"]
   },
+  fsharp: {
+    command: ["fsautocomplete"],
+    extensions: [".fs", ".fsi", ".fsx", ".fsscript"]
+  },
   "sourcekit-lsp": {
     command: ["sourcekit-lsp"],
     extensions: [".swift", ".objc", ".objcpp"]
@@ -10712,26 +11150,125 @@ var BUILTIN_SERVERS = {
   dart: {
     command: ["dart", "language-server", "--lsp"],
     extensions: [".dart"]
+  },
+  "terraform-ls": {
+    command: ["terraform-ls", "serve"],
+    extensions: [".tf", ".tfvars"]
   }
 };
 var EXT_TO_LANG = {
+  ".abap": "abap",
+  ".bat": "bat",
+  ".bib": "bibtex",
+  ".bibtex": "bibtex",
+  ".clj": "clojure",
+  ".cljs": "clojure",
+  ".cljc": "clojure",
+  ".edn": "clojure",
+  ".coffee": "coffeescript",
+  ".c": "c",
+  ".cpp": "cpp",
+  ".cxx": "cpp",
+  ".cc": "cpp",
+  ".c++": "cpp",
+  ".cs": "csharp",
+  ".css": "css",
+  ".d": "d",
+  ".pas": "pascal",
+  ".pascal": "pascal",
+  ".diff": "diff",
+  ".patch": "diff",
+  ".dart": "dart",
+  ".dockerfile": "dockerfile",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".erl": "erlang",
+  ".hrl": "erlang",
+  ".fs": "fsharp",
+  ".fsi": "fsharp",
+  ".fsx": "fsharp",
+  ".fsscript": "fsharp",
+  ".gitcommit": "git-commit",
+  ".gitrebase": "git-rebase",
+  ".go": "go",
+  ".groovy": "groovy",
+  ".gleam": "gleam",
+  ".hbs": "handlebars",
+  ".handlebars": "handlebars",
+  ".hs": "haskell",
+  ".html": "html",
+  ".htm": "html",
+  ".ini": "ini",
+  ".java": "java",
+  ".js": "javascript",
+  ".jsx": "javascriptreact",
+  ".json": "json",
+  ".jsonc": "jsonc",
+  ".tex": "latex",
+  ".latex": "latex",
+  ".less": "less",
+  ".lua": "lua",
+  ".makefile": "makefile",
+  makefile: "makefile",
+  ".md": "markdown",
+  ".markdown": "markdown",
+  ".m": "objective-c",
+  ".mm": "objective-cpp",
+  ".pl": "perl",
+  ".pm": "perl",
+  ".pm6": "perl6",
+  ".php": "php",
+  ".ps1": "powershell",
+  ".psm1": "powershell",
+  ".pug": "jade",
+  ".jade": "jade",
   ".py": "python",
   ".pyi": "python",
+  ".r": "r",
+  ".cshtml": "razor",
+  ".razor": "razor",
+  ".rb": "ruby",
+  ".rake": "ruby",
+  ".gemspec": "ruby",
+  ".ru": "ruby",
+  ".erb": "erb",
+  ".html.erb": "erb",
+  ".js.erb": "erb",
+  ".css.erb": "erb",
+  ".json.erb": "erb",
+  ".rs": "rust",
+  ".scss": "scss",
+  ".sass": "sass",
+  ".scala": "scala",
+  ".shader": "shaderlab",
+  ".sh": "shellscript",
+  ".bash": "shellscript",
+  ".zsh": "shellscript",
+  ".ksh": "shellscript",
+  ".sql": "sql",
+  ".svelte": "svelte",
+  ".swift": "swift",
   ".ts": "typescript",
   ".tsx": "typescriptreact",
   ".mts": "typescript",
   ".cts": "typescript",
-  ".js": "javascript",
-  ".jsx": "javascriptreact",
+  ".mtsx": "typescriptreact",
+  ".ctsx": "typescriptreact",
+  ".xml": "xml",
+  ".xsl": "xsl",
+  ".yaml": "yaml",
+  ".yml": "yaml",
   ".mjs": "javascript",
   ".cjs": "javascript",
-  ".go": "go",
-  ".rs": "rust",
-  ".c": "c",
-  ".cpp": "cpp",
-  ".cc": "cpp",
-  ".cxx": "cpp",
-  ".c++": "cpp",
+  ".vue": "vue",
+  ".zig": "zig",
+  ".zon": "zig",
+  ".astro": "astro",
+  ".ml": "ocaml",
+  ".mli": "ocaml",
+  ".tf": "terraform",
+  ".tfvars": "terraform-vars",
+  ".hcl": "hcl",
   ".h": "c",
   ".hpp": "cpp",
   ".hh": "cpp",
@@ -10739,46 +11276,16 @@ var EXT_TO_LANG = {
   ".h++": "cpp",
   ".objc": "objective-c",
   ".objcpp": "objective-cpp",
-  ".java": "java",
-  ".rb": "ruby",
-  ".rake": "ruby",
-  ".gemspec": "ruby",
-  ".ru": "ruby",
-  ".lua": "lua",
-  ".swift": "swift",
-  ".cs": "csharp",
-  ".php": "php",
-  ".dart": "dart",
-  ".ex": "elixir",
-  ".exs": "elixir",
-  ".zig": "zig",
-  ".zon": "zig",
-  ".vue": "vue",
-  ".svelte": "svelte",
-  ".astro": "astro",
-  ".yaml": "yaml",
-  ".yml": "yaml",
-  ".json": "json",
-  ".jsonc": "jsonc",
-  ".html": "html",
-  ".htm": "html",
-  ".css": "css",
-  ".scss": "scss",
-  ".less": "less",
-  ".sh": "shellscript",
-  ".bash": "shellscript",
-  ".zsh": "shellscript",
   ".fish": "fish",
-  ".md": "markdown",
-  ".tf": "terraform",
-  ".tfvars": "terraform"
+  ".graphql": "graphql",
+  ".gql": "graphql"
 };
 // src/tools/lsp/config.ts
-import { existsSync as existsSync27, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync18 } from "fs";
 import { join as join37 } from "path";
 import { homedir as homedir16 } from "os";
 function loadJsonFile(path7) {
-  if (!existsSync27(path7))
+  if (!existsSync28(path7))
     return null;
   try {
     return JSON.parse(readFileSync18(path7, "utf-8"));
@@ -10881,10 +11388,27 @@ function isServerInstalled(command) {
   if (command.length === 0)
     return false;
   const cmd = command[0];
+  const isWindows2 = process.platform === "win32";
+  const ext = isWindows2 ? ".exe" : "";
   const pathEnv = process.env.PATH || "";
-  const paths = pathEnv.split(":");
+  const pathSeparator = isWindows2 ? ";" : ":";
+  const paths = pathEnv.split(pathSeparator);
   for (const p of paths) {
-    if (existsSync27(join37(p, cmd))) {
+    if (existsSync28(join37(p, cmd)) || existsSync28(join37(p, cmd + ext))) {
+      return true;
+    }
+  }
+  const cwd = process.cwd();
+  const additionalPaths = [
+    join37(cwd, "node_modules", ".bin", cmd),
+    join37(cwd, "node_modules", ".bin", cmd + ext),
+    join37(homedir16(), ".config", "opencode", "bin", cmd),
+    join37(homedir16(), ".config", "opencode", "bin", cmd + ext),
+    join37(homedir16(), ".config", "opencode", "node_modules", ".bin", cmd),
+    join37(homedir16(), ".config", "opencode", "node_modules", ".bin", cmd + ext)
+  ];
+  for (const p of additionalPaths) {
+    if (existsSync28(p)) {
       return true;
     }
   }
@@ -11479,16 +12003,16 @@ ${msg}`);
 }
 // src/tools/lsp/utils.ts
 import { extname as extname2, resolve as resolve6 } from "path";
-import { existsSync as existsSync28, readFileSync as readFileSync20, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync20, writeFileSync as writeFileSync12 } from "fs";
 function findWorkspaceRoot(filePath) {
   let dir = resolve6(filePath);
-  if (!existsSync28(dir) || !__require("fs").statSync(dir).isDirectory()) {
+  if (!existsSync29(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 (existsSync28(__require("path").join(dir, marker))) {
+      if (existsSync29(__require("path").join(dir, marker))) {
         return dir;
       }
     }
@@ -24414,11 +24938,11 @@ var lsp_code_action_resolve = tool({
 // src/tools/ast-grep/constants.ts
 import { createRequire as createRequire4 } from "module";
 import { dirname as dirname6, join as join39 } from "path";
-import { existsSync as existsSync30, statSync as statSync4 } from "fs";
+import { existsSync as existsSync31, statSync as statSync4 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 var {spawn: spawn5 } = globalThis.Bun;
-import { existsSync as existsSync29, mkdirSync as mkdirSync10, chmodSync as chmodSync2, unlinkSync as unlinkSync9 } from "fs";
+import { existsSync as existsSync30, mkdirSync as mkdirSync10, chmodSync as chmodSync2, unlinkSync as unlinkSync9 } from "fs";
 import { join as join38 } from "path";
 import { homedir as homedir17 } from "os";
 import { createRequire as createRequire3 } from "module";
@@ -24457,7 +24981,7 @@ function getBinaryName3() {
 }
 function getCachedBinaryPath2() {
   const binaryPath = join38(getCacheDir3(), getBinaryName3());
-  return existsSync29(binaryPath) ? binaryPath : null;
+  return existsSync30(binaryPath) ? binaryPath : null;
 }
 async function extractZip2(archivePath, destDir) {
   const proc = process.platform === "win32" ? spawn5([
@@ -24484,7 +25008,7 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   const cacheDir = getCacheDir3();
   const binaryName = getBinaryName3();
   const binaryPath = join38(cacheDir, binaryName);
-  if (existsSync29(binaryPath)) {
+  if (existsSync30(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os5 } = platformInfo;
@@ -24492,7 +25016,7 @@ 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 (!existsSync29(cacheDir)) {
+    if (!existsSync30(cacheDir)) {
       mkdirSync10(cacheDir, { recursive: true });
     }
     const response2 = await fetch(downloadUrl, { redirect: "follow" });
@@ -24503,10 +25027,10 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
     const arrayBuffer = await response2.arrayBuffer();
     await Bun.write(archivePath, arrayBuffer);
     await extractZip2(archivePath, cacheDir);
-    if (existsSync29(archivePath)) {
+    if (existsSync30(archivePath)) {
       unlinkSync9(archivePath);
     }
-    if (process.platform !== "win32" && existsSync29(binaryPath)) {
+    if (process.platform !== "win32" && existsSync30(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode] ast-grep binary ready.`);
@@ -24558,7 +25082,7 @@ function findSgCliPathSync() {
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDir = dirname6(cliPkgPath);
     const sgPath = join39(cliDir, binaryName);
-    if (existsSync30(sgPath) && isValidBinary(sgPath)) {
+    if (existsSync31(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -24570,7 +25094,7 @@ function findSgCliPathSync() {
       const pkgDir = dirname6(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
       const binaryPath = join39(pkgDir, astGrepName);
-      if (existsSync30(binaryPath) && isValidBinary(binaryPath)) {
+      if (existsSync31(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -24578,7 +25102,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path7 of homebrewPaths) {
-      if (existsSync30(path7) && isValidBinary(path7)) {
+      if (existsSync31(path7) && isValidBinary(path7)) {
         return path7;
       }
     }
@@ -24634,11 +25158,11 @@ var DEFAULT_MAX_MATCHES = 500;
 
 // src/tools/ast-grep/cli.ts
 var {spawn: spawn6 } = globalThis.Bun;
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 var resolvedCliPath3 = null;
 var initPromise2 = null;
 async function getAstGrepPath() {
-  if (resolvedCliPath3 !== null && existsSync31(resolvedCliPath3)) {
+  if (resolvedCliPath3 !== null && existsSync32(resolvedCliPath3)) {
     return resolvedCliPath3;
   }
   if (initPromise2) {
@@ -24646,7 +25170,7 @@ async function getAstGrepPath() {
   }
   initPromise2 = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync31(syncPath)) {
+    if (syncPath && existsSync32(syncPath)) {
       resolvedCliPath3 = syncPath;
       setSgCliPath(syncPath);
       return syncPath;
@@ -24680,7 +25204,7 @@ async function runSg(options) {
   const paths = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths);
   let cliPath = getSgCliPath();
-  if (!existsSync31(cliPath) && cliPath !== "sg") {
+  if (!existsSync32(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -24944,12 +25468,12 @@ var ast_grep_replace = tool({
 var {spawn: spawn7 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
-import { existsSync as existsSync33 } from "fs";
+import { existsSync as existsSync34 } from "fs";
 import { join as join41, dirname as dirname7 } from "path";
 import { spawnSync } from "child_process";
 
 // src/tools/grep/downloader.ts
-import { existsSync as existsSync32, mkdirSync as mkdirSync11, chmodSync as chmodSync3, unlinkSync as unlinkSync10, readdirSync as readdirSync9 } from "fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync11, chmodSync as chmodSync3, unlinkSync as unlinkSync10, readdirSync as readdirSync9 } from "fs";
 import { join as join40 } from "path";
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
@@ -24961,7 +25485,7 @@ function getRgPath() {
 }
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
-  return existsSync32(rgPath) ? rgPath : null;
+  return existsSync33(rgPath) ? rgPath : null;
 }
 
 // src/tools/grep/constants.ts
@@ -24990,7 +25514,7 @@ function getOpenCodeBundledRg() {
     join41(execDir, "..", "libexec", rgName)
   ];
   for (const candidate of candidates) {
-    if (existsSync33(candidate)) {
+    if (existsSync34(candidate)) {
       return candidate;
     }
   }
@@ -25393,11 +25917,11 @@ var glob = tool({
   }
 });
 // src/tools/slashcommand/tools.ts
-import { existsSync as existsSync34, readdirSync as readdirSync10, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync35, readdirSync as readdirSync10, readFileSync as readFileSync21 } from "fs";
 import { homedir as homedir18 } from "os";
 import { join as join42, basename as basename3, dirname as dirname8 } from "path";
 function discoverCommandsFromDir(commandsDir, scope) {
-  if (!existsSync34(commandsDir)) {
+  if (!existsSync35(commandsDir)) {
     return [];
   }
   const entries = readdirSync10(commandsDir, { withFileTypes: true });
@@ -25568,7 +26092,7 @@ var SkillFrontmatterSchema = exports_external.object({
   metadata: exports_external.record(exports_external.string(), exports_external.string()).optional()
 });
 // src/tools/skill/tools.ts
-import { existsSync as existsSync35, readdirSync as readdirSync11, readFileSync as readFileSync22 } from "fs";
+import { existsSync as existsSync36, readdirSync as readdirSync11, readFileSync as readFileSync22 } from "fs";
 import { homedir as homedir19 } from "os";
 import { join as join43, basename as basename4 } from "path";
 function parseSkillFrontmatter(data) {
@@ -25581,7 +26105,7 @@ function parseSkillFrontmatter(data) {
   };
 }
 function discoverSkillsFromDir(skillsDir, scope) {
-  if (!existsSync35(skillsDir)) {
+  if (!existsSync36(skillsDir)) {
     return [];
   }
   const entries = readdirSync11(skillsDir, { withFileTypes: true });
@@ -25593,7 +26117,7 @@ function discoverSkillsFromDir(skillsDir, scope) {
     if (entry.isDirectory() || entry.isSymbolicLink()) {
       const resolvedPath = resolveSymlink(skillPath);
       const skillMdPath = join43(resolvedPath, "SKILL.md");
-      if (!existsSync35(skillMdPath))
+      if (!existsSync36(skillMdPath))
         continue;
       try {
         const content = readFileSync22(skillMdPath, "utf-8");
@@ -25623,7 +26147,7 @@ var skillListForDescription = availableSkills.map((s) => `- ${s.name}: ${s.descr
 async function parseSkillMd(skillPath) {
   const resolvedPath = resolveSymlink(skillPath);
   const skillMdPath = join43(resolvedPath, "SKILL.md");
-  if (!existsSync35(skillMdPath)) {
+  if (!existsSync36(skillMdPath)) {
     return null;
   }
   try {
@@ -25641,9 +26165,9 @@ async function parseSkillMd(skillPath) {
     const referencesDir = join43(resolvedPath, "references");
     const scriptsDir = join43(resolvedPath, "scripts");
     const assetsDir = join43(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(".")) : [];
+    const references = existsSync36(referencesDir) ? readdirSync11(referencesDir).filter((f) => !f.startsWith(".")) : [];
+    const scripts = existsSync36(scriptsDir) ? readdirSync11(scriptsDir).filter((f) => !f.startsWith(".") && !f.startsWith("__")) : [];
+    const assets = existsSync36(assetsDir) ? readdirSync11(assetsDir).filter((f) => !f.startsWith(".")) : [];
     return {
       name: metadata.name,
       path: resolvedPath,
@@ -25659,7 +26183,7 @@ async function parseSkillMd(skillPath) {
   }
 }
 async function discoverSkillsFromDirAsync(skillsDir) {
-  if (!existsSync35(skillsDir)) {
+  if (!existsSync36(skillsDir)) {
     return [];
   }
   const entries = readdirSync11(skillsDir, { withFileTypes: true });
@@ -26474,17 +26998,17 @@ var builtinTools = {
   skill
 };
 // src/features/background-agent/manager.ts
-import { existsSync as existsSync36, readdirSync as readdirSync12 } from "fs";
+import { existsSync as existsSync37, readdirSync as readdirSync12 } from "fs";
 import { join as join44 } from "path";
 function getMessageDir4(sessionID) {
-  if (!existsSync36(MESSAGE_STORAGE))
+  if (!existsSync37(MESSAGE_STORAGE))
     return null;
   const directPath = join44(MESSAGE_STORAGE, sessionID);
-  if (existsSync36(directPath))
+  if (existsSync37(directPath))
     return directPath;
   for (const dir of readdirSync12(MESSAGE_STORAGE)) {
     const sessionPath = join44(MESSAGE_STORAGE, dir, sessionID);
-    if (existsSync36(sessionPath))
+    if (existsSync37(sessionPath))
       return sessionPath;
   }
   return null;
@@ -26955,8 +27479,9 @@ var SisyphusAgentConfigSchema = exports_external.object({
 });
 var ExperimentalConfigSchema = exports_external.object({
   aggressive_truncation: exports_external.boolean().optional(),
-  empty_message_recovery: exports_external.boolean().optional(),
-  auto_resume: exports_external.boolean().optional()
+  auto_resume: exports_external.boolean().optional(),
+  preemptive_compaction: exports_external.boolean().optional(),
+  preemptive_compaction_threshold: exports_external.number().min(0.5).max(0.95).optional()
 });
 var OhMyOpenCodeConfigSchema = exports_external.object({
   $schema: exports_external.string().optional(),
@@ -27042,7 +27567,7 @@ var PLAN_PERMISSION = {
 };
 
 // src/index.ts
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as path7 from "path";
 var AGENT_NAME_MAP = {
   omo: "Sisyphus",
@@ -27087,7 +27612,7 @@ function migrateConfigFile(configPath, rawConfig) {
   }
   if (needsWrite) {
     try {
-      fs6.writeFileSync(configPath, JSON.stringify(rawConfig, null, 2) + `
+      fs7.writeFileSync(configPath, JSON.stringify(rawConfig, null, 2) + `
 `, "utf-8");
       log(`Migrated config file: ${configPath} (OmO \u2192 Sisyphus)`);
     } catch (err) {
@@ -27098,8 +27623,8 @@ function migrateConfigFile(configPath, rawConfig) {
 }
 function loadConfigFromPath2(configPath) {
   try {
-    if (fs6.existsSync(configPath)) {
-      const content = fs6.readFileSync(configPath, "utf-8");
+    if (fs7.existsSync(configPath)) {
+      const content = fs7.readFileSync(configPath, "utf-8");
       const rawConfig = JSON.parse(content);
       migrateConfigFile(configPath, rawConfig);
       const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
@@ -27166,6 +27691,18 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const pluginConfig = loadPluginConfig(ctx.directory);
   const disabledHooks = new Set(pluginConfig.disabled_hooks ?? []);
   const isHookEnabled = (hookName) => !disabledHooks.has(hookName);
+  const modelContextLimitsCache = new Map;
+  let anthropicContext1MEnabled = false;
+  const getModelLimit = (providerID, modelID) => {
+    const key = `${providerID}/${modelID}`;
+    const cached2 = modelContextLimitsCache.get(key);
+    if (cached2)
+      return cached2;
+    if (providerID === "anthropic" && anthropicContext1MEnabled && modelID.includes("sonnet")) {
+      return 1e6;
+    }
+    return;
+  };
   const todoContinuationEnforcer = isHookEnabled("todo-continuation-enforcer") ? createTodoContinuationEnforcer(ctx) : null;
   const contextWindowMonitor = isHookEnabled("context-window-monitor") ? createContextWindowMonitorHook(ctx) : null;
   const sessionRecovery = isHookEnabled("session-recovery") ? createSessionRecoveryHook(ctx, { experimental: pluginConfig.experimental }) : null;
@@ -27184,6 +27721,12 @@ var OhMyOpenCodePlugin = async (ctx) => {
     disabledHooks: pluginConfig.claude_code?.hooks ?? true ? undefined : true
   });
   const anthropicAutoCompact = isHookEnabled("anthropic-auto-compact") ? createAnthropicAutoCompactHook(ctx, { experimental: pluginConfig.experimental }) : null;
+  const compactionContextInjector = createCompactionContextInjector();
+  const preemptiveCompaction = createPreemptiveCompactionHook(ctx, {
+    experimental: pluginConfig.experimental,
+    onBeforeSummarize: compactionContextInjector,
+    getModelLimit
+  });
   const rulesInjector = isHookEnabled("rules-injector") ? createRulesInjectorHook(ctx) : null;
   const autoUpdateChecker = isHookEnabled("auto-update-checker") ? createAutoUpdateCheckerHook(ctx, {
     showStartupToast: isHookEnabled("startup-toast"),
@@ -27219,6 +27762,22 @@ var OhMyOpenCodePlugin = async (ctx) => {
       await emptyMessageSanitizer?.["experimental.chat.messages.transform"]?.(input, output);
     },
     config: async (config3) => {
+      const providers = config3.provider;
+      const anthropicBeta = providers?.anthropic?.options?.headers?.["anthropic-beta"];
+      anthropicContext1MEnabled = anthropicBeta?.includes("context-1m") ?? false;
+      if (providers) {
+        for (const [providerID, providerConfig] of Object.entries(providers)) {
+          const models = providerConfig?.models;
+          if (models) {
+            for (const [modelID, modelConfig] of Object.entries(models)) {
+              const contextLimit = modelConfig?.limit?.context;
+              if (contextLimit) {
+                modelContextLimitsCache.set(`${providerID}/${modelID}`, contextLimit);
+              }
+            }
+          }
+        }
+      }
       const builtinAgents = createBuiltinAgents(pluginConfig.disabled_agents, pluginConfig.agents, ctx.directory, config3.model);
       const userAgents = pluginConfig.claude_code?.agents ?? true ? loadUserAgents() : {};
       const projectAgents = pluginConfig.claude_code?.agents ?? true ? loadProjectAgents() : {};
@@ -27315,6 +27874,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
       await rulesInjector?.event(input);
       await thinkMode?.event(input);
       await anthropicAutoCompact?.event(input);
+      await preemptiveCompaction?.event(input);
       await agentUsageReminder?.event(input);
       await interactiveBashSession?.event(input);
       const { event } = input;
@@ -27356,6 +27916,9 @@ var OhMyOpenCodePlugin = async (ctx) => {
       await claudeCodeHooks["tool.execute.before"](input, output);
       await nonInteractiveEnv?.["tool.execute.before"](input, output);
       await commentChecker?.["tool.execute.before"](input, output);
+      await directoryAgentsInjector?.["tool.execute.before"]?.(input, output);
+      await directoryReadmeInjector?.["tool.execute.before"]?.(input, output);
+      await rulesInjector?.["tool.execute.before"]?.(input, output);
       if (input.tool === "task") {
         const args = output.args;
         const subagentType = args.subagent_type;