fix(tools): avoid shared barrel import in ripgrep downloader

- Use tool.schema.enum() for output_mode instead of generic string()
- Remove unsafe type assertion for output_mode
- Fix files_with_matches mode returning empty results by adding
  filesOnly flag to parseOutput for --files-with-matches rg output

src/plugin/event.ts

@@ -1,58 +1,53 @@
-import type { OhMyOpenCodeConfig } from "../config";
-import type { PluginContext } from "./types";
+import type { OhMyOpenCodeConfig } from "../config"
+import type { PluginContext } from "./types"
 
 import {
   clearSessionAgent,
   getMainSessionID,
   getSessionAgent,
-  setMainSession,
   subagentSessions,
   syncSubagentSessions,
+  setMainSession,
   updateSessionAgent,
-} from "../features/claude-code-session-state";
-import {
-  clearPendingModelFallback,
-  clearSessionFallbackChain,
-  setPendingModelFallback,
-} from "../hooks/model-fallback/hook";
-import { resetMessageCursor } from "../shared";
-import { log } from "../shared/logger";
-import { shouldRetryError } from "../shared/model-error-classifier";
-import { clearSessionModel, setSessionModel } from "../shared/session-model-state";
-import { deleteSessionTools } from "../shared/session-tools-store";
-import { lspManager } from "../tools";
+} from "../features/claude-code-session-state"
+import { resetMessageCursor } from "../shared"
+import { lspManager } from "../tools"
+import { shouldRetryError } from "../shared/model-error-classifier"
+import { clearPendingModelFallback, clearSessionFallbackChain, setPendingModelFallback } from "../hooks/model-fallback/hook"
+import { log } from "../shared/logger"
+import { clearSessionModel, setSessionModel } from "../shared/session-model-state"
 
-import type { CreatedHooks } from "../create-hooks";
-import type { Managers } from "../create-managers";
-import { pruneRecentSyntheticIdles } from "./recent-synthetic-idles";
-import { normalizeSessionStatusToIdle } from "./session-status-normalizer";
+import type { CreatedHooks } from "../create-hooks"
+import type { Managers } from "../create-managers"
+import { normalizeSessionStatusToIdle } from "./session-status-normalizer"
+import { pruneRecentSyntheticIdles } from "./recent-synthetic-idles"
 
 type FirstMessageVariantGate = {
-  markSessionCreated: (sessionInfo: { id?: string; title?: string; parentID?: string } | undefined) => void;
-  clear: (sessionID: string) => void;
-};
+  markSessionCreated: (sessionInfo: { id?: string; title?: string; parentID?: string } | undefined) => void
+  clear: (sessionID: string) => void
+}
 
 function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
+  return typeof value === "object" && value !== null
 }
 
 function normalizeFallbackModelID(modelID: string): string {
   return modelID
     .replace(/-thinking$/i, "")
     .replace(/-max$/i, "")
-    .replace(/-high$/i, "");
+    .replace(/-high$/i, "")
 }
 
 function extractErrorName(error: unknown): string | undefined {
-  if (isRecord(error) && typeof error.name === "string") return error.name;
-  if (error instanceof Error) return error.name;
-  return undefined;
+  if (isRecord(error) && typeof error.name === "string") return error.name
+  if (error instanceof Error) return error.name
+  return undefined
 }
 
 function extractErrorMessage(error: unknown): string {
-  if (!error) return "";
-  if (typeof error === "string") return error;
-  if (error instanceof Error) return error.message;
+  if (!error) return ""
+  if (typeof error === "string") return error
+  if (error instanceof Error) return error.message
 
   if (isRecord(error)) {
     const candidates: unknown[] = [
@@ -61,112 +56,116 @@ function extractErrorMessage(error: unknown): string {
       error.error,
       isRecord(error.data) ? error.data.error : undefined,
       error.cause,
-    ];
+    ]
 
     for (const candidate of candidates) {
       if (isRecord(candidate) && typeof candidate.message === "string" && candidate.message.length > 0) {
-        return candidate.message;
+        return candidate.message
       }
     }
   }
 
   try {
-    return JSON.stringify(error);
+    return JSON.stringify(error)
   } catch {
-    return String(error);
+    return String(error)
   }
 }
 
-function extractProviderModelFromErrorMessage(message: string): { providerID?: string; modelID?: string } {
-  const lower = message.toLowerCase();
+function extractProviderModelFromErrorMessage(
+  message: string,
+): { providerID?: string; modelID?: string } {
+  const lower = message.toLowerCase()
 
-  const providerModel = lower.match(/model\s+not\s+found:\s*([a-z0-9_-]+)\s*\/\s*([a-z0-9._-]+)/i);
+  const providerModel = lower.match(/model\s+not\s+found:\s*([a-z0-9_-]+)\s*\/\s*([a-z0-9._-]+)/i)
   if (providerModel) {
     return {
       providerID: providerModel[1],
       modelID: providerModel[2],
-    };
+    }
   }
 
-  const modelOnly = lower.match(/unknown\s+provider\s+for\s+model\s+([a-z0-9._-]+)/i);
+  const modelOnly = lower.match(/unknown\s+provider\s+for\s+model\s+([a-z0-9._-]+)/i)
   if (modelOnly) {
     return {
       modelID: modelOnly[1],
-    };
+    }
   }
 
-  return {};
+  return {}
 }
-type EventInput = Parameters<NonNullable<NonNullable<CreatedHooks["writeExistingFileGuard"]>["event"]>>[0];
+type EventInput = Parameters<
+  NonNullable<NonNullable<CreatedHooks["writeExistingFileGuard"]>["event"]>
+>[0]
 export function createEventHandler(args: {
-  ctx: PluginContext;
-  pluginConfig: OhMyOpenCodeConfig;
-  firstMessageVariantGate: FirstMessageVariantGate;
-  managers: Managers;
-  hooks: CreatedHooks;
+  ctx: PluginContext
+  pluginConfig: OhMyOpenCodeConfig
+  firstMessageVariantGate: FirstMessageVariantGate
+  managers: Managers
+  hooks: CreatedHooks
 }): (input: EventInput) => Promise<void> {
-  const { ctx, firstMessageVariantGate, managers, hooks } = args;
+  const { ctx, firstMessageVariantGate, managers, hooks } = args
   const pluginContext = ctx as {
-    directory: string;
+    directory: string
     client: {
       session: {
-        abort: (input: { path: { id: string } }) => Promise<unknown>;
+        abort: (input: { path: { id: string } }) => Promise<unknown>
         prompt: (input: {
-          path: { id: string };
-          body: { parts: Array<{ type: "text"; text: string }> };
-          query: { directory: string };
-        }) => Promise<unknown>;
-      };
-    };
-  };
+          path: { id: string }
+          body: { parts: Array<{ type: "text"; text: string }> }
+          query: { directory: string }
+        }) => Promise<unknown>
+      }
+    }
+  }
   const isRuntimeFallbackEnabled =
     hooks.runtimeFallback !== null &&
     hooks.runtimeFallback !== undefined &&
     (typeof args.pluginConfig.runtime_fallback === "boolean"
       ? args.pluginConfig.runtime_fallback
-      : (args.pluginConfig.runtime_fallback?.enabled ?? false));
+      : (args.pluginConfig.runtime_fallback?.enabled ?? false))
 
   // Avoid triggering multiple abort+continue cycles for the same failing assistant message.
