oh-my-opencode 2.6.1 → 2.7.0

package/dist/index.js

@@ -222,8 +222,8 @@ var require_utils = __commonJS((exports) => {
     }
     return output;
   };
-  exports.basename = (path5, { windows } = {}) => {
-    const segs = path5.split(windows ? /[\\/]/ : "/");
+  exports.basename = (path4, { windows } = {}) => {
+    const segs = path4.split(windows ? /[\\/]/ : "/");
     const last = segs[segs.length - 1];
     if (last === "") {
       return segs[segs.length - 2];
@@ -3276,9 +3276,6 @@ function getUserConfigDir() {
 import * as path3 from "path";
 import * as os3 from "os";
 function getDataDir() {
-  if (process.platform === "win32") {
-    return process.env.LOCALAPPDATA ?? path3.join(os3.homedir(), "AppData", "Local");
-  }
   return process.env.XDG_DATA_HOME ?? path3.join(os3.homedir(), ".local", "share");
 }
 function getOpenCodeStorageDir() {
@@ -4374,23 +4371,6 @@ function injectHookMessage(sessionID, hookContent, originalMessage) {
     return false;
   }
 }
-// src/hooks/non-interactive-env/detector.ts
-function isNonInteractive() {
-  if (process.env.CI === "true" || process.env.CI === "1") {
-    return true;
-  }
-  if (process.env.OPENCODE_RUN === "true" || process.env.OPENCODE_NON_INTERACTIVE === "true") {
-    return true;
-  }
-  if (process.env.GITHUB_ACTIONS === "true") {
-    return true;
-  }
-  if (process.stdout.isTTY !== true) {
-    return true;
-  }
-  return false;
-}
-
 // src/hooks/todo-continuation-enforcer.ts
 var HOOK_NAME = "todo-continuation-enforcer";
 var CONTINUATION_PROMPT = `[SYSTEM REMINDER - TODO CONTINUATION]
@@ -4400,6 +4380,9 @@ Incomplete tasks remain in your todo list. Continue working on the next pending
 - Proceed without asking for permission
 - Mark each task complete when finished
 - Do not stop until all tasks are done`;
+var COUNTDOWN_SECONDS = 2;
+var TOAST_DURATION_MS = 900;
+var MIN_INJECTION_INTERVAL_MS = 1e4;
 function getMessageDir(sessionID) {
   if (!existsSync6(MESSAGE_STORAGE))
     return null;
@@ -4433,39 +4416,216 @@ function detectInterrupt(error) {
   }
   return false;
 }
-var COUNTDOWN_SECONDS = 2;
-var TOAST_DURATION_MS = 900;
+function getIncompleteCount(todos) {
+  return todos.filter((t) => t.status !== "completed" && t.status !== "cancelled").length;
+}
 function createTodoContinuationEnforcer(ctx, options = {}) {
   const { backgroundManager } = options;
-  const remindedSessions = new Set;
-  const interruptedSessions = new Set;
-  const errorSessions = new Set;
-  const recoveringSessions = new Set;
-  const pendingCountdowns = new Map;
-  const preemptivelyInjectedSessions = new Set;
+  const sessions = new Map;
+  function getOrCreateState(sessionID) {
+    let state2 = sessions.get(sessionID);
+    if (!state2) {
+      state2 = { version: 0, mode: "idle" };
+      sessions.set(sessionID, state2);
+    }
+    return state2;
+  }
+  function clearTimer(state2) {
+    if (state2.timer) {
+      clearTimeout(state2.timer);
+      state2.timer = undefined;
+    }
+  }
+  function invalidate(sessionID, reason) {
+    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";
+    }
+  }
+  function isMainSession(sessionID) {
+    const mainSessionID2 = getMainSessionID();
+    return !mainSessionID2 || sessionID === mainSessionID2;
+  }
   const markRecovering = (sessionID) => {
-    recoveringSessions.add(sessionID);
+    const state2 = getOrCreateState(sessionID);
+    invalidate(sessionID, "entering recovery mode");
+    state2.mode = "recovering";
+    log(`[${HOOK_NAME}] Session marked as recovering`, { sessionID });
   };
   const markRecoveryComplete = (sessionID) => {
-    recoveringSessions.delete(sessionID);
+    const state2 = sessions.get(sessionID);
+    if (state2 && state2.mode === "recovering") {
+      state2.mode = "idle";
+      log(`[${HOOK_NAME}] Session recovery complete`, { sessionID });
+    }
   };
+  async function showCountdownToast(seconds, incompleteCount) {
+    await ctx.client.tui.showToast({
+      body: {
+        title: "Todo Continuation",
+        message: `Resuming in ${seconds}s... (${incompleteCount} tasks remaining)`,
+        variant: "warning",
+        duration: TOAST_DURATION_MS
+      }
+    }).catch(() => {});
+  }
+  async function executeInjection(sessionID, capturedVersion) {
+    const state2 = sessions.get(sessionID);
+    if (!state2)
+      return;
+    if (state2.version !== capturedVersion) {
+      log(`[${HOOK_NAME}] Injection aborted: version mismatch`, {
+        sessionID,
+        capturedVersion,
+        currentVersion: state2.version
+      });
+      return;
+    }
+    if (state2.mode !== "countingDown") {
+      log(`[${HOOK_NAME}] Injection aborted: mode changed`, {
+        sessionID,
+        mode: state2.mode
+      });
+      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;
+      }
+    }
+    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";
+      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";
+      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";
+      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";
+      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();
+    try {
+      log(`[${HOOK_NAME}] Injecting continuation prompt`, {
+        sessionID,
+        agent: prevMessage?.agent,
+        incompleteCount
+      });
+      await ctx.client.session.prompt({
+        path: { id: sessionID },
+        body: {
+          agent: prevMessage?.agent,
+          parts: [{ type: "text", text: prompt }]
+        },
+        query: { directory: ctx.directory }
+      });
+      log(`[${HOOK_NAME}] Continuation prompt injected successfully`, { sessionID });
+    } catch (err) {
+      log(`[${HOOK_NAME}] Prompt 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);
+    let secondsRemaining = COUNTDOWN_SECONDS;
+    const toastInterval = setInterval(() => {
+      if (state2.version !== capturedVersion) {
+        clearInterval(toastInterval);
+        return;
+      }
+      secondsRemaining--;
+      if (secondsRemaining > 0) {
+        showCountdownToast(secondsRemaining, incompleteCount);
+      }
+    }, 1000);
+    state2.timer = setTimeout(() => {
+      clearInterval(toastInterval);
+      clearTimer(state2);
+      executeInjection(sessionID, capturedVersion);
+    }, COUNTDOWN_SECONDS * 1000);
+  }
   const handler = async ({ event }) => {
     const props = event.properties;
     if (event.type === "session.error") {
       const sessionID = props?.sessionID;
-      if (sessionID) {
-        const isInterrupt = detectInterrupt(props?.error);
-        errorSessions.add(sessionID);
-        if (isInterrupt) {
-          interruptedSessions.add(sessionID);
-        }
-        log(`[${HOOK_NAME}] session.error received`, { sessionID, isInterrupt, error: props?.error });
-        const countdown = pendingCountdowns.get(sessionID);
-        if (countdown) {
-          clearInterval(countdown.intervalId);
-          pendingCountdowns.delete(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 });
       return;
     }
     if (event.type === "session.idle") {
@@ -4473,40 +4633,27 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
       if (!sessionID)
         return;
       log(`[${HOOK_NAME}] session.idle received`, { sessionID });
-      const mainSessionID2 = getMainSessionID();
-      if (mainSessionID2 && sessionID !== mainSessionID2) {
-        log(`[${HOOK_NAME}] Skipped: not main session`, { sessionID, mainSessionID: mainSessionID2 });
+      if (!isMainSession(sessionID)) {
+        log(`[${HOOK_NAME}] Skipped: not main session`, { sessionID });
         return;
       }
-      const existingCountdown = pendingCountdowns.get(sessionID);
-      if (existingCountdown) {
-        clearInterval(existingCountdown.intervalId);
-        pendingCountdowns.delete(sessionID);
-        log(`[${HOOK_NAME}] Cancelled existing countdown`, { sessionID });
-      }
-      if (recoveringSessions.has(sessionID)) {
+      const state2 = getOrCreateState(sessionID);
+      if (state2.mode === "recovering") {
         log(`[${HOOK_NAME}] Skipped: session in recovery mode`, { sessionID });
         return;
       }
-      const shouldBypass = interruptedSessions.has(sessionID) || errorSessions.has(sessionID);
-      if (shouldBypass) {
-        interruptedSessions.delete(sessionID);
-        errorSessions.delete(sessionID);
-        log(`[${HOOK_NAME}] Skipped: error/interrupt bypass`, { sessionID });
+      if (state2.mode === "errorBypass") {
+        log(`[${HOOK_NAME}] Skipped: error bypass (awaiting user message to resume)`, { sessionID });
         return;
       }
-      if (remindedSessions.has(sessionID)) {
-        log(`[${HOOK_NAME}] Skipped: already reminded this session`, { sessionID });
+      if (state2.mode === "countingDown" || state2.mode === "injecting") {
+        log(`[${HOOK_NAME}] Skipped: already ${state2.mode}`, { sessionID });
         return;
       }
       let todos = [];
       try {
-        log(`[${HOOK_NAME}] Fetching todos for session`, { sessionID });
-        const response = await ctx.client.session.todo({
-          path: { id: sessionID }
-        });
+        const response = await ctx.client.session.todo({ path: { id: sessionID } });
         todos = response.data ?? response;
-        log(`[${HOOK_NAME}] Todo API response`, { sessionID, todosCount: todos?.length ?? 0 });
       } catch (err) {
         log(`[${HOOK_NAME}] Todo API error`, { sessionID, error: String(err) });
         return;
@@ -4515,188 +4662,77 @@ function createTodoContinuationEnforcer(ctx, options = {}) {
         log(`[${HOOK_NAME}] No todos found`, { sessionID });
         return;
       }
-      const incomplete = todos.filter((t) => t.status !== "completed" && t.status !== "cancelled");
-      if (incomplete.length === 0) {
+      const incompleteCount = getIncompleteCount(todos);
+      if (incompleteCount === 0) {
         log(`[${HOOK_NAME}] All todos completed`, { sessionID, total: todos.length });
         return;
       }
-      log(`[${HOOK_NAME}] Found incomplete todos, starting countdown`, { sessionID, incomplete: incomplete.length, total: todos.length });
-      const showCountdownToast = async (seconds) => {
-        await ctx.client.tui.showToast({
-          body: {
-            title: "Todo Continuation",
-            message: `Resuming in ${seconds}s... (${incomplete.length} tasks remaining)`,
-            variant: "warning",
-            duration: TOAST_DURATION_MS
-          }
-        }).catch(() => {});
-      };
-      const executeAfterCountdown = async () => {
-        pendingCountdowns.delete(sessionID);
-        log(`[${HOOK_NAME}] Countdown finished, executing continuation`, { sessionID });
-        if (recoveringSessions.has(sessionID)) {
-          log(`[${HOOK_NAME}] Abort: session entered recovery mode during countdown`, { sessionID });
-          return;
-        }
-        if (interruptedSessions.has(sessionID) || errorSessions.has(sessionID)) {
-          log(`[${HOOK_NAME}] Abort: error/interrupt occurred during countdown`, { sessionID });
-          interruptedSessions.delete(sessionID);
-          errorSessions.delete(sessionID);
-          return;
-        }
-        let freshTodos = [];
-        try {
-          log(`[${HOOK_NAME}] Re-verifying todos after countdown`, { sessionID });
-          const response = await ctx.client.session.todo({
-            path: { id: sessionID }
-          });
-          freshTodos = response.data ?? response;
-          log(`[${HOOK_NAME}] Fresh todo count`, { sessionID, todosCount: freshTodos?.length ?? 0 });
-        } catch (err) {
-          log(`[${HOOK_NAME}] Failed to re-verify todos`, { sessionID, error: String(err) });
-          return;
-        }
-        const freshIncomplete = freshTodos.filter((t) => t.status !== "completed" && t.status !== "cancelled");
-        if (freshIncomplete.length === 0) {
-          log(`[${HOOK_NAME}] Abort: no incomplete todos after countdown`, { sessionID, total: freshTodos.length });
-          return;
-        }
-        log(`[${HOOK_NAME}] Confirmed incomplete todos, proceeding with injection`, { sessionID, incomplete: freshIncomplete.length, total: freshTodos.length });
-        remindedSessions.add(sessionID);
-        try {
-          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: previous agent lacks write permission`, { sessionID, agent: prevMessage?.agent, tools: prevMessage?.tools });
-            remindedSessions.delete(sessionID);
-            return;
-          }
-          log(`[${HOOK_NAME}] Injecting continuation prompt`, { sessionID, agent: prevMessage?.agent });
-          await ctx.client.session.prompt({
-            path: { id: sessionID },
-            body: {
-              agent: prevMessage?.agent,
-              parts: [
-                {
-                  type: "text",
-                  text: `${CONTINUATION_PROMPT}
-
-[Status: ${freshTodos.length - freshIncomplete.length}/${freshTodos.length} completed, ${freshIncomplete.length} remaining]`
-                }
-              ]
-            },
-            query: { directory: ctx.directory }
-          });
-          log(`[${HOOK_NAME}] Continuation prompt injected successfully`, { sessionID });
-        } catch (err) {
-          log(`[${HOOK_NAME}] Prompt injection failed`, { sessionID, error: String(err) });
-          remindedSessions.delete(sessionID);
-        }
-      };
-      let secondsRemaining = COUNTDOWN_SECONDS;
-      showCountdownToast(secondsRemaining).catch(() => {});
-      const intervalId = setInterval(() => {
-        secondsRemaining--;
-        if (secondsRemaining <= 0) {
-          clearInterval(intervalId);
-          pendingCountdowns.delete(sessionID);
-          executeAfterCountdown();
-          return;
-        }
-        const countdown = pendingCountdowns.get(sessionID);
-        if (!countdown) {
-          clearInterval(intervalId);
-          return;
-        }
-        countdown.secondsRemaining = secondsRemaining;
-        showCountdownToast(secondsRemaining).catch(() => {});
-      }, 1000);
-      pendingCountdowns.set(sessionID, { secondsRemaining, intervalId });
+      const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((t) => t.status === "running") : false;
+      if (hasRunningBgTasks) {
+        log(`[${HOOK_NAME}] Skipped: background tasks still running`, { sessionID });
+        return;
+      }
+      log(`[${HOOK_NAME}] Found incomplete todos`, {
+        sessionID,
+        incomplete: incompleteCount,
+        total: todos.length
+      });
+      startCountdown(sessionID, incompleteCount);
+      return;
     }
     if (event.type === "message.updated") {
       const info = props?.info;
       const sessionID = info?.sessionID;
       const role = info?.role;
       const finish = info?.finish;
-      log(`[${HOOK_NAME}] message.updated received`, { sessionID, role, finish });
-      if (sessionID && role === "user") {
-        const countdown = pendingCountdowns.get(sessionID);
-        if (countdown) {
-          clearInterval(countdown.intervalId);
-          pendingCountdowns.delete(sessionID);
-          log(`[${HOOK_NAME}] Cancelled countdown on user message`, { sessionID });
-        }
-        remindedSessions.delete(sessionID);
-        preemptivelyInjectedSessions.delete(sessionID);
-      }
-      if (sessionID && role === "assistant" && finish) {
-        remindedSessions.delete(sessionID);
-        preemptivelyInjectedSessions.delete(sessionID);
-        log(`[${HOOK_NAME}] Cleared reminded/preemptive state on assistant finish`, { sessionID });
-        const isTerminalFinish = finish && !["tool-calls", "unknown"].includes(finish);
-        if (isTerminalFinish && isNonInteractive()) {
-          log(`[${HOOK_NAME}] Terminal finish in non-interactive mode`, { sessionID, finish });
-          const mainSessionID2 = getMainSessionID();
-          if (mainSessionID2 && sessionID !== mainSessionID2) {
-            log(`[${HOOK_NAME}] Skipped preemptive: not main session`, { sessionID, mainSessionID: mainSessionID2 });
-            return;
-          }
-          if (preemptivelyInjectedSessions.has(sessionID)) {
-            log(`[${HOOK_NAME}] Skipped preemptive: already injected`, { sessionID });
-            return;
-          }
-          if (recoveringSessions.has(sessionID) || errorSessions.has(sessionID) || interruptedSessions.has(sessionID)) {
-            log(`[${HOOK_NAME}] Skipped preemptive: session in error/recovery state`, { sessionID });
-            return;
-          }
-          const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((t) => t.status === "running") : false;
-          let hasIncompleteTodos = false;
-          try {
-            const response = await ctx.client.session.todo({ path: { id: sessionID } });
-            const todos = response.data ?? response;
-            hasIncompleteTodos = todos?.some((t) => t.status !== "completed" && t.status !== "cancelled") ?? false;
-          } catch {
-            log(`[${HOOK_NAME}] Failed to fetch todos for preemptive check`, { sessionID });
-          }
-          if (hasRunningBgTasks || hasIncompleteTodos) {
-            log(`[${HOOK_NAME}] Preemptive injection needed`, { sessionID, hasRunningBgTasks, hasIncompleteTodos });
-            preemptivelyInjectedSessions.add(sessionID);
-            try {
-              const messageDir = getMessageDir(sessionID);
-              const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
-              const prompt = hasRunningBgTasks ? "[SYSTEM] Background tasks are still running. Wait for their completion before proceeding." : CONTINUATION_PROMPT;
-              await ctx.client.session.prompt({
-                path: { id: sessionID },
-                body: {
-                  agent: prevMessage?.agent,
-                  parts: [{ type: "text", text: prompt }]
-                },
-                query: { directory: ctx.directory }
-              });
-              log(`[${HOOK_NAME}] Preemptive injection successful`, { sessionID });
-            } catch (err) {
-              log(`[${HOOK_NAME}] Preemptive injection failed`, { sessionID, error: String(err) });
-              preemptivelyInjectedSessions.delete(sessionID);
-            }
-          }
+      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 });
         }
+        invalidate(sessionID, "user message received");
+        return;
+      }
+      if (role === "assistant" && !finish) {
+        invalidate(sessionID, "assistant is working (streaming)");
+        return;
+      }
+      if (role === "assistant" && finish) {
+        log(`[${HOOK_NAME}] Assistant turn finished`, { sessionID, finish });
+        return;
       }
