oh-my-opencode 0.4.4 → 1.0.1

package/README.ko.md

@@ -110,7 +110,7 @@ cat ~/.config/opencode/opencode.json  # plugin 배열에 "oh-my-opencode"가 있
 
 ### 4단계: 인증정보 설정
 
-plugin 에 oh my opencode 를 추가했다면, tmux 를 사용하여 사용자의 인증 설정을 도와주세요.
+plugin 에 oh my opencode 를 추가했다면, tmux 를 사용하여 사용자의 인증 설정을 도와주세요. **기본적으로 Google Auth (4.2단계) 설정을 권장합니다.**
 
 #### 4.1 Anthropic (Claude)
 
@@ -123,7 +123,9 @@ opencode auth login
 
 #### 4.2 Google Gemini (내장 Antigravity OAuth)
 
-먼저 `~/.config/opencode/oh-my-opencode.json` (또는 프로젝트 레벨의 `.opencode/oh-my-opencode.json`)에서 Google auth를 활성화:
+**권장되는 기본 설정입니다.**
+
+먼저 주도적으로 `~/.config/opencode/oh-my-opencode.json` (또는 프로젝트 레벨의 `.opencode/oh-my-opencode.json`)에서 Google auth를 활성화하세요:
 
 ```json
 {
@@ -170,9 +172,9 @@ opencode auth login
 
 ### ⚠️ 주의
 
-**사용자가 명시적으로 요청하지 않는 한, `oh-my-opencode.json` 설정 파일을 생성하거나 수정하지 마세요.**
+**사용자가 명시적으로 요청하지 않는 한, 모델 설정을 변경하거나 기능(에이전트, 훅, MCP)을 비활성화하지 마세요.**
 
-플러그인은 설정 파일 없이도 기본값으로 완벽하게 동작합니다. 설정 파일은 사용자가 커스터마이징을 원할 때만 필요합니다.
+플러그인은 기본값으로 완벽하게 동작합니다. 권장 사항인 `google_auth: true` 설정을 제외하고는, 명시적인 요청 없이 다른 설정을 변경하거나 기능을 끄지 마세요.
 
 </details>
 
@@ -330,10 +332,23 @@ OpenCode 는 아주 확장가능하고 아주 커스터마이저블합니다.
     - Use camelCase for function names
     ```
 - **Think Mode**: 확장된 사고(Extended Thinking)가 필요한 상황을 자동으로 감지하고 모드를 전환합니다. 사용자가 깊은 사고를 요청하는 표현(예: "think deeply", "ultrathink")을 감지하면, 추론 능력을 극대화하도록 모델 설정을 동적으로 조정합니다.
+- **Ultrawork Mode**: 사용자가 "ultrawork" 또는 "ulw" 키워드를 입력하면 자동으로 에이전트 오케스트레이션 가이드를 주입합니다. 메인 에이전트가 모든 가용한 전문 에이전트(탐색, 사서, 계획, UI)를 백그라운드 작업을 통해 병렬로 최대한 활용하도록 강제하며, 엄격한 TODO 추적 및 검증 프로토콜을 따르게 합니다.
 - **Anthropic Auto Compact**: Anthropic 모델 사용 시 컨텍스트 한계에 도달하면 대화 기록을 자동으로 압축하여 효율적으로 관리합니다.
 - **Empty Task Response Detector**: 서브 에이전트가 수행한 작업이 비어있거나 무의미한 응답을 반환하는 경우를 감지하여, 오류 없이 우아하게 처리합니다.
 - **Grep Output Truncator**: Grep 검색 결과가 너무 길어 컨텍스트를 장악해버리는 것을 방지하기 위해, 과도한 출력을 자동으로 자릅니다.
 