-  const lastHandledModelErrorMessageID = new Map<string, string>();
-  const lastHandledRetryStatusKey = new Map<string, string>();
-  const lastKnownModelBySession = new Map<string, { providerID: string; modelID: string }>();
+  const lastHandledModelErrorMessageID = new Map<string, string>()
+  const lastHandledRetryStatusKey = new Map<string, string>()
+  const lastKnownModelBySession = new Map<string, { providerID: string; modelID: string }>()
 
   const dispatchToHooks = async (input: EventInput): Promise<void> => {
-    await Promise.resolve(hooks.autoUpdateChecker?.event?.(input));
-    await Promise.resolve(hooks.claudeCodeHooks?.event?.(input));
-    await Promise.resolve(hooks.backgroundNotificationHook?.event?.(input));
-    await Promise.resolve(hooks.sessionNotification?.(input));
-    await Promise.resolve(hooks.todoContinuationEnforcer?.handler?.(input));
-    await Promise.resolve(hooks.unstableAgentBabysitter?.event?.(input));
-    await Promise.resolve(hooks.contextWindowMonitor?.event?.(input));
-    await Promise.resolve(hooks.directoryAgentsInjector?.event?.(input));
-    await Promise.resolve(hooks.directoryReadmeInjector?.event?.(input));
-    await Promise.resolve(hooks.rulesInjector?.event?.(input));
-    await Promise.resolve(hooks.thinkMode?.event?.(input));
-    await Promise.resolve(hooks.anthropicContextWindowLimitRecovery?.event?.(input));
-    await Promise.resolve(hooks.runtimeFallback?.event?.(input));
-    await Promise.resolve(hooks.agentUsageReminder?.event?.(input));
-    await Promise.resolve(hooks.categorySkillReminder?.event?.(input));
-    await Promise.resolve(hooks.interactiveBashSession?.event?.(input as EventInput));
-    await Promise.resolve(hooks.ralphLoop?.event?.(input));
-    await Promise.resolve(hooks.stopContinuationGuard?.event?.(input));
-    await Promise.resolve(hooks.compactionTodoPreserver?.event?.(input));
-    await Promise.resolve(hooks.writeExistingFileGuard?.event?.(input));
-    await Promise.resolve(hooks.atlasHook?.handler?.(input));
-  };
+    await Promise.resolve(hooks.autoUpdateChecker?.event?.(input))
+    await Promise.resolve(hooks.claudeCodeHooks?.event?.(input))
+    await Promise.resolve(hooks.backgroundNotificationHook?.event?.(input))
+    await Promise.resolve(hooks.sessionNotification?.(input))
+    await Promise.resolve(hooks.todoContinuationEnforcer?.handler?.(input))
+    await Promise.resolve(hooks.unstableAgentBabysitter?.event?.(input))
+    await Promise.resolve(hooks.contextWindowMonitor?.event?.(input))
+    await Promise.resolve(hooks.directoryAgentsInjector?.event?.(input))
+    await Promise.resolve(hooks.directoryReadmeInjector?.event?.(input))
+    await Promise.resolve(hooks.rulesInjector?.event?.(input))
+    await Promise.resolve(hooks.thinkMode?.event?.(input))
+    await Promise.resolve(hooks.anthropicContextWindowLimitRecovery?.event?.(input))
+    await Promise.resolve(hooks.runtimeFallback?.event?.(input))
+    await Promise.resolve(hooks.agentUsageReminder?.event?.(input))
+    await Promise.resolve(hooks.categorySkillReminder?.event?.(input))
+    await Promise.resolve(hooks.interactiveBashSession?.event?.(input as EventInput))
+    await Promise.resolve(hooks.ralphLoop?.event?.(input))
+    await Promise.resolve(hooks.stopContinuationGuard?.event?.(input))
+    await Promise.resolve(hooks.compactionTodoPreserver?.event?.(input))
+    await Promise.resolve(hooks.writeExistingFileGuard?.event?.(input))
+    await Promise.resolve(hooks.atlasHook?.handler?.(input))
+  }
 