+      return;
+    }
+    if (event.type === "message.part.updated") {
+      const info = props?.info;
+      const sessionID = info?.sessionID;
+      const role = info?.role;
+      if (sessionID && role === "assistant") {
+        invalidate(sessionID, "assistant streaming");
+      }
+      return;
+    }
+    if (event.type === "tool.execute.before" || event.type === "tool.execute.after") {
+      const sessionID = props?.sessionID;
+      if (sessionID) {
+        invalidate(sessionID, `tool execution (${event.type})`);
+      }
+      return;
     }
     if (event.type === "session.deleted") {
       const sessionInfo = props?.info;
       if (sessionInfo?.id) {
-        remindedSessions.delete(sessionInfo.id);
-        interruptedSessions.delete(sessionInfo.id);
-        errorSessions.delete(sessionInfo.id);
-        recoveringSessions.delete(sessionInfo.id);
-        preemptivelyInjectedSessions.delete(sessionInfo.id);
-        const countdown = pendingCountdowns.get(sessionInfo.id);
-        if (countdown) {
-          clearInterval(countdown.intervalId);
-          pendingCountdowns.delete(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 });
       }
+      return;
     }
   };
   return {
@@ -5154,28 +5190,7 @@ import { join as join10 } from "path";
 
 // src/hooks/session-recovery/constants.ts
 import { join as join9 } from "path";
-
-// node_modules/xdg-basedir/index.js
-import os4 from "os";
-import path4 from "path";
-var homeDirectory = os4.homedir();
-var { env } = process;
-var xdgData = env.XDG_DATA_HOME || (homeDirectory ? path4.join(homeDirectory, ".local", "share") : undefined);
-var xdgConfig = env.XDG_CONFIG_HOME || (homeDirectory ? path4.join(homeDirectory, ".config") : undefined);
-var xdgState = env.XDG_STATE_HOME || (homeDirectory ? path4.join(homeDirectory, ".local", "state") : undefined);
-var xdgCache = env.XDG_CACHE_HOME || (homeDirectory ? path4.join(homeDirectory, ".cache") : undefined);
-var xdgRuntime = env.XDG_RUNTIME_DIR || undefined;
-var xdgDataDirectories = (env.XDG_DATA_DIRS || "/usr/local/share/:/usr/share/").split(":");
-if (xdgData) {
-  xdgDataDirectories.unshift(xdgData);
-}
-var xdgConfigDirectories = (env.XDG_CONFIG_DIRS || "/etc/xdg").split(":");
-if (xdgConfig) {
-  xdgConfigDirectories.unshift(xdgConfig);
-}
-
-// src/hooks/session-recovery/constants.ts
-var OPENCODE_STORAGE2 = join9(xdgData ?? "", "opencode", "storage");
+var OPENCODE_STORAGE2 = getOpenCodeStorageDir();
 var MESSAGE_STORAGE2 = join9(OPENCODE_STORAGE2, "message");
 var PART_STORAGE2 = join9(OPENCODE_STORAGE2, "part");
 var THINKING_TYPES = new Set(["thinking", "redacted_thinking", "reasoning"]);
@@ -5297,7 +5312,16 @@ function findEmptyMessages(sessionID) {
 }
 function findEmptyMessageByIndex(sessionID, targetIndex) {
   const messages = readMessages(sessionID);
-  const indicesToTry = [targetIndex, targetIndex - 1, targetIndex - 2];
+  const indicesToTry = [
+    targetIndex,
+    targetIndex - 1,
+    targetIndex + 1,
+    targetIndex - 2,
+    targetIndex + 2,
+    targetIndex - 3,
+    targetIndex - 4,
+    targetIndex - 5
+  ];
   for (const idx of indicesToTry) {
     if (idx < 0 || idx >= messages.length)
       continue;
@@ -5723,8 +5747,8 @@ var PLATFORM_MAP = {
   "win32-x64": { os: "windows", arch: "amd64", ext: "zip" }
 };
 function getCacheDir() {
-  const xdgCache2 = process.env.XDG_CACHE_HOME;
-  const base = xdgCache2 || join11(homedir5(), ".cache");
+  const xdgCache = process.env.XDG_CACHE_HOME;
+  const base = xdgCache || join11(homedir5(), ".cache");
   return join11(base, "oh-my-opencode", "bin");
 }
 function getBinaryName() {
@@ -5785,8 +5809,8 @@ async function downloadCommentChecker() {
     return binaryPath;
   }
   const version = getPackageVersion();
-  const { os: os5, arch, ext } = platformInfo;
-  const assetName = `comment-checker_v${version}_${os5}_${arch}.${ext}`;
+  const { os: os4, arch, ext } = platformInfo;
+  const assetName = `comment-checker_v${version}_${os4}_${arch}.${ext}`;
   const downloadUrl = `https://github.com/${REPO}/releases/download/v${version}/${assetName}`;
   debugLog(`Downloading from: ${downloadUrl}`);
   console.log(`[oh-my-opencode] Downloading comment-checker binary...`);
@@ -5898,15 +5922,15 @@ async function getCommentCheckerPath() {
 function startBackgroundInit() {
   if (!initPromise) {
     initPromise = getCommentCheckerPath();
-    initPromise.then((path5) => {
-      debugLog2("background init complete:", path5 || "no binary");
+    initPromise.then((path4) => {
+      debugLog2("background init complete:", path4 || "no binary");
     }).catch((err) => {
       debugLog2("background init error:", err);
     });
   }
 }
 var COMMENT_CHECKER_CLI_PATH = findCommentCheckerPathSync();
-async function runCommentChecker(input, cliPath) {
+async function runCommentChecker(input, cliPath, customPrompt) {
   const binaryPath = cliPath ?? resolvedCliPath ?? COMMENT_CHECKER_CLI_PATH;
   if (!binaryPath) {
     debugLog2("comment-checker binary not found");
@@ -5919,7 +5943,11 @@ async function runCommentChecker(input, cliPath) {
   const jsonInput = JSON.stringify(input);
   debugLog2("running comment-checker with input:", jsonInput.substring(0, 200));
   try {
-    const proc = spawn4([binaryPath], {
+    const args = [binaryPath];
+    if (customPrompt) {
+      args.push("--prompt", customPrompt);
+    }
+    const proc = spawn4(args, {
       stdin: "pipe",
       stdout: "pipe",
       stderr: "pipe"
@@ -5961,6 +5989,7 @@ function debugLog3(...args) {
 var pendingCalls = new Map;
 var PENDING_CALL_TTL = 60000;
 var cliPathPromise = null;
+var cleanupIntervalStarted = false;
 function cleanupOldPendingCalls() {
   const now = Date.now();
   for (const [callID, call] of pendingCalls) {
@@ -5969,13 +5998,16 @@ function cleanupOldPendingCalls() {
     }
   }
 }
-setInterval(cleanupOldPendingCalls, 1e4);
-function createCommentCheckerHooks() {
-  debugLog3("createCommentCheckerHooks called");
+function createCommentCheckerHooks(config) {
+  debugLog3("createCommentCheckerHooks called", { config });
+  if (!cleanupIntervalStarted) {
+    cleanupIntervalStarted = true;
+    setInterval(cleanupOldPendingCalls, 1e4);
+  }
   startBackgroundInit();
   cliPathPromise = getCommentCheckerPath();
-  cliPathPromise.then((path5) => {
-    debugLog3("CLI path resolved:", path5 || "disabled (no binary)");
+  cliPathPromise.then((path4) => {
+    debugLog3("CLI path resolved:", path4 || "disabled (no binary)");
   }).catch((err) => {
     debugLog3("CLI path resolution error:", err);
   });
@@ -6031,14 +6063,14 @@ function createCommentCheckerHooks() {
           return;
         }
         debugLog3("using CLI:", cliPath);
-        await processWithCli(input, pendingCall, output, cliPath);
+        await processWithCli(input, pendingCall, output, cliPath, config?.custom_prompt);
       } catch (err) {
         debugLog3("tool.execute.after failed:", err);
       }
     }
   };
 }
-async function processWithCli(input, pendingCall, output, cliPath) {
+async function processWithCli(input, pendingCall, output, cliPath, customPrompt) {
   debugLog3("using CLI mode with path:", cliPath);
   const hookInput = {
     session_id: pendingCall.sessionID,
@@ -6054,7 +6086,7 @@ async function processWithCli(input, pendingCall, output, cliPath) {
       edits: pendingCall.edits
     }
   };
-  const result = await runCommentChecker(hookInput, cliPath);
+  const result = await runCommentChecker(hookInput, cliPath, customPrompt);
   if (result.hasComments && result.message) {
     debugLog3("CLI detected comments, appending message");
     output.output += `
@@ -6113,7 +6145,7 @@ import { join as join15 } from "path";
 
 // src/hooks/directory-agents-injector/constants.ts
 import { join as join14 } from "path";
-var OPENCODE_STORAGE3 = join14(xdgData ?? "", "opencode", "storage");
+var OPENCODE_STORAGE3 = getOpenCodeStorageDir();
 var AGENTS_INJECTOR_STORAGE = join14(OPENCODE_STORAGE3, "directory-agents");
 var AGENTS_FILENAME = "AGENTS.md";
 
@@ -6162,12 +6194,12 @@ function createDirectoryAgentsInjectorHook(ctx) {
     }
     return sessionCaches.get(sessionID);
   }
-  function resolveFilePath2(path5) {
-    if (!path5)
+  function resolveFilePath2(path4) {
+    if (!path4)
       return null;
-    if (path5.startsWith("/"))
-      return path5;
-    return resolve2(ctx.directory, path5);
+    if (path4.startsWith("/"))
+      return path4;
+    return resolve2(ctx.directory, path4);
   }
   function findAgentsMdUp(startDir) {
     const found = [];
@@ -6285,7 +6317,7 @@ import { join as join18 } from "path";
 
 // src/hooks/directory-readme-injector/constants.ts
 import { join as join17 } from "path";
-var OPENCODE_STORAGE4 = join17(xdgData ?? "", "opencode", "storage");
+var OPENCODE_STORAGE4 = getOpenCodeStorageDir();
 var README_INJECTOR_STORAGE = join17(OPENCODE_STORAGE4, "directory-readme");
 var README_FILENAME = "README.md";
 
@@ -6334,12 +6366,12 @@ function createDirectoryReadmeInjectorHook(ctx) {
     }
     return sessionCaches.get(sessionID);
   }
-  function resolveFilePath2(path5) {
-    if (!path5)
+  function resolveFilePath2(path4) {
+    if (!path4)
       return null;
-    if (path5.startsWith("/"))
-      return path5;
-    return resolve3(ctx.directory, path5);
+    if (path4.startsWith("/"))
+      return path4;
+    return resolve3(ctx.directory, path4);
   }
   function findReadmeMdUp(startDir) {
     const found = [];
@@ -6478,7 +6510,8 @@ var TOKEN_LIMIT_KEYWORDS = [
   "token limit",
   "context length",
   "too many tokens",
-  "non-empty content"
+  "non-empty content",
+  "invalid_request_error"
 ];
 var MESSAGE_INDEX_PATTERN = /messages\.(\d+)/;
 function extractTokensFromMessage(message) {
@@ -6566,9 +6599,9 @@ function parseAnthropicTokenLimitError(err) {
   if (typeof responseBody === "string") {
     try {
       const jsonPatterns = [
-        /data:\s*(\{[\s\S]*?\})\s*$/m,
-        /(\{"type"\s*:\s*"error"[\s\S]*?\})/,
-        /(\{[\s\S]*?"error"[\s\S]*?\})/
+        /data:\s*(\{[\s\S]*\})\s*$/m,
+        /(\{"type"\s*:\s*"error"[\s\S]*\})/,
+        /(\{[\s\S]*"error"[\s\S]*\})/
       ];
       for (const pattern of jsonPatterns) {
         const dataMatch = responseBody.match(pattern);
@@ -6655,7 +6688,6 @@ function estimateTokens2(text) {
 }
 
 // src/hooks/anthropic-auto-compact/pruning-deduplication.ts
-var MESSAGE_STORAGE3 = join20(process.env.HOME || process.env.USERPROFILE || "", ".config", "opencode", "sessions");
 function createToolSignature(toolName, input) {
   const sortedInput = sortObject(input);
   return `${toolName}::${JSON.stringify(sortedInput)}`;
@@ -6675,13 +6707,13 @@ function sortObject(obj) {
   return sorted;
 }
 function getMessageDir3(sessionID) {
-  if (!existsSync15(MESSAGE_STORAGE3))
+  if (!existsSync15(MESSAGE_STORAGE))
     return null;
-  const directPath = join20(MESSAGE_STORAGE3, sessionID);
+  const directPath = join20(MESSAGE_STORAGE, sessionID);
   if (existsSync15(directPath))
     return directPath;
-  for (const dir of readdirSync4(MESSAGE_STORAGE3)) {
-    const sessionPath = join20(MESSAGE_STORAGE3, dir, sessionID);
+  for (const dir of readdirSync4(MESSAGE_STORAGE)) {
+    const sessionPath = join20(MESSAGE_STORAGE, dir, sessionID);
     if (existsSync15(sessionPath))
       return sessionPath;
   }
@@ -6793,15 +6825,14 @@ function findToolOutput(messages, callID) {
 // src/hooks/anthropic-auto-compact/pruning-supersede.ts
 import { existsSync as existsSync16, readdirSync as readdirSync5, readFileSync as readFileSync10 } from "fs";
 import { join as join21 } from "path";
-var MESSAGE_STORAGE4 = join21(process.env.HOME || process.env.USERPROFILE || "", ".config", "opencode", "sessions");
 function getMessageDir4(sessionID) {
-  if (!existsSync16(MESSAGE_STORAGE4))
+  if (!existsSync16(MESSAGE_STORAGE))
     return null;
-  const directPath = join21(MESSAGE_STORAGE4, sessionID);
+  const directPath = join21(MESSAGE_STORAGE, sessionID);
   if (existsSync16(directPath))
     return directPath;
-  for (const dir of readdirSync5(MESSAGE_STORAGE4)) {
-    const sessionPath = join21(MESSAGE_STORAGE4, dir, sessionID);
+  for (const dir of readdirSync5(MESSAGE_STORAGE)) {
+    const sessionPath = join21(MESSAGE_STORAGE, dir, sessionID);
     if (existsSync16(sessionPath))
       return sessionPath;
   }
@@ -6956,15 +6987,14 @@ function findToolInput(messages, callID) {
 // src/hooks/anthropic-auto-compact/pruning-purge-errors.ts
 import { existsSync as existsSync17, readdirSync as readdirSync6, readFileSync as readFileSync11 } from "fs";
 import { join as join22 } from "path";
-var MESSAGE_STORAGE5 = join22(process.env.HOME || process.env.USERPROFILE || "", ".config", "opencode", "sessions");
 function getMessageDir5(sessionID) {
-  if (!existsSync17(MESSAGE_STORAGE5))
+  if (!existsSync17(MESSAGE_STORAGE))
     return null;
-  const directPath = join22(MESSAGE_STORAGE5, sessionID);
+  const directPath = join22(MESSAGE_STORAGE, sessionID);
   if (existsSync17(directPath))
     return directPath;
-  for (const dir of readdirSync6(MESSAGE_STORAGE5)) {
-    const sessionPath = join22(MESSAGE_STORAGE5, dir, sessionID);
+  for (const dir of readdirSync6(MESSAGE_STORAGE)) {
+    const sessionPath = join22(MESSAGE_STORAGE, dir, sessionID);
     if (existsSync17(sessionPath))
       return sessionPath;
   }
@@ -7062,15 +7092,14 @@ function executePurgeErrors(sessionID, state2, config, protectedTools) {
 // src/hooks/anthropic-auto-compact/pruning-storage.ts
 import { existsSync as existsSync18, readdirSync as readdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync5 } from "fs";
 import { join as join23 } from "path";
-var MESSAGE_STORAGE6 = join23(process.env.HOME || process.env.USERPROFILE || "", ".config", "opencode", "sessions");
 function getMessageDir6(sessionID) {
-  if (!existsSync18(MESSAGE_STORAGE6))
+  if (!existsSync18(MESSAGE_STORAGE))
     return null;
-  const directPath = join23(MESSAGE_STORAGE6, sessionID);
+  const directPath = join23(MESSAGE_STORAGE, sessionID);
   if (existsSync18(directPath))
     return directPath;
-  for (const dir of readdirSync7(MESSAGE_STORAGE6)) {
-    const sessionPath = join23(MESSAGE_STORAGE6, dir, sessionID);
+  for (const dir of readdirSync7(MESSAGE_STORAGE)) {
+    const sessionPath = join23(MESSAGE_STORAGE, dir, sessionID);
     if (existsSync18(sessionPath))
       return sessionPath;
   }
@@ -7212,27 +7241,20 @@ async function executeDynamicContextPruning(sessionID, config, client) {
 
 // src/hooks/anthropic-auto-compact/storage.ts
 import { existsSync as existsSync19, readdirSync as readdirSync8, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
-import { homedir as homedir6 } from "os";
 import { join as join24 } from "path";
-var OPENCODE_STORAGE5 = join24(xdgData ?? "", "opencode", "storage");
-if (process.platform === "darwin" && !existsSync19(OPENCODE_STORAGE5)) {
-  const localShare = join24(homedir6(), ".local", "share", "opencode", "storage");
-  if (existsSync19(localShare)) {
-    OPENCODE_STORAGE5 = localShare;
-  }
-}
-var MESSAGE_STORAGE7 = join24(OPENCODE_STORAGE5, "message");
+var OPENCODE_STORAGE5 = getOpenCodeStorageDir();
+var MESSAGE_STORAGE3 = join24(OPENCODE_STORAGE5, "message");
 var PART_STORAGE3 = join24(OPENCODE_STORAGE5, "part");
 var TRUNCATION_MESSAGE = "[TOOL RESULT TRUNCATED - Context limit exceeded. Original output was too large and has been truncated to recover the session. Please re-run this tool if you need the full output.]";
 function getMessageDir7(sessionID) {
-  if (!existsSync19(MESSAGE_STORAGE7))
+  if (!existsSync19(MESSAGE_STORAGE3))
     return "";
-  const directPath = join24(MESSAGE_STORAGE7, sessionID);
+  const directPath = join24(MESSAGE_STORAGE3, sessionID);
   if (existsSync19(directPath)) {
     return directPath;
   }
-  for (const dir of readdirSync8(MESSAGE_STORAGE7)) {
-    const sessionPath = join24(MESSAGE_STORAGE7, dir, sessionID);
+  for (const dir of readdirSync8(MESSAGE_STORAGE3)) {
+    const sessionPath = join24(MESSAGE_STORAGE3, dir, sessionID);
     if (existsSync19(sessionPath)) {
       return sessionPath;
     }
@@ -7360,6 +7382,7 @@ function truncateUntilTargetTokens(sessionID, currentTokens, maxTokens, targetRa
 }
 
 // src/hooks/anthropic-auto-compact/executor.ts
+var PLACEHOLDER_TEXT = "[user interrupted]";
 function getOrCreateRetryState(autoCompactState, sessionID) {
   let state2 = autoCompactState.retryStateBySession.get(sessionID);
   if (!state2) {
@@ -7392,6 +7415,32 @@ function getOrCreateDcpState(autoCompactState, sessionID) {
   }
   return state2;
 }
+function sanitizeEmptyMessagesBeforeSummarize(sessionID) {
+  const emptyMessageIds = findEmptyMessages(sessionID);
+  if (emptyMessageIds.length === 0) {
+    return 0;
+  }
+  let fixedCount = 0;
+  for (const messageID of emptyMessageIds) {
+    const replaced = replaceEmptyTextParts(messageID, PLACEHOLDER_TEXT);
+    if (replaced) {
+      fixedCount++;
+    } else {
+      const injected = injectTextPart(sessionID, messageID, PLACEHOLDER_TEXT);
+      if (injected) {
+        fixedCount++;
+      }
+    }
+  }
+  if (fixedCount > 0) {
+    log("[auto-compact] pre-summarize sanitization fixed empty messages", {
+      sessionID,
+      fixedCount,
+      totalEmpty: emptyMessageIds.length
+    });
+  }
+  return fixedCount;
+}
 async function getLastMessagePair(sessionID, client, directory) {
   try {
     const resp = await client.session.messages({
@@ -7547,6 +7596,77 @@ async function executeCompact(sessionID, msg, autoCompactState, client, director
   try {
     const errorData = autoCompactState.errorDataBySession.get(sessionID);
     const truncateState = getOrCreateTruncateState(autoCompactState, sessionID);
+    const dcpState = getOrCreateDcpState(autoCompactState, sessionID);
+    if (experimental?.dcp_for_compaction && !dcpState.attempted && errorData?.currentTokens && errorData?.maxTokens && errorData.currentTokens > errorData.maxTokens) {
+      dcpState.attempted = true;
+      log("[auto-compact] DCP triggered FIRST on token limit error", {
+        sessionID,
+        currentTokens: errorData.currentTokens,
+        maxTokens: errorData.maxTokens
+      });
+      const dcpConfig = experimental.dynamic_context_pruning ?? {
+        enabled: true,
+        notification: "detailed",
+        protected_tools: ["task", "todowrite", "todoread", "lsp_rename", "lsp_code_action_resolve"]
+      };
+      try {
+        const pruningResult = await executeDynamicContextPruning(sessionID, dcpConfig, client);
+        if (pruningResult.itemsPruned > 0) {
+          dcpState.itemsPruned = pruningResult.itemsPruned;
+          log("[auto-compact] DCP successful, proceeding to compaction", {
+            itemsPruned: pruningResult.itemsPruned,
+            tokensSaved: pruningResult.totalTokensSaved
+          });
+          await client.tui.showToast({
+            body: {
+              title: "Dynamic Context Pruning",
+              message: `Pruned ${pruningResult.itemsPruned} items (~${Math.round(pruningResult.totalTokensSaved / 1000)}k tokens). Running compaction...`,
+              variant: "success",
+              duration: 3000
+            }
+          }).catch(() => {});
+          const providerID = msg.providerID;
+          const modelID = msg.modelID;
+          if (providerID && modelID) {
+            try {
+              sanitizeEmptyMessagesBeforeSummarize(sessionID);
+              await client.tui.showToast({
+                body: {
+                  title: "Auto Compact",
+                  message: "Summarizing session after DCP...",
+                  variant: "warning",
+                  duration: 3000
+                }
+              }).catch(() => {});
+              await client.session.summarize({
+                path: { id: sessionID },
+                body: { providerID, modelID },
+                query: { directory }
+              });
+              clearSessionState(autoCompactState, sessionID);
+              setTimeout(async () => {
+                try {
+                  await client.session.prompt_async({
+                    path: { sessionID },
+                    body: { parts: [{ type: "text", text: "Continue" }] },
+                    query: { directory }
+                  });
+                } catch {}
+              }, 500);
+              return;
+            } catch (summarizeError) {
+              log("[auto-compact] summarize after DCP failed, continuing recovery", {
+                error: String(summarizeError)
+              });
+            }
+          }
+        } else {
+          log("[auto-compact] DCP did not prune any items", { sessionID });
+        }
+      } catch (error) {
+        log("[auto-compact] DCP failed", { error: String(error) });
+      }
+    }
     if (experimental?.aggressive_truncation && errorData?.currentTokens && errorData?.maxTokens && errorData.currentTokens > errorData.maxTokens && truncateState.truncateAttempt < TRUNCATE_CONFIG.maxTruncateAttempts) {
       log("[auto-compact] aggressive truncation triggered (experimental)", {
         currentTokens: errorData.currentTokens,
@@ -7673,6 +7793,7 @@ async function executeCompact(sessionID, msg, autoCompactState, client, director
       const modelID = msg.modelID;
       if (providerID && modelID) {
         try {
+          sanitizeEmptyMessagesBeforeSummarize(sessionID);
           await client.tui.showToast({
             body: {
               title: "Auto Compact",
@@ -7715,45 +7836,6 @@ async function executeCompact(sessionID, msg, autoCompactState, client, director
         }).catch(() => {});
       }
     }
-    const dcpState = getOrCreateDcpState(autoCompactState, sessionID);
-    if (experimental?.dcp_on_compaction_failure && !dcpState.attempted) {
-      dcpState.attempted = true;
-      log("[auto-compact] attempting DCP after summarize failed", { sessionID });
-      const dcpConfig = experimental.dynamic_context_pruning ?? {
-        enabled: true,
-        notification: "detailed",
-        protected_tools: ["task", "todowrite", "todoread", "lsp_rename", "lsp_code_action_resolve"]
-      };
-      try {
-        const pruningResult = await executeDynamicContextPruning(sessionID, dcpConfig, client);
-        if (pruningResult.itemsPruned > 0) {
-          dcpState.itemsPruned = pruningResult.itemsPruned;
-          log("[auto-compact] DCP successful, retrying compaction", {
-            itemsPruned: pruningResult.itemsPruned,
-            tokensSaved: pruningResult.totalTokensSaved
-          });
-          await client.tui.showToast({
-            body: {
-              title: "Dynamic Context Pruning",
-              message: `Pruned ${pruningResult.itemsPruned} items (~${Math.round(pruningResult.totalTokensSaved / 1000)}k tokens). Retrying compaction...`,
-              variant: "success",
-              duration: 3000
-            }
-          }).catch(() => {});
-          retryState.attempt = 0;
-          setTimeout(() => {
-            executeCompact(sessionID, msg, autoCompactState, client, directory, experimental);
-          }, 500);
-          return;
-        } else {
-          log("[auto-compact] DCP did not prune any items, continuing to revert", { sessionID });
-        }
-      } catch (error) {
-        log("[auto-compact] DCP failed, continuing to revert", {
-          error: String(error)
-        });
-      }
-    }
     const fallbackState = getOrCreateFallbackState(autoCompactState, sessionID);
     if (fallbackState.revertAttempt < FALLBACK_CONFIG.maxRevertAttempts) {
       const pair = await getLastMessagePair(sessionID, client, directory);
@@ -8506,21 +8588,21 @@ async function loadClaudeHooksConfig(customSettingsPath) {
 
 // src/hooks/claude-code-hooks/config-loader.ts
 import { existsSync as existsSync22 } from "fs";
-import { homedir as homedir7 } from "os";
+import { homedir as homedir6 } from "os";
 import { join as join27 } from "path";
-var USER_CONFIG_PATH = join27(homedir7(), ".config", "opencode", "opencode-cc-plugin.json");
+var USER_CONFIG_PATH = join27(homedir6(), ".config", "opencode", "opencode-cc-plugin.json");
 function getProjectConfigPath() {
   return join27(process.cwd(), ".opencode", "opencode-cc-plugin.json");
 }
-async function loadConfigFromPath(path5) {
-  if (!existsSync22(path5)) {
+async function loadConfigFromPath(path4) {
+  if (!existsSync22(path4)) {
     return null;
   }
   try {
-    const content = await Bun.file(path5).text();
+    const content = await Bun.file(path4).text();
     return JSON.parse(content);
   } catch (error) {
-    log("Failed to load config", { path: path5, error });
+    log("Failed to load config", { path: path4, error });
     return null;
   }
 }
@@ -8708,10 +8790,10 @@ function ensureTranscriptDir() {
 }
 function appendTranscriptEntry(sessionId, entry) {
   ensureTranscriptDir();
-  const path5 = getTranscriptPath(sessionId);
+  const path4 = getTranscriptPath(sessionId);
   const line = JSON.stringify(entry) + `
 `;
-  appendFileSync5(path5, line);
+  appendFileSync5(path4, line);
 }
 function recordToolUse(sessionId, toolName, toolInput) {
   appendTranscriptEntry(sessionId, {
@@ -8818,11 +8900,11 @@ async function buildTranscriptFromSession(client, sessionId, directory, currentT
     }
   }
 }
-function deleteTempTranscript(path5) {
-  if (!path5)
+function deleteTempTranscript(path4) {
+  if (!path4)
     return;
   try {
-    unlinkSync5(path5);
+    unlinkSync5(path4);
   } catch {}
 }
 
@@ -9449,7 +9531,7 @@ ${result.message}`;
 }
 // src/hooks/rules-injector/index.ts
 import { readFileSync as readFileSync15 } from "fs";
-import { homedir as homedir8 } from "os";
+import { homedir as homedir7 } from "os";
 import { relative as relative3, resolve as resolve4 } from "path";
 
 // src/hooks/rules-injector/finder.ts
@@ -9463,7 +9545,7 @@ import { dirname as dirname4, join as join31, relative } from "path";
 
 // src/hooks/rules-injector/constants.ts
 import { join as join30 } from "path";
-var OPENCODE_STORAGE6 = join30(xdgData ?? "", "opencode", "storage");
+var OPENCODE_STORAGE6 = getOpenCodeStorageDir();
 var RULES_INJECTOR_STORAGE = join30(OPENCODE_STORAGE6, "rules-injector");
 var PROJECT_MARKERS = [
   ".git",
@@ -9804,12 +9886,12 @@ function createRulesInjectorHook(ctx) {
     }
     return sessionCaches.get(sessionID);
   }
-  function resolveFilePath2(path5) {
-    if (!path5)
+  function resolveFilePath2(path4) {
+    if (!path4)
       return null;
-    if (path5.startsWith("/"))
-      return path5;
-    return resolve4(ctx.directory, path5);
+    if (path4.startsWith("/"))
+      return path4;
+    return resolve4(ctx.directory, path4);
   }
   async function processFilePathForInjection(filePath, sessionID, output) {
     const resolved = resolveFilePath2(filePath);
@@ -9817,7 +9899,7 @@ function createRulesInjectorHook(ctx) {
       return;
     const projectRoot = findProjectRoot(resolved);
     const cache2 = getSessionCache(sessionID);
-    const home = homedir8();
+    const home = homedir7();
     const ruleFileCandidates = findRuleFiles(projectRoot, home, resolved);
     const toInject = [];
     for (const candidate of ruleFileCandidates) {
@@ -9932,33 +10014,33 @@ function createBackgroundNotificationHook(manager) {
 }
 // src/hooks/auto-update-checker/checker.ts
 import * as fs5 from "fs";
-import * as path6 from "path";
+import * as path5 from "path";
 import { fileURLToPath } from "url";
 
 // src/hooks/auto-update-checker/constants.ts
-import * as path5 from "path";
-import * as os5 from "os";
+import * as path4 from "path";
+import * as os4 from "os";
 var PACKAGE_NAME = "oh-my-opencode";
 var NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
 var NPM_FETCH_TIMEOUT = 5000;
 function getCacheDir2() {
   if (process.platform === "win32") {
-    return path5.join(process.env.LOCALAPPDATA ?? os5.homedir(), "opencode");
+    return path4.join(process.env.LOCALAPPDATA ?? os4.homedir(), "opencode");
   }
-  return path5.join(os5.homedir(), ".cache", "opencode");
+  return path4.join(os4.homedir(), ".cache", "opencode");
 }
 var CACHE_DIR = getCacheDir2();
-var VERSION_FILE = path5.join(CACHE_DIR, "version");
-var INSTALLED_PACKAGE_JSON = path5.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
+var VERSION_FILE = path4.join(CACHE_DIR, "version");
+var INSTALLED_PACKAGE_JSON = path4.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
 function getUserConfigDir2() {
   if (process.platform === "win32") {
-    return process.env.APPDATA ?? path5.join(os5.homedir(), "AppData", "Roaming");
+    return process.env.APPDATA ?? path4.join(os4.homedir(), "AppData", "Roaming");
   }
-  return process.env.XDG_CONFIG_HOME ?? path5.join(os5.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME ?? path4.join(os4.homedir(), ".config");
 }
 var USER_CONFIG_DIR = getUserConfigDir2();
-var USER_OPENCODE_CONFIG = path5.join(USER_CONFIG_DIR, "opencode", "opencode.json");
-var USER_OPENCODE_CONFIG_JSONC = path5.join(USER_CONFIG_DIR, "opencode", "opencode.jsonc");
+var USER_OPENCODE_CONFIG = path4.join(USER_CONFIG_DIR, "opencode", "opencode.json");
+var USER_OPENCODE_CONFIG_JSONC = path4.join(USER_CONFIG_DIR, "opencode", "opencode.jsonc");
 
 // src/hooks/auto-update-checker/checker.ts
 function stripJsonComments(json) {
@@ -9966,8 +10048,8 @@ function stripJsonComments(json) {
 }
 function getConfigPaths(directory) {
   return [
-    path6.join(directory, ".opencode", "opencode.json"),
-    path6.join(directory, ".opencode", "opencode.jsonc"),
+    path5.join(directory, ".opencode", "opencode.json"),
+    path5.join(directory, ".opencode", "opencode.jsonc"),
     USER_OPENCODE_CONFIG,
     USER_OPENCODE_CONFIG_JSONC
   ];
@@ -9998,9 +10080,9 @@ function getLocalDevPath(directory) {
 function findPackageJsonUp(startPath) {
   try {
     const stat = fs5.statSync(startPath);
-    let dir = stat.isDirectory() ? startPath : path6.dirname(startPath);
+    let dir = stat.isDirectory() ? startPath : path5.dirname(startPath);
     for (let i = 0;i < 10; i++) {
-      const pkgPath = path6.join(dir, "package.json");
+      const pkgPath = path5.join(dir, "package.json");
       if (fs5.existsSync(pkgPath)) {
         try {
           const content = fs5.readFileSync(pkgPath, "utf-8");
@@ -10009,7 +10091,7 @@ function findPackageJsonUp(startPath) {
             return pkgPath;
         } catch {}
       }
-      const parent = path6.dirname(dir);
+      const parent = path5.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -10066,7 +10148,7 @@ function getCachedVersion() {
     }
   } catch {}
   try {
-    const currentDir = path6.dirname(fileURLToPath(import.meta.url));
+    const currentDir = path5.dirname(fileURLToPath(import.meta.url));
     const pkgPath = findPackageJsonUp(currentDir);
     if (pkgPath) {
       const content = fs5.readFileSync(pkgPath, "utf-8");
@@ -10142,12 +10224,12 @@ async function getLatestVersion() {
 
 // src/hooks/auto-update-checker/cache.ts
 import * as fs6 from "fs";
-import * as path7 from "path";
+import * as path6 from "path";
 function stripTrailingCommas(json) {
   return json.replace(/,(\s*[}\]])/g, "$1");
 }
 function removeFromBunLock(packageName) {
-  const lockPath = path7.join(CACHE_DIR, "bun.lock");
+  const lockPath = path6.join(CACHE_DIR, "bun.lock");
   if (!fs6.existsSync(lockPath))
     return false;
   try {
@@ -10173,8 +10255,8 @@ function removeFromBunLock(packageName) {
 }
 function invalidatePackage(packageName = PACKAGE_NAME) {
   try {
-    const pkgDir = path7.join(CACHE_DIR, "node_modules", packageName);
-    const pkgJsonPath = path7.join(CACHE_DIR, "package.json");
+    const pkgDir = path6.join(CACHE_DIR, "node_modules", packageName);
+    const pkgJsonPath = path6.join(CACHE_DIR, "package.json");
     let packageRemoved = false;
     let dependencyRemoved = false;
     let lockRemoved = false;
@@ -10372,7 +10454,7 @@ import { join as join37 } from "path";
 
 // src/hooks/agent-usage-reminder/constants.ts
 import { join as join36 } from "path";
-var OPENCODE_STORAGE7 = join36(xdgData ?? "", "opencode", "storage");
+var OPENCODE_STORAGE7 = getOpenCodeStorageDir();
 var AGENT_USAGE_REMINDER_STORAGE = join36(OPENCODE_STORAGE7, "agent-usage-reminder");
 var TARGET_TOOLS = new Set([
   "grep",
@@ -10756,7 +10838,7 @@ import { join as join39 } from "path";
 
 // src/hooks/interactive-bash-session/constants.ts
 import { join as join38 } from "path";
-var OPENCODE_STORAGE8 = join38(xdgData ?? "", "opencode", "storage");
+var OPENCODE_STORAGE8 = getOpenCodeStorageDir();
 var INTERACTIVE_BASH_SESSION_STORAGE = join38(OPENCODE_STORAGE8, "interactive-bash-session");
 var OMO_SESSION_PREFIX = "omo-";
 function buildSessionReminderMessage(sessions) {
@@ -10979,7 +11061,7 @@ function createInteractiveBashSessionHook(_ctx) {
   };
 }
 // src/hooks/empty-message-sanitizer/index.ts
-var PLACEHOLDER_TEXT = "[user interrupted]";
+var PLACEHOLDER_TEXT2 = "[user interrupted]";
 function hasTextContent(part) {
   if (part.type === "text") {
     const text = part.text;
@@ -11008,7 +11090,7 @@ function createEmptyMessageSanitizerHook() {
             if (part.type === "text") {
               const textPart = part;
               if (!textPart.text || !textPart.text.trim()) {
-                textPart.text = PLACEHOLDER_TEXT;
+                textPart.text = PLACEHOLDER_TEXT2;
                 textPart.synthetic = true;
                 injected = true;
                 break;
@@ -11022,7 +11104,7 @@ function createEmptyMessageSanitizerHook() {
               messageID: message.info.id,
               sessionID: message.info.sessionID ?? "",
               type: "text",
-              text: PLACEHOLDER_TEXT,
+              text: PLACEHOLDER_TEXT2,
               synthetic: true
             };
             if (insertIndex === -1) {
@@ -11036,7 +11118,7 @@ function createEmptyMessageSanitizerHook() {
           if (part.type === "text") {
             const textPart = part;
             if (textPart.text !== undefined && textPart.text.trim() === "") {
-              textPart.text = PLACEHOLDER_TEXT;
+              textPart.text = PLACEHOLDER_TEXT2;
               textPart.synthetic = true;
             }
           }
@@ -11055,12 +11137,12 @@ function isExtendedThinkingModel(modelID) {
   }
   return lower.includes("claude-sonnet-4") || lower.includes("claude-opus-4") || lower.includes("claude-3");
 }
-function hasToolParts(parts) {
+function hasContentParts(parts) {
   if (!parts || parts.length === 0)
     return false;
   return parts.some((part) => {
     const type = part.type;
-    return type === "tool" || type === "tool_use";
+    return type === "tool" || type === "tool_use" || type === "text";
   });
 }
 function startsWithThinkingBlock(parts) {
@@ -11119,7 +11201,7 @@ function createThinkingBlockValidatorHook() {
         const msg = messages[i];
         if (msg.info.role !== "assistant")
           continue;
-        if (hasToolParts(msg.parts) && !startsWithThinkingBlock(msg.parts)) {
+        if (hasContentParts(msg.parts) && !startsWithThinkingBlock(msg.parts)) {
           const previousThinking = findPreviousThinkingContent(messages, i);
           const thinkingContent = previousThinking || "[Continuing from previous reasoning]";
           prependThinkingBlock(msg, thinkingContent);
@@ -11392,10 +11474,66 @@ function startCallbackServer(timeoutMs = 5 * 60 * 1000) {
   };
 }
 // src/auth/antigravity/token.ts
+class AntigravityTokenRefreshError extends Error {
+  code;
+  description;
+  status;
+  statusText;
+  responseBody;
+  constructor(options) {
+    super(options.message);
+    this.name = "AntigravityTokenRefreshError";
+    this.code = options.code;
+    this.description = options.description;
+    this.status = options.status;
+    this.statusText = options.statusText;
+    this.responseBody = options.responseBody;
+  }
+  get isInvalidGrant() {
+    return this.code === "invalid_grant";
+  }
+  get isNetworkError() {
+    return this.status === 0;
+  }
+}
+function parseOAuthErrorPayload(text) {
+  if (!text) {
+    return {};
+  }
+  try {
+    const payload = JSON.parse(text);
+    let code;
+    if (typeof payload.error === "string") {
+      code = payload.error;
+    } else if (payload.error && typeof payload.error === "object") {
+      code = payload.error.status ?? payload.error.code;
+    }
+    return {
+      code,
+      description: payload.error_description
+    };
+  } catch {
+    return { description: text };
+  }
+}
 function isTokenExpired(tokens) {
   const expirationTime = tokens.timestamp + tokens.expires_in * 1000;
   return Date.now() >= expirationTime - ANTIGRAVITY_TOKEN_REFRESH_BUFFER_MS;
 }
+var MAX_REFRESH_RETRIES = 3;
+var INITIAL_RETRY_DELAY_MS = 1000;
+function calculateRetryDelay(attempt) {
+  return Math.min(INITIAL_RETRY_DELAY_MS * Math.pow(2, attempt), 1e4);
+}
+function isRetryableError(status) {
+  if (status === 0)
+    return true;
+  if (status === 429)
+    return true;
+  if (status >= 500 && status < 600)
+    return true;
+  return false;
+}
 async function refreshAccessToken(refreshToken, clientId = ANTIGRAVITY_CLIENT_ID, clientSecret = ANTIGRAVITY_CLIENT_SECRET) {
   const params = new URLSearchParams({
     grant_type: "refresh_token",
@@ -11403,24 +11541,67 @@ async function refreshAccessToken(refreshToken, clientId = ANTIGRAVITY_CLIENT_ID
     client_id: clientId,
     client_secret: clientSecret
   });
-  const response = await fetch(GOOGLE_TOKEN_URL, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
-    body: params
-  });
-  if (!response.ok) {
-    const errorText = await response.text().catch(() => "Unknown error");
-    throw new Error(`Token refresh failed: ${response.status} ${response.statusText} - ${errorText}`);
+  let lastError;
+  for (let attempt = 0;attempt <= MAX_REFRESH_RETRIES; attempt++) {
+    try {
+      const response = await fetch(GOOGLE_TOKEN_URL, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: params
+      });
+      if (response.ok) {
+        const data = await response.json();
+        return {
+          access_token: data.access_token,
+          refresh_token: data.refresh_token || refreshToken,
+          expires_in: data.expires_in,
+          token_type: data.token_type
+        };
+      }
+      const responseBody = await response.text().catch(() => {
+        return;
+      });
+      const parsed = parseOAuthErrorPayload(responseBody);
+      lastError = new AntigravityTokenRefreshError({
+        message: parsed.description || `Token refresh failed: ${response.status} ${response.statusText}`,
+        code: parsed.code,
+        description: parsed.description,
+        status: response.status,
+        statusText: response.statusText,
+        responseBody
+      });
+      if (parsed.code === "invalid_grant") {
+        throw lastError;
+      }
+      if (!isRetryableError(response.status)) {
+        throw lastError;
+      }
+      if (attempt < MAX_REFRESH_RETRIES) {
+        const delay = calculateRetryDelay(attempt);
+        await new Promise((resolve5) => setTimeout(resolve5, delay));
+      }
+    } catch (error) {
+      if (error instanceof AntigravityTokenRefreshError) {
+        throw error;
+      }
+      lastError = new AntigravityTokenRefreshError({
+        message: error instanceof Error ? error.message : "Network error during token refresh",
+        status: 0,
+        statusText: "Network Error"
+      });
+      if (attempt < MAX_REFRESH_RETRIES) {
+        const delay = calculateRetryDelay(attempt);
+        await new Promise((resolve5) => setTimeout(resolve5, delay));
+      }
+    }
   }
-  const data = await response.json();
-  return {
-    access_token: data.access_token,
-    refresh_token: data.refresh_token || refreshToken,
-    expires_in: data.expires_in,
-    token_type: data.token_type
-  };
+  throw lastError || new AntigravityTokenRefreshError({
+    message: "Token refresh failed after all retries",
+    status: 0,
+    statusText: "Max Retries Exceeded"
+  });
 }
 function parseStoredToken(stored) {
   const parts = stored.split("|");
@@ -11645,6 +11826,10 @@ function clearProjectContextCache(accessToken) {
     projectContextCache.clear();
   }
 }
+function invalidateProjectContextByRefreshToken(_refreshToken) {
+  projectContextCache.clear();
+  debugLog4(`[invalidateProjectContextByRefreshToken] Cleared all project context cache due to refresh token invalidation`);
+}
 // src/auth/antigravity/request.ts
 function buildRequestHeaders(accessToken) {
   return {
@@ -12359,7 +12544,7 @@ function debugLog7(message) {
     console.log(`[antigravity-fetch] ${message}`);
   }
 }
-function isRetryableError(status) {
+function isRetryableError2(status) {
   if (status === 0)
     return true;
   if (status === 429)
@@ -12377,11 +12562,11 @@ var GCP_PERMISSION_ERROR_PATTERNS = [
 function isGcpPermissionError(text) {
   return GCP_PERMISSION_ERROR_PATTERNS.some((pattern) => text.includes(pattern));
 }
-function calculateRetryDelay(attempt) {
+function calculateRetryDelay2(attempt) {
   return Math.min(200 * Math.pow(2, attempt), 2000);
 }
 async function isRetryableResponse(response) {
-  if (isRetryableError(response.status))
+  if (isRetryableError2(response.status))
     return true;
   if (response.status === 403) {
     try {
@@ -12460,7 +12645,7 @@ async function attemptFetch(options) {
           const text = await response.clone().text();
           if (isGcpPermissionError(text)) {
             if (attempt < maxPermissionRetries) {
-              const delay = calculateRetryDelay(attempt);
+              const delay = calculateRetryDelay2(attempt);
               debugLog7(`[RETRY] GCP permission error, retry ${attempt + 1}/${maxPermissionRetries} after ${delay}ms`);
               await new Promise((resolve5) => setTimeout(resolve5, delay));
               continue;
@@ -12581,6 +12766,14 @@ function createAntigravityFetch(getAuth, client, providerId, clientId, clientSec
         });
         debugLog7("Token refreshed successfully");
       } catch (error) {
+        if (error instanceof AntigravityTokenRefreshError) {
+          if (error.isInvalidGrant) {
+            debugLog7(`[REFRESH] Token revoked (invalid_grant), clearing caches`);
+            invalidateProjectContextByRefreshToken(refreshParts.refreshToken);
+            clearProjectContextCache();
+          }
+          throw new Error(`Antigravity: Token refresh failed: ${error.description || error.message}${error.code ? ` (${error.code})` : ""}`);
+        }
         throw new Error(`Antigravity: Token refresh failed: ${error instanceof Error ? error.message : "Unknown error"}`);
       }
     }
@@ -12662,10 +12855,29 @@ function createAntigravityFetch(getAuth, client, providerId, clientId, clientSec
             debugLog7("[401] Token refreshed, retrying request...");
             return executeWithEndpoints();
           } catch (refreshError) {
+            if (refreshError instanceof AntigravityTokenRefreshError) {
+              if (refreshError.isInvalidGrant) {
+                debugLog7(`[401] Token revoked (invalid_grant), clearing caches`);
+                invalidateProjectContextByRefreshToken(refreshParts.refreshToken);
+                clearProjectContextCache();
+              }
+              debugLog7(`[401] Token refresh failed: ${refreshError.description || refreshError.message}`);
+              return new Response(JSON.stringify({
+                error: {
+                  message: refreshError.description || refreshError.message,
+                  type: refreshError.isInvalidGrant ? "token_revoked" : "unauthorized",
+                  code: refreshError.code || "token_refresh_failed"
+                }
+              }), {
+                status: 401,
+                statusText: "Unauthorized",
+                headers: { "Content-Type": "application/json" }
+              });
+            }
             debugLog7(`[401] Token refresh failed: ${refreshError instanceof Error ? refreshError.message : "Unknown error"}`);
             return new Response(JSON.stringify({
               error: {
-                message: `Token refresh failed: ${refreshError instanceof Error ? refreshError.message : "Unknown error"}`,
+                message: refreshError instanceof Error ? refreshError.message : "Unknown error",
                 type: "unauthorized",
                 code: "token_refresh_failed"
               }
@@ -12892,8 +13104,8 @@ function loadProjectCommands() {
   return commandsToRecord(commands);
 }
 function loadOpencodeGlobalCommands() {
-  const { homedir: homedir10 } = __require("os");
-  const opencodeCommandsDir = join40(homedir10(), ".config", "opencode", "command");
+  const { homedir: homedir9 } = __require("os");
+  const opencodeCommandsDir = join40(homedir9(), ".config", "opencode", "command");
   const commands = loadCommandsFromDir(opencodeCommandsDir, "opencode");
   return commandsToRecord(commands);
 }
@@ -12902,6 +13114,334 @@ function loadOpencodeProjectCommands() {
   const commands = loadCommandsFromDir(opencodeProjectDir, "opencode-project");
   return commandsToRecord(commands);
 }
+// src/features/builtin-commands/templates/init-deep.ts
+var INIT_DEEP_TEMPLATE = `# Initialize Deep Knowledge Base
+
+Generate comprehensive AGENTS.md files across project hierarchy. Combines root-level project knowledge (gen-knowledge) with complexity-based subdirectory documentation (gen-knowledge-deep).
+
+## Usage
+
+\`\`\`
+/init-deep                      # Analyze and generate hierarchical AGENTS.md
+/init-deep --create-new         # Force create from scratch (ignore existing)
+/init-deep --max-depth=2        # Limit to N directory levels (default: 3)
+\`\`\`
+
+---
+
+## Core Principles
+
+- **Telegraphic Style**: Sacrifice grammar for concision ("Project uses React" \u2192 "React 18")
+- **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
+
+---
+
+## Process
+
+<critical>
+**MANDATORY: TodoWrite for ALL phases. Mark in_progress \u2192 completed in real-time.**
+</critical>
+
+### Phase 0: Initialize
+
+\`\`\`
+TodoWrite([
+  { id: "p1-analysis", content: "Parallel project structure & complexity analysis", status: "pending", priority: "high" },
+  { id: "p2-scoring", content: "Score directories, determine AGENTS.md locations", status: "pending", priority: "high" },
+  { id: "p3-root", content: "Generate root AGENTS.md with Predict-then-Compare", status: "pending", priority: "high" },
+  { id: "p4-subdirs", content: "Generate subdirectory AGENTS.md files in parallel", status: "pending", priority: "high" },
+  { id: "p5-review", content: "Review, deduplicate, validate all files", status: "pending", priority: "medium" }
+])
+\`\`\`
+
+---
+
+## Phase 1: Parallel Project Analysis
+
+**Mark "p1-analysis" as in_progress.**
+
+Launch **ALL tasks simultaneously**:
+
+<parallel-tasks>
+
+### Structural Analysis (bash - run in parallel)
+\`\`\`bash
+# Task A: Directory depth analysis
+find . -type d -not -path '*/\\.*' -not -path '*/node_modules/*' -not -path '*/venv/*' -not -path '*/__pycache__/*' -not -path '*/dist/*' -not -path '*/build/*' | awk -F/ '{print NF-1}' | sort -n | uniq -c
+
+# Task B: File count per directory  
+find . -type f -not -path '*/\\.*' -not -path '*/node_modules/*' -not -path '*/venv/*' -not -path '*/__pycache__/*' | sed 's|/[^/]*$||' | sort | uniq -c | sort -rn | head -30
+
+# Task C: Code concentration
+find . -type f \\( -name "*.py" -o -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.jsx" -o -name "*.go" -o -name "*.rs" -o -name "*.java" \\) -not -path '*/node_modules/*' -not -path '*/venv/*' | sed 's|/[^/]*$||' | sort | uniq -c | sort -rn | head -20
+
+# Task D: Existing knowledge files
+find . -type f \\( -name "AGENTS.md" -o -name "CLAUDE.md" \\) -not -path '*/node_modules/*' 2>/dev/null
+\`\`\`
+
+### Context Gathering (Explore agents - background_task in parallel)
+
+\`\`\`
+background_task(agent="explore", prompt="Project structure: PREDICT standard {lang} patterns \u2192 FIND package.json/pyproject.toml/go.mod \u2192 REPORT deviations only")
+
+background_task(agent="explore", prompt="Entry points: PREDICT typical (main.py, index.ts) \u2192 FIND actual \u2192 REPORT non-standard organization")
+
+background_task(agent="explore", prompt="Conventions: FIND .cursor/rules, .cursorrules, eslintrc, pyproject.toml \u2192 REPORT project-specific rules DIFFERENT from defaults")
+
+background_task(agent="explore", prompt="Anti-patterns: FIND comments with 'DO NOT', 'NEVER', 'ALWAYS', 'LEGACY', 'DEPRECATED' \u2192 REPORT forbidden patterns")
+
+background_task(agent="explore", prompt="Build/CI: FIND .github/workflows, Makefile, justfile \u2192 REPORT non-standard build/deploy patterns")
+
+background_task(agent="explore", prompt="Test patterns: FIND pytest.ini, jest.config, test structure \u2192 REPORT unique testing conventions")
+\`\`\`
+
+</parallel-tasks>
+
+**Collect all results. Mark "p1-analysis" as completed.**
+
+---
+
+## Phase 2: Complexity Scoring & Location Decision
+
+**Mark "p2-scoring" as in_progress.**
+
+### 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 |
+
+### Decision Rules
+
+| Score | Action |
+|-------|--------|
+| **Root (.)** | ALWAYS create AGENTS.md |
+| **High (>15)** | Create dedicated AGENTS.md |
+| **Medium (8-15)** | Create if distinct domain |
+| **Low (<8)** | Skip, parent sufficient |
+
+### Output Format
+
+\`\`\`
+AGENTS_LOCATIONS = [
+  { path: ".", type: "root" },
+  { path: "src/api", score: 18, reason: "high complexity, 45 files" },
+  { path: "src/hooks", score: 12, reason: "distinct domain, unique patterns" },
+]
+\`\`\`
+
+**Mark "p2-scoring" as completed.**
+
+---
+
+## Phase 3: Generate Root AGENTS.md
+
+**Mark "p3-root" as in_progress.**
+
+Root AGENTS.md gets **full treatment** with Predict-then-Compare synthesis.
+
+### Required Sections
+
+\`\`\`markdown
+# PROJECT KNOWLEDGE BASE
+
+**Generated:** {TIMESTAMP}
+**Commit:** {SHORT_SHA}
+**Branch:** {BRANCH}
+
+## OVERVIEW
+
+{1-2 sentences: what project does, core tech stack}
+
+## STRUCTURE
+
+\\\`\\\`\\\`
+{project-root}/
+\u251C\u2500\u2500 {dir}/      # {non-obvious purpose only}
+\u2514\u2500\u2500 {entry}     # entry point
+\\\`\\\`\\\`
+
+## WHERE TO LOOK
+
+| Task | Location | Notes |
+|------|----------|-------|
+| Add feature X | \\\`src/x/\\\` | {pattern hint} |
+
+## CONVENTIONS
+
+{ONLY deviations from standard - skip generic advice}
+
+- **{rule}**: {specific detail}
+
+## ANTI-PATTERNS (THIS PROJECT)
+
+{Things explicitly forbidden HERE}
+
+- **{pattern}**: {why} \u2192 {alternative}
+
+## UNIQUE STYLES
+
+{Project-specific coding styles}
+
+- **{style}**: {how different}
+
+## COMMANDS
+
+\\\`\\\`\\\`bash
+{dev-command}
+{test-command}
+{build-command}
+\\\`\\\`\\\`
+
+## NOTES
+
+{Gotchas, non-obvious info}
+\`\`\`
+
+### Quality Gates
+
+- [ ] Size: 50-150 lines
+- [ ] No generic advice ("write clean code")
+- [ ] No obvious info ("tests/ has tests")
+- [ ] Every item is project-specific
+
+**Mark "p3-root" as completed.**
+
+---
+
+## Phase 4: Generate Subdirectory AGENTS.md
+
+**Mark "p4-subdirs" as in_progress.**
+
+For each location in AGENTS_LOCATIONS (except root), launch **parallel document-writer agents**:
+
+\`\`\`typescript
+for (const loc of AGENTS_LOCATIONS.filter(l => l.path !== ".")) {
+  background_task({
+    agent: "document-writer",
+    prompt: \\\`
+      Generate AGENTS.md for: \${loc.path}
+      
+      CONTEXT:
+      - Complexity reason: \${loc.reason}
+      - Parent AGENTS.md: ./AGENTS.md (already covers project overview)
+      
+      CRITICAL RULES:
+      1. Focus ONLY on this directory's specific context
+      2. NEVER repeat parent AGENTS.md content
+      3. Shorter is better - 30-80 lines max
+      4. Telegraphic style - sacrifice grammar
+      
+      REQUIRED SECTIONS:
+      - OVERVIEW (1 line: what this directory does)
+      - STRUCTURE (only if >5 subdirs)
+      - WHERE TO LOOK (directory-specific tasks)
+      - CONVENTIONS (only if DIFFERENT from root)
+      - ANTI-PATTERNS (directory-specific only)
+      
+      OUTPUT: Write to \${loc.path}/AGENTS.md
+    \\\`
+  })
+}
+\`\`\`
+
+**Wait for all agents. Mark "p4-subdirs" as completed.**
+
+---
+
+## Phase 5: Review & Deduplicate
+
+**Mark "p5-review" as in_progress.**
+
+### Validation Checklist
+
+For EACH generated AGENTS.md:
+
+| Check | Action if Fail |
+|-------|----------------|
+| Contains generic advice | REMOVE the line |
+| Repeats parent content | REMOVE the line |
+| Missing required section | ADD it |
+| Over 150 lines (root) / 80 lines (subdir) | TRIM |
+| Verbose explanations | REWRITE telegraphic |
+
+### Cross-Reference Validation
+
+\`\`\`
+For each child AGENTS.md:
+  For each line in child:
+    If similar line exists in parent:
+      REMOVE from child (parent already covers)
+\`\`\`
+
+**Mark "p5-review" as completed.**
+
+---
+
+## Final Report
+
+\`\`\`
+=== init-deep Complete ===
+
+Files Generated:
+  \u2713 ./AGENTS.md (root, {N} lines)
+  \u2713 ./src/hooks/AGENTS.md ({N} lines)
+  \u2713 ./src/tools/AGENTS.md ({N} lines)
+
+Directories Analyzed: {N}
+AGENTS.md Created: {N}
+Total Lines: {N}
+
+Hierarchy:
+  ./AGENTS.md
+  \u251C\u2500\u2500 src/hooks/AGENTS.md
+  \u2514\u2500\u2500 src/tools/AGENTS.md
+\`\`\`
+
+---
+
+## Anti-Patterns for THIS Command
+
+- **Over-documenting**: Not every directory needs AGENTS.md
+- **Redundancy**: Child must NOT repeat parent
+- **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`;
+
+// src/features/builtin-commands/commands.ts
+var BUILTIN_COMMAND_DEFINITIONS = {
+  "init-deep": {
+    description: "(builtin) Initialize hierarchical AGENTS.md knowledge base",
+    template: `<command-instruction>
+${INIT_DEEP_TEMPLATE}
+</command-instruction>
+
+<user-request>
+$ARGUMENTS
+</user-request>`,
+    argumentHint: "[--create-new] [--max-depth=N]"
+  }
+};
+function loadBuiltinCommands(disabledCommands) {
+  const disabled = new Set(disabledCommands ?? []);
+  const commands = {};
+  for (const [name, definition] of Object.entries(BUILTIN_COMMAND_DEFINITIONS)) {
+    if (!disabled.has(name)) {
+      commands[name] = {
+        name,
+        ...definition
+      };
+    }
+  }
+  return commands;
+}
 // src/features/claude-code-agent-loader/loader.ts
 import { existsSync as existsSync31, readdirSync as readdirSync12, readFileSync as readFileSync21 } from "fs";
 import { join as join41, basename as basename2 } from "path";
@@ -13065,13 +13605,13 @@ async function loadMcpConfigs() {
   const servers = {};
   const loadedServers = [];
   const paths = getMcpConfigPaths();
-  for (const { path: path8, scope } of paths) {
-    const config = await loadMcpConfigFile(path8);
+  for (const { path: path7, scope } of paths) {
+    const config = await loadMcpConfigFile(path7);
     if (!config?.mcpServers)
       continue;
     for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
       if (serverConfig.disabled) {
-        log(`Skipping disabled MCP server "${name}"`, { path: path8 });
+        log(`Skipping disabled MCP server "${name}"`, { path: path7 });
         continue;
       }
       try {
@@ -13082,7 +13622,7 @@ async function loadMcpConfigs() {
           loadedServers.splice(existingIndex, 1);
         }
         loadedServers.push({ name, scope, config: transformed });
-        log(`Loaded MCP server "${name}" from ${scope}`, { path: path8 });
+        log(`Loaded MCP server "${name}" from ${scope}`, { path: path7 });
       } catch (error) {
         log(`Failed to transform MCP server "${name}"`, error);
       }
@@ -13092,20 +13632,20 @@ async function loadMcpConfigs() {
 }
 // src/features/claude-code-plugin-loader/loader.ts
 import { existsSync as existsSync33, readdirSync as readdirSync13, readFileSync as readFileSync22 } from "fs";
-import { homedir as homedir10 } from "os";
+import { homedir as homedir9 } from "os";
 import { join as join43, basename as basename3 } from "path";
 var CLAUDE_PLUGIN_ROOT_VAR = "${CLAUDE_PLUGIN_ROOT}";
 function getPluginsBaseDir() {
   if (process.env.CLAUDE_PLUGINS_HOME) {
     return process.env.CLAUDE_PLUGINS_HOME;
   }
-  return join43(homedir10(), ".claude", "plugins");
+  return join43(homedir9(), ".claude", "plugins");
 }
 function getInstalledPluginsPath() {
   return join43(getPluginsBaseDir(), "installed_plugins.json");
 }
-function resolvePluginPath(path8, pluginRoot) {
-  return path8.replace(CLAUDE_PLUGIN_ROOT_VAR, pluginRoot);
+function resolvePluginPath(path7, pluginRoot) {
+  return path7.replace(CLAUDE_PLUGIN_ROOT_VAR, pluginRoot);
 }
 function resolvePluginPaths(obj, pluginRoot) {
   if (obj === null || obj === undefined)
@@ -13142,7 +13682,7 @@ function getClaudeSettingsPath() {
   if (process.env.CLAUDE_SETTINGS_PATH) {
     return process.env.CLAUDE_SETTINGS_PATH;
   }
-  return join43(homedir10(), ".claude", "settings.json");
+  return join43(homedir9(), ".claude", "settings.json");
 }
 function loadClaudeSettings() {
   const settingsPath = getClaudeSettingsPath();
@@ -13186,6 +13726,12 @@ function isPluginEnabled(pluginKey, settingsEnabledPlugins, overrideEnabledPlugi
   }
   return true;
 }
+function extractPluginEntries(db) {
+  if (db.version === 1) {
+    return Object.entries(db.plugins).map(([key, installation]) => [key, installation]);
+  }
+  return Object.entries(db.plugins).map(([key, installations]) => [key, installations[0]]);
+}
 function discoverInstalledPlugins(options) {
   const db = loadInstalledPlugins();
   const settings = loadClaudeSettings();
@@ -13196,14 +13742,13 @@ function discoverInstalledPlugins(options) {
   }
   const settingsEnabledPlugins = settings?.enabledPlugins;
   const overrideEnabledPlugins = options?.enabledPluginsOverride;
-  for (const [pluginKey, installations] of Object.entries(db.plugins)) {
-    if (!installations || installations.length === 0)
+  for (const [pluginKey, installation] of extractPluginEntries(db)) {
+    if (!installation)
       continue;
     if (!isPluginEnabled(pluginKey, settingsEnabledPlugins, overrideEnabledPlugins)) {
       log(`Plugin disabled: ${pluginKey}`);
       continue;
     }
-    const installation = installations[0];
     const { installPath, scope, version } = installation;
     if (!existsSync33(installPath)) {
       errors.push({
@@ -13246,7 +13791,7 @@ function discoverInstalledPlugins(options) {
   return { plugins, errors };
 }
 function loadPluginCommands(plugins) {
-  const commands = {};
+  const commands2 = {};
   for (const plugin2 of plugins) {
     if (!plugin2.commandsDir || !existsSync33(plugin2.commandsDir))
       continue;
@@ -13268,7 +13813,7 @@ ${body.trim()}
 $ARGUMENTS
 </user-request>`;
         const formattedDescription = `(plugin: ${plugin2.name}) ${data.description || ""}`;
-        commands[namespacedName] = {
+        commands2[namespacedName] = {
           name: namespacedName,
           description: formattedDescription,
           template: wrappedTemplate,
@@ -13283,7 +13828,7 @@ $ARGUMENTS
       }
     }
   }
-  return commands;
+  return commands2;
 }
 function loadPluginSkillsAsCommands(plugins) {
   const skills = {};
@@ -13431,14 +13976,14 @@ function loadPluginHooksConfigs(plugins) {
 }
 async function loadAllPluginComponents(options) {
   const { plugins, errors } = discoverInstalledPlugins(options);
-  const commands = loadPluginCommands(plugins);
+  const commands2 = loadPluginCommands(plugins);
   const skills = loadPluginSkillsAsCommands(plugins);
   const agents = loadPluginAgents(plugins);
   const mcpServers = await loadPluginMcpServers(plugins);
   const hooksConfigs = loadPluginHooksConfigs(plugins);
-  log(`Loaded ${plugins.length} plugins with ${Object.keys(commands).length} commands, ${Object.keys(skills).length} skills, ${Object.keys(agents).length} agents, ${Object.keys(mcpServers).length} MCP servers`);
+  log(`Loaded ${plugins.length} plugins with ${Object.keys(commands2).length} commands, ${Object.keys(skills).length} skills, ${Object.keys(agents).length} agents, ${Object.keys(mcpServers).length} MCP servers`);
   return {
-    commands,
+    commands: commands2,
     skills,
     agents,
     mcpServers,
@@ -13485,6 +14030,36 @@ var SEVERITY_MAP = {
 var DEFAULT_MAX_REFERENCES = 200;
 var DEFAULT_MAX_SYMBOLS = 200;
 var DEFAULT_MAX_DIAGNOSTICS = 200;
+var LSP_INSTALL_HINTS = {
+  typescript: "npm install -g typescript-language-server typescript",
+  deno: "Install Deno from https://deno.land",
+  vue: "npm install -g @vue/language-server",
+  eslint: "npm install -g vscode-langservers-extracted",
+  oxlint: "npm install -g oxlint",
+  biome: "npm install -g @biomejs/biome",
+  gopls: "go install golang.org/x/tools/gopls@latest",
+  "ruby-lsp": "gem install ruby-lsp",
+  basedpyright: "pip install basedpyright",
+  pyright: "pip install pyright",
+  ty: "pip install ty",
+  ruff: "pip install ruff",
+  "elixir-ls": "See https://github.com/elixir-lsp/elixir-ls",
+  zls: "See https://github.com/zigtools/zls",
+  csharp: "dotnet tool install -g csharp-ls",
+  fsharp: "dotnet tool install -g fsautocomplete",
+  "sourcekit-lsp": "Included with Xcode or Swift toolchain",
+  rust: "rustup component add rust-analyzer",
+  clangd: "See https://clangd.llvm.org/installation",
+  svelte: "npm install -g svelte-language-server",
+  astro: "npm install -g @astrojs/language-server",
+  "bash-ls": "npm install -g bash-language-server",
+  jdtls: "See https://github.com/eclipse-jdtls/eclipse.jdt.ls",
+  "yaml-ls": "npm install -g yaml-language-server",
+  "lua-ls": "See https://github.com/LuaLS/lua-language-server",
+  php: "npm install -g intelephense",
+  dart: "Included with Dart SDK",
+  "terraform-ls": "See https://github.com/hashicorp/terraform-ls"
+};
 var BUILTIN_SERVERS = {
   typescript: {
     command: ["typescript-language-server", "--stdio"],
@@ -13744,12 +14319,12 @@ var EXT_TO_LANG = {
 // src/tools/lsp/config.ts
 import { existsSync as existsSync34, readFileSync as readFileSync23 } from "fs";
 import { join as join44 } from "path";
-import { homedir as homedir11 } from "os";
-function loadJsonFile(path8) {
-  if (!existsSync34(path8))
+import { homedir as homedir10 } from "os";
+function loadJsonFile(path7) {
+  if (!existsSync34(path7))
     return null;
   try {
-    return JSON.parse(readFileSync23(path8, "utf-8"));
+    return JSON.parse(readFileSync23(path7, "utf-8"));
   } catch {
     return null;
   }
@@ -13758,8 +14333,8 @@ function getConfigPaths2() {
   const cwd = process.cwd();
   return {
     project: join44(cwd, ".opencode", "oh-my-opencode.json"),
-    user: join44(homedir11(), ".config", "opencode", "oh-my-opencode.json"),
-    opencode: join44(homedir11(), ".config", "opencode", "opencode.json")
+    user: join44(homedir10(), ".config", "opencode", "oh-my-opencode.json"),
+    opencode: join44(homedir10(), ".config", "opencode", "opencode.json")
   };
 }
 function loadAllConfigs() {
@@ -13831,16 +14406,38 @@ function findServerForExtension(ext) {
   for (const server of servers) {
     if (server.extensions.includes(ext) && isServerInstalled(server.command)) {
       return {
-        id: server.id,
-        command: server.command,
-        extensions: server.extensions,
-        priority: server.priority,
-        env: server.env,
-        initialization: server.initialization
+        status: "found",
+        server: {
+          id: server.id,
+          command: server.command,
+          extensions: server.extensions,
+          priority: server.priority,
+          env: server.env,
+          initialization: server.initialization
+        }
       };
     }
   }
-  return null;
+  for (const server of servers) {
+    if (server.extensions.includes(ext)) {
+      const installHint = LSP_INSTALL_HINTS[server.id] || `Install '${server.command[0]}' and ensure it's in your PATH`;
+      return {
+        status: "not_installed",
+        server: {
+          id: server.id,
+          command: server.command,
+          extensions: server.extensions
+        },
+        installHint
+      };
+    }
+  }
+  const availableServers = [...new Set(servers.map((s) => s.id))];
+  return {
+    status: "not_configured",
+    extension: ext,
+    availableServers
+  };
 }
 function getLanguageId(ext) {
   return EXT_TO_LANG[ext] || "plaintext";
@@ -13863,10 +14460,10 @@ function isServerInstalled(command) {
   const additionalPaths = [
     join44(cwd, "node_modules", ".bin", cmd),
     join44(cwd, "node_modules", ".bin", cmd + ext),
-    join44(homedir11(), ".config", "opencode", "bin", cmd),
-    join44(homedir11(), ".config", "opencode", "bin", cmd + ext),
-    join44(homedir11(), ".config", "opencode", "node_modules", ".bin", cmd),
-    join44(homedir11(), ".config", "opencode", "node_modules", ".bin", cmd + ext)
+    join44(homedir10(), ".config", "opencode", "bin", cmd),
+    join44(homedir10(), ".config", "opencode", "bin", cmd + ext),
+    join44(homedir10(), ".config", "opencode", "node_modules", ".bin", cmd),
+    join44(homedir10(), ".config", "opencode", "node_modules", ".bin", cmd + ext)
   ];
   for (const p of additionalPaths) {
     if (existsSync34(p)) {
@@ -14481,13 +15078,49 @@ function findWorkspaceRoot(filePath) {
   }
   return __require("path").dirname(resolve6(filePath));
 }
+function formatServerLookupError(result) {
+  if (result.status === "not_installed") {
+    const { server, installHint } = result;
+    return [
+      `LSP server '${server.id}' is configured but NOT INSTALLED.`,
+      ``,
+      `Command not found: ${server.command[0]}`,
+      ``,
+      `To install:`,
+      `  ${installHint}`,
+      ``,
+      `Supported extensions: ${server.extensions.join(", ")}`,
+      ``,
+      `After installation, the server will be available automatically.`,
+      `Run 'lsp_servers' tool to verify installation status.`
+    ].join(`
+`);
+  }
+  return [
+    `No LSP server configured for extension: ${result.extension}`,
+    ``,
+    `Available servers: ${result.availableServers.slice(0, 10).join(", ")}${result.availableServers.length > 10 ? "..." : ""}`,
+    ``,
+    `To add a custom server, configure 'lsp' in oh-my-opencode.json:`,
+    `  {`,
+    `    "lsp": {`,
+    `      "my-server": {`,
+    `        "command": ["my-lsp", "--stdio"],`,
+    `        "extensions": ["${result.extension}"]`,
+    `      }`,
+    `    }`,
+    `  }`
+  ].join(`
+`);
+}
 async function withLspClient(filePath, fn) {
   const absPath = resolve6(filePath);
   const ext = extname2(absPath);
-  const server = findServerForExtension(ext);
-  if (!server) {
-    throw new Error(`No LSP server configured for extension: ${ext}`);
+  const result = findServerForExtension(ext);
+  if (result.status !== "found") {
+    throw new Error(formatServerLookupError(result));
   }
+  const server = result.server;
   const root = findWorkspaceRoot(absPath);
   const client = await lspManager.getClient(root, server);
   try {
@@ -15478,10 +16111,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path8) {
-  if (!path8)
+function getElementAtPath(obj, path7) {
+  if (!path7)
     return obj;
-  return path8.reduce((acc, key) => acc?.[key], obj);
+  return path7.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -15840,11 +16473,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path8, issues) {
+function prefixIssues(path7, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path8);
+    iss.path.unshift(path7);
     return iss;
   });
 }
@@ -16012,7 +16645,7 @@ function treeifyError(error, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error2, path8 = []) => {
+  const processError = (error2, path7 = []) => {
     var _a, _b;
     for (const issue2 of error2.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -16022,7 +16655,7 @@ function treeifyError(error, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path8, ...issue2.path];
+        const fullpath = [...path7, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -16054,8 +16687,8 @@ function treeifyError(error, _mapper) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path8 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path8) {
+  const path7 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path7) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24833,10 +25466,10 @@ function _property(property, schema, params) {
     ...normalizeParams(params)
   });
 }
-function _mime(types10, params) {
+function _mime(types11, params) {
   return new $ZodCheckMimeType({
     check: "mime_type",
-    mime: types10,
+    mime: types11,
     ...normalizeParams(params)
   });
 }
@@ -26746,7 +27379,7 @@ var ZodFile = /* @__PURE__ */ $constructor("ZodFile", (inst, def) => {
   ZodType.init(inst, def);
   inst.min = (size, params) => inst.check(_minSize(size, params));
   inst.max = (size, params) => inst.check(_maxSize(size, params));
-  inst.mime = (types10, params) => inst.check(_mime(Array.isArray(types10) ? types10 : [types10], params));
+  inst.mime = (types11, params) => inst.check(_mime(Array.isArray(types11) ? types11 : [types11], params));
 });
 function file(params) {
   return _file(ZodFile, params);
@@ -27405,7 +28038,7 @@ import { existsSync as existsSync37, statSync as statSync4 } from "fs";
 var {spawn: spawn6 } = globalThis.Bun;
 import { existsSync as existsSync36, mkdirSync as mkdirSync10, chmodSync as chmodSync2, unlinkSync as unlinkSync9 } from "fs";
 import { join as join45 } from "path";
-import { homedir as homedir12 } from "os";
+import { homedir as homedir11 } from "os";
 import { createRequire as createRequire3 } from "module";
 var REPO2 = "ast-grep/ast-grep";
 var DEFAULT_VERSION = "0.40.0";
@@ -27430,11 +28063,11 @@ var PLATFORM_MAP2 = {
 function getCacheDir3() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join45(homedir12(), "AppData", "Local");
+    const base2 = localAppData || join45(homedir11(), "AppData", "Local");
     return join45(base2, "oh-my-opencode", "bin");
   }
-  const xdgCache2 = process.env.XDG_CACHE_HOME;
-  const base = xdgCache2 || join45(homedir12(), ".cache");
+  const xdgCache = process.env.XDG_CACHE_HOME;
+  const base = xdgCache || join45(homedir11(), ".cache");
   return join45(base, "oh-my-opencode", "bin");
 }
 function getBinaryName3() {
@@ -27472,8 +28105,8 @@ async function downloadAstGrep(version2 = DEFAULT_VERSION) {
   if (existsSync36(binaryPath)) {
     return binaryPath;
   }
-  const { arch, os: os6 } = platformInfo;
-  const assetName = `app-${arch}-${os6}.zip`;
+  const { arch, os: os5 } = platformInfo;
+  const assetName = `app-${arch}-${os5}.zip`;
   const downloadUrl = `https://github.com/${REPO2}/releases/download/${version2}/${assetName}`;
   console.log(`[oh-my-opencode] Downloading ast-grep binary...`);
   try {
@@ -27562,9 +28195,9 @@ function findSgCliPathSync() {
   }
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
-    for (const path8 of homebrewPaths) {
-      if (existsSync37(path8) && isValidBinary(path8)) {
-        return path8;
+    for (const path7 of homebrewPaths) {
+      if (existsSync37(path7) && isValidBinary(path7)) {
+        return path7;
       }
     }
   }
@@ -27582,10 +28215,9 @@ function getSgCliPath() {
   }
   return "sg";
 }
-function setSgCliPath(path8) {
-  resolvedCliPath2 = path8;
+function setSgCliPath(path7) {
+  resolvedCliPath2 = path7;
 }
-var SG_CLI_PATH = getSgCliPath();
 var CLI_LANGUAGES = [
   "bash",
   "c",
@@ -28385,7 +29017,7 @@ function discoverCommandsFromDir(commandsDir, scope) {
     return [];
   }
   const entries = readdirSync15(commandsDir, { withFileTypes: true });
-  const commands = [];
+  const commands2 = [];
   for (const entry of entries) {
     if (!isMarkdownFile(entry))
       continue;
@@ -28403,7 +29035,7 @@ function discoverCommandsFromDir(commandsDir, scope) {
         agent: data.agent,
         subtask: Boolean(data.subtask)
       };
-      commands.push({
+      commands2.push({
         name: commandName,
         path: commandPath,
         metadata,
@@ -28414,13 +29046,13 @@ function discoverCommandsFromDir(commandsDir, scope) {
       continue;
     }
   }
-  return commands;
+  return commands2;
 }
 function discoverCommandsSync() {
-  const { homedir: homedir13 } = __require("os");
+  const { homedir: homedir12 } = __require("os");
   const userCommandsDir = join49(getClaudeConfigDir(), "commands");
   const projectCommandsDir = join49(process.cwd(), ".claude", "commands");
-  const opencodeGlobalDir = join49(homedir13(), ".config", "opencode", "command");
+  const opencodeGlobalDir = join49(homedir12(), ".config", "opencode", "command");
   const opencodeProjectDir = join49(process.cwd(), ".opencode", "command");
   const userCommands = discoverCommandsFromDir(userCommandsDir, "user");
   const opencodeGlobalCommands = discoverCommandsFromDir(opencodeGlobalDir, "opencode");
@@ -28471,18 +29103,18 @@ async function formatLoadedCommand(cmd) {
   return sections.join(`
 `);
 }
-function formatCommandList(commands) {
-  if (commands.length === 0) {
+function formatCommandList(commands2) {
+  if (commands2.length === 0) {
     return "No commands found.";
   }
   const lines = [`# Available Commands
 `];
-  for (const cmd of commands) {
+  for (const cmd of commands2) {
     const hint = cmd.metadata.argumentHint ? ` ${cmd.metadata.argumentHint}` : "";
     lines.push(`- **/${cmd.name}${hint}**: ${cmd.metadata.description || "(no description)"} (${cmd.scope})`);
   }
   lines.push(`
-**Total**: ${commands.length} commands`);
+**Total**: ${commands2.length} commands`);
   return lines.join(`
 `);
 }
@@ -28519,27 +29151,27 @@ ${commandListForDescription}`,
     command: tool.schema.string().describe("The slash command to execute (without the leading slash). E.g., 'commit', 'plan', 'execute'.")
   },
   async execute(args) {
-    const commands = discoverCommandsSync();
+    const commands2 = discoverCommandsSync();
     if (!args.command) {
-      return formatCommandList(commands) + `
+      return formatCommandList(commands2) + `
 
 Provide a command name to execute.`;
     }
     const cmdName = args.command.replace(/^\//, "");
-    const exactMatch = commands.find((cmd) => cmd.name.toLowerCase() === cmdName.toLowerCase());
+    const exactMatch = commands2.find((cmd) => cmd.name.toLowerCase() === cmdName.toLowerCase());
     if (exactMatch) {
       return await formatLoadedCommand(exactMatch);
     }
-    const partialMatches = commands.filter((cmd) => cmd.name.toLowerCase().includes(cmdName.toLowerCase()));
+    const partialMatches = commands2.filter((cmd) => cmd.name.toLowerCase().includes(cmdName.toLowerCase()));
     if (partialMatches.length > 0) {
       const matchList = partialMatches.map((cmd) => `/${cmd.name}`).join(", ");
       return `No exact match for "/${cmdName}". Did you mean: ${matchList}?
 
-` + formatCommandList(commands);
+` + formatCommandList(commands2);
     }
     return `Command "/${cmdName}" not found.
 
-` + formatCommandList(commands) + `
+` + formatCommandList(commands2) + `
 
 Try a different command name.`;
   }
@@ -28547,7 +29179,7 @@ Try a different command name.`;
 // src/tools/session-manager/constants.ts
 import { join as join50 } from "path";
 var OPENCODE_STORAGE9 = getOpenCodeStorageDir();
-var MESSAGE_STORAGE8 = join50(OPENCODE_STORAGE9, "message");
+var MESSAGE_STORAGE4 = join50(OPENCODE_STORAGE9, "message");
 var PART_STORAGE4 = join50(OPENCODE_STORAGE9, "part");
 var TODO_DIR2 = join50(getClaudeConfigDir(), "todos");
 var TRANSCRIPT_DIR2 = join50(getClaudeConfigDir(), "transcripts");
@@ -28623,22 +29255,24 @@ Has Todos: Yes (12 items, 8 completed)
 Has Transcript: Yes (234 entries)`;
 
 // src/tools/session-manager/storage.ts
-import { existsSync as existsSync42, readdirSync as readdirSync16, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync42, readdirSync as readdirSync16 } from "fs";
+import { readdir, readFile } from "fs/promises";
 import { join as join51 } from "path";
-function getAllSessions() {
-  if (!existsSync42(MESSAGE_STORAGE8))
+async function getAllSessions() {
+  if (!existsSync42(MESSAGE_STORAGE4))
     return [];
   const sessions = [];
-  function scanDirectory(dir) {
+  async function scanDirectory(dir) {
     try {
-      for (const entry of readdirSync16(dir, { withFileTypes: true })) {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
         if (entry.isDirectory()) {
           const sessionPath = join51(dir, entry.name);
-          const files = readdirSync16(sessionPath);
+          const files = await readdir(sessionPath);
           if (files.some((f) => f.endsWith(".json"))) {
             sessions.push(entry.name);
           } else {
-            scanDirectory(sessionPath);
+            await scanDirectory(sessionPath);
           }
         }
       }
@@ -28646,49 +29280,58 @@ function getAllSessions() {
       return;
     }
   }
-  scanDirectory(MESSAGE_STORAGE8);
+  await scanDirectory(MESSAGE_STORAGE4);
   return [...new Set(sessions)];
 }
 function getMessageDir9(sessionID) {
-  if (!existsSync42(MESSAGE_STORAGE8))
+  if (!existsSync42(MESSAGE_STORAGE4))
     return "";
-  const directPath = join51(MESSAGE_STORAGE8, sessionID);
+  const directPath = join51(MESSAGE_STORAGE4, sessionID);
   if (existsSync42(directPath)) {
     return directPath;
   }
-  for (const dir of readdirSync16(MESSAGE_STORAGE8)) {
-    const sessionPath = join51(MESSAGE_STORAGE8, dir, sessionID);
-    if (existsSync42(sessionPath)) {
-      return sessionPath;
+  try {
+    for (const dir of readdirSync16(MESSAGE_STORAGE4)) {
+      const sessionPath = join51(MESSAGE_STORAGE4, dir, sessionID);
+      if (existsSync42(sessionPath)) {
+        return sessionPath;
+      }
     }
+  } catch {
+    return "";
   }
   return "";
 }
 function sessionExists(sessionID) {
   return getMessageDir9(sessionID) !== "";
 }
-function readSessionMessages(sessionID) {
+async function readSessionMessages(sessionID) {
   const messageDir = getMessageDir9(sessionID);
   if (!messageDir || !existsSync42(messageDir))
     return [];
   const messages = [];
-  for (const file2 of readdirSync16(messageDir)) {
-    if (!file2.endsWith(".json"))
-      continue;
-    try {
-      const content = readFileSync27(join51(messageDir, file2), "utf-8");
-      const meta = JSON.parse(content);
-      const parts = readParts2(meta.id);
-      messages.push({
-        id: meta.id,
-        role: meta.role,
-        agent: meta.agent,
-        time: meta.time,
-        parts
-      });
-    } catch {
-      continue;
+  try {
+    const files = await readdir(messageDir);
+    for (const file2 of files) {
+      if (!file2.endsWith(".json"))
+        continue;
+      try {
+        const content = await readFile(join51(messageDir, file2), "utf-8");
+        const meta = JSON.parse(content);
+        const parts = await readParts2(meta.id);
+        messages.push({
+          id: meta.id,
+          role: meta.role,
+          agent: meta.agent,
+          time: meta.time,
+          parts
+        });
+      } catch {
+        continue;
+      }
     }
+  } catch {
+    return [];
   }
   return messages.sort((a, b) => {
     const aTime = a.time?.created ?? 0;
@@ -28698,61 +29341,71 @@ function readSessionMessages(sessionID) {
     return a.id.localeCompare(b.id);
   });
 }
-function readParts2(messageID) {
+async function readParts2(messageID) {
   const partDir = join51(PART_STORAGE4, messageID);
   if (!existsSync42(partDir))
     return [];
   const parts = [];
-  for (const file2 of readdirSync16(partDir)) {
-    if (!file2.endsWith(".json"))
-      continue;
-    try {
-      const content = readFileSync27(join51(partDir, file2), "utf-8");
-      parts.push(JSON.parse(content));
-    } catch {
-      continue;
+  try {
+    const files = await readdir(partDir);
+    for (const file2 of files) {
+      if (!file2.endsWith(".json"))
+        continue;
+      try {
+        const content = await readFile(join51(partDir, file2), "utf-8");
+        parts.push(JSON.parse(content));
+      } catch {
+        continue;
+      }
     }
+  } catch {
+    return [];
   }
   return parts.sort((a, b) => a.id.localeCompare(b.id));
 }
-function readSessionTodos(sessionID) {
+async function readSessionTodos(sessionID) {
   if (!existsSync42(TODO_DIR2))
     return [];
-  const todoFiles = readdirSync16(TODO_DIR2).filter((f) => f.includes(sessionID) && f.endsWith(".json"));
-  for (const file2 of todoFiles) {
-    try {
-      const content = readFileSync27(join51(TODO_DIR2, file2), "utf-8");
-      const data = JSON.parse(content);
-      if (Array.isArray(data)) {
-        return data.map((item) => ({
-          id: item.id || "",
-          content: item.content || "",
-          status: item.status || "pending",
-          priority: item.priority
-        }));
+  try {
+    const allFiles = await readdir(TODO_DIR2);
+    const todoFiles = allFiles.filter((f) => f.includes(sessionID) && f.endsWith(".json"));
+    for (const file2 of todoFiles) {
+      try {
+        const content = await readFile(join51(TODO_DIR2, file2), "utf-8");
+        const data = JSON.parse(content);
+        if (Array.isArray(data)) {
+          return data.map((item) => ({
+            id: item.id || "",
+            content: item.content || "",
+            status: item.status || "pending",
+            priority: item.priority
+          }));
+        }
+      } catch {
+        continue;
       }
-    } catch {
-      continue;
     }
+  } catch {
+    return [];
   }
   return [];
 }
-function readSessionTranscript(sessionID) {
+async function readSessionTranscript(sessionID) {
   if (!existsSync42(TRANSCRIPT_DIR2))
     return 0;
   const transcriptFile = join51(TRANSCRIPT_DIR2, `${sessionID}.jsonl`);
   if (!existsSync42(transcriptFile))
     return 0;
   try {
-    const content = readFileSync27(transcriptFile, "utf-8");
+    const content = await readFile(transcriptFile, "utf-8");
     return content.trim().split(`
 `).filter(Boolean).length;
   } catch {
     return 0;
   }
 }
-function getSessionInfo(sessionID) {
-  const messages = readSessionMessages(sessionID);
+async function getSessionInfo(sessionID) {
+  const messages = await readSessionMessages(sessionID);
   if (messages.length === 0)
     return null;
   const agentsUsed = new Set;
@@ -28769,8 +29422,8 @@ function getSessionInfo(sessionID) {
         lastMessage = date5;
     }
   }
-  const todos = readSessionTodos(sessionID);
-  const transcriptEntries = readSessionTranscript(sessionID);
+  const todos = await readSessionTodos(sessionID);
+  const transcriptEntries = await readSessionTranscript(sessionID);
   return {
     id: sessionID,
     message_count: messages.length,
@@ -28785,11 +29438,11 @@ function getSessionInfo(sessionID) {
 }
 
 // src/tools/session-manager/utils.ts
-function formatSessionList(sessionIDs) {
+async function formatSessionList(sessionIDs) {
   if (sessionIDs.length === 0) {
     return "No sessions found.";
   }
-  const infos = sessionIDs.map((id) => getSessionInfo(id)).filter((info) => info !== null);
+  const infos = (await Promise.all(sessionIDs.map((id) => getSessionInfo(id)))).filter((info) => info !== null);
   if (infos.length === 0) {
     return "No valid sessions found.";
   }
@@ -28881,29 +29534,33 @@ function formatSearchResults(results) {
   return lines.join(`
 `);
 }
-function filterSessionsByDate(sessionIDs, fromDate, toDate) {
+async function filterSessionsByDate(sessionIDs, fromDate, toDate) {
   if (!fromDate && !toDate)
     return sessionIDs;
   const from = fromDate ? new Date(fromDate) : null;
   const to = toDate ? new Date(toDate) : null;
-  return sessionIDs.filter((id) => {
-    const info = getSessionInfo(id);
+  const results = [];
+  for (const id of sessionIDs) {
+    const info = await getSessionInfo(id);
     if (!info || !info.last_message)
-      return false;
+      continue;
     if (from && info.last_message < from)
-      return false;
+      continue;
     if (to && info.last_message > to)
-      return false;
-    return true;
-  });
+      continue;
+    results.push(id);
+  }
+  return results;
 }
-function searchInSession(sessionID, query, caseSensitive = false) {
-  const messages = readSessionMessages(sessionID);
+async function searchInSession(sessionID, query, caseSensitive = false, maxResults) {
+  const messages = await readSessionMessages(sessionID);
   const results = [];
   const searchQuery = caseSensitive ? query : query.toLowerCase();
   for (const msg of messages) {
+    if (maxResults && results.length >= maxResults)
+      break;
     let matchCount = 0;
-    let excerpts = [];
+    const excerpts = [];
     for (const part of msg.parts) {
       if (part.type === "text" && part.text) {
         const text = caseSensitive ? part.text : part.text.toLowerCase();
@@ -28939,6 +29596,14 @@ function searchInSession(sessionID, query, caseSensitive = false) {
 }
 
 // src/tools/session-manager/tools.ts
+var SEARCH_TIMEOUT_MS = 60000;
+var MAX_SESSIONS_TO_SCAN = 50;
+function withTimeout(promise2, ms, operation) {
+  return Promise.race([
+    promise2,
+    new Promise((_, reject) => setTimeout(() => reject(new Error(`${operation} timed out after ${ms}ms`)), ms))
+  ]);
+}
 var session_list = tool({
   description: SESSION_LIST_DESCRIPTION,
   args: {
@@ -28948,14 +29613,14 @@ var session_list = tool({
   },
   execute: async (args, _context) => {
     try {
-      let sessions = getAllSessions();
+      let sessions = await getAllSessions();
       if (args.from_date || args.to_date) {
-        sessions = filterSessionsByDate(sessions, args.from_date, args.to_date);
+        sessions = await filterSessionsByDate(sessions, args.from_date, args.to_date);
       }
       if (args.limit && args.limit > 0) {
         sessions = sessions.slice(0, args.limit);
       }
-      return formatSessionList(sessions);
+      return await formatSessionList(sessions);
     } catch (e) {
       return `Error: ${e instanceof Error ? e.message : String(e)}`;
     }
@@ -28974,11 +29639,11 @@ var session_read = tool({
       if (!sessionExists(args.session_id)) {
         return `Session not found: ${args.session_id}`;
       }
-      let messages = readSessionMessages(args.session_id);
+      let messages = await readSessionMessages(args.session_id);
       if (args.limit && args.limit > 0) {
         messages = messages.slice(0, args.limit);
       }
-      const todos = args.include_todos ? readSessionTodos(args.session_id) : undefined;
+      const todos = args.include_todos ? await readSessionTodos(args.session_id) : undefined;
       return formatSessionMessages(messages, args.include_todos, todos);
     } catch (e) {
       return `Error: ${e instanceof Error ? e.message : String(e)}`;
@@ -28995,10 +29660,25 @@ var session_search = tool({
   },
   execute: async (args, _context) => {
     try {
-      const sessions = args.session_id ? [args.session_id] : getAllSessions();
-      const allResults = sessions.flatMap((sid) => searchInSession(sid, args.query, args.case_sensitive));
-      const limited = args.limit && args.limit > 0 ? allResults.slice(0, args.limit) : allResults.slice(0, 20);
-      return formatSearchResults(limited);
+      const resultLimit = args.limit && args.limit > 0 ? args.limit : 20;
+      const searchOperation = async () => {
+        if (args.session_id) {
+          return searchInSession(args.session_id, args.query, args.case_sensitive, resultLimit);
+        }
+        const allSessions = await getAllSessions();
+        const sessionsToScan = allSessions.slice(0, MAX_SESSIONS_TO_SCAN);
+        const allResults = [];
+        for (const sid of sessionsToScan) {
+          if (allResults.length >= resultLimit)
+            break;
+          const remaining = resultLimit - allResults.length;
+          const sessionResults = await searchInSession(sid, args.query, args.case_sensitive, remaining);
+          allResults.push(...sessionResults);
+        }
+        return allResults.slice(0, resultLimit);
+      };
+      const results = await withTimeout(searchOperation(), SEARCH_TIMEOUT_MS, "Search");
+      return formatSearchResults(results);
     } catch (e) {
       return `Error: ${e instanceof Error ? e.message : String(e)}`;
     }
@@ -29011,7 +29691,7 @@ var session_info = tool({
   },
   execute: async (args, _context) => {
     try {
-      const info = getSessionInfo(args.session_id);
+      const info = await getSessionInfo(args.session_id);
       if (!info) {
         return `Session not found: ${args.session_id}`;
       }
@@ -29054,12 +29734,12 @@ async function findTmuxPath() {
       return null;
     }
     const stdout = await new Response(proc.stdout).text();
-    const path8 = stdout.trim().split(`
+    const path7 = stdout.trim().split(`
 `)[0];
-    if (!path8) {
+    if (!path7) {
       return null;
     }
-    const verifyProc = spawn10([path8, "-V"], {
+    const verifyProc = spawn10([path7, "-V"], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -29067,7 +29747,7 @@ async function findTmuxPath() {
     if (verifyExitCode !== 0) {
       return null;
     }
-    return path8;
+    return path7;
   } catch {
     return null;
   }
@@ -29080,9 +29760,9 @@ async function getTmuxPath() {
     return initPromise3;
   }
   initPromise3 = (async () => {
-    const path8 = await findTmuxPath();
-    tmuxPath = path8;
-    return path8;
+    const path7 = await findTmuxPath();
+    tmuxPath = path7;
+    return path7;
   })();
   return initPromise3;
 }
@@ -29219,21 +29899,26 @@ function createBackgroundTask(manager) {
       agent: tool.schema.string().describe("Agent type to use (any registered agent)")
     },
     async execute(args, toolContext) {
+      const ctx = toolContext;
       if (!args.agent || args.agent.trim() === "") {
         return `\u274C Agent parameter is required. Please specify which agent to use (e.g., "explore", "librarian", "build", etc.)`;
       }
       try {
-        const messageDir = getMessageDir10(toolContext.sessionID);
+        const messageDir = getMessageDir10(ctx.sessionID);
         const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null;
         const parentModel = prevMessage?.model?.providerID && prevMessage?.model?.modelID ? { providerID: prevMessage.model.providerID, modelID: prevMessage.model.modelID } : undefined;
         const task = await manager.launch({
           description: args.description,
           prompt: args.prompt,
           agent: args.agent.trim(),
-          parentSessionID: toolContext.sessionID,
-          parentMessageID: toolContext.messageID,
+          parentSessionID: ctx.sessionID,
+          parentMessageID: ctx.messageID,
           parentModel
         });
+        ctx.metadata?.({
+          title: args.description,
+          metadata: { sessionId: task.sessionID }
+        });
         return `Background task launched successfully.
 
 Task ID: ${task.id}
@@ -29489,6 +30174,7 @@ function createCallOmoAgent(ctx, backgroundManager) {
       session_id: tool.schema.string().describe("Existing Task session to continue").optional()
     },
     async execute(args, toolContext) {
+      const toolCtx = toolContext;
       log(`[call_omo_agent] Starting with agent: ${args.subagent_type}, background: ${args.run_in_background}`);
       if (!ALLOWED_AGENTS.includes(args.subagent_type)) {
         return `Error: Invalid agent type "${args.subagent_type}". Only ${ALLOWED_AGENTS.join(", ")} are allowed.`;
@@ -29497,9 +30183,9 @@ function createCallOmoAgent(ctx, backgroundManager) {
         if (args.session_id) {
           return `Error: session_id is not supported in background mode. Use run_in_background=false to continue an existing session.`;
         }
-        return await executeBackground(args, toolContext, backgroundManager);
+        return await executeBackground(args, toolCtx, backgroundManager);
       }
-      return await executeSync(args, toolContext, ctx);
+      return await executeSync(args, toolCtx, ctx);
     }
   });
 }
@@ -29512,6 +30198,10 @@ async function executeBackground(args, toolContext, manager) {
       parentSessionID: toolContext.sessionID,
       parentMessageID: toolContext.messageID
     });
+    toolContext.metadata?.({
+      title: args.description,
+      metadata: { sessionId: task.sessionID }
+    });
     return `Background agent task launched successfully.
 
 Task ID: ${task.id}
@@ -29556,6 +30246,10 @@ async function executeSync(args, toolContext, ctx) {
     sessionID = createResult.data.id;
     log(`[call_omo_agent] Created session: ${sessionID}`);
   }
+  toolContext.metadata?.({
+    title: args.description,
+    metadata: { sessionId: sessionID }
+  });
   log(`[call_omo_agent] Sending prompt to session ${sessionID}`);
   log(`[call_omo_agent] Prompt text:`, args.prompt.substring(0, 100));
   try {
@@ -30001,6 +30695,7 @@ class BackgroundManager {
     }
     const message = `[BACKGROUND TASK COMPLETED] Task "${task.description}" finished in ${duration3}. Use background_output with task_id="${task.id}" to get results.`;
     log("[background-agent] Sending notification to parent session:", { parentSessionID: task.parentSessionID });
+    const taskId = task.id;
     setTimeout(async () => {
       try {
         const messageDir = getMessageDir11(task.parentSessionID);
@@ -30016,10 +30711,13 @@ class BackgroundManager {
           },
           query: { directory: this.directory }
         });
-        this.clearNotificationsForTask(task.id);
+        this.clearNotificationsForTask(taskId);
         log("[background-agent] Successfully sent prompt to parent session:", { parentSessionID: task.parentSessionID });
       } catch (error45) {
         log("[background-agent] prompt failed:", String(error45));
+      } finally {
+        this.tasks.delete(taskId);
+        log("[background-agent] Removed completed task from memory:", taskId);
       }
     }, 200);
   }
@@ -30207,6 +30905,9 @@ var HookNameSchema = exports_external.enum([
   "empty-message-sanitizer",
   "thinking-block-validator"
 ]);
+var BuiltinCommandNameSchema = exports_external.enum([
+  "init-deep"
+]);
 var AgentOverrideConfigSchema = exports_external.object({
   model: exports_external.string().optional(),
   temperature: exports_external.number().min(0).max(2).optional(),
@@ -30248,6 +30949,9 @@ var SisyphusAgentConfigSchema = exports_external.object({
   planner_enabled: exports_external.boolean().optional(),
   replace_plan: exports_external.boolean().optional()
 });
+var CommentCheckerConfigSchema = exports_external.object({
+  custom_prompt: exports_external.string().optional()
+});
 var DynamicContextPruningConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(false),
   notification: exports_external.enum(["off", "minimal", "detailed"]).default("detailed"),
@@ -30286,17 +30990,19 @@ var ExperimentalConfigSchema = exports_external.object({
   preemptive_compaction_threshold: exports_external.number().min(0.5).max(0.95).optional(),
   truncate_all_tool_outputs: exports_external.boolean().default(true),
   dynamic_context_pruning: DynamicContextPruningConfigSchema.optional(),
-  dcp_on_compaction_failure: exports_external.boolean().optional()
+  dcp_for_compaction: exports_external.boolean().optional()
 });
 var OhMyOpenCodeConfigSchema = exports_external.object({
   $schema: exports_external.string().optional(),
   disabled_mcps: exports_external.array(McpNameSchema).optional(),
   disabled_agents: exports_external.array(BuiltinAgentNameSchema).optional(),
   disabled_hooks: exports_external.array(HookNameSchema).optional(),
+  disabled_commands: exports_external.array(BuiltinCommandNameSchema).optional(),
   agents: AgentOverridesSchema.optional(),
   claude_code: ClaudeCodeConfigSchema.optional(),
   google_auth: exports_external.boolean().optional(),
   sisyphus_agent: SisyphusAgentConfigSchema.optional(),
+  comment_checker: CommentCheckerConfigSchema.optional(),
   experimental: ExperimentalConfigSchema.optional(),
   auto_update: exports_external.boolean().optional()
 });
@@ -30373,7 +31079,7 @@ var PLAN_PERMISSION = {
 
 // src/index.ts
 import * as fs7 from "fs";
-import * as path8 from "path";
+import * as path7 from "path";
 var AGENT_NAME_MAP = {
   omo: "Sisyphus",
   OmO: "Sisyphus",
@@ -30472,14 +31178,20 @@ function mergeConfigs(base, override) {
         ...override.disabled_hooks ?? []
       ])
     ],
+    disabled_commands: [
+      ...new Set([
+        ...base.disabled_commands ?? [],
+        ...override.disabled_commands ?? []
+      ])
+    ],
     claude_code: deepMerge(base.claude_code, override.claude_code)
   };
 }
 function loadPluginConfig(directory, ctx) {
-  const userBasePath = path8.join(getUserConfigDir(), "opencode", "oh-my-opencode");
+  const userBasePath = path7.join(getUserConfigDir(), "opencode", "oh-my-opencode");
   const userDetected = detectConfigFile(userBasePath);
   const userConfigPath = userDetected.format !== "none" ? userDetected.path : userBasePath + ".json";
-  const projectBasePath = path8.join(directory, ".opencode", "oh-my-opencode");
+  const projectBasePath = path7.join(directory, ".opencode", "oh-my-opencode");
   const projectDetected = detectConfigFile(projectBasePath);
   const projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : projectBasePath + ".json";
   let config3 = loadConfigFromPath2(userConfigPath, ctx) ?? {};
@@ -30515,7 +31227,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
   const contextWindowMonitor = isHookEnabled("context-window-monitor") ? createContextWindowMonitorHook(ctx) : null;
   const sessionRecovery = isHookEnabled("session-recovery") ? createSessionRecoveryHook(ctx, { experimental: pluginConfig.experimental }) : null;
   const sessionNotification = isHookEnabled("session-notification") ? createSessionNotification(ctx) : null;
-  const commentChecker = isHookEnabled("comment-checker") ? createCommentCheckerHooks() : null;
+  const commentChecker = isHookEnabled("comment-checker") ? createCommentCheckerHooks(pluginConfig.comment_checker) : null;
   const toolOutputTruncator = isHookEnabled("tool-output-truncator") ? createToolOutputTruncatorHook(ctx, { experimental: pluginConfig.experimental }) : null;
   const directoryAgentsInjector = isHookEnabled("directory-agents-injector") ? createDirectoryAgentsInjectorHook(ctx) : null;
   const directoryReadmeInjector = isHookEnabled("directory-readme-injector") ? createDirectoryReadmeInjectorHook(ctx) : null;
@@ -30695,12 +31407,14 @@ var OhMyOpenCodePlugin = async (ctx) => {
         ...mcpResult.servers,
         ...pluginComponents.mcpServers
       };
+      const builtinCommands = loadBuiltinCommands(pluginConfig.disabled_commands);
       const userCommands = pluginConfig.claude_code?.commands ?? true ? loadUserCommands() : {};
       const opencodeGlobalCommands = loadOpencodeGlobalCommands();
       const systemCommands = config3.command ?? {};
       const projectCommands = pluginConfig.claude_code?.commands ?? true ? loadProjectCommands() : {};
       const opencodeProjectCommands = loadOpencodeProjectCommands();
       config3.command = {
+        ...builtinCommands,
         ...userCommands,
         ...opencodeGlobalCommands,
         ...systemCommands,