oh-my-opencode 2.7.0 → 2.7.2

package/dist/index.js

@@ -4382,7 +4382,7 @@ Incomplete tasks remain in your todo list. Continue working on the next pending
 - Do not stop until all tasks are done`;
 var COUNTDOWN_SECONDS = 2;
 var TOAST_DURATION_MS = 900;
-var MIN_INJECTION_INTERVAL_MS = 1e4;
+var ERROR_COOLDOWN_MS = 3000;
 function getMessageDir(sessionID) {
   if (!existsSync6(MESSAGE_STORAGE))
     return null;
@@ -4396,7 +4396,7 @@ function getMessageDir(sessionID) {
   }
   return null;
 }
-function detectInterrupt(error) {
+function isAbortError(error) {
   if (!error)
     return false;
   if (typeof error === "object") {
@@ -4422,47 +4422,41 @@ function getIncompleteCount(todos) {
 function createTodoContinuationEnforcer(ctx, options = {}) {
   const { backgroundManager } = options;
   const sessions = new Map;
-  function getOrCreateState(sessionID) {
+  function getState(sessionID) {
     let state2 = sessions.get(sessionID);
     if (!state2) {
-      state2 = { version: 0, mode: "idle" };
+      state2 = {};
       sessions.set(sessionID, state2);
     }
     return state2;
   }
-  function clearTimer(state2) {
-    if (state2.timer) {
-      clearTimeout(state2.timer);
-      state2.timer = undefined;
-    }
-  }
-  function invalidate(sessionID, reason) {
+  function cancelCountdown(sessionID) {
     const state2 = sessions.get(sessionID);
     if (!state2)
       return;
-    if (state2.mode === "recovering")
-      return;
-    state2.version++;
-    clearTimer(state2);
-    if (state2.mode !== "idle" && state2.mode !== "errorBypass") {
-      log(`[${HOOK_NAME}] Invalidated`, { sessionID, reason, prevMode: state2.mode, newVersion: state2.version });
-      state2.mode = "idle";
+    if (state2.countdownTimer) {
+      clearTimeout(state2.countdownTimer);
+      state2.countdownTimer = undefined;
+    }
+    if (state2.countdownInterval) {
+      clearInterval(state2.countdownInterval);
+      state2.countdownInterval = undefined;
     }
   }
-  function isMainSession(sessionID) {
-    const mainSessionID2 = getMainSessionID();
-    return !mainSessionID2 || sessionID === mainSessionID2;
+  function cleanup(sessionID) {
+    cancelCountdown(sessionID);
+    sessions.delete(sessionID);
   }
   const markRecovering = (sessionID) => {
-    const state2 = getOrCreateState(sessionID);
-    invalidate(sessionID, "entering recovery mode");
-    state2.mode = "recovering";
+    const state2 = getState(sessionID);
+    state2.isRecovering = true;
+    cancelCountdown(sessionID);
     log(`[${HOOK_NAME}] Session marked as recovering`, { sessionID });
   };
   const markRecoveryComplete = (sessionID) => {
     const state2 = sessions.get(sessionID);
-    if (state2 && state2.mode === "recovering") {
-      state2.mode = "idle";
+    if (state2) {
+      state2.isRecovering = false;
       log(`[${HOOK_NAME}] Session recovery complete`, { sessionID });
     }
   };
@@ -4476,101 +4470,51 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
       }
     }).catch(() => {});
   }
-  async function executeInjection(sessionID, capturedVersion) {
+  async function injectContinuation(sessionID, incompleteCount, total) {
     const state2 = sessions.get(sessionID);
-    if (!state2)
-      return;
-    if (state2.version !== capturedVersion) {
-      log(`[${HOOK_NAME}] Injection aborted: version mismatch`, {
-        sessionID,
-        capturedVersion,
-        currentVersion: state2.version
-      });
+    if (state2?.isRecovering) {
+      log(`[${HOOK_NAME}] Skipped injection: in recovery`, { sessionID });
       return;
     }
-    if (state2.mode !== "countingDown") {
-      log(`[${HOOK_NAME}] Injection aborted: mode changed`, {
-        sessionID,
-        mode: state2.mode
-      });
+    if (state2?.lastErrorAt && Date.now() - state2.lastErrorAt < ERROR_COOLDOWN_MS) {
+      log(`[${HOOK_NAME}] Skipped injection: recent error`, { sessionID });
       return;
     }
-    if (state2.lastAttemptedAt) {
-      const elapsed = Date.now() - state2.lastAttemptedAt;
-      if (elapsed < MIN_INJECTION_INTERVAL_MS) {
-        log(`[${HOOK_NAME}] Injection throttled: too soon since last injection`, {
-          sessionID,
-          elapsedMs: elapsed,
-          minIntervalMs: MIN_INJECTION_INTERVAL_MS
-        });
-        state2.mode = "idle";
-        return;
-      }
+    const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((t) => t.status === "running") : false;
+    if (hasRunningBgTasks) {
+      log(`[${HOOK_NAME}] Skipped injection: background tasks running`, { sessionID });
+      return;
     }
-    state2.mode = "injecting";
     let todos = [];
     try {
       const response = await ctx.client.session.todo({ path: { id: sessionID } });
       todos = response.data ?? response;
     } catch (err) {
-      log(`[${HOOK_NAME}] Failed to fetch todos for injection`, { sessionID, error: String(err) });
-      state2.mode = "idle";
-      return;
-    }
-    if (state2.version !== capturedVersion) {
-      log(`[${HOOK_NAME}] Injection aborted after todo fetch: version mismatch`, { sessionID });
-      state2.mode = "idle";
+      log(`[${HOOK_NAME}] Failed to fetch todos`, { sessionID, error: String(err) });
       return;
     }
-    const incompleteCount = getIncompleteCount(todos);
-    if (incompleteCount === 0) {
-      log(`[${HOOK_NAME}] No incomplete todos at injection time`, { sessionID, total: todos.length });
-      state2.mode = "idle";
-      return;
-    }
-    const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((t) => t.status === "running") : false;
-    if (hasRunningBgTasks) {
-      log(`[${HOOK_NAME}] Skipped: background tasks still running`, { sessionID });
-      state2.mode = "idle";
+    const freshIncompleteCount = getIncompleteCount(todos);
+    if (freshIncompleteCount === 0) {
+      log(`[${HOOK_NAME}] Skipped injection: no incomplete todos`, { sessionID });
       return;
     }
     const messageDir = getMessageDir(sessionID);
     const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
-    const agentHasWritePermission = !prevMessage?.tools || prevMessage.tools.write !== false && prevMessage.tools.edit !== false;
-    if (!agentHasWritePermission) {
-      log(`[${HOOK_NAME}] Skipped: agent lacks write permission`, {
-        sessionID,
-        agent: prevMessage?.agent,
-        tools: prevMessage?.tools
-      });
-      state2.mode = "idle";
+    const hasWritePermission = !prevMessage?.tools || prevMessage.tools.write !== false && prevMessage.tools.edit !== false;
+    if (!hasWritePermission) {
+      log(`[${HOOK_NAME}] Skipped: agent lacks write permission`, { sessionID, agent: prevMessage?.agent });
       return;
     }
     const agentName = prevMessage?.agent?.toLowerCase() ?? "";
-    const isPlanModeAgent = agentName === "plan" || agentName === "planner-sisyphus";
-    if (isPlanModeAgent) {
-      log(`[${HOOK_NAME}] Skipped: plan mode agent detected`, {
-        sessionID,
-        agent: prevMessage?.agent
-      });
-      state2.mode = "idle";
+    if (agentName === "plan" || agentName === "planner-sisyphus") {
+      log(`[${HOOK_NAME}] Skipped: plan mode agent`, { sessionID, agent: prevMessage?.agent });
       return;
     }
     const prompt = `${CONTINUATION_PROMPT}
 