-  const recentSyntheticIdles = new Map<string, number>();
-  const recentRealIdles = new Map<string, number>();
-  const DEDUP_WINDOW_MS = 500;
+  const recentSyntheticIdles = new Map<string, number>()
+  const recentRealIdles = new Map<string, number>()
+  const DEDUP_WINDOW_MS = 500
 
   const shouldAutoRetrySession = (sessionID: string): boolean => {
-    if (syncSubagentSessions.has(sessionID)) return true;
-    const mainSessionID = getMainSessionID();
-    if (mainSessionID) return sessionID === mainSessionID;
+    if (syncSubagentSessions.has(sessionID)) return true
+    const mainSessionID = getMainSessionID()
+    if (mainSessionID) return sessionID === mainSessionID
     // Headless runs (or resumed sessions) may not emit session.created, so mainSessionID can be unset.
     // In that case, treat any non-subagent session as the "main" interactive session.
-    return !subagentSessions.has(sessionID);
-  };
+    return !subagentSessions.has(sessionID)
+  }
 
   return async (input): Promise<void> => {
     pruneRecentSyntheticIdles({
@@ -174,98 +173,97 @@ export function createEventHandler(args: {
       recentRealIdles,
       now: Date.now(),
       dedupWindowMs: DEDUP_WINDOW_MS,
-    });
+    })
 
     if (input.event.type === "session.idle") {
-      const sessionID = (input.event.properties as Record<string, unknown> | undefined)?.sessionID as
-        | string
-        | undefined;
+      const sessionID = (input.event.properties as Record<string, unknown> | undefined)?.sessionID as string | undefined
       if (sessionID) {
-        const emittedAt = recentSyntheticIdles.get(sessionID);
+        const emittedAt = recentSyntheticIdles.get(sessionID)
         if (emittedAt && Date.now() - emittedAt < DEDUP_WINDOW_MS) {
-          recentSyntheticIdles.delete(sessionID);
-          return;
+          recentSyntheticIdles.delete(sessionID)
+          return
         }
-        recentRealIdles.set(sessionID, Date.now());
+        recentRealIdles.set(sessionID, Date.now())
       }
     }
 
-    await dispatchToHooks(input);
+    await dispatchToHooks(input)
 
-    const syntheticIdle = normalizeSessionStatusToIdle(input);
+    const syntheticIdle = normalizeSessionStatusToIdle(input)
     if (syntheticIdle) {
-      const sessionID = (syntheticIdle.event.properties as Record<string, unknown>)?.sessionID as string;
-      const emittedAt = recentRealIdles.get(sessionID);
+      const sessionID = (syntheticIdle.event.properties as Record<string, unknown>)?.sessionID as string
+      const emittedAt = recentRealIdles.get(sessionID)
       if (emittedAt && Date.now() - emittedAt < DEDUP_WINDOW_MS) {
-        recentRealIdles.delete(sessionID);
-        return;
+        recentRealIdles.delete(sessionID)
+        return
       }
-      recentSyntheticIdles.set(sessionID, Date.now());
-      await dispatchToHooks(syntheticIdle as EventInput);
+      recentSyntheticIdles.set(sessionID, Date.now())
+      await dispatchToHooks(syntheticIdle as EventInput)
     }
 
-    const { event } = input;
-    const props = event.properties as Record<string, unknown> | undefined;
+    const { event } = input
+    const props = event.properties as Record<string, unknown> | undefined
 
     if (event.type === "session.created") {
-      const sessionInfo = props?.info as { id?: string; title?: string; parentID?: string } | undefined;
+      const sessionInfo = props?.info as
+        | { id?: string; title?: string; parentID?: string }
+        | undefined
 
       if (!sessionInfo?.parentID) {
-        setMainSession(sessionInfo?.id);
+        setMainSession(sessionInfo?.id)
       }
 
-      firstMessageVariantGate.markSessionCreated(sessionInfo);
+      firstMessageVariantGate.markSessionCreated(sessionInfo)
 
       await managers.tmuxSessionManager.onSessionCreated(
         event as {
-          type: string;
+          type: string
           properties?: {
-            info?: { id?: string; parentID?: string; title?: string };
-          };
+            info?: { id?: string; parentID?: string; title?: string }
+          }
         },
-      );
+      )
     }
 
     if (event.type === "session.deleted") {
-      const sessionInfo = props?.info as { id?: string } | undefined;
+      const sessionInfo = props?.info as { id?: string } | undefined
       if (sessionInfo?.id === getMainSessionID()) {
-        setMainSession(undefined);
+        setMainSession(undefined)
       }
 
       if (sessionInfo?.id) {
-        clearSessionAgent(sessionInfo.id);
-        lastHandledModelErrorMessageID.delete(sessionInfo.id);
-        lastHandledRetryStatusKey.delete(sessionInfo.id);
-        lastKnownModelBySession.delete(sessionInfo.id);
-        clearPendingModelFallback(sessionInfo.id);
-        clearSessionFallbackChain(sessionInfo.id);
-        resetMessageCursor(sessionInfo.id);
-        firstMessageVariantGate.clear(sessionInfo.id);
-        clearSessionModel(sessionInfo.id);
-        syncSubagentSessions.delete(sessionInfo.id);
-        deleteSessionTools(sessionInfo.id);
-        await managers.skillMcpManager.disconnectSession(sessionInfo.id);
-        await lspManager.cleanupTempDirectoryClients();
+        clearSessionAgent(sessionInfo.id)
+        lastHandledModelErrorMessageID.delete(sessionInfo.id)
+        lastHandledRetryStatusKey.delete(sessionInfo.id)
+        lastKnownModelBySession.delete(sessionInfo.id)
+        clearPendingModelFallback(sessionInfo.id)
+        clearSessionFallbackChain(sessionInfo.id)
+        resetMessageCursor(sessionInfo.id)
+        firstMessageVariantGate.clear(sessionInfo.id)
+        clearSessionModel(sessionInfo.id)
+        syncSubagentSessions.delete(sessionInfo.id)
+        await managers.skillMcpManager.disconnectSession(sessionInfo.id)
+        await lspManager.cleanupTempDirectoryClients()
         await managers.tmuxSessionManager.onSessionDeleted({
           sessionID: sessionInfo.id,
-        });
+        })
       }
     }
 
     if (event.type === "message.updated") {
-      const info = props?.info as Record<string, unknown> | undefined;
-      const sessionID = info?.sessionID as string | undefined;
-      const agent = info?.agent as string | undefined;
-      const role = info?.role as string | undefined;
+      const info = props?.info as Record<string, unknown> | undefined
+      const sessionID = info?.sessionID as string | undefined
+      const agent = info?.agent as string | undefined
+      const role = info?.role as string | undefined
       if (sessionID && role === "user") {
         if (agent) {
-          updateSessionAgent(sessionID, agent);
+          updateSessionAgent(sessionID, agent)
         }
-        const providerID = info?.providerID as string | undefined;
-        const modelID = info?.modelID as string | undefined;
+        const providerID = info?.providerID as string | undefined
+        const modelID = info?.modelID as string | undefined
         if (providerID && modelID) {
-          lastKnownModelBySession.set(sessionID, { providerID, modelID });
-          setSessionModel(sessionID, { providerID, modelID });
+          lastKnownModelBySession.set(sessionID, { providerID, modelID })
+          setSessionModel(sessionID, { providerID, modelID })
         }
       }
 
@@ -273,128 +271,132 @@ export function createEventHandler(args: {
       // session.error events are not guaranteed for all providers, so we also observe message.updated.
       if (sessionID && role === "assistant" && !isRuntimeFallbackEnabled) {
         try {
-          const assistantMessageID = info?.id as string | undefined;
-          const assistantError = info?.error;
+          const assistantMessageID = info?.id as string | undefined
+          const assistantError = info?.error
           if (assistantMessageID && assistantError) {
-            const lastHandled = lastHandledModelErrorMessageID.get(sessionID);
+            const lastHandled = lastHandledModelErrorMessageID.get(sessionID)
             if (lastHandled === assistantMessageID) {
-              return;
+              return
             }
 
-            const errorName = extractErrorName(assistantError);
-            const errorMessage = extractErrorMessage(assistantError);
-            const errorInfo = { name: errorName, message: errorMessage };
+            const errorName = extractErrorName(assistantError)
+            const errorMessage = extractErrorMessage(assistantError)
+            const errorInfo = { name: errorName, message: errorMessage }
 
             if (shouldRetryError(errorInfo)) {
               // Prefer the agent/model/provider from the assistant message payload.
-              let agentName = agent ?? getSessionAgent(sessionID);
+              let agentName = agent ?? getSessionAgent(sessionID)
               if (!agentName && sessionID === getMainSessionID()) {
                 if (errorMessage.includes("claude-opus") || errorMessage.includes("opus")) {
-                  agentName = "sisyphus";
+                  agentName = "sisyphus"
                 } else if (errorMessage.includes("gpt-5")) {
-                  agentName = "hephaestus";
+                  agentName = "hephaestus"
                 } else {
-                  agentName = "sisyphus";
+                  agentName = "sisyphus"
                 }
               }
 
               if (agentName) {
-                const currentProvider = (info?.providerID as string | undefined) ?? "opencode";
-                const rawModel = (info?.modelID as string | undefined) ?? "claude-opus-4-6";
-                const currentModel = normalizeFallbackModelID(rawModel);
+                const currentProvider = (info?.providerID as string | undefined) ?? "opencode"
+                const rawModel = (info?.modelID as string | undefined) ?? "claude-opus-4-6"
+                const currentModel = normalizeFallbackModelID(rawModel)
 
-                const setFallback = setPendingModelFallback(sessionID, agentName, currentProvider, currentModel);
+                const setFallback = setPendingModelFallback(
+                  sessionID,
+                  agentName,
+                  currentProvider,
+                  currentModel,
+                )
 
-                if (
-                  setFallback &&
-                  shouldAutoRetrySession(sessionID) &&
-                  !hooks.stopContinuationGuard?.isStopped(sessionID)
-                ) {
-                  lastHandledModelErrorMessageID.set(sessionID, assistantMessageID);
+                if (setFallback && shouldAutoRetrySession(sessionID) && !hooks.stopContinuationGuard?.isStopped(sessionID)) {
+                  lastHandledModelErrorMessageID.set(sessionID, assistantMessageID)
 
-                  await pluginContext.client.session.abort({ path: { id: sessionID } }).catch(() => {});
+                  await pluginContext.client.session.abort({ path: { id: sessionID } }).catch(() => {})
                   await pluginContext.client.session
                     .prompt({
                       path: { id: sessionID },
                       body: { parts: [{ type: "text", text: "continue" }] },
                       query: { directory: pluginContext.directory },
                     })
-                    .catch(() => {});
+                    .catch(() => {})
                 }
               }
             }
           }
         } catch (err) {
-          log("[event] model-fallback error in message.updated:", { sessionID, error: err });
+          log("[event] model-fallback error in message.updated:", { sessionID, error: err })
         }
       }
     }
 
     if (event.type === "session.status") {
-      const sessionID = props?.sessionID as string | undefined;
-      const status = props?.status as { type?: string; attempt?: number; message?: string; next?: number } | undefined;
+      const sessionID = props?.sessionID as string | undefined
+      const status = props?.status as
+        | { type?: string; attempt?: number; message?: string; next?: number }
+        | undefined
 
       if (sessionID && status?.type === "retry") {
         try {
-          const retryMessage = typeof status.message === "string" ? status.message : "";
-          const retryKey = `${status.attempt ?? "?"}:${status.next ?? "?"}:${retryMessage}`;
+          const retryMessage = typeof status.message === "string" ? status.message : ""
+          const retryKey = `${status.attempt ?? "?"}:${status.next ?? "?"}:${retryMessage}`
           if (lastHandledRetryStatusKey.get(sessionID) === retryKey) {
-            return;
+            return
           }
-          lastHandledRetryStatusKey.set(sessionID, retryKey);
+          lastHandledRetryStatusKey.set(sessionID, retryKey)
 
-          const errorInfo = { name: undefined as string | undefined, message: retryMessage };
+          const errorInfo = { name: undefined as string | undefined, message: retryMessage }
           if (shouldRetryError(errorInfo)) {
-            let agentName = getSessionAgent(sessionID);
+            let agentName = getSessionAgent(sessionID)
             if (!agentName && sessionID === getMainSessionID()) {
               if (retryMessage.includes("claude-opus") || retryMessage.includes("opus")) {
-                agentName = "sisyphus";
+                agentName = "sisyphus"
               } else if (retryMessage.includes("gpt-5")) {
-                agentName = "hephaestus";
+                agentName = "hephaestus"
               } else {
-                agentName = "sisyphus";
+                agentName = "sisyphus"
               }
             }
 
             if (agentName) {
-              const parsed = extractProviderModelFromErrorMessage(retryMessage);
-              const lastKnown = lastKnownModelBySession.get(sessionID);
-              const currentProvider = parsed.providerID ?? lastKnown?.providerID ?? "opencode";
-              let currentModel = parsed.modelID ?? lastKnown?.modelID ?? "claude-opus-4-6";
-              currentModel = normalizeFallbackModelID(currentModel);
+              const parsed = extractProviderModelFromErrorMessage(retryMessage)
+              const lastKnown = lastKnownModelBySession.get(sessionID)
+              const currentProvider = parsed.providerID ?? lastKnown?.providerID ?? "opencode"
+              let currentModel = parsed.modelID ?? lastKnown?.modelID ?? "claude-opus-4-6"
+              currentModel = normalizeFallbackModelID(currentModel)
 
-              const setFallback = setPendingModelFallback(sessionID, agentName, currentProvider, currentModel);
+              const setFallback = setPendingModelFallback(
+                sessionID,
+                agentName,
+                currentProvider,
+                currentModel,
+              )
 
-              if (
-                setFallback &&
-                shouldAutoRetrySession(sessionID) &&
-                !hooks.stopContinuationGuard?.isStopped(sessionID)
-              ) {
-                await pluginContext.client.session.abort({ path: { id: sessionID } }).catch(() => {});
+              if (setFallback && shouldAutoRetrySession(sessionID) && !hooks.stopContinuationGuard?.isStopped(sessionID)) {
+                await pluginContext.client.session.abort({ path: { id: sessionID } }).catch(() => {})
                 await pluginContext.client.session
                   .prompt({
                     path: { id: sessionID },
                     body: { parts: [{ type: "text", text: "continue" }] },
                     query: { directory: pluginContext.directory },
                   })
-                  .catch(() => {});
+                  .catch(() => {})
               }
             }
           }
         } catch (err) {
-          log("[event] model-fallback error in session.status:", { sessionID, error: err });
+          log("[event] model-fallback error in session.status:", { sessionID, error: err })
         }
       }
     }
 
     if (event.type === "session.error") {
       try {
-        const sessionID = props?.sessionID as string | undefined;
-        const error = props?.error;
+        const sessionID = props?.sessionID as string | undefined
+        const error = props?.error
 
-        const errorName = extractErrorName(error);
-        const errorMessage = extractErrorMessage(error);
-        const errorInfo = { name: errorName, message: errorMessage };
+        const errorName = extractErrorName(error)
+        const errorMessage = extractErrorMessage(error)
+        const errorInfo = { name: errorName, message: errorMessage }
 
         // First, try session recovery for internal errors (thinking blocks, tool results, etc.)
         if (hooks.sessionRecovery?.isRecoverableError(error)) {
@@ -403,8 +405,8 @@ export function createEventHandler(args: {
             role: "assistant" as const,
             sessionID,
             error,
-          };
-          const recovered = await hooks.sessionRecovery.handleSessionRecovery(messageInfo);
+          }
+          const recovered = await hooks.sessionRecovery.handleSessionRecovery(messageInfo)
 
           if (
             recovered &&
@@ -418,52 +420,53 @@ export function createEventHandler(args: {
                 body: { parts: [{ type: "text", text: "continue" }] },
                 query: { directory: pluginContext.directory },
               })
-              .catch(() => {});
+              .catch(() => {})
           }
-        }
+        } 
         // Second, try model fallback for model errors (rate limit, quota, provider issues, etc.)
         else if (sessionID && shouldRetryError(errorInfo) && !isRuntimeFallbackEnabled) {
-          let agentName = getSessionAgent(sessionID);
-
+          let agentName = getSessionAgent(sessionID)
+          
           if (!agentName && sessionID === getMainSessionID()) {
             if (errorMessage.includes("claude-opus") || errorMessage.includes("opus")) {
-              agentName = "sisyphus";
+              agentName = "sisyphus"
             } else if (errorMessage.includes("gpt-5")) {
-              agentName = "hephaestus";
+              agentName = "hephaestus"
             } else {
-              agentName = "sisyphus";
+              agentName = "sisyphus"
             }
           }
-
+          
           if (agentName) {
-            const parsed = extractProviderModelFromErrorMessage(errorMessage);
-            const currentProvider = (props?.providerID as string) || parsed.providerID || "opencode";
-            let currentModel = (props?.modelID as string) || parsed.modelID || "claude-opus-4-6";
-            currentModel = normalizeFallbackModelID(currentModel);
+            const parsed = extractProviderModelFromErrorMessage(errorMessage)
+            const currentProvider = props?.providerID as string || parsed.providerID || "opencode"
+            let currentModel = props?.modelID as string || parsed.modelID || "claude-opus-4-6"
+            currentModel = normalizeFallbackModelID(currentModel)
 
-            const setFallback = setPendingModelFallback(sessionID, agentName, currentProvider, currentModel);
-
-            if (
-              setFallback &&
-              shouldAutoRetrySession(sessionID) &&
-              !hooks.stopContinuationGuard?.isStopped(sessionID)
-            ) {
-              await pluginContext.client.session.abort({ path: { id: sessionID } }).catch(() => {});
-
-              await pluginContext.client.session
-                .prompt({
-                  path: { id: sessionID },
-                  body: { parts: [{ type: "text", text: "continue" }] },
-                  query: { directory: pluginContext.directory },
-                })
-                .catch(() => {});
+            const setFallback = setPendingModelFallback(
+              sessionID,
+              agentName,
+              currentProvider,
+              currentModel,
+            )
+            
+            if (setFallback && shouldAutoRetrySession(sessionID) && !hooks.stopContinuationGuard?.isStopped(sessionID)) {
+                await pluginContext.client.session.abort({ path: { id: sessionID } }).catch(() => {})
+                
+                await pluginContext.client.session
+                  .prompt({
+                    path: { id: sessionID },
+                    body: { parts: [{ type: "text", text: "continue" }] },
+                    query: { directory: pluginContext.directory },
+                  })
+                  .catch(() => {})
             }
           }
         }
       } catch (err) {
-        const sessionID = props?.sessionID as string | undefined;
-        log("[event] model-fallback error in session.error:", { sessionID, error: err });
+        const sessionID = props?.sessionID as string | undefined
+        log("[event] model-fallback error in session.error:", { sessionID, error: err })
       }
     }
-  };
+  }
 }

src/shared/command-executor/execute-hook-command.ts

@@ -1,129 +1,78 @@
-import { spawn } from "node:child_process";
-import { getHomeDirectory } from "./home-directory";
-import { findBashPath, findZshPath } from "./shell-path";
+import { spawn } from "node:child_process"
+import { getHomeDirectory } from "./home-directory"
+import { findBashPath, findZshPath } from "./shell-path"
 
 export interface CommandResult {
-  exitCode: number;
-  stdout?: string;
-  stderr?: string;
+	exitCode: number
+	stdout?: string
+	stderr?: string
 }
 
-const DEFAULT_HOOK_TIMEOUT_MS = 30_000;
-const SIGKILL_GRACE_MS = 5_000;
-
 export interface ExecuteHookOptions {
-  forceZsh?: boolean;
-  zshPath?: string;
-  /** Timeout in milliseconds. Process is killed after this. Default: 30000 */
-  timeoutMs?: number;
+	forceZsh?: boolean
+	zshPath?: string
 }
 
 export async function executeHookCommand(
-  command: string,
-  stdin: string,
-  cwd: string,
-  options?: ExecuteHookOptions,
+	command: string,
+	stdin: string,
+	cwd: string,
+	options?: ExecuteHookOptions,
 ): Promise<CommandResult> {
-  const home = getHomeDirectory();
-  const timeoutMs = options?.timeoutMs ?? DEFAULT_HOOK_TIMEOUT_MS;
+	const home = getHomeDirectory()
 
-  const expandedCommand = command
-    .replace(/^~(?=\/|$)/g, home)
-    .replace(/\s~(?=\/)/g, ` ${home}`)
-    .replace(/\$CLAUDE_PROJECT_DIR/g, cwd)
-    .replace(/\$\{CLAUDE_PROJECT_DIR\}/g, cwd);
+	const expandedCommand = command
+		.replace(/^~(?=\/|$)/g, home)
+		.replace(/\s~(?=\/)/g, ` ${home}`)
+		.replace(/\$CLAUDE_PROJECT_DIR/g, cwd)
+		.replace(/\$\{CLAUDE_PROJECT_DIR\}/g, cwd)
 
-  let finalCommand = expandedCommand;
+	let finalCommand = expandedCommand
 
-  if (options?.forceZsh) {
-    const zshPath = findZshPath(options.zshPath);
-    const escapedCommand = expandedCommand.replace(/'/g, "'\\''");
-    if (zshPath) {
-      finalCommand = `${zshPath} -lc '${escapedCommand}'`;
-    } else {
-      const bashPath = findBashPath();
-      if (bashPath) {
-        finalCommand = `${bashPath} -lc '${escapedCommand}'`;
-      }
-    }
-  }
+	if (options?.forceZsh) {
+		const zshPath = findZshPath(options.zshPath)
+		const escapedCommand = expandedCommand.replace(/'/g, "'\\''")
+		if (zshPath) {
+			finalCommand = `${zshPath} -lc '${escapedCommand}'`
+		} else {
+			const bashPath = findBashPath()
+			if (bashPath) {
+				finalCommand = `${bashPath} -lc '${escapedCommand}'`
+			}
+		}
+	}
 
-  return new Promise(resolve => {
-    let settled = false;
-    let killTimer: ReturnType<typeof setTimeout> | null = null;
+	return new Promise((resolve) => {
+		const proc = spawn(finalCommand, {
+			cwd,
+			shell: true,
+			env: { ...process.env, HOME: home, CLAUDE_PROJECT_DIR: cwd },
+		})
 
-    const isWin32 = process.platform === "win32";
-    const proc = spawn(finalCommand, {
-      cwd,
-      shell: true,
-      detached: !isWin32,
-      env: { ...process.env, HOME: home, CLAUDE_PROJECT_DIR: cwd },
-    });
+		let stdout = ""
+		let stderr = ""
 
-    let stdout = "";
-    let stderr = "";
+		proc.stdout?.on("data", (data) => {
+			stdout += data.toString()
+		})
 
-    proc.stdout?.on("data", (data: Buffer) => {
-      stdout += data.toString();
-    });
+		proc.stderr?.on("data", (data) => {
+			stderr += data.toString()
+		})
 
-    proc.stderr?.on("data", (data: Buffer) => {
-      stderr += data.toString();
-    });
+		proc.stdin?.write(stdin)
+		proc.stdin?.end()
 
-    proc.stdin?.on("error", () => {});
-    proc.stdin?.write(stdin);
-    proc.stdin?.end();
+		proc.on("close", (code) => {
+			resolve({
+				exitCode: code ?? 0,
+				stdout: stdout.trim(),
+				stderr: stderr.trim(),
+			})
+		})
 
-    const settle = (result: CommandResult) => {
-      if (settled) return;
-      settled = true;
-      if (killTimer) clearTimeout(killTimer);
-      if (timeoutTimer) clearTimeout(timeoutTimer);
-      resolve(result);
-    };
-
-    proc.on("close", code => {
-      settle({
-        exitCode: code ?? 1,
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-      });
-    });
-
-    proc.on("error", err => {
-      settle({ exitCode: 1, stderr: err.message });
-    });
-
-    const killProcessGroup = (signal: NodeJS.Signals) => {
-      try {
-        if (!isWin32 && proc.pid) {
-          try {
-            process.kill(-proc.pid, signal);
-          } catch {
-            proc.kill(signal);
-          }
-        } else {
-          proc.kill(signal);
-        }
-      } catch {}
-    };
-
-    const timeoutTimer = setTimeout(() => {
-      if (settled) return;
-      // Kill entire process group to avoid orphaned children
-      killProcessGroup("SIGTERM");
-      killTimer = setTimeout(() => {
-        if (settled) return;
-        killProcessGroup("SIGKILL");
-      }, SIGKILL_GRACE_MS);
-      // Append timeout notice to stderr
-      stderr += `\nHook command timed out after ${timeoutMs}ms`;
-    }, timeoutMs);
-
-    // Don't let the timeout timer keep the process alive
-    if (timeoutTimer && typeof timeoutTimer === "object" && "unref" in timeoutTimer) {
-      timeoutTimer.unref();
-    }
-  });
+		proc.on("error", (err) => {
+			resolve({ exitCode: 1, stderr: err.message })
+		})
+	})
 }

src/shared/session-tools-store.ts

@@ -1,18 +1,14 @@
-const store = new Map<string, Record<string, boolean>>();
+const store = new Map<string, Record<string, boolean>>()
 
 export function setSessionTools(sessionID: string, tools: Record<string, boolean>): void {
-  store.set(sessionID, { ...tools });
+  store.set(sessionID, { ...tools })
 }
 
 export function getSessionTools(sessionID: string): Record<string, boolean> | undefined {
-  const tools = store.get(sessionID);
-  return tools ? { ...tools } : undefined;
-}
-
-export function deleteSessionTools(sessionID: string): void {
-  store.delete(sessionID);
+  const tools = store.get(sessionID)
+  return tools ? { ...tools } : undefined
 }
 
 export function clearSessionTools(): void {
-  store.clear();
+  store.clear()
 }

src/tools/glob/cli.ts

@@ -7,9 +7,11 @@ import {
   DEFAULT_MAX_DEPTH,
   DEFAULT_MAX_OUTPUT_BYTES,
   RG_FILES_FLAGS,
+  DEFAULT_RG_THREADS,
 } from "./constants"
 import type { GlobOptions, GlobResult, FileMatch } from "./types"
 import { stat } from "node:fs/promises"
+import { rgSemaphore } from "../shared/semaphore"
 
 export interface ResolvedCli {
   path: string
@@ -19,6 +21,7 @@ export interface ResolvedCli {
 function buildRgArgs(options: GlobOptions): string[] {
   const args: string[] = [
     ...RG_FILES_FLAGS,
+    `--threads=${Math.min(options.threads ?? DEFAULT_RG_THREADS, DEFAULT_RG_THREADS)}`,
     `--max-depth=${Math.min(options.maxDepth ?? DEFAULT_MAX_DEPTH, DEFAULT_MAX_DEPTH)}`,
   ]
 
@@ -91,6 +94,18 @@ export { buildRgArgs, buildFindArgs, buildPowerShellCommand }
 export async function runRgFiles(
   options: GlobOptions,
   resolvedCli?: ResolvedCli
+): Promise<GlobResult> {
+  await rgSemaphore.acquire()
+  try {
+    return await runRgFilesInternal(options, resolvedCli)
+  } finally {
+    rgSemaphore.release()
+  }
+}
+
+async function runRgFilesInternal(
+  options: GlobOptions,
+  resolvedCli?: ResolvedCli
 ): Promise<GlobResult> {
   const cli = resolvedCli ?? resolveGrepCli()
   const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS, DEFAULT_TIMEOUT_MS)

src/tools/glob/constants.ts

@@ -1,4 +1,4 @@
-export { resolveGrepCli, resolveGrepCliWithAutoInstall, type GrepBackend } from "../grep/constants"
+export { resolveGrepCli, resolveGrepCliWithAutoInstall, type GrepBackend, DEFAULT_RG_THREADS } from "../grep/constants"
 
 export const DEFAULT_TIMEOUT_MS = 60_000
 export const DEFAULT_LIMIT = 100

src/tools/glob/types.ts

@@ -19,4 +19,5 @@ export interface GlobOptions {
   maxDepth?: number
   timeout?: number
   limit?: number
+  threads?: number  // limit rg thread count
 }

src/tools/grep/cli.ts

@@ -8,14 +8,17 @@ import {
   DEFAULT_MAX_COLUMNS,
   DEFAULT_TIMEOUT_MS,
   DEFAULT_MAX_OUTPUT_BYTES,
+  DEFAULT_RG_THREADS,
   RG_SAFETY_FLAGS,
   GREP_SAFETY_FLAGS,
 } from "./constants"
 import type { GrepOptions, GrepMatch, GrepResult, CountResult } from "./types"
+import { rgSemaphore } from "../shared/semaphore"
 
 function buildRgArgs(options: GrepOptions): string[] {
   const args: string[] = [
     ...RG_SAFETY_FLAGS,
+    `--threads=${Math.min(options.threads ?? DEFAULT_RG_THREADS, DEFAULT_RG_THREADS)}`,
     `--max-depth=${Math.min(options.maxDepth ?? DEFAULT_MAX_DEPTH, DEFAULT_MAX_DEPTH)}`,
     `--max-filesize=${options.maxFilesize ?? DEFAULT_MAX_FILESIZE}`,
     `--max-count=${Math.min(options.maxCount ?? DEFAULT_MAX_COUNT, DEFAULT_MAX_COUNT)}`,
@@ -51,6 +54,12 @@ function buildRgArgs(options: GrepOptions): string[] {
     }
   }
 
+  if (options.outputMode === "files_with_matches") {
+    args.push("--files-with-matches")
+  } else if (options.outputMode === "count") {
+    args.push("--count")
+  }
+
   return args
 }
 
@@ -86,7 +95,7 @@ function buildArgs(options: GrepOptions, backend: GrepBackend): string[] {
   return backend === "rg" ? buildRgArgs(options) : buildGrepArgs(options)
 }
 
-function parseOutput(output: string): GrepMatch[] {
+function parseOutput(output: string, filesOnly = false): GrepMatch[] {
   if (!output.trim()) return []
 
   const matches: GrepMatch[] = []
@@ -95,6 +104,16 @@ function parseOutput(output: string): GrepMatch[] {
   for (const line of lines) {
     if (!line.trim()) continue
 
+    if (filesOnly) {
+      // --files-with-matches outputs only file paths, one per line
+      matches.push({
+        file: line.trim(),
+        line: 0,
+        text: "",
+      })
+      continue
+    }
+
     const match = line.match(/^(.+?):(\d+):(.*)$/)
     if (match) {
       matches.push({
@@ -130,6 +149,15 @@ function parseCountOutput(output: string): CountResult[] {
 }
 
 export async function runRg(options: GrepOptions): Promise<GrepResult> {
+  await rgSemaphore.acquire()
+  try {
+    return await runRgInternal(options)
+  } finally {
+    rgSemaphore.release()
+  }
+}
+
+async function runRgInternal(options: GrepOptions): Promise<GrepResult> {
   const cli = resolveGrepCli()
   const args = buildArgs(options, cli.backend)
   const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS, DEFAULT_TIMEOUT_MS)
@@ -173,14 +201,17 @@ export async function runRg(options: GrepOptions): Promise<GrepResult> {
       }
     }
 
-    const matches = parseOutput(outputToProcess)
-    const filesSearched = new Set(matches.map((m) => m.file)).size
+    const matches = parseOutput(outputToProcess, options.outputMode === "files_with_matches")
+    const limited = options.headLimit && options.headLimit > 0
+      ? matches.slice(0, options.headLimit)
+      : matches
+    const filesSearched = new Set(limited.map((m) => m.file)).size
 
     return {
-      matches,
-      totalMatches: matches.length,
+      matches: limited,
+      totalMatches: limited.length,
       filesSearched,
-      truncated,
+      truncated: truncated || (options.headLimit ? matches.length > options.headLimit : false),
     }
   } catch (e) {
     return {
@@ -194,6 +225,15 @@ export async function runRg(options: GrepOptions): Promise<GrepResult> {
 }
 
 export async function runRgCount(options: Omit<GrepOptions, "context">): Promise<CountResult[]> {
+  await rgSemaphore.acquire()
+  try {
+    return await runRgCountInternal(options)
+  } finally {
+    rgSemaphore.release()
+  }
+}
+
+async function runRgCountInternal(options: Omit<GrepOptions, "context">): Promise<CountResult[]> {
   const cli = resolveGrepCli()
   const args = buildArgs({ ...options, context: 0 }, cli.backend)
 

src/tools/grep/constants.ts

@@ -113,8 +113,9 @@ export const DEFAULT_MAX_FILESIZE = "10M"
 export const DEFAULT_MAX_COUNT = 500
 export const DEFAULT_MAX_COLUMNS = 1000
 export const DEFAULT_CONTEXT = 2
-export const DEFAULT_TIMEOUT_MS = 300_000
-export const DEFAULT_MAX_OUTPUT_BYTES = 10 * 1024 * 1024
+export const DEFAULT_TIMEOUT_MS = 60_000
+export const DEFAULT_MAX_OUTPUT_BYTES = 256 * 1024
+export const DEFAULT_RG_THREADS = 4
 
 export const RG_SAFETY_FLAGS = [
   "--no-follow",

src/tools/grep/downloader.ts

@@ -1,6 +1,6 @@
 import { existsSync, readdirSync } from "node:fs"
 import { join } from "node:path"
-import { extractZip as extractZipBase } from "../../shared"
+import { extractZip as extractZipBase } from "../../shared/zip-extractor"
 import {
   cleanupArchive,
   downloadArchive,

src/tools/grep/tools.ts

@@ -1,16 +1,16 @@
 import type { PluginInput } from "@opencode-ai/plugin"
 import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
-import { runRg } from "./cli"
-import { formatGrepResult } from "./result-formatter"
+import { runRg, runRgCount } from "./cli"
+import { formatGrepResult, formatCountResult } from "./result-formatter"
 
 export function createGrepTools(ctx: PluginInput): Record<string, ToolDefinition> {
   const grep: ToolDefinition = tool({
     description:
-      "Fast content search tool with safety limits (60s timeout, 10MB output). " +
+      "Fast content search tool with safety limits (60s timeout, 256KB output). " +
       "Searches file contents using regular expressions. " +
       "Supports full regex syntax (eg. \"log.*Error\", \"function\\s+\\w+\", etc.). " +
       "Filter files by pattern with the include parameter (eg. \"*.js\", \"*.{ts,tsx}\"). " +
-      "Returns file paths with matches sorted by modification time.",
+      "Output modes: \"content\" shows matching lines, \"files_with_matches\" shows only file paths (default), \"count\" shows match counts per file.",
     args: {
       pattern: tool.schema.string().describe("The regex pattern to search for in file contents"),
       include: tool.schema
@@ -21,18 +21,42 @@ export function createGrepTools(ctx: PluginInput): Record<string, ToolDefinition
         .string()
         .optional()
         .describe("The directory to search in. Defaults to the current working directory."),
+      output_mode: tool.schema
+        .enum(["content", "files_with_matches", "count"])
+        .optional()
+        .describe(
+          "Output mode: \"content\" shows matching lines, \"files_with_matches\" shows only file paths (default), \"count\" shows match counts per file."
+        ),
+      head_limit: tool.schema
+        .number()
+        .optional()
+        .describe("Limit output to first N entries. 0 or omitted means no limit."),
     },
     execute: async (args) => {
       try {
         const globs = args.include ? [args.include] : undefined
         const searchPath = args.path ?? ctx.directory
         const paths = [searchPath]
+        const outputMode = args.output_mode ?? "files_with_matches"
+        const headLimit = args.head_limit ?? 0
+
+        if (outputMode === "count") {
+          const results = await runRgCount({
+            pattern: args.pattern,
+            paths,
+            globs,
+          })
+          const limited = headLimit > 0 ? results.slice(0, headLimit) : results
+          return formatCountResult(limited)
+        }
 
         const result = await runRg({
           pattern: args.pattern,
           paths,
           globs,
           context: 0,
+          outputMode,
+          headLimit,
         })
 
         return formatGrepResult(result)

src/tools/grep/types.ts

@@ -31,6 +31,9 @@ export interface GrepOptions {
   noIgnore?: boolean
   fileType?: string[]
   timeout?: number
+  threads?: number
+  outputMode?: "content" | "files_with_matches" | "count"
+  headLimit?: number
 }
 
 export interface CountResult {

src/tools/lsp/lsp-manager-process-cleanup.ts

@@ -1,71 +1,45 @@
 type ManagedClientForCleanup = {
   client: {
-    stop: () => Promise<void>;
-  };
-};
+    stop: () => Promise<void>
+  }
+}
 
 type ProcessCleanupOptions = {
-  getClients: () => IterableIterator<[string, ManagedClientForCleanup]>;
-  clearClients: () => void;
-  clearCleanupInterval: () => void;
-};
-
-type RegisteredHandler = {
-  event: string;
-  listener: (...args: unknown[]) => void;
-};
-
-export type LspProcessCleanupHandle = {
-  unregister: () => void;
-};
-
-export function registerLspManagerProcessCleanup(options: ProcessCleanupOptions): LspProcessCleanupHandle {
-  const handlers: RegisteredHandler[] = [];
+  getClients: () => IterableIterator<[string, ManagedClientForCleanup]>
+  clearClients: () => void
+  clearCleanupInterval: () => void
+}
 
+export function registerLspManagerProcessCleanup(options: ProcessCleanupOptions): void {
   // Synchronous cleanup for 'exit' event (cannot await)
   const syncCleanup = () => {
     for (const [, managed] of options.getClients()) {
       try {
         // Fire-and-forget during sync exit - process is terminating
-        void managed.client.stop().catch(() => {});
+        void managed.client.stop().catch(() => {})
       } catch {}
     }
-    options.clearClients();
-    options.clearCleanupInterval();
-  };
+    options.clearClients()
+    options.clearCleanupInterval()
+  }
 
   // Async cleanup for signal handlers - properly await all stops
   const asyncCleanup = async () => {
-    const stopPromises: Promise<void>[] = [];
+    const stopPromises: Promise<void>[] = []
     for (const [, managed] of options.getClients()) {
-      stopPromises.push(managed.client.stop().catch(() => {}));
+      stopPromises.push(managed.client.stop().catch(() => {}))
     }
-    await Promise.allSettled(stopPromises);
-    options.clearClients();
-    options.clearCleanupInterval();
-  };
-
-  const registerHandler = (event: string, listener: (...args: unknown[]) => void) => {
-    handlers.push({ event, listener });
-    process.on(event, listener);
-  };
-
-  registerHandler("exit", syncCleanup);
-
-  // Don't call process.exit() here; other handlers (background-agent manager) handle final exit.
-  const signalCleanup = () => void asyncCleanup().catch(() => {});
-  registerHandler("SIGINT", signalCleanup);
-  registerHandler("SIGTERM", signalCleanup);
-  if (process.platform === "win32") {
-    registerHandler("SIGBREAK", signalCleanup);
+    await Promise.allSettled(stopPromises)
+    options.clearClients()
+    options.clearCleanupInterval()
   }
 
-  return {
-    unregister: () => {
-      for (const { event, listener } of handlers) {
-        process.off(event, listener);
-      }
-      handlers.length = 0;
-    },
-  };
+  process.on("exit", syncCleanup)
+
+  // Don't call process.exit() here; other handlers (background-agent manager) handle final exit.
+  process.on("SIGINT", () => void asyncCleanup().catch(() => {}))
+  process.on("SIGTERM", () => void asyncCleanup().catch(() => {}))
+  if (process.platform === "win32") {
+    process.on("SIGBREAK", () => void asyncCleanup().catch(() => {}))
+  }
 }

src/tools/lsp/lsp-server.ts

@@ -1,74 +1,73 @@
-import { LSPClient } from "./lsp-client";
-import { registerLspManagerProcessCleanup, type LspProcessCleanupHandle } from "./lsp-manager-process-cleanup";
-import { cleanupTempDirectoryLspClients } from "./lsp-manager-temp-directory-cleanup";
-import type { ResolvedServer } from "./types";
+import type { ResolvedServer } from "./types"
+import { registerLspManagerProcessCleanup } from "./lsp-manager-process-cleanup"
+import { cleanupTempDirectoryLspClients } from "./lsp-manager-temp-directory-cleanup"
+import { LSPClient } from "./lsp-client"
 interface ManagedClient {
-  client: LSPClient;
-  lastUsedAt: number;
-  refCount: number;
-  initPromise?: Promise<void>;
-  isInitializing: boolean;
-  initializingSince?: number;
+  client: LSPClient
+  lastUsedAt: number
+  refCount: number
+  initPromise?: Promise<void>
+  isInitializing: boolean
+  initializingSince?: number
 }
 class LSPServerManager {
-  private static instance: LSPServerManager;
-  private clients = new Map<string, ManagedClient>();
-  private cleanupInterval: ReturnType<typeof setInterval> | null = null;
-  private readonly IDLE_TIMEOUT = 5 * 60 * 1000;
-  private readonly INIT_TIMEOUT = 60 * 1000;
-  private cleanupHandle: LspProcessCleanupHandle | null = null;
+  private static instance: LSPServerManager
+  private clients = new Map<string, ManagedClient>()
+  private cleanupInterval: ReturnType<typeof setInterval> | null = null
+  private readonly IDLE_TIMEOUT = 5 * 60 * 1000
+  private readonly INIT_TIMEOUT = 60 * 1000
   private constructor() {
-    this.startCleanupTimer();
-    this.registerProcessCleanup();
+    this.startCleanupTimer()
+    this.registerProcessCleanup()
   }
   private registerProcessCleanup(): void {
-    this.cleanupHandle = registerLspManagerProcessCleanup({
+    registerLspManagerProcessCleanup({
       getClients: () => this.clients.entries(),
       clearClients: () => {
-        this.clients.clear();
+        this.clients.clear()
       },
       clearCleanupInterval: () => {
         if (this.cleanupInterval) {
-          clearInterval(this.cleanupInterval);
-          this.cleanupInterval = null;
+          clearInterval(this.cleanupInterval)
+          this.cleanupInterval = null
         }
       },
-    });
+    })
   }
 
   static getInstance(): LSPServerManager {
     if (!LSPServerManager.instance) {
-      LSPServerManager.instance = new LSPServerManager();
+      LSPServerManager.instance = new LSPServerManager()
     }
-    return LSPServerManager.instance;
+    return LSPServerManager.instance
   }
 
   private getKey(root: string, serverId: string): string {
-    return `${root}::${serverId}`;
+    return `${root}::${serverId}`
   }
 
   private startCleanupTimer(): void {
-    if (this.cleanupInterval) return;
+    if (this.cleanupInterval) return
     this.cleanupInterval = setInterval(() => {
-      this.cleanupIdleClients();
-    }, 60000);
+      this.cleanupIdleClients()
+    }, 60000)
   }
 
   private cleanupIdleClients(): void {
-    const now = Date.now();
+    const now = Date.now()
     for (const [key, managed] of this.clients) {
       if (managed.refCount === 0 && now - managed.lastUsedAt > this.IDLE_TIMEOUT) {
-        managed.client.stop();
-        this.clients.delete(key);
+        managed.client.stop()
+        this.clients.delete(key)
       }
     }
   }
 
   async getClient(root: string, server: ResolvedServer): Promise<LSPClient> {
-    const key = this.getKey(root, server.id);
-    let managed = this.clients.get(key);
+    const key = this.getKey(root, server.id)
+    let managed = this.clients.get(key)
     if (managed) {
-      const now = Date.now();
+      const now = Date.now()
       if (
         managed.isInitializing &&
         managed.initializingSince !== undefined &&
@@ -76,45 +75,45 @@ class LSPServerManager {
       ) {
         // Stale init can permanently block subsequent calls (e.g., LSP process hang)
         try {
-          await managed.client.stop();
+          await managed.client.stop()
         } catch {}
-        this.clients.delete(key);
-        managed = undefined;
+        this.clients.delete(key)
+        managed = undefined
       }
     }
     if (managed) {
       if (managed.initPromise) {
         try {
-          await managed.initPromise;
+          await managed.initPromise
         } catch {
           // Failed init should not keep the key blocked forever.
           try {
-            await managed.client.stop();
+            await managed.client.stop()
           } catch {}
-          this.clients.delete(key);
-          managed = undefined;
+          this.clients.delete(key)
+          managed = undefined
         }
       }
 
       if (managed) {
         if (managed.client.isAlive()) {
-          managed.refCount++;
-          managed.lastUsedAt = Date.now();
-          return managed.client;
+          managed.refCount++
+          managed.lastUsedAt = Date.now()
+          return managed.client
         }
         try {
-          await managed.client.stop();
+          await managed.client.stop()
         } catch {}
-        this.clients.delete(key);
+        this.clients.delete(key)
       }
     }
 
-    const client = new LSPClient(root, server);
+    const client = new LSPClient(root, server)
     const initPromise = (async () => {
-      await client.start();
-      await client.initialize();
-    })();
-    const initStartedAt = Date.now();
+      await client.start()
+      await client.initialize()
+    })()
+    const initStartedAt = Date.now()
     this.clients.set(key, {
       client,
       lastUsedAt: initStartedAt,
@@ -122,37 +121,37 @@ class LSPServerManager {
       initPromise,
       isInitializing: true,
       initializingSince: initStartedAt,
-    });
+    })
 
     try {
-      await initPromise;
+      await initPromise
     } catch (error) {
-      this.clients.delete(key);
+      this.clients.delete(key)
       try {
-        await client.stop();
+        await client.stop()
       } catch {}
-      throw error;
+      throw error
     }
-    const m = this.clients.get(key);
+    const m = this.clients.get(key)
     if (m) {
-      m.initPromise = undefined;
-      m.isInitializing = false;
-      m.initializingSince = undefined;
+      m.initPromise = undefined
+      m.isInitializing = false
+      m.initializingSince = undefined
     }
 
-    return client;
+    return client
   }
 
   warmupClient(root: string, server: ResolvedServer): void {
-    const key = this.getKey(root, server.id);
-    if (this.clients.has(key)) return;
-    const client = new LSPClient(root, server);
+    const key = this.getKey(root, server.id)
+    if (this.clients.has(key)) return
+    const client = new LSPClient(root, server)
     const initPromise = (async () => {
-      await client.start();
-      await client.initialize();
-    })();
+      await client.start()
+      await client.initialize()
+    })()
 
-    const initStartedAt = Date.now();
+    const initStartedAt = Date.now()
     this.clients.set(key, {
       client,
       lastUsedAt: initStartedAt,
@@ -160,55 +159,53 @@ class LSPServerManager {
       initPromise,
       isInitializing: true,
       initializingSince: initStartedAt,
-    });
+    })
 
     initPromise
       .then(() => {
-        const m = this.clients.get(key);
+        const m = this.clients.get(key)
         if (m) {
-          m.initPromise = undefined;
-          m.isInitializing = false;
-          m.initializingSince = undefined;
+          m.initPromise = undefined
+          m.isInitializing = false
+          m.initializingSince = undefined
         }
       })
       .catch(() => {
         // Warmup failures must not permanently block future initialization.
-        this.clients.delete(key);
-        void client.stop().catch(() => {});
-      });
+        this.clients.delete(key)
+        void client.stop().catch(() => {})
+      })
   }
 
   releaseClient(root: string, serverId: string): void {
-    const key = this.getKey(root, serverId);
-    const managed = this.clients.get(key);
+    const key = this.getKey(root, serverId)
+    const managed = this.clients.get(key)
     if (managed && managed.refCount > 0) {
-      managed.refCount--;
-      managed.lastUsedAt = Date.now();
+      managed.refCount--
+      managed.lastUsedAt = Date.now()
     }
   }
 
   isServerInitializing(root: string, serverId: string): boolean {
-    const key = this.getKey(root, serverId);
-    const managed = this.clients.get(key);
-    return managed?.isInitializing ?? false;
+    const key = this.getKey(root, serverId)
+    const managed = this.clients.get(key)
+    return managed?.isInitializing ?? false
   }
 
   async stopAll(): Promise<void> {
-    this.cleanupHandle?.unregister();
-    this.cleanupHandle = null;
     for (const [, managed] of this.clients) {
-      await managed.client.stop();
+      await managed.client.stop()
     }
-    this.clients.clear();
+    this.clients.clear()
     if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
+      clearInterval(this.cleanupInterval)
+      this.cleanupInterval = null
     }
   }
 
   async cleanupTempDirectoryClients(): Promise<void> {
-    await cleanupTempDirectoryLspClients(this.clients);
+    await cleanupTempDirectoryLspClients(this.clients)
   }
 }
 
-export const lspManager = LSPServerManager.getInstance();
+export const lspManager = LSPServerManager.getInstance()

src/tools/shared/semaphore.ts

@@ -0,0 +1,32 @@
+/**
+ * Simple counting semaphore to limit concurrent process execution.
+ * Used to prevent multiple ripgrep processes from saturating CPU.
+ */
+export class Semaphore {
+  private queue: (() => void)[] = []
+  private running = 0
+
+  constructor(private readonly max: number) {}
+
+  async acquire(): Promise<void> {
+    if (this.running < this.max) {
+      this.running++
+      return
+    }
+    return new Promise<void>((resolve) => {
+      this.queue.push(() => {
+        this.running++
+        resolve()
+      })
+    })
+  }
+
+  release(): void {
+    this.running--
+    const next = this.queue.shift()
+    if (next) next()
+  }
+}
+
+/** Global semaphore limiting concurrent ripgrep processes to 2 */
+export const rgSemaphore = new Semaphore(2)