+필요 없는 훅이 있다면, `~/.config/opencode/oh-my-opencode.json` 혹은 `.opencode/oh-my-opencode.json`의 `disabled_hooks`를 사용하여 비활성화할 수 있습니다:
+
+```json
+{
+  "disabled_hooks": ["session-notification", "comment-checker"]
+}
+```
+
+사용 가능한 훅: `todo-continuation-enforcer`, `context-window-monitor`, `session-recovery`, `session-notification`, `comment-checker`, `grep-output-truncator`, `directory-agents-injector`, `directory-readme-injector`, `empty-task-response-detector`, `think-mode`, `ultrawork-mode`, `anthropic-auto-compact`, `rules-injector`, `background-notification`, `auto-update-checker`
+
+> **참고**: `disabled_hooks`는 Oh My OpenCode의 내장 훅을 제어합니다. Claude Code의 `settings.json` 훅을 비활성화하려면 `claude_code.hooks: false`를 대신 사용하세요 ([호환성 토글](#호환성-토글) 참고).
+
 ### Claude Code 호환성
 
 Oh My OpenCode는 Claude Code 설정과 완벽하게 호환됩니다. Claude Code를 사용하셨다면, 기존 설정을 그대로 사용할 수 있습니다.

package/README.md

@@ -109,7 +109,7 @@ cat ~/.config/opencode/opencode.json  # Should contain "oh-my-opencode" in plugi
 
 ### Step 4: Configure Authentication
 
-Once `oh-my-opencode` is added to the plugin list, use `tmux` to assist the user with authentication setup.
+Once `oh-my-opencode` is added to the plugin list, use `tmux` to assist the user with authentication setup. **It is RECOMMENDED to set up Google Auth (Step 4.2) by default.**
 
 #### 4.1 Anthropic (Claude)
 
@@ -122,7 +122,9 @@ opencode auth login
 
 #### 4.2 Google Gemini (Built-in Antigravity OAuth)
 
-First, enable Google auth in `~/.config/opencode/oh-my-opencode.json` (or `.opencode/oh-my-opencode.json` for project-level):
+**This is the RECOMMENDED default configuration.**
+
+First, proactively enable Google auth in `~/.config/opencode/oh-my-opencode.json` (or `.opencode/oh-my-opencode.json` for project-level):
 
 ```json
 {
@@ -169,9 +171,9 @@ For users who prefer proxy-based authentication, [VibeProxy](https://github.com/
 
 ### ⚠️ Warning
 
-**Do NOT create or modify the `oh-my-opencode.json` configuration file unless the user explicitly requests it.**
+**Do NOT modify model settings or disable features (agents, hooks, MCPs) unless the user explicitly requests it.**
 
-The plugin works perfectly with default settings without any configuration file. The configuration file is only needed when the user wants customization.
+The plugin works perfectly with default settings. While you SHOULD enable `google_auth: true` as recommended, do not alter other configurations or disable features without a specific request.
 
 </details>
 
@@ -328,10 +330,23 @@ Example workflow:
     - Use camelCase for function names
     ```
 - **Think Mode**: Automatic extended thinking detection and mode switching. Detects when user requests deep thinking (e.g., "think deeply", "ultrathink") and dynamically adjusts model settings for enhanced reasoning.
+- **Ultrawork Mode**: When user triggers "ultrawork" or "ulw" keywords, automatically injects agent orchestration guidance. Forces the main agent to leverage all available specialized agents (exploration, librarian, planning, UI) via background tasks in parallel, with strict TODO tracking and verification protocols.
 - **Anthropic Auto Compact**: Automatically compacts conversation history when approaching context limits for Anthropic models.
 - **Empty Task Response Detector**: Detects when subagent tasks return empty or meaningless responses and handles gracefully.
 - **Grep Output Truncator**: Prevents grep output from overwhelming the context by truncating excessively long results.
 
+You can disable specific built-in hooks using `disabled_hooks` in `~/.config/opencode/oh-my-opencode.json` or `.opencode/oh-my-opencode.json`:
+
+```json
+{
+  "disabled_hooks": ["session-notification", "comment-checker"]
+}
+```
+
+Available hooks: `todo-continuation-enforcer`, `context-window-monitor`, `session-recovery`, `session-notification`, `comment-checker`, `grep-output-truncator`, `directory-agents-injector`, `directory-readme-injector`, `empty-task-response-detector`, `think-mode`, `ultrawork-mode`, `anthropic-auto-compact`, `rules-injector`, `background-notification`, `auto-update-checker`
+
+> **Note**: `disabled_hooks` controls Oh My OpenCode's built-in hooks. To disable Claude Code's `settings.json` hooks, use `claude_code.hooks: false` instead (see [Compatibility Toggles](#compatibility-toggles)).
+
 ### Claude Code Compatibility
 
 Oh My OpenCode provides seamless Claude Code configuration compatibility. If you've been using Claude Code, your existing setup works out of the box.

package/dist/config/index.d.ts

@@ -1,2 +1,2 @@
-export { OhMyOpenCodeConfigSchema, AgentOverrideConfigSchema, AgentOverridesSchema, McpNameSchema, AgentNameSchema, } from "./schema";
-export type { OhMyOpenCodeConfig, AgentOverrideConfig, AgentOverrides, McpName, AgentName, } from "./schema";
+export { OhMyOpenCodeConfigSchema, AgentOverrideConfigSchema, AgentOverridesSchema, McpNameSchema, AgentNameSchema, HookNameSchema, } from "./schema";
+export type { OhMyOpenCodeConfig, AgentOverrideConfig, AgentOverrides, McpName, AgentName, HookName, } from "./schema";

package/dist/config/schema.d.ts

@@ -6,6 +6,23 @@ export declare const AgentNameSchema: z.ZodEnum<{
     "frontend-ui-ux-engineer": "frontend-ui-ux-engineer";
     "document-writer": "document-writer";
 }>;
+export declare const HookNameSchema: z.ZodEnum<{
+    "comment-checker": "comment-checker";
+    "rules-injector": "rules-injector";
+    "todo-continuation-enforcer": "todo-continuation-enforcer";
+    "context-window-monitor": "context-window-monitor";
+    "session-recovery": "session-recovery";
+    "session-notification": "session-notification";
+    "grep-output-truncator": "grep-output-truncator";
+    "directory-agents-injector": "directory-agents-injector";
+    "directory-readme-injector": "directory-readme-injector";
+    "empty-task-response-detector": "empty-task-response-detector";
+    "think-mode": "think-mode";
+    "anthropic-auto-compact": "anthropic-auto-compact";
+    "background-notification": "background-notification";
+    "auto-update-checker": "auto-update-checker";
+    "ultrawork-mode": "ultrawork-mode";
+}>;
 export declare const AgentOverrideConfigSchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodString>;
     temperature: z.ZodOptional<z.ZodNumber>;
@@ -304,6 +321,23 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         "frontend-ui-ux-engineer": "frontend-ui-ux-engineer";
         "document-writer": "document-writer";
     }>>>;
+    disabled_hooks: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "comment-checker": "comment-checker";
+        "rules-injector": "rules-injector";
+        "todo-continuation-enforcer": "todo-continuation-enforcer";
+        "context-window-monitor": "context-window-monitor";
+        "session-recovery": "session-recovery";
+        "session-notification": "session-notification";
+        "grep-output-truncator": "grep-output-truncator";
+        "directory-agents-injector": "directory-agents-injector";
+        "directory-readme-injector": "directory-readme-injector";
+        "empty-task-response-detector": "empty-task-response-detector";
+        "think-mode": "think-mode";
+        "anthropic-auto-compact": "anthropic-auto-compact";
+        "background-notification": "background-notification";
+        "auto-update-checker": "auto-update-checker";
+        "ultrawork-mode": "ultrawork-mode";
+    }>>>;
     agents: z.ZodOptional<z.ZodObject<{
         oracle: z.ZodOptional<z.ZodOptional<z.ZodObject<{
             model: z.ZodOptional<z.ZodString>;
@@ -549,4 +583,5 @@ export type OhMyOpenCodeConfig = z.infer<typeof OhMyOpenCodeConfigSchema>;
 export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
 export type AgentOverrides = z.infer<typeof AgentOverridesSchema>;
 export type AgentName = z.infer<typeof AgentNameSchema>;
+export type HookName = z.infer<typeof HookNameSchema>;
 export { McpNameSchema, type McpName } from "../mcp/types";

package/dist/features/background-agent/types.d.ts

@@ -3,6 +3,8 @@ export interface TaskProgress {
     toolCalls: number;
     lastTool?: string;
     lastUpdate: Date;
+    lastMessage?: string;
+    lastMessageAt?: Date;
 }
 export interface BackgroundTask {
     id: string;
@@ -10,6 +12,7 @@ export interface BackgroundTask {
     parentSessionID: string;
     parentMessageID: string;
     description: string;
+    prompt: string;
     agent: string;
     status: BackgroundTaskStatus;
     startedAt: Date;

package/dist/hooks/index.d.ts

@@ -13,3 +13,4 @@ export { createClaudeCodeHooksHook } from "./claude-code-hooks";
 export { createRulesInjectorHook } from "./rules-injector";
 export { createBackgroundNotificationHook } from "./background-notification";
 export { createAutoUpdateCheckerHook } from "./auto-update-checker";
+export { createUltraworkModeHook } from "./ultrawork-mode";

package/dist/hooks/session-notification.d.ts

@@ -8,6 +8,8 @@ interface SessionNotificationConfig {
     idleConfirmationDelay?: number;
     /** Skip notification if there are incomplete todos (default: true) */
     skipIfIncompleteTodos?: boolean;
+    /** Maximum number of sessions to track before cleanup (default: 100) */
+    maxTrackedSessions?: number;
 }
 export declare function createSessionNotification(ctx: PluginInput, config?: SessionNotificationConfig): ({ event }: {
     event: {

package/dist/hooks/think-mode/types.d.ts

@@ -1,6 +1,7 @@
 export interface ThinkModeState {
     requested: boolean;
     modelSwitched: boolean;
+    thinkingConfigInjected: boolean;
     providerID?: string;
     modelID?: string;
 }

package/dist/hooks/ultrawork-mode/constants.d.ts

@@ -0,0 +1,15 @@
+/** Keyword patterns - "ultrawork", "ulw" (case-insensitive, word boundary) */
+export declare const ULTRAWORK_PATTERNS: RegExp[];
+/** Code block pattern to exclude from keyword detection */
+export declare const CODE_BLOCK_PATTERN: RegExp;
+/** Inline code pattern to exclude */
+export declare const INLINE_CODE_PATTERN: RegExp;
+/**
+ * ULTRAWORK_CONTEXT - Agent-Agnostic Guidance
+ *
+ * Key principles:
+ * - NO specific agent names (oracle, librarian, etc.)
+ * - Only provide guidance based on agent role/capability
+ * - Emphasize parallel execution, TODO tracking, delegation
+ */
+export declare const ULTRAWORK_CONTEXT = "<ultrawork-mode>\n[CODE RED] Maximum precision required. Ultrathink before acting.\n\nYOU MUST LEVERAGE ALL AVAILABLE AGENTS TO THEIR FULLEST POTENTIAL.\nTELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.\n\n## AGENT UTILIZATION PRINCIPLES (by capability, not by name)\n- **Codebase Exploration**: Spawn exploration agents using BACKGROUND TASKS for file patterns, internal implementations, project structure\n- **Documentation & References**: Use librarian-type agents via BACKGROUND TASKS for API references, examples, external library docs\n- **Planning & Strategy**: NEVER plan yourself - ALWAYS spawn a dedicated planning agent for work breakdown\n- **High-IQ Reasoning**: Leverage specialized agents for architecture decisions, code review, strategic planning\n- **Frontend/UI Tasks**: Delegate to UI-specialized agents for design and implementation\n\n## EXECUTION RULES\n- **TODO**: Track EVERY step. Mark complete IMMEDIATELY after each.\n- **PARALLEL**: Fire independent agent calls simultaneously via background_task - NEVER wait sequentially.\n- **BACKGROUND FIRST**: Use background_task for exploration/research agents (10+ concurrent if needed).\n- **VERIFY**: Re-read request after completion. Check ALL requirements met before reporting done.\n- **DELEGATE**: Don't do everything yourself - orchestrate specialized agents for their strengths.\n\n## WORKFLOW\n1. Analyze the request and identify required capabilities\n2. Spawn exploration/librarian agents via background_task in PARALLEL (10+ if needed)\n3. Use planning agents to create detailed work breakdown\n4. Execute with continuous verification against original requirements\n\n</ultrawork-mode>\n\n---\n\n";

package/dist/hooks/ultrawork-mode/detector.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Remove code blocks and inline code from text.
+ * Prevents false positives when keywords appear in code.
+ */
+export declare function removeCodeBlocks(text: string): string;
+/**
+ * Detect ultrawork keywords in text (excluding code blocks).
+ */
+export declare function detectUltraworkKeyword(text: string): boolean;
+/**
+ * Extract text content from message parts.
+ */
+export declare function extractPromptText(parts: Array<{
+    type: string;
+    text?: string;
+}>): string;

package/dist/hooks/ultrawork-mode/index.d.ts

@@ -0,0 +1,40 @@
+export * from "./detector";
+export * from "./constants";
+export * from "./types";
+export declare function clearUltraworkModeState(sessionID: string): void;
+export declare function createUltraworkModeHook(): {
+    /**
+     * chat.message hook - detect ultrawork/ulw keywords, inject context via history
+     *
+     * Execution timing: AFTER claudeCodeHooks["chat.message"]
+     * Behavior:
+     *   1. Extract text from user prompt
+     *   2. Detect ultrawork/ulw keywords (excluding code blocks)
+     *   3. If detected, inject ULTRAWORK_CONTEXT via injectHookMessage (history injection)
+     */
+    "chat.message": (input: {
+        sessionID: string;
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+        messageID?: string;
+    }, output: {
+        message: Record<string, unknown>;
+        parts: Array<{
+            type: string;
+            text?: string;
+            [key: string]: unknown;
+        }>;
+    }) => Promise<void>;
+    /**
+     * event hook - cleanup session state on deletion
+     */
+    event: ({ event, }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};

package/dist/hooks/ultrawork-mode/types.d.ts

@@ -0,0 +1,20 @@
+export interface UltraworkModeState {
+    /** Whether ultrawork keyword was detected */
+    detected: boolean;
+    /** Whether context was injected */
+    injected: boolean;
+}
+export interface ModelRef {
+    providerID: string;
+    modelID: string;
+}
+export interface MessageWithModel {
+    model?: ModelRef;
+}
+export interface UltraworkModeInput {
+    parts: Array<{
+        type: string;
+        text?: string;
+    }>;
+    message: MessageWithModel;
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 import type { Plugin } from "@opencode-ai/plugin";
 declare const OhMyOpenCodePlugin: Plugin;
 export default OhMyOpenCodePlugin;
-export type { OhMyOpenCodeConfig, AgentName, AgentOverrideConfig, AgentOverrides, McpName, } from "./config";
+export type { OhMyOpenCodeConfig, AgentName, AgentOverrideConfig, AgentOverrides, McpName, HookName, } from "./config";

package/dist/index.js

@@ -184,8 +184,8 @@ var require_utils = __commonJS((exports) => {
   exports.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
   exports.isWindows = () => {
     if (typeof navigator !== "undefined" && navigator.platform) {
-      const platform = navigator.platform.toLowerCase();
-      return platform === "win32" || platform === "windows";
+      const platform2 = navigator.platform.toLowerCase();
+      return platform2 === "win32" || platform2 === "windows";
     }
     if (typeof process !== "undefined" && process.platform) {
       return process.platform === "win32";
@@ -2934,6 +2934,198 @@ ${CONTEXT_REMINDER}
     event: eventHandler
   };
 }
+// src/hooks/session-notification.ts
+import { platform } from "os";
+function detectPlatform() {
+  const p = platform();
+  if (p === "darwin" || p === "linux" || p === "win32")
+    return p;
+  return "unsupported";
+}
+function getDefaultSoundPath(p) {
+  switch (p) {
+    case "darwin":
+      return "/System/Library/Sounds/Glass.aiff";
+    case "linux":
+      return "/usr/share/sounds/freedesktop/stereo/complete.oga";
+    case "win32":
+      return "C:\\Windows\\Media\\notify.wav";
+    default:
+      return "";
+  }
+}
+async function sendNotification(ctx, p, title, message) {
+  const escapedTitle = title.replace(/"/g, "\\\"").replace(/'/g, "\\'");
+  const escapedMessage = message.replace(/"/g, "\\\"").replace(/'/g, "\\'");
+  switch (p) {
+    case "darwin":
+      await ctx.$`osascript -e ${'display notification "' + escapedMessage + '" with title "' + escapedTitle + '"'}`;
+      break;
+    case "linux":
+      await ctx.$`notify-send ${escapedTitle} ${escapedMessage}`;
+      break;
+    case "win32":
+      await ctx.$`powershell -Command ${"[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); [System.Windows.Forms.MessageBox]::Show('" + escapedMessage + "', '" + escapedTitle + "')"}`;
+      break;
+  }
+}
+async function playSound(ctx, p, soundPath) {
+  switch (p) {
+    case "darwin":
+      ctx.$`afplay ${soundPath}`.catch(() => {});
+      break;
+    case "linux":
+      ctx.$`paplay ${soundPath}`.catch(() => {
+        ctx.$`aplay ${soundPath}`.catch(() => {});
+      });
+      break;
+    case "win32":
+      ctx.$`powershell -Command ${"(New-Object Media.SoundPlayer '" + soundPath + "').PlaySync()"}`.catch(() => {});
+      break;
+  }
+}
+async function hasIncompleteTodos(ctx, sessionID) {
+  try {
+    const response = await ctx.client.session.todo({ path: { id: sessionID } });
+    const todos = response.data ?? response;
+    if (!todos || todos.length === 0)
+      return false;
+    return todos.some((t) => t.status !== "completed" && t.status !== "cancelled");
+  } catch {
+    return false;
+  }
+}
+function createSessionNotification(ctx, config = {}) {
+  const currentPlatform = detectPlatform();
+  const defaultSoundPath = getDefaultSoundPath(currentPlatform);
+  const mergedConfig = {
+    title: "OpenCode",
+    message: "Agent is ready for input",
+    playSound: false,
+    soundPath: defaultSoundPath,
+    idleConfirmationDelay: 1500,
+    skipIfIncompleteTodos: true,
+    maxTrackedSessions: 100,
+    ...config
+  };
+  const notifiedSessions = new Set;
+  const pendingTimers = new Map;
+  const sessionActivitySinceIdle = new Set;
+  const notificationVersions = new Map;
+  function cleanupOldSessions() {
+    const maxSessions = mergedConfig.maxTrackedSessions;
+    if (notifiedSessions.size > maxSessions) {
+      const sessionsToRemove = Array.from(notifiedSessions).slice(0, notifiedSessions.size - maxSessions);
+      sessionsToRemove.forEach((id) => notifiedSessions.delete(id));
+    }
+    if (sessionActivitySinceIdle.size > maxSessions) {
+      const sessionsToRemove = Array.from(sessionActivitySinceIdle).slice(0, sessionActivitySinceIdle.size - maxSessions);
+      sessionsToRemove.forEach((id) => sessionActivitySinceIdle.delete(id));
+    }
+    if (notificationVersions.size > maxSessions) {
+      const sessionsToRemove = Array.from(notificationVersions.keys()).slice(0, notificationVersions.size - maxSessions);
+      sessionsToRemove.forEach((id) => notificationVersions.delete(id));
+    }
+  }
+  function cancelPendingNotification(sessionID) {
+    const timer = pendingTimers.get(sessionID);
+    if (timer) {
+      clearTimeout(timer);
+      pendingTimers.delete(sessionID);
+    }
+    sessionActivitySinceIdle.add(sessionID);
+    notificationVersions.set(sessionID, (notificationVersions.get(sessionID) ?? 0) + 1);
+  }
+  function markSessionActivity(sessionID) {
+    cancelPendingNotification(sessionID);
+    notifiedSessions.delete(sessionID);
+  }
+  async function executeNotification(sessionID, version) {
+    pendingTimers.delete(sessionID);
+    if (notificationVersions.get(sessionID) !== version) {
+      return;
+    }
+    if (sessionActivitySinceIdle.has(sessionID)) {
+      sessionActivitySinceIdle.delete(sessionID);
+      return;
+    }
+    if (notifiedSessions.has(sessionID))
+      return;
+    if (mergedConfig.skipIfIncompleteTodos) {
+      const hasPendingWork = await hasIncompleteTodos(ctx, sessionID);
+      if (notificationVersions.get(sessionID) !== version) {
+        return;
+      }
+      if (hasPendingWork)
+        return;
+    }
+    if (notificationVersions.get(sessionID) !== version) {
+      return;
+    }
+    notifiedSessions.add(sessionID);
+    try {
+      await sendNotification(ctx, currentPlatform, mergedConfig.title, mergedConfig.message);
+      if (mergedConfig.playSound && mergedConfig.soundPath) {
+        await playSound(ctx, currentPlatform, mergedConfig.soundPath);
+      }
+    } catch {}
+  }
+  return async ({ event }) => {
+    if (currentPlatform === "unsupported")
+      return;
+    const props = event.properties;
+    if (event.type === "session.updated" || event.type === "session.created") {
+      const info = props?.info;
+      const sessionID = info?.id;
+      if (sessionID) {
+        markSessionActivity(sessionID);
+      }
+      return;
+    }
+    if (event.type === "session.idle") {
+      const sessionID = props?.sessionID;
+      if (!sessionID)
+        return;
+      if (notifiedSessions.has(sessionID))
+        return;
+      if (pendingTimers.has(sessionID))
+        return;
+      sessionActivitySinceIdle.delete(sessionID);
+      const currentVersion = (notificationVersions.get(sessionID) ?? 0) + 1;
+      notificationVersions.set(sessionID, currentVersion);
+      const timer = setTimeout(() => {
+        executeNotification(sessionID, currentVersion);
+      }, mergedConfig.idleConfirmationDelay);
+      pendingTimers.set(sessionID, timer);
+      cleanupOldSessions();
+      return;
+    }
+    if (event.type === "message.updated" || event.type === "message.created") {
+      const info = props?.info;
+      const sessionID = info?.sessionID;
+      if (sessionID) {
+        markSessionActivity(sessionID);
+      }
+      return;
+    }
+    if (event.type === "tool.execute.before" || event.type === "tool.execute.after") {
+      const sessionID = props?.sessionID;
+      if (sessionID) {
+        markSessionActivity(sessionID);
+      }
+      return;
+    }
+    if (event.type === "session.deleted") {
+      const sessionInfo = props?.info;
+      if (sessionInfo?.id) {
+        cancelPendingNotification(sessionInfo.id);
+        notifiedSessions.delete(sessionInfo.id);
+        sessionActivitySinceIdle.delete(sessionInfo.id);
+        notificationVersions.delete(sessionInfo.id);
+      }
+    }
+  };
+}
 // src/hooks/session-recovery/storage.ts
 import { existsSync as existsSync3, mkdirSync, readdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
 import { join as join4 } from "path";
@@ -4625,6 +4817,46 @@ var ALREADY_HIGH = new Set([
   "gpt-5.2-chat-latest-high",
   "gpt-5.2-pro-high"
 ]);
+var THINKING_CONFIGS = {
+  anthropic: {
+    thinking: {
+      type: "enabled",
+      budgetTokens: 64000
+    },
+    maxTokens: 128000
+  },
+  "amazon-bedrock": {
+    reasoningConfig: {
+      type: "enabled",
+      budgetTokens: 32000
+    },
+    maxTokens: 64000
+  },
+  google: {
+    providerOptions: {
+      google: {
+        thinkingConfig: {
+          thinkingLevel: "HIGH"
+        }
+      }
+    }
+  },
+  "google-vertex": {
+    providerOptions: {
+      "google-vertex": {
+        thinkingConfig: {
+          thinkingLevel: "HIGH"
+        }
+      }
+    }
+  }
+};
+var THINKING_CAPABLE_MODELS = {
+  anthropic: ["claude-sonnet-4", "claude-opus-4", "claude-3"],
+  "amazon-bedrock": ["claude", "anthropic"],
+  google: ["gemini-2", "gemini-3"],
+  "google-vertex": ["gemini-2", "gemini-3"]
+};
 function getHighVariant(modelID) {
   if (ALREADY_HIGH.has(modelID)) {
     return null;
@@ -4634,6 +4866,19 @@ function getHighVariant(modelID) {
 function isAlreadyHighVariant(modelID) {
   return ALREADY_HIGH.has(modelID) || modelID.endsWith("-high");
 }
+function getThinkingConfig(providerID, modelID) {
+  if (isAlreadyHighVariant(modelID)) {
+    return null;
+  }
+  const config = THINKING_CONFIGS[providerID];
+  const capablePatterns = THINKING_CAPABLE_MODELS[providerID];
+  if (!config || !capablePatterns) {
+    return null;
+  }
+  const modelLower = modelID.toLowerCase();
+  const isCapable = capablePatterns.some((pattern) => modelLower.includes(pattern.toLowerCase()));
+  return isCapable ? config : null;
+}
 
 // src/hooks/think-mode/index.ts
 var thinkModeState = new Map;
@@ -4643,7 +4888,8 @@ function createThinkModeHook() {
       const promptText = extractPromptText(output.parts);
       const state = {
         requested: false,
-        modelSwitched: false
+        modelSwitched: false,
+        thinkingConfigInjected: false
       };
       if (!detectThinkKeyword(promptText)) {
         thinkModeState.set(sessionID, state);
@@ -4662,15 +4908,28 @@ function createThinkModeHook() {
         return;
       }
       const highVariant = getHighVariant(currentModel.modelID);
-      if (!highVariant) {
-        thinkModeState.set(sessionID, state);
-        return;
+      const thinkingConfig = getThinkingConfig(currentModel.providerID, currentModel.modelID);
+      if (highVariant) {
+        output.message.model = {
+          providerID: currentModel.providerID,
+          modelID: highVariant
+        };
+        state.modelSwitched = true;
+        log("Think mode: model switched to high variant", {
+          sessionID,
+          from: currentModel.modelID,
+          to: highVariant
+        });
+      }
+      if (thinkingConfig) {
+        Object.assign(output.message, thinkingConfig);
+        state.thinkingConfigInjected = true;
+        log("Think mode: thinking config injected", {
+          sessionID,
+          provider: currentModel.providerID,
+          config: thinkingConfig
+        });
       }
-      output.message.model = {
-        providerID: currentModel.providerID,
-        modelID: highVariant
-      };
-      state.modelSwitched = true;
       thinkModeState.set(sessionID, state);
     },
     event: async ({ event }) => {
@@ -6330,6 +6589,97 @@ function createAutoUpdateCheckerHook(ctx) {
     }
   };
 }
+// src/hooks/ultrawork-mode/constants.ts
+var ULTRAWORK_PATTERNS = [/\bultrawork\b/i, /\bulw\b/i];
+var CODE_BLOCK_PATTERN2 = /```[\s\S]*?```/g;
+var INLINE_CODE_PATTERN2 = /`[^`]+`/g;
+var ULTRAWORK_CONTEXT = `<ultrawork-mode>
+[CODE RED] Maximum precision required. Ultrathink before acting.
+
+YOU MUST LEVERAGE ALL AVAILABLE AGENTS TO THEIR FULLEST POTENTIAL.
+TELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.
+
+## AGENT UTILIZATION PRINCIPLES (by capability, not by name)
+- **Codebase Exploration**: Spawn exploration agents using BACKGROUND TASKS for file patterns, internal implementations, project structure
+- **Documentation & References**: Use librarian-type agents via BACKGROUND TASKS for API references, examples, external library docs
+- **Planning & Strategy**: NEVER plan yourself - ALWAYS spawn a dedicated planning agent for work breakdown
+- **High-IQ Reasoning**: Leverage specialized agents for architecture decisions, code review, strategic planning
+- **Frontend/UI Tasks**: Delegate to UI-specialized agents for design and implementation
+
+## EXECUTION RULES
+- **TODO**: Track EVERY step. Mark complete IMMEDIATELY after each.
+- **PARALLEL**: Fire independent agent calls simultaneously via background_task - NEVER wait sequentially.
+- **BACKGROUND FIRST**: Use background_task for exploration/research agents (10+ concurrent if needed).
+- **VERIFY**: Re-read request after completion. Check ALL requirements met before reporting done.
+- **DELEGATE**: Don't do everything yourself - orchestrate specialized agents for their strengths.
+
+## WORKFLOW
+1. Analyze the request and identify required capabilities
+2. Spawn exploration/librarian agents via background_task in PARALLEL (10+ if needed)
+3. Use planning agents to create detailed work breakdown
+4. Execute with continuous verification against original requirements
+
+</ultrawork-mode>
+
+---
+
+`;
+
+// src/hooks/ultrawork-mode/detector.ts
+function removeCodeBlocks2(text) {
+  return text.replace(CODE_BLOCK_PATTERN2, "").replace(INLINE_CODE_PATTERN2, "");
+}
+function detectUltraworkKeyword(text) {
+  const textWithoutCode = removeCodeBlocks2(text);
+  return ULTRAWORK_PATTERNS.some((pattern) => pattern.test(textWithoutCode));
+}
+function extractPromptText2(parts) {
+  return parts.filter((p) => p.type === "text").map((p) => p.text || "").join("");
+}
+
+// src/hooks/ultrawork-mode/index.ts
+var ultraworkModeState = new Map;
+function createUltraworkModeHook() {
+  return {
+    "chat.message": async (input, output) => {
+      const state = {
+        detected: false,
+        injected: false
+      };
+      const promptText = extractPromptText2(output.parts);
+      if (!detectUltraworkKeyword(promptText)) {
+        ultraworkModeState.set(input.sessionID, state);
+        return;
+      }
+      state.detected = true;
+      log("Ultrawork keyword detected", { sessionID: input.sessionID });
+      const message = output.message;
+      const success = injectHookMessage(input.sessionID, ULTRAWORK_CONTEXT, {
+        agent: message.agent,
+        model: message.model,
+        path: message.path,
+        tools: message.tools
+      });
+      if (success) {
+        state.injected = true;
+        log("Ultrawork context injected via history", { sessionID: input.sessionID });
+      } else {
+        log("Ultrawork context injection failed", { sessionID: input.sessionID });
+      }
+      ultraworkModeState.set(input.sessionID, state);
+    },
+    event: async ({
+      event
+    }) => {
+      if (event.type === "session.deleted") {
+        const props = event.properties;
+        if (props?.info?.id) {
+          ultraworkModeState.delete(props.info.id);
+        }
+      }
+    }
+  };
+}
 // src/auth/antigravity/constants.ts
 var ANTIGRAVITY_CLIENT_ID = "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com";
 var ANTIGRAVITY_CLIENT_SECRET = "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";
@@ -7434,6 +7784,18 @@ function isRetryableError(status) {
     return true;
   return false;
 }
+var GCP_PERMISSION_ERROR_PATTERNS = [
+  "PERMISSION_DENIED",
+  "does not have permission",
+  "Cloud AI Companion API has not been used",
+  "has not been enabled"
+];
+function isGcpPermissionError(text) {
+  return GCP_PERMISSION_ERROR_PATTERNS.some((pattern) => text.includes(pattern));
+}
+function calculateRetryDelay2(attempt) {
+  return Math.min(200 * Math.pow(2, attempt), 2000);
+}
 async function isRetryableResponse(response) {
   if (isRetryableError(response.status))
     return true;
@@ -7496,18 +7858,36 @@ async function attemptFetch(options) {
       thoughtSignature
     });
     debugLog6(`[REQ] streaming=${transformed.streaming}, url=${transformed.url}`);
-    const response = await fetch(transformed.url, {
-      method: init.method || "POST",
-      headers: transformed.headers,
-      body: JSON.stringify(transformed.body),
-      signal: init.signal
-    });
-    debugLog6(`[RESP] status=${response.status} content-type=${response.headers.get("content-type") ?? ""} url=${response.url}`);
-    if (!response.ok && await isRetryableResponse(response)) {
-      debugLog6(`Endpoint failed: ${endpoint} (status: ${response.status}), trying next`);
-      return null;
+    const maxPermissionRetries = 10;
+    for (let attempt = 0;attempt <= maxPermissionRetries; attempt++) {
+      const response = await fetch(transformed.url, {
+        method: init.method || "POST",
+        headers: transformed.headers,
+        body: JSON.stringify(transformed.body),
+        signal: init.signal
+      });
+      debugLog6(`[RESP] status=${response.status} content-type=${response.headers.get("content-type") ?? ""} url=${response.url}`);
+      if (response.status === 403) {
+        try {
+          const text = await response.clone().text();
+          if (isGcpPermissionError(text)) {
+            if (attempt < maxPermissionRetries) {
+              const delay = calculateRetryDelay2(attempt);
+              debugLog6(`[RETRY] GCP permission error, retry ${attempt + 1}/${maxPermissionRetries} after ${delay}ms`);
+              await new Promise((resolve4) => setTimeout(resolve4, delay));
+              continue;
+            }
+            debugLog6(`[RETRY] GCP permission error, max retries exceeded`);
+          }
+        } catch {}
+      }
+      if (!response.ok && await isRetryableResponse(response)) {
+        debugLog6(`Endpoint failed: ${endpoint} (status: ${response.status}), trying next`);
+        return null;
+      }
+      return response;
     }
-    return response;
+    return null;
   } catch (error) {
     debugLog6(`Endpoint failed: ${endpoint} (${error instanceof Error ? error.message : "Unknown error"}), trying next`);
     return null;
@@ -7883,7 +8263,7 @@ function loadOpencodeProjectCommands() {
   return commandsToRecord(commands);
 }
 // src/features/claude-code-skill-loader/loader.ts
-import { existsSync as existsSync20, readdirSync as readdirSync5, readFileSync as readFileSync12, statSync as statSync3, readlinkSync } from "fs";
+import { existsSync as existsSync20, readdirSync as readdirSync5, readFileSync as readFileSync12, lstatSync, readlinkSync } from "fs";
 import { homedir as homedir10 } from "os";
 import { join as join25, resolve as resolve4 } from "path";
 function loadSkillsFromDir(skillsDir, scope) {
@@ -7899,8 +8279,12 @@ function loadSkillsFromDir(skillsDir, scope) {
     if (!entry.isDirectory() && !entry.isSymbolicLink())
       continue;
     let resolvedPath = skillPath;
-    if (statSync3(skillPath, { throwIfNoEntry: false })?.isSymbolicLink()) {
-      resolvedPath = resolve4(skillPath, "..", readlinkSync(skillPath));
+    try {
+      if (lstatSync(skillPath, { throwIfNoEntry: false })?.isSymbolicLink()) {
+        resolvedPath = resolve4(skillPath, "..", readlinkSync(skillPath));
+      }
+    } catch {
+      continue;
     }
     const skillMdPath = join25(resolvedPath, "SKILL.md");
     if (!existsSync20(skillMdPath))
@@ -19435,10 +19819,10 @@ function _property(property, schema, params) {
     ...normalizeParams(params)
   });
 }
-function _mime(types9, params) {
+function _mime(types10, params) {
   return new $ZodCheckMimeType({
     check: "mime_type",
-    mime: types9,
+    mime: types10,
     ...normalizeParams(params)
   });
 }
@@ -21348,7 +21732,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 = (types9, params) => inst.check(_mime(Array.isArray(types9) ? types9 : [types9], params));
+  inst.mime = (types10, params) => inst.check(_mime(Array.isArray(types10) ? types10 : [types10], params));
 });
 function file(params) {
   return _file(ZodFile, params);
@@ -22001,7 +22385,7 @@ var lsp_code_action_resolve = tool({
 // src/tools/ast-grep/constants.ts
 import { createRequire as createRequire4 } from "module";
 import { dirname as dirname5, join as join30 } from "path";
-import { existsSync as existsSync26, statSync as statSync4 } from "fs";
+import { existsSync as existsSync26, statSync as statSync3 } from "fs";
 
 // src/tools/ast-grep/downloader.ts
 var {spawn: spawn5 } = globalThis.Bun;
@@ -22115,13 +22499,13 @@ async function ensureAstGrepBinary() {
 // src/tools/ast-grep/constants.ts
 function isValidBinary(filePath) {
   try {
-    return statSync4(filePath).size > 1e4;
+    return statSync3(filePath).size > 1e4;
   } catch {
     return false;
   }
 }
 function getPlatformPackageName() {
-  const platform = process.platform;
+  const platform2 = process.platform;
   const arch = process.arch;
   const platformMap = {
     "darwin-arm64": "@ast-grep/cli-darwin-arm64",
@@ -22132,7 +22516,7 @@ function getPlatformPackageName() {
     "win32-arm64": "@ast-grep/cli-win32-arm64-msvc",
     "win32-ia32": "@ast-grep/cli-win32-ia32-msvc"
   };
-  return platformMap[`${platform}-${arch}`] ?? null;
+  return platformMap[`${platform2}-${arch}`] ?? null;
 }
 function findSgCliPathSync() {
   const binaryName = process.platform === "win32" ? "sg.exe" : "sg";
@@ -23135,7 +23519,7 @@ var SkillFrontmatterSchema = exports_external.object({
   metadata: exports_external.record(exports_external.string(), exports_external.string()).optional()
 });
 // src/tools/skill/tools.ts
-import { existsSync as existsSync30, readdirSync as readdirSync8, statSync as statSync5, readlinkSync as readlinkSync2, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync30, readdirSync as readdirSync8, lstatSync as lstatSync2, readlinkSync as readlinkSync2, readFileSync as readFileSync18 } from "fs";
 import { homedir as homedir16 } from "os";
 import { join as join33, resolve as resolve7, basename as basename4 } from "path";
 function parseSkillFrontmatter(data) {
@@ -23160,7 +23544,7 @@ function discoverSkillsFromDir(skillsDir, scope) {
     if (entry.isDirectory() || entry.isSymbolicLink()) {
       let resolvedPath = skillPath;
       try {
-        const stats = statSync5(skillPath, { throwIfNoEntry: false });
+        const stats = lstatSync2(skillPath, { throwIfNoEntry: false });
         if (stats?.isSymbolicLink()) {
           resolvedPath = resolve7(skillPath, "..", readlinkSync2(skillPath));
         }
@@ -23197,7 +23581,7 @@ var skillListForDescription = availableSkills.map((s) => `- ${s.name}: ${s.descr
 `);
 function resolveSymlink(skillPath) {
   try {
-    const stats = statSync5(skillPath, { throwIfNoEntry: false });
+    const stats = lstatSync2(skillPath, { throwIfNoEntry: false });
     if (stats?.isSymbolicLink()) {
       return resolve7(skillPath, "..", readlinkSync2(skillPath));
     }
@@ -23479,20 +23863,48 @@ Use \`background_output\` tool with task_id="${task.id}" to check progress:
 function delay(ms) {
   return new Promise((resolve8) => setTimeout(resolve8, ms));
 }
+function truncateText(text, maxLength) {
+  if (text.length <= maxLength)
+    return text;
+  return text.slice(0, maxLength) + "...";
+}
 function formatTaskStatus(task) {
   const duration3 = formatDuration(task.startedAt, task.completedAt);
-  const progress = task.progress ? `
+  const promptPreview = truncateText(task.prompt, 500);
+  let progressSection = "";
+  if (task.progress) {
+    progressSection = `
 Tool calls: ${task.progress.toolCalls}
-Last tool: ${task.progress.lastTool ?? "N/A"}` : "";
-  return `Task Status
+Last tool: ${task.progress.lastTool ?? "N/A"}`;
+  }
+  let lastMessageSection = "";
+  if (task.progress?.lastMessage) {
+    const truncated = truncateText(task.progress.lastMessage, 500);
+    const messageTime = task.progress.lastMessageAt ? task.progress.lastMessageAt.toISOString() : "N/A";
+    lastMessageSection = `
 
-Task ID: ${task.id}
-Description: ${task.description}
-Agent: ${task.agent}
-Status: ${task.status}
-Duration: ${duration3}${progress}
+## Last Message (${messageTime})
+
+\`\`\`
+${truncated}
+\`\`\``;
+  }
+  return `# Task Status
+
+| Field | Value |
+|-------|-------|
+| Task ID | \`${task.id}\` |
+| Description | ${task.description} |
+| Agent | ${task.agent} |
+| Status | **${task.status}** |
+| Duration | ${duration3} |
+| Session ID | \`${task.sessionID}\` |${progressSection}
 
-Session ID: ${task.sessionID}`;
+## Original Prompt
+
+\`\`\`
+${promptPreview}
+\`\`\`${lastMessageSection}`;
 }
 async function formatTaskResult(task, client2) {
   const messagesResult = await client2.session.messages({
@@ -23834,6 +24246,7 @@ class BackgroundManager {
       parentSessionID: input.parentSessionID,
       parentMessageID: input.parentMessageID,
       description: input.description,
+      prompt: input.prompt,
       agent: input.agent,
       status: "running",
       startedAt: new Date,
@@ -23991,23 +24404,18 @@ class BackgroundManager {
       }).catch(() => {});
     }
     const message = `[BACKGROUND TASK COMPLETED] Task "${task.description}" finished in ${duration3}. Use background_output with task_id="${task.id}" to get results.`;
-    const mainSessionID2 = getMainSessionID();
-    if (!mainSessionID2) {
-      log("[background-agent] No main session ID available, relying on pending queue");
-      return;
-    }
-    log("[background-agent] Sending notification to main session:", mainSessionID2);
+    log("[background-agent] Sending notification to parent session:", { parentSessionID: task.parentSessionID });
     setTimeout(async () => {
       try {
         await this.client.session.prompt({
-          path: { id: mainSessionID2 },
+          path: { id: task.parentSessionID },
           body: {
             parts: [{ type: "text", text: message }]
           },
           query: { directory: this.directory }
         });
         this.clearNotificationsForTask(task.id);
-        log("[background-agent] Successfully sent prompt to main session");
+        log("[background-agent] Successfully sent prompt to parent session:", { parentSessionID: task.parentSessionID });
       } catch (error45) {
         log("[background-agent] prompt failed:", String(error45));
       }
@@ -24060,6 +24468,7 @@ class BackgroundManager {
           const assistantMsgs = messages.filter((m) => m.info?.role === "assistant");
           let toolCalls = 0;
           let lastTool;
+          let lastMessage;
           for (const msg of assistantMsgs) {
             const parts = msg.parts ?? [];
             for (const part of parts) {
@@ -24067,6 +24476,9 @@ class BackgroundManager {
                 toolCalls++;
                 lastTool = part.tool || part.name || "unknown";
               }
+              if (part.type === "text" && part.text) {
+                lastMessage = part.text;
+              }
             }
           }
           if (!task.progress) {
@@ -24075,6 +24487,10 @@ class BackgroundManager {
           task.progress.toolCalls = toolCalls;
           task.progress.lastTool = lastTool;
           task.progress.lastUpdate = new Date;
+          if (lastMessage) {
+            task.progress.lastMessage = lastMessage;
+            task.progress.lastMessageAt = new Date;
+          }
         }
       } catch (error45) {
         log("[background-agent] Poll error for task:", { taskId: task.id, error: error45 });
@@ -24137,6 +24553,23 @@ var AgentNameSchema = exports_external.enum([
   "frontend-ui-ux-engineer",
   "document-writer"
 ]);
+var HookNameSchema = exports_external.enum([
+  "todo-continuation-enforcer",
+  "context-window-monitor",
+  "session-recovery",
+  "session-notification",
+  "comment-checker",
+  "grep-output-truncator",
+  "directory-agents-injector",
+  "directory-readme-injector",
+  "empty-task-response-detector",
+  "think-mode",
+  "anthropic-auto-compact",
+  "rules-injector",
+  "background-notification",
+  "auto-update-checker",
+  "ultrawork-mode"
+]);
 var AgentOverrideConfigSchema = exports_external.object({
   model: exports_external.string().optional(),
   temperature: exports_external.number().min(0).max(2).optional(),
@@ -24167,6 +24600,7 @@ var OhMyOpenCodeConfigSchema = exports_external.object({
   $schema: exports_external.string().optional(),
   disabled_mcps: exports_external.array(McpNameSchema).optional(),
   disabled_agents: exports_external.array(AgentNameSchema).optional(),
+  disabled_hooks: exports_external.array(HookNameSchema).optional(),
   agents: AgentOverridesSchema.optional(),
   claude_code: ClaudeCodeConfigSchema.optional(),
   google_auth: exports_external.boolean().optional()
@@ -24216,6 +24650,12 @@ function mergeConfigs(base, override) {
         ...override.disabled_mcps ?? []
       ])
     ],
+    disabled_hooks: [
+      ...new Set([
+        ...base.disabled_hooks ?? [],
+        ...override.disabled_hooks ?? []
+      ])
+    ],
     claude_code: deepMerge(base.claude_code, override.claude_code)
   };
 }
@@ -24231,32 +24671,39 @@ function loadPluginConfig(directory) {
     agents: config3.agents,
     disabled_agents: config3.disabled_agents,
     disabled_mcps: config3.disabled_mcps,
+    disabled_hooks: config3.disabled_hooks,
     claude_code: config3.claude_code
   });
   return config3;
 }
 var OhMyOpenCodePlugin = async (ctx) => {
   const pluginConfig = loadPluginConfig(ctx.directory);
-  const todoContinuationEnforcer = createTodoContinuationEnforcer(ctx);
-  const contextWindowMonitor = createContextWindowMonitorHook(ctx);
-  const sessionRecovery = createSessionRecoveryHook(ctx);
-  sessionRecovery.setOnAbortCallback(todoContinuationEnforcer.markRecovering);
-  sessionRecovery.setOnRecoveryCompleteCallback(todoContinuationEnforcer.markRecoveryComplete);
-  const commentChecker = createCommentCheckerHooks();
-  const grepOutputTruncator = createGrepOutputTruncatorHook(ctx);
-  const directoryAgentsInjector = createDirectoryAgentsInjectorHook(ctx);
-  const directoryReadmeInjector = createDirectoryReadmeInjectorHook(ctx);
-  const emptyTaskResponseDetector = createEmptyTaskResponseDetectorHook(ctx);
-  const thinkMode = createThinkModeHook();
+  const disabledHooks = new Set(pluginConfig.disabled_hooks ?? []);
+  const isHookEnabled = (hookName) => !disabledHooks.has(hookName);
+  const todoContinuationEnforcer = isHookEnabled("todo-continuation-enforcer") ? createTodoContinuationEnforcer(ctx) : null;
+  const contextWindowMonitor = isHookEnabled("context-window-monitor") ? createContextWindowMonitorHook(ctx) : null;
+  const sessionRecovery = isHookEnabled("session-recovery") ? createSessionRecoveryHook(ctx) : null;
+  const sessionNotification = isHookEnabled("session-notification") ? createSessionNotification(ctx) : null;
+  if (sessionRecovery && todoContinuationEnforcer) {
+    sessionRecovery.setOnAbortCallback(todoContinuationEnforcer.markRecovering);
+    sessionRecovery.setOnRecoveryCompleteCallback(todoContinuationEnforcer.markRecoveryComplete);
+  }
+  const commentChecker = isHookEnabled("comment-checker") ? createCommentCheckerHooks() : null;
+  const grepOutputTruncator = isHookEnabled("grep-output-truncator") ? createGrepOutputTruncatorHook(ctx) : null;
+  const directoryAgentsInjector = isHookEnabled("directory-agents-injector") ? createDirectoryAgentsInjectorHook(ctx) : null;
+  const directoryReadmeInjector = isHookEnabled("directory-readme-injector") ? createDirectoryReadmeInjectorHook(ctx) : null;
+  const emptyTaskResponseDetector = isHookEnabled("empty-task-response-detector") ? createEmptyTaskResponseDetectorHook(ctx) : null;
+  const thinkMode = isHookEnabled("think-mode") ? createThinkModeHook() : null;
   const claudeCodeHooks = createClaudeCodeHooksHook(ctx, {
     disabledHooks: pluginConfig.claude_code?.hooks ?? true ? undefined : true
   });
-  const anthropicAutoCompact = createAnthropicAutoCompactHook(ctx);
-  const rulesInjector = createRulesInjectorHook(ctx);
-  const autoUpdateChecker = createAutoUpdateCheckerHook(ctx);
+  const anthropicAutoCompact = isHookEnabled("anthropic-auto-compact") ? createAnthropicAutoCompactHook(ctx) : null;
+  const rulesInjector = isHookEnabled("rules-injector") ? createRulesInjectorHook(ctx) : null;
+  const autoUpdateChecker = isHookEnabled("auto-update-checker") ? createAutoUpdateCheckerHook(ctx) : null;
+  const ultraworkMode = isHookEnabled("ultrawork-mode") ? createUltraworkModeHook() : null;
   updateTerminalTitle({ sessionId: "main" });
   const backgroundManager = new BackgroundManager(ctx);
-  const backgroundNotificationHook = createBackgroundNotificationHook(backgroundManager);
+  const backgroundNotificationHook = isHookEnabled("background-notification") ? createBackgroundNotificationHook(backgroundManager) : null;
   const backgroundTools = createBackgroundTools(backgroundManager, ctx.client);
   const callOmoAgent = createCallOmoAgent(ctx, backgroundManager);
   const googleAuthHooks = pluginConfig.google_auth ? await createGoogleAntigravityAuthPlugin(ctx) : null;
@@ -24269,6 +24716,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
     },
     "chat.message": async (input, output) => {
       await claudeCodeHooks["chat.message"]?.(input, output);
+      await ultraworkMode?.["chat.message"]?.(input, output);
     },
     config: async (config3) => {
       const builtinAgents = createBuiltinAgents(pluginConfig.disabled_agents, pluginConfig.agents);
@@ -24319,16 +24767,18 @@ var OhMyOpenCodePlugin = async (ctx) => {
       };
     },
     event: async (input) => {
-      await autoUpdateChecker.event(input);
+      await autoUpdateChecker?.event(input);
       await claudeCodeHooks.event(input);
-      await backgroundNotificationHook.event(input);
-      await todoContinuationEnforcer.handler(input);
-      await contextWindowMonitor.event(input);
-      await directoryAgentsInjector.event(input);
-      await directoryReadmeInjector.event(input);
-      await rulesInjector.event(input);
-      await thinkMode.event(input);
-      await anthropicAutoCompact.event(input);
+      await backgroundNotificationHook?.event(input);
+      await sessionNotification?.(input);
+      await todoContinuationEnforcer?.handler(input);
+      await contextWindowMonitor?.event(input);
+      await directoryAgentsInjector?.event(input);
+      await directoryReadmeInjector?.event(input);
+      await rulesInjector?.event(input);
+      await thinkMode?.event(input);
+      await anthropicAutoCompact?.event(input);
+      await ultraworkMode?.event(input);
       const { event } = input;
       const props = event.properties;
       if (event.type === "session.created") {
@@ -24370,7 +24820,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
       if (event.type === "session.error") {
         const sessionID = props?.sessionID;
         const error45 = props?.error;
-        if (sessionRecovery.isRecoverableError(error45)) {
+        if (sessionRecovery?.isRecoverableError(error45)) {
           const messageInfo = {
             id: props?.messageID,
             role: "assistant",
@@ -24409,7 +24859,7 @@ var OhMyOpenCodePlugin = async (ctx) => {
     },
     "tool.execute.before": async (input, output) => {
       await claudeCodeHooks["tool.execute.before"](input, output);
-      await commentChecker["tool.execute.before"](input, output);
+      await commentChecker?.["tool.execute.before"](input, output);
       if (input.sessionID === getMainSessionID()) {
         updateTerminalTitle({
           sessionId: input.sessionID,
@@ -24422,13 +24872,13 @@ var OhMyOpenCodePlugin = async (ctx) => {
     },
     "tool.execute.after": async (input, output) => {
       await claudeCodeHooks["tool.execute.after"](input, output);
-      await grepOutputTruncator["tool.execute.after"](input, output);
-      await contextWindowMonitor["tool.execute.after"](input, output);
-      await commentChecker["tool.execute.after"](input, output);
-      await directoryAgentsInjector["tool.execute.after"](input, output);
-      await directoryReadmeInjector["tool.execute.after"](input, output);
-      await rulesInjector["tool.execute.after"](input, output);
-      await emptyTaskResponseDetector["tool.execute.after"](input, output);
+      await grepOutputTruncator?.["tool.execute.after"](input, output);
+      await contextWindowMonitor?.["tool.execute.after"](input, output);
+      await commentChecker?.["tool.execute.after"](input, output);
+      await directoryAgentsInjector?.["tool.execute.after"](input, output);
+      await directoryReadmeInjector?.["tool.execute.after"](input, output);
+      await rulesInjector?.["tool.execute.after"](input, output);
+      await emptyTaskResponseDetector?.["tool.execute.after"](input, output);
       if (input.sessionID === getMainSessionID()) {
         updateTerminalTitle({
           sessionId: input.sessionID,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "0.4.4",
+  "version": "1.0.1",
   "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",