oh-my-opencode 0.4.3 → 1.0.0

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>
 
@@ -334,6 +336,18 @@ OpenCode 는 아주 확장가능하고 아주 커스터마이저블합니다.
 - **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`, `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>
 
@@ -332,6 +334,18 @@ Example workflow:
 - **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`, `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/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
+     *
+     * Execution timing: AFTER claudeCodeHooks["chat.message"]
+     * Behavior:
+     *   1. Extract text from user prompt
+     *   2. Detect ultrawork/ulw keywords (excluding code blocks)
+     *   3. If detected, prepend ULTRAWORK_CONTEXT to first text part
+     */
+    "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";
@@ -6330,6 +6522,91 @@ 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 parts = output.parts;
+      const idx = parts.findIndex((p) => p.type === "text" && p.text);
+      if (idx >= 0) {
+        parts[idx].text = `${ULTRAWORK_CONTEXT}${parts[idx].text ?? ""}`;
+        state.injected = true;
+        log("Ultrawork context injected", { 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 +7711,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 +7785,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;
@@ -19435,10 +19742,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 +21655,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);
@@ -22121,7 +22428,7 @@ function isValidBinary(filePath) {
   }
 }
 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 +22439,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";
@@ -23479,20 +23786,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})
 
-Session ID: ${task.sessionID}`;
+\`\`\`
+${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}
+
+## Original Prompt
+
+\`\`\`
+${promptPreview}
+\`\`\`${lastMessageSection}`;
 }
 async function formatTaskResult(task, client2) {
   const messagesResult = await client2.session.messages({
@@ -23834,6 +24169,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 +24327,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 +24391,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 +24399,9 @@ class BackgroundManager {
                 toolCalls++;
                 lastTool = part.tool || part.name || "unknown";
               }
+              if (part.type === "text" && part.text) {
+                lastMessage = part.text;
+              }
             }
           }
           if (!task.progress) {
@@ -24075,6 +24410,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 +24476,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 +24523,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 +24573,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 +24594,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 +24639,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 +24690,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 +24743,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 +24782,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 +24795,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.3",
+  "version": "1.0.0",
   "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",