-[Status: ${todos.length - incompleteCount}/${todos.length} completed, ${incompleteCount} remaining]`;
-    if (state2.version !== capturedVersion) {
-      log(`[${HOOK_NAME}] Injection aborted: version changed before API call`, { sessionID });
-      state2.mode = "idle";
-      return;
-    }
-    state2.lastAttemptedAt = Date.now();
+[Status: ${todos.length - freshIncompleteCount}/${todos.length} completed, ${freshIncompleteCount} remaining]`;
     try {
-      log(`[${HOOK_NAME}] Injecting continuation prompt`, {
-        sessionID,
-        agent: prevMessage?.agent,
-        incompleteCount
-      });
+      log(`[${HOOK_NAME}] Injecting continuation`, { sessionID, agent: prevMessage?.agent, incompleteCount: freshIncompleteCount });
       await ctx.client.session.prompt({
         path: { id: sessionID },
         body: {
@@ -4579,41 +4523,27 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
         },
         query: { directory: ctx.directory }
       });
-      log(`[${HOOK_NAME}] Continuation prompt injected successfully`, { sessionID });
+      log(`[${HOOK_NAME}] Injection successful`, { sessionID });
     } catch (err) {
-      log(`[${HOOK_NAME}] Prompt injection failed`, { sessionID, error: String(err) });
+      log(`[${HOOK_NAME}] Injection failed`, { sessionID, error: String(err) });
     }
-    state2.mode = "idle";
   }
-  function startCountdown(sessionID, incompleteCount) {
-    const state2 = getOrCreateState(sessionID);
-    invalidate(sessionID, "starting new countdown");
-    state2.version++;
-    state2.mode = "countingDown";
-    const capturedVersion = state2.version;
-    log(`[${HOOK_NAME}] Starting countdown`, {
-      sessionID,
-      seconds: COUNTDOWN_SECONDS,
-      version: capturedVersion,
-      incompleteCount
-    });
-    showCountdownToast(COUNTDOWN_SECONDS, incompleteCount);
+  function startCountdown(sessionID, incompleteCount, total) {
+    const state2 = getState(sessionID);
+    cancelCountdown(sessionID);
     let secondsRemaining = COUNTDOWN_SECONDS;
-    const toastInterval = setInterval(() => {
-      if (state2.version !== capturedVersion) {
-        clearInterval(toastInterval);
-        return;
-      }
+    showCountdownToast(secondsRemaining, incompleteCount);
+    state2.countdownInterval = setInterval(() => {
       secondsRemaining--;
       if (secondsRemaining > 0) {
         showCountdownToast(secondsRemaining, incompleteCount);
       }
     }, 1000);
-    state2.timer = setTimeout(() => {
-      clearInterval(toastInterval);
-      clearTimer(state2);
-      executeInjection(sessionID, capturedVersion);
+    state2.countdownTimer = setTimeout(() => {
+      cancelCountdown(sessionID);
+      injectContinuation(sessionID, incompleteCount, total);
     }, COUNTDOWN_SECONDS * 1000);
+    log(`[${HOOK_NAME}] Countdown started`, { sessionID, seconds: COUNTDOWN_SECONDS, incompleteCount });
   }
   const handler = async ({ event }) => {
     const props = event.properties;
@@ -4621,33 +4551,36 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
       const sessionID = props?.sessionID;
       if (!sessionID)
         return;
-      const isInterrupt = detectInterrupt(props?.error);
-      const state2 = getOrCreateState(sessionID);
-      invalidate(sessionID, isInterrupt ? "user interrupt" : "session error");
-      state2.mode = "errorBypass";
-      log(`[${HOOK_NAME}] session.error received`, { sessionID, isInterrupt, error: props?.error });
+      const state2 = getState(sessionID);
+      state2.lastErrorAt = Date.now();
+      cancelCountdown(sessionID);
+      log(`[${HOOK_NAME}] session.error`, { sessionID, isAbort: isAbortError(props?.error) });
       return;
     }
     if (event.type === "session.idle") {
       const sessionID = props?.sessionID;
       if (!sessionID)
         return;
-      log(`[${HOOK_NAME}] session.idle received`, { sessionID });
-      if (!isMainSession(sessionID)) {
-        log(`[${HOOK_NAME}] Skipped: not main session`, { sessionID });
+      log(`[${HOOK_NAME}] session.idle`, { sessionID });
+      const mainSessionID2 = getMainSessionID();
+      const isMainSession = sessionID === mainSessionID2;
+      const isBackgroundTaskSession = subagentSessions.has(sessionID);
+      if (mainSessionID2 && !isMainSession && !isBackgroundTaskSession) {
+        log(`[${HOOK_NAME}] Skipped: not main or background task session`, { sessionID });
         return;
       }
-      const state2 = getOrCreateState(sessionID);
-      if (state2.mode === "recovering") {
-        log(`[${HOOK_NAME}] Skipped: session in recovery mode`, { sessionID });
+      const state2 = getState(sessionID);
+      if (state2.isRecovering) {
+        log(`[${HOOK_NAME}] Skipped: in recovery`, { sessionID });
         return;
       }
-      if (state2.mode === "errorBypass") {
-        log(`[${HOOK_NAME}] Skipped: error bypass (awaiting user message to resume)`, { sessionID });
+      if (state2.lastErrorAt && Date.now() - state2.lastErrorAt < ERROR_COOLDOWN_MS) {
+        log(`[${HOOK_NAME}] Skipped: recent error (cooldown)`, { sessionID });
         return;
       }
-      if (state2.mode === "countingDown" || state2.mode === "injecting") {
-        log(`[${HOOK_NAME}] Skipped: already ${state2.mode}`, { sessionID });
+      const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((t) => t.status === "running") : false;
+      if (hasRunningBgTasks) {
+        log(`[${HOOK_NAME}] Skipped: background tasks running`, { sessionID });
         return;
       }
       let todos = [];
@@ -4655,54 +4588,37 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
         const response = await ctx.client.session.todo({ path: { id: sessionID } });
         todos = response.data ?? response;
       } catch (err) {
-        log(`[${HOOK_NAME}] Todo API error`, { sessionID, error: String(err) });
+        log(`[${HOOK_NAME}] Todo fetch failed`, { sessionID, error: String(err) });
         return;
       }
       if (!todos || todos.length === 0) {
-        log(`[${HOOK_NAME}] No todos found`, { sessionID });
+        log(`[${HOOK_NAME}] No todos`, { sessionID });
         return;
       }
       const incompleteCount = getIncompleteCount(todos);
       if (incompleteCount === 0) {
-        log(`[${HOOK_NAME}] All todos completed`, { sessionID, total: todos.length });
-        return;
-      }
-      const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((t) => t.status === "running") : false;
-      if (hasRunningBgTasks) {
-        log(`[${HOOK_NAME}] Skipped: background tasks still running`, { sessionID });
+        log(`[${HOOK_NAME}] All todos complete`, { sessionID, total: todos.length });
         return;
       }
-      log(`[${HOOK_NAME}] Found incomplete todos`, {
-        sessionID,
-        incomplete: incompleteCount,
-        total: todos.length
-      });
-      startCountdown(sessionID, incompleteCount);
+      startCountdown(sessionID, incompleteCount, todos.length);
       return;
     }
     if (event.type === "message.updated") {
       const info = props?.info;
       const sessionID = info?.sessionID;
       const role = info?.role;
-      const finish = info?.finish;
       if (!sessionID)
         return;
       if (role === "user") {
         const state2 = sessions.get(sessionID);
-        if (state2?.mode === "errorBypass") {
-          state2.mode = "idle";
-          log(`[${HOOK_NAME}] User message cleared errorBypass mode`, { sessionID });
+        if (state2) {
+          state2.lastErrorAt = undefined;
         }
-        invalidate(sessionID, "user message received");
-        return;
+        cancelCountdown(sessionID);
+        log(`[${HOOK_NAME}] User message: cleared error state`, { sessionID });
       }
-      if (role === "assistant" && !finish) {
-        invalidate(sessionID, "assistant is working (streaming)");
-        return;
-      }
-      if (role === "assistant" && finish) {
-        log(`[${HOOK_NAME}] Assistant turn finished`, { sessionID, finish });
-        return;
+      if (role === "assistant") {
+        cancelCountdown(sessionID);
       }
       return;
     }
@@ -4711,26 +4627,22 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
       const sessionID = info?.sessionID;
       const role = info?.role;
       if (sessionID && role === "assistant") {
-        invalidate(sessionID, "assistant streaming");
+        cancelCountdown(sessionID);
       }
       return;
     }
     if (event.type === "tool.execute.before" || event.type === "tool.execute.after") {
       const sessionID = props?.sessionID;
       if (sessionID) {
-        invalidate(sessionID, `tool execution (${event.type})`);
+        cancelCountdown(sessionID);
       }
       return;
     }
     if (event.type === "session.deleted") {
       const sessionInfo = props?.info;
       if (sessionInfo?.id) {
-        const state2 = sessions.get(sessionInfo.id);
-        if (state2) {
-          clearTimer(state2);
-        }
-        sessions.delete(sessionInfo.id);
-        log(`[${HOOK_NAME}] Session deleted, state cleaned up`, { sessionID: sessionInfo.id });
+        cleanup(sessionInfo.id);
+        log(`[${HOOK_NAME}] Session deleted: cleaned up`, { sessionID: sessionInfo.id });
       }
       return;
     }
@@ -11080,8 +10992,11 @@ function createEmptyMessageSanitizerHook() {
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
       const { messages } = output;
-      for (const message of messages) {
-        if (message.info.role === "user")
+      for (let i = 0;i < messages.length; i++) {
+        const message = messages[i];
+        const isLastMessage = i === messages.length - 1;
+        const isAssistant = message.info.role === "assistant";
+        if (isLastMessage && isAssistant)
           continue;
         const parts = message.parts;
         if (!hasValidContent(parts)) {
@@ -13135,6 +13050,7 @@ Generate comprehensive AGENTS.md files across project hierarchy. Combines root-l
 - **Predict-then-Compare**: Predict standard \u2192 find actual \u2192 document ONLY deviations
 - **Hierarchy Aware**: Parent covers general, children cover specific
 - **No Redundancy**: Child AGENTS.md NEVER repeats parent content
+- **LSP-First**: Use LSP tools for accurate code intelligence when available (semantic > text search)
 
 ---
 
@@ -13197,6 +13113,53 @@ background_task(agent="explore", prompt="Build/CI: FIND .github/workflows, Makef
 background_task(agent="explore", prompt="Test patterns: FIND pytest.ini, jest.config, test structure \u2192 REPORT unique testing conventions")
 \`\`\`
 
+### Code Intelligence Analysis (LSP tools - run in parallel)
+
+LSP provides semantic understanding beyond text search. Use for accurate code mapping.
+
+\`\`\`
+# Step 1: Check LSP availability
+lsp_servers()  # Verify language server is available
+
+# Step 2: Analyze entry point files (run in parallel)
+# Find entry points first, then analyze each with lsp_document_symbols
+lsp_document_symbols(filePath="src/index.ts")      # Main entry
+lsp_document_symbols(filePath="src/main.py")       # Python entry
+lsp_document_symbols(filePath="cmd/main.go")       # Go entry
+
+# Step 3: Discover key symbols across workspace (run in parallel)
+lsp_workspace_symbols(filePath=".", query="class")      # All classes
+lsp_workspace_symbols(filePath=".", query="interface")  # All interfaces
+lsp_workspace_symbols(filePath=".", query="function")   # Top-level functions
+lsp_workspace_symbols(filePath=".", query="type")       # Type definitions
+
+# Step 4: Analyze symbol centrality (for top 5-10 key symbols)
+# High reference count = central/important concept
+lsp_find_references(filePath="src/index.ts", line=X, character=Y)  # Main export
+\`\`\`
+
+#### LSP Analysis Output Format
+
+\`\`\`
+CODE_INTELLIGENCE = {
+  entry_points: [
+    { file: "src/index.ts", exports: ["Plugin", "createHook"], symbol_count: 12 }
+  ],
+  key_symbols: [
+    { name: "Plugin", type: "class", file: "src/index.ts", refs: 45, role: "Central orchestrator" },
+    { name: "createHook", type: "function", file: "src/utils.ts", refs: 23, role: "Hook factory" }
+  ],
+  module_boundaries: [
+    { dir: "src/hooks", exports: 21, imports_from: ["shared/"] },
+    { dir: "src/tools", exports: 15, imports_from: ["shared/", "hooks/"] }
+  ]
+}
+\`\`\`
+
+<critical>
+**LSP Fallback**: If LSP unavailable (no server installed), skip this section and rely on explore agents + AST-grep patterns.
+</critical>
+
 </parallel-tasks>
 
 **Collect all results. Mark "p1-analysis" as completed.**
@@ -13209,13 +13172,35 @@ background_task(agent="explore", prompt="Test patterns: FIND pytest.ini, jest.co
 
 ### Scoring Matrix
 
-| Factor | Weight | Threshold |
-|--------|--------|-----------|
-| File count | 3x | >20 files = high |
-| Subdirectory count | 2x | >5 subdirs = high |
-| Code file ratio | 2x | >70% code = high |
-| Unique patterns | 1x | Has own config |
-| Module boundary | 2x | Has __init__.py/index.ts |
+| Factor | Weight | Threshold | Source |
+|--------|--------|-----------|--------|
+| File count | 3x | >20 files = high | bash |
+| Subdirectory count | 2x | >5 subdirs = high | bash |
+| Code file ratio | 2x | >70% code = high | bash |
+| Unique patterns | 1x | Has own config | explore |
+| Module boundary | 2x | Has __init__.py/index.ts | bash |
+| **Symbol density** | 2x | >30 symbols = high | LSP |
+| **Export count** | 2x | >10 exports = high | LSP |
+| **Reference centrality** | 3x | Symbols with >20 refs | LSP |
+
+<lsp-scoring>
+**LSP-Enhanced Scoring** (if available):
+
+\`\`\`
+For each directory in candidates:
+  symbols = lsp_document_symbols(dir/index.ts or dir/__init__.py)
+  
+  symbol_score = len(symbols) > 30 ? 6 : len(symbols) > 15 ? 3 : 0
+  export_score = count(exported symbols) > 10 ? 4 : 0
+  
+  # Check if this module is central (many things depend on it)
+  for each exported symbol:
+    refs = lsp_find_references(symbol)
+    if refs > 20: centrality_score += 3
+  
+  total_score += symbol_score + export_score + centrality_score
+\`\`\`
+</lsp-scoring>
 
 ### Decision Rules
 
@@ -13273,6 +13258,28 @@ Root AGENTS.md gets **full treatment** with Predict-then-Compare synthesis.
 |------|----------|-------|
 | Add feature X | \\\`src/x/\\\` | {pattern hint} |
 
+## CODE MAP
+
+{Generated from LSP analysis - shows key symbols and their relationships}
+
+| Symbol | Type | Location | Refs | Role |
+|--------|------|----------|------|------|
+| {MainClass} | Class | \\\`src/index.ts\\\` | {N} | {Central orchestrator} |
+| {createX} | Function | \\\`src/utils.ts\\\` | {N} | {Factory pattern} |
+| {Config} | Interface | \\\`src/types.ts\\\` | {N} | {Configuration contract} |
+
+### Module Dependencies
+
+\\\`\\\`\\\`
+{entry} \u2500\u2500imports\u2500\u2500> {core/}
+   \u2502                    \u2502
+   \u2514\u2500\u2500imports\u2500\u2500> {utils/} <\u2500\u2500imports\u2500\u2500 {features/}
+\\\`\\\`\\\`
+
+<code-map-note>
+**Skip CODE MAP if**: LSP unavailable OR project too small (<10 files) OR no clear module boundaries.
+</code-map-note>
+
 ## CONVENTIONS
 
 {ONLY deviations from standard - skip generic advice}
@@ -13413,7 +13420,10 @@ Hierarchy:
 - **Generic content**: Remove anything that applies to ALL projects
 - **Sequential execution**: MUST use parallel agents
 - **Deep nesting**: Rarely need AGENTS.md at depth 4+
-- **Verbose style**: "This directory contains..." \u2192 just list it`;
+- **Verbose style**: "This directory contains..." \u2192 just list it
+- **Ignoring LSP**: If LSP available, USE IT - semantic analysis > text grep
+- **LSP without fallback**: Always have explore agent backup if LSP unavailable
+- **Over-referencing**: Don't trace refs for EVERY symbol - focus on exports only`;
 
 // src/features/builtin-commands/commands.ts
 var BUILTIN_COMMAND_DEFINITIONS = {
@@ -14446,6 +14456,10 @@ function isServerInstalled(command) {
   if (command.length === 0)
     return false;
   const cmd = command[0];
+  if (cmd.includes("/") || cmd.includes("\\")) {
+    if (existsSync34(cmd))
+      return true;
+  }
   const isWindows2 = process.platform === "win32";
   const ext = isWindows2 ? ".exe" : "";
   const pathEnv = process.env.PATH || "";
@@ -14470,6 +14484,9 @@ function isServerInstalled(command) {
       return true;
     }
   }
+  if (cmd === "bun" || cmd === "node") {
+    return true;
+  }
   return false;
 }
 function getAllServers() {
@@ -28558,7 +28575,7 @@ var ast_grep_replace = tool({
   }
 });
 // src/tools/grep/cli.ts
-var {spawn: spawn8 } = globalThis.Bun;
+var {spawn: spawn9 } = globalThis.Bun;
 
 // src/tools/grep/constants.ts
 import { existsSync as existsSync40 } from "fs";
@@ -28568,6 +28585,31 @@ import { spawnSync } from "child_process";
 // src/tools/grep/downloader.ts
 import { existsSync as existsSync39, mkdirSync as mkdirSync11, chmodSync as chmodSync3, unlinkSync as unlinkSync10, readdirSync as readdirSync14 } from "fs";
 import { join as join47 } from "path";
+var {spawn: spawn8 } = globalThis.Bun;
+function findFileRecursive(dir, filename) {
+  try {
+    const entries = readdirSync14(dir, { withFileTypes: true, recursive: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name === filename) {
+        return join47(entry.parentPath ?? dir, entry.name);
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+var RG_VERSION = "14.1.1";
+var PLATFORM_CONFIG = {
+  "arm64-darwin": { platform: "aarch64-apple-darwin", extension: "tar.gz" },
+  "arm64-linux": { platform: "aarch64-unknown-linux-gnu", extension: "tar.gz" },
+  "x64-darwin": { platform: "x86_64-apple-darwin", extension: "tar.gz" },
+  "x64-linux": { platform: "x86_64-unknown-linux-musl", extension: "tar.gz" },
+  "x64-win32": { platform: "x86_64-pc-windows-msvc", extension: "zip" }
+};
+function getPlatformKey() {
+  return `${process.arch}-${process.platform}`;
+}
 function getInstallDir() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
   return join47(homeDir, ".cache", "oh-my-opencode", "bin");
@@ -28576,6 +28618,110 @@ function getRgPath() {
   const isWindows2 = process.platform === "win32";
   return join47(getInstallDir(), isWindows2 ? "rg.exe" : "rg");
 }
+async function downloadFile(url2, destPath) {
+  const response2 = await fetch(url2);
+  if (!response2.ok) {
+    throw new Error(`Failed to download: ${response2.status} ${response2.statusText}`);
+  }
+  const buffer = await response2.arrayBuffer();
+  await Bun.write(destPath, buffer);
+}
+async function extractTarGz2(archivePath, destDir) {
+  const platformKey = getPlatformKey();
+  const args = ["tar", "-xzf", archivePath, "--strip-components=1"];
+  if (platformKey.endsWith("-darwin")) {
+    args.push("--include=*/rg");
+  } else if (platformKey.endsWith("-linux")) {
+    args.push("--wildcards", "*/rg");
+  }
+  const proc = spawn8(args, {
+    cwd: destDir,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`Failed to extract tar.gz: ${stderr}`);
+  }
+}
+async function extractZipWindows(archivePath, destDir) {
+  const proc = spawn8(["powershell", "-Command", `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`], { stdout: "pipe", stderr: "pipe" });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error("Failed to extract zip with PowerShell");
+  }
+  const foundPath = findFileRecursive(destDir, "rg.exe");
+  if (foundPath) {
+    const destPath = join47(destDir, "rg.exe");
+    if (foundPath !== destPath) {
+      const { renameSync } = await import("fs");
+      renameSync(foundPath, destPath);
+    }
+  }
+}
+async function extractZipUnix(archivePath, destDir) {
+  const proc = spawn8(["unzip", "-o", archivePath, "-d", destDir], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new Error("Failed to extract zip");
+  }
+  const foundPath = findFileRecursive(destDir, "rg");
+  if (foundPath) {
+    const destPath = join47(destDir, "rg");
+    if (foundPath !== destPath) {
+      const { renameSync } = await import("fs");
+      renameSync(foundPath, destPath);
+    }
+  }
+}
+async function extractZip3(archivePath, destDir) {
+  if (process.platform === "win32") {
+    await extractZipWindows(archivePath, destDir);
+  } else {
+    await extractZipUnix(archivePath, destDir);
+  }
+}
+async function downloadAndInstallRipgrep() {
+  const platformKey = getPlatformKey();
+  const config3 = PLATFORM_CONFIG[platformKey];
+  if (!config3) {
+    throw new Error(`Unsupported platform: ${platformKey}`);
+  }
+  const installDir = getInstallDir();
+  const rgPath = getRgPath();
+  if (existsSync39(rgPath)) {
+    return rgPath;
+  }
+  mkdirSync11(installDir, { recursive: true });
+  const filename = `ripgrep-${RG_VERSION}-${config3.platform}.${config3.extension}`;
+  const url2 = `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/${filename}`;
+  const archivePath = join47(installDir, filename);
+  try {
+    await downloadFile(url2, archivePath);
+    if (config3.extension === "tar.gz") {
+      await extractTarGz2(archivePath, installDir);
+    } else {
+      await extractZip3(archivePath, installDir);
+    }
+    if (process.platform !== "win32") {
+      chmodSync3(rgPath, 493);
+    }
+    if (!existsSync39(rgPath)) {
+      throw new Error("ripgrep binary not found after extraction");
+    }
+    return rgPath;
+  } finally {
+    if (existsSync39(archivePath)) {
+      try {
+        unlinkSync10(archivePath);
+      } catch {}
+    }
+  }
+}
 function getInstalledRipgrepPath() {
   const rgPath = getRgPath();
   return existsSync39(rgPath) ? rgPath : null;
@@ -28583,6 +28729,7 @@ function getInstalledRipgrepPath() {
 
 // src/tools/grep/constants.ts
 var cachedCli = null;
+var autoInstallAttempted = false;
 function findExecutable(name) {
   const isWindows2 = process.platform === "win32";
   const cmd = isWindows2 ? "where" : "which";
@@ -28601,6 +28748,7 @@ function getOpenCodeBundledRg() {
   const isWindows2 = process.platform === "win32";
   const rgName = isWindows2 ? "rg.exe" : "rg";
   const candidates = [
+    join48(getDataDir(), "opencode", "bin", rgName),
     join48(execDir, rgName),
     join48(execDir, "bin", rgName),
     join48(execDir, "..", "bin", rgName),
@@ -28639,6 +28787,23 @@ function resolveGrepCli() {
   cachedCli = { path: "rg", backend: "rg" };
   return cachedCli;
 }
+async function resolveGrepCliWithAutoInstall() {
+  const current = resolveGrepCli();
+  if (current.backend === "rg") {
+    return current;
+  }
+  if (autoInstallAttempted) {
+    return current;
+  }
+  autoInstallAttempted = true;
+  try {
+    const rgPath = await downloadAndInstallRipgrep();
+    cachedCli = { path: rgPath, backend: "rg" };
+    return cachedCli;
+  } catch {
+    return current;
+  }
+}
 var DEFAULT_MAX_DEPTH = 20;
 var DEFAULT_MAX_FILESIZE = "10M";
 var DEFAULT_MAX_COUNT = 500;
@@ -28753,7 +28918,7 @@ async function runRg(options) {
   }
   const paths = options.paths?.length ? options.paths : ["."];
   args.push(...paths);
-  const proc = spawn8([cli.path, ...args], {
+  const proc = spawn9([cli.path, ...args], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -28855,7 +29020,7 @@ var grep = tool({
 });
 
 // src/tools/glob/cli.ts
-var {spawn: spawn9 } = globalThis.Bun;
+var {spawn: spawn10 } = globalThis.Bun;
 
 // src/tools/glob/constants.ts
 var DEFAULT_TIMEOUT_MS3 = 60000;
@@ -28893,6 +29058,19 @@ function buildFindArgs(options) {
   }
   return args;
 }
+function buildPowerShellCommand(options) {
+  const maxDepth = Math.min(options.maxDepth ?? DEFAULT_MAX_DEPTH2, DEFAULT_MAX_DEPTH2);
+  const paths = options.paths?.length ? options.paths : ["."];
+  const searchPath = paths[0] || ".";
+  const escapedPath = searchPath.replace(/'/g, "''");
+  const escapedPattern = options.pattern.replace(/'/g, "''");
+  let psCommand = `Get-ChildItem -Path '${escapedPath}' -File -Recurse -Depth ${maxDepth - 1} -Filter '${escapedPattern}'`;
+  if (options.hidden) {
+    psCommand += " -Force";
+  }
+  psCommand += " -ErrorAction SilentlyContinue | Select-Object -ExpandProperty FullName";
+  return ["powershell", "-NoProfile", "-Command", psCommand];
+}
 async function getFileMtime(filePath) {
   try {
     const stats = await stat(filePath);
@@ -28901,21 +29079,33 @@ async function getFileMtime(filePath) {
     return 0;
   }
 }
-async function runRgFiles(options) {
-  const cli = resolveGrepCli();
+async function runRgFiles(options, resolvedCli) {
+  const cli = resolvedCli ?? resolveGrepCli();
   const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS3, DEFAULT_TIMEOUT_MS3);
   const limit = Math.min(options.limit ?? DEFAULT_LIMIT, DEFAULT_LIMIT);
   const isRg = cli.backend === "rg";
-  const args = isRg ? buildRgArgs2(options) : buildFindArgs(options);
-  const paths = options.paths?.length ? options.paths : ["."];
+  const isWindows2 = process.platform === "win32";
+  let command;
+  let cwd;
   if (isRg) {
+    const args = buildRgArgs2(options);
+    const paths = options.paths?.length ? options.paths : ["."];
     args.push(...paths);
+    command = [cli.path, ...args];
+    cwd = undefined;
+  } else if (isWindows2) {
+    command = buildPowerShellCommand(options);
+    cwd = undefined;
+  } else {
+    const args = buildFindArgs(options);
+    const paths = options.paths?.length ? options.paths : ["."];
+    cwd = paths[0] || ".";
+    command = [cli.path, ...args];
   }
-  const cwd = paths[0] || ".";
-  const proc = spawn9([cli.path, ...args], {
+  const proc = spawn10(command, {
     stdout: "pipe",
     stderr: "pipe",
-    cwd: isRg ? undefined : cwd
+    cwd
   });
   const timeoutPromise = new Promise((_, reject) => {
     const id = setTimeout(() => {
@@ -28947,7 +29137,14 @@ async function runRgFiles(options) {
         truncated = true;
         break;
       }
-      const filePath = isRg ? line : `${cwd}/${line}`;
+      let filePath;
+      if (isRg) {
+        filePath = line;
+      } else if (isWindows2) {
+        filePath = line.trim();
+      } else {
+        filePath = `${cwd}/${line}`;
+      }
       const mtime = await getFileMtime(filePath);
       files.push({ path: filePath, mtime });
     }
@@ -28998,11 +29195,12 @@ var glob = tool({
   },
   execute: async (args) => {
     try {
+      const cli = await resolveGrepCliWithAutoInstall();
       const paths = args.path ? [args.path] : undefined;
       const result = await runRgFiles({
         pattern: args.pattern,
         paths
-      });
+      }, cli);
       return formatGlobResult(result);
     } catch (e) {
       return `Error: ${e instanceof Error ? e.message : String(e)}`;
@@ -29718,14 +29916,14 @@ var INTERACTIVE_BASH_DESCRIPTION = `Execute tmux commands. Use "omo-{name}" sess
 Blocked (use bash instead): capture-pane, save-buffer, show-buffer, pipe-pane.`;
 
 // src/tools/interactive-bash/utils.ts
-var {spawn: spawn10 } = globalThis.Bun;
+var {spawn: spawn11 } = globalThis.Bun;
 var tmuxPath = null;
 var initPromise3 = null;
 async function findTmuxPath() {
   const isWindows2 = process.platform === "win32";
   const cmd = isWindows2 ? "where" : "which";
   try {
-    const proc = spawn10([cmd, "tmux"], {
+    const proc = spawn11([cmd, "tmux"], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -29739,7 +29937,7 @@ async function findTmuxPath() {
     if (!path7) {
       return null;
     }
-    const verifyProc = spawn10([path7, "-V"], {
+    const verifyProc = spawn11([path7, "-V"], {
       stdout: "pipe",
       stderr: "pipe"
     });