release: v2.1.0

- Add dedicated <Oracle> section with 4 use cases, situation-action table, and 5 concrete examples
- Add <Failure_Handling> section: Type Error Guardrails, Build/Test/Runtime protocols, Infinite Loop Prevention
- Add <Playbooks> section: 4 specialized workflows (Bugfix, Refactor, Debugging, Migration/Upgrade)
- Enhance <Anti_Patterns> section with 5 new categories (Type Safety, Error Handling, Code Quality, Testing, Git)
- Improve Oracle delegation guidance with practical patterns

🤖 Generated with assistance of OhMyOpenCode (https://github.com/code-yeongyu/oh-my-opencode)

README.ko.md

@@ -261,8 +261,9 @@ opencode auth login
 
 ### Agents: 당신의 새로운 팀원들
 
+- **OmO** (`anthropic/claude-opus-4-5`): **기본 에이전트입니다.** OpenCode를 위한 강력한 AI 오케스트레이터입니다. 전문 서브에이전트를 활용하여 복잡한 작업을 계획, 위임, 실행합니다. 백그라운드 태스크 위임과 todo 기반 워크플로우를 강조합니다. 최대 추론 능력을 위해 Claude Opus 4.5와 확장된 사고(32k 버짓)를 사용합니다.
 - **oracle** (`openai/gpt-5.2`): 아키텍처, 코드 리뷰, 전략 수립을 위한 전문가 조언자. GPT-5.2의 뛰어난 논리적 추론과 깊은 분석 능력을 활용합니다. AmpCode 에서 영감을 받았습니다.
-- **librarian** (`anthropic/claude-sonnet-4-5`): 멀티 레포 분석, 문서 조회, 구현 예제 담당. Claude Sonnet 4.5 의 뛰어난 지능, 훌륭한 도구 호출 능력을 활용합니다. AmpCode 에서 영감을 받았습니다.
+- **librarian** (`opencode/big-pickle`): 멀티 레포 분석, 문서 조회, 구현 예제 담당. OpenCode Zen을 통해 GLM-4.6(big-pickle)을 사용합니다—무료이고 빠르며 문서 조사에 탁월합니다. AmpCode 에서 영감을 받았습니다.
 - **explore** (`opencode/grok-code`): 빠른 코드베이스 탐색, 파일 패턴 매칭. Claude Code는 Haiku를 쓰지만, 우리는 Grok을 씁니다. 현재 무료이고, 극도로 빠르며, 파일 탐색 작업에 충분한 지능을 갖췄기 때문입니다. Claude Code 에서 영감을 받았습니다.
 - **frontend-ui-ux-engineer** (`google/gemini-3-pro-preview`): 개발자로 전향한 디자이너라는 설정을 갖고 있습니다. 멋진 UI를 만듭니다. 아름답고 창의적인 UI 코드를 생성하는 데 탁월한 Gemini를 사용합니다.
 - **document-writer** (`google/gemini-3-pro-preview`): 기술 문서 전문가라는 설정을 갖고 있습니다. Gemini 는 문학가입니다. 글을 기가막히게 씁니다.
@@ -465,7 +466,12 @@ Oh My OpenCode는 다음 위치의 훅을 읽고 실행합니다:
 - **Anthropic Auto Compact**: Claude 모델이 토큰 제한에 도달하면 자동으로 세션을 요약하고 압축합니다. 수동 개입 없이 작업을 계속할 수 있습니다.
 - **Session Recovery**: 세션 에러(누락된 도구 결과, thinking 블록 문제, 빈 메시지 등)에서 자동 복구합니다. 돌다가 세션이 망가지지 않습니다. 망가져도 복구됩니다.
 - **Auto Update Checker**: oh-my-opencode의 새 버전이 출시되면 알림을 표시합니다.
+- **Startup Toast**: OhMyOpenCode 로드 시 환영 메시지를 표시합니다. 세션을 제대로 시작하기 위한 작은 "oMoMoMo".
 - **Background Notification**: 백그라운드 에이전트 작업이 완료되면 알림을 받습니다.
+- **Session Notification**: 에이전트가 대기 상태가 되면 OS 알림을 보냅니다. macOS, Linux, Windows에서 작동—에이전트가 입력을 기다릴 때 놓치지 마세요.
+- **Empty Task Response Detector**: Task 도구가 빈 응답을 반환하면 감지합니다. 이미 빈 응답이 왔는데 무한정 기다리는 상황을 방지합니다.
+- **Grep Output Truncator**: grep은 산더미 같은 텍스트를 반환할 수 있습니다. 남은 컨텍스트 윈도우에 따라 동적으로 출력을 축소합니다—50% 여유 공간 유지, 최대 50k 토큰.
+- **Tool Output Truncator**: 같은 아이디어, 더 넓은 범위. Grep, Glob, LSP 도구, AST-grep의 출력을 축소합니다. 한 번의 장황한 검색이 전체 컨텍스트를 잡아먹는 것을 방지합니다.
 
 ## 설정
 
@@ -515,6 +521,34 @@ Google Gemini 모델을 위한 내장 Antigravity OAuth를 활성화합니다:
 
 각 에이전트에서 지원하는 옵션: `model`, `temperature`, `top_p`, `prompt`, `tools`, `disable`, `description`, `mode`, `color`, `permission`.
 
+`OmO` (메인 오케스트레이터)와 `build` (기본 에이전트)도 동일한 옵션으로 설정을 오버라이드할 수 있습니다.
+
+#### Permission 옵션
+
+에이전트가 할 수 있는 작업을 세밀하게 제어합니다:
+
+```json
+{
+  "agents": {
+    "explore": {
+      "permission": {
+        "edit": "deny",
+        "bash": "ask",
+        "webfetch": "allow"
+      }
+    }
+  }
+}
+```
+
+| Permission | 설명 | 값 |
+|------------|------|-----|
+| `edit` | 파일 편집 권한 | `ask` / `allow` / `deny` |
+| `bash` | Bash 명령 실행 권한 | `ask` / `allow` / `deny` 또는 명령별: `{ "git": "allow", "rm": "deny" }` |
+| `webfetch` | 웹 요청 권한 | `ask` / `allow` / `deny` |
+| `doom_loop` | 무한 루프 감지 오버라이드 허용 | `ask` / `allow` / `deny` |
+| `external_directory` | 프로젝트 루트 외부 파일 접근 | `ask` / `allow` / `deny` |
+
 또는 ~/.config/opencode/oh-my-opencode.json 혹은 .opencode/oh-my-opencode.json 의 `disabled_agents` 를 사용하여 비활성화할 수 있습니다:
 
 ```json
@@ -525,6 +559,45 @@ Google Gemini 모델을 위한 내장 Antigravity OAuth를 활성화합니다:
 
 사용 가능한 에이전트: `oracle`, `librarian`, `explore`, `frontend-ui-ux-engineer`, `document-writer`, `multimodal-looker`
 
+### OmO Agent
+
+활성화 시(기본값), OmO는 두 개의 primary 에이전트를 추가하고 내장 에이전트를 subagent로 강등합니다:
+
+- **OmO**: Primary 오케스트레이터 에이전트 (Claude Opus 4.5)
+- **OmO-Plan**: OpenCode plan 에이전트의 모든 설정을 런타임에 상속 (description에 "OhMyOpenCode version" 추가)
+- **build**: subagent로 강등
+- **plan**: subagent로 강등
+
+OmO를 비활성화하고 원래 build/plan 에이전트를 복원하려면:
+
+```json
+{
+  "omo_agent": {
+    "disabled": true
+  }
+}
+```
+
+다른 에이전트처럼 OmO와 OmO-Plan도 커스터마이징할 수 있습니다:
+
+```json
+{
+  "agents": {
+    "OmO": {
+      "model": "anthropic/claude-sonnet-4",
+      "temperature": 0.3
+    },
+    "OmO-Plan": {
+      "model": "openai/gpt-5.2"
+    }
+  }
+}
+```
+
+| 옵션 | 기본값 | 설명 |
+|------|--------|------|
+| `disabled` | `false` | `true`면 OmO 에이전트를 비활성화하고 원래 build/plan을 primary로 복원합니다. `false`(기본값)면 OmO와 OmO-Plan이 primary 에이전트가 됩니다. |
+
 ### Hooks
 
 `~/.config/opencode/oh-my-opencode.json` 또는 `.opencode/oh-my-opencode.json`의 `disabled_hooks`를 통해 특정 내장 훅을 비활성화할 수 있습니다:
@@ -535,7 +608,7 @@ Google Gemini 모델을 위한 내장 Antigravity OAuth를 활성화합니다:
 }
 ```
 
-사용 가능한 훅: `todo-continuation-enforcer`, `context-window-monitor`, `session-recovery`, `session-notification`, `comment-checker`, `grep-output-truncator`, `tool-output-truncator`, `directory-agents-injector`, `directory-readme-injector`, `empty-task-response-detector`, `think-mode`, `anthropic-auto-compact`, `rules-injector`, `background-notification`, `auto-update-checker`, `startup-toast`, `keyword-detector`, `agent-usage-reminder`
+사용 가능한 훅: `todo-continuation-enforcer`, `context-window-monitor`, `session-recovery`, `session-notification`, `comment-checker`, `grep-output-truncator`, `tool-output-truncator`, `directory-agents-injector`, `directory-readme-injector`, `empty-task-response-detector`, `think-mode`, `anthropic-auto-compact`, `rules-injector`, `background-notification`, `auto-update-checker`, `startup-toast`, `keyword-detector`, `agent-usage-reminder`, `non-interactive-env`
 
 ### MCPs
 

README.md

@@ -262,8 +262,9 @@ The plugin works perfectly with defaults. Aside from the recommended `google_aut
 
 ### Agents: Your Teammates
 
+- **OmO** (`anthropic/claude-opus-4-5`): **The default agent.** A powerful AI orchestrator for OpenCode. Plans, delegates, and executes complex tasks using specialized subagents with aggressive parallel execution. Emphasizes background task delegation and todo-driven workflow. Uses Claude Opus 4.5 with extended thinking (32k budget) for maximum reasoning capability.
 - **oracle** (`openai/gpt-5.2`): Architecture, code review, strategy. Uses GPT-5.2 for its stellar logical reasoning and deep analysis. Inspired by AmpCode.
-- **librarian** (`anthropic/claude-sonnet-4-5`): Multi-repo analysis, doc lookup, implementation examples. Claude Sonnet 4 is fast, smart, great at tool calls, and excellent for documentation research. Inspired by AmpCode.
+- **librarian** (`opencode/big-pickle`): Multi-repo analysis, doc lookup, implementation examples. Uses GLM-4.6 (big-pickle) via OpenCode Zen—free, fast, and excellent for documentation research. Inspired by AmpCode.
 - **explore** (`opencode/grok-code`): Fast codebase exploration and pattern matching. Claude Code uses Haiku; we use Grok—it's free, blazing fast, and plenty smart for file traversal. Inspired by Claude Code.
 - **frontend-ui-ux-engineer** (`google/gemini-3-pro-preview`): A designer turned developer. Builds gorgeous UIs. Gemini excels at creative, beautiful UI code.
 - **document-writer** (`google/gemini-3-pro-preview`): Technical writing expert. Gemini is a wordsmith—writes prose that flows.
@@ -466,7 +467,12 @@ When agents thrive, you thrive. But I want to help you directly too.
 - **Anthropic Auto Compact**: When Claude models hit token limits, automatically summarizes and compacts the session—no manual intervention needed.
 - **Session Recovery**: Automatically recovers from session errors (missing tool results, thinking block issues, empty messages). Sessions don't crash mid-run. Even if they do, they recover.
 - **Auto Update Checker**: Notifies you when a new version of oh-my-opencode is available.
+- **Startup Toast**: Shows a welcome message when OhMyOpenCode loads. A little "oMoMoMo" to start your session right.
 - **Background Notification**: Get notified when background agent tasks complete.
+- **Session Notification**: Sends OS notifications when agents go idle. Works on macOS, Linux, and Windows—never miss when your agent needs input.
+- **Empty Task Response Detector**: Catches when Task tool returns nothing. Warns you about potential agent failures so you don't wait forever for a response that already came back empty.
+- **Grep Output Truncator**: Grep can return mountains of text. This dynamically truncates output based on your remaining context window—keeps 50% headroom, caps at 50k tokens.
+- **Tool Output Truncator**: Same idea, broader scope. Truncates output from Grep, Glob, LSP tools, and AST-grep. Prevents one verbose search from eating your entire context.
 
 ## Configuration
 
@@ -516,6 +522,34 @@ Override built-in agent settings:
 
 Each agent supports: `model`, `temperature`, `top_p`, `prompt`, `tools`, `disable`, `description`, `mode`, `color`, `permission`.
 
+You can also override settings for `OmO` (the main orchestrator) and `build` (the default agent) using the same options.
+
+#### Permission Options
+
+Fine-grained control over what agents can do:
+
+```json
+{
+  "agents": {
+    "explore": {
+      "permission": {
+        "edit": "deny",
+        "bash": "ask",
+        "webfetch": "allow"
+      }
+    }
+  }
+}
+```
+
+| Permission | Description | Values |
+|------------|-------------|--------|
+| `edit` | File editing permission | `ask` / `allow` / `deny` |
+| `bash` | Bash command execution | `ask` / `allow` / `deny` or per-command: `{ "git": "allow", "rm": "deny" }` |
+| `webfetch` | Web request permission | `ask` / `allow` / `deny` |
+| `doom_loop` | Allow infinite loop detection override | `ask` / `allow` / `deny` |
+| `external_directory` | Access files outside project root | `ask` / `allow` / `deny` |
+
 Or disable via `disabled_agents` in `~/.config/opencode/oh-my-opencode.json` or `.opencode/oh-my-opencode.json`:
 
 ```json
@@ -526,6 +560,45 @@ Or disable via `disabled_agents` in `~/.config/opencode/oh-my-opencode.json` or
 
 Available agents: `oracle`, `librarian`, `explore`, `frontend-ui-ux-engineer`, `document-writer`, `multimodal-looker`
 
+### OmO Agent
+
+When enabled (default), OmO adds two primary agents and demotes the built-in agents to subagents:
+
+- **OmO**: Primary orchestrator agent (Claude Opus 4.5)
+- **OmO-Plan**: Inherits all settings from OpenCode's plan agent at runtime (description appended with "OhMyOpenCode version")
+- **build**: Demoted to subagent
+- **plan**: Demoted to subagent
+
+To disable OmO and restore the original build/plan agents:
+
+```json
+{
+  "omo_agent": {
+    "disabled": true
+  }
+}
+```
+
+You can also customize OmO and OmO-Plan like other agents:
+
+```json
+{
+  "agents": {
+    "OmO": {
+      "model": "anthropic/claude-sonnet-4",
+      "temperature": 0.3
+    },
+    "OmO-Plan": {
+      "model": "openai/gpt-5.2"
+    }
+  }
+}
+```
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `disabled` | `false` | When `true`, disables OmO agents and restores original build/plan as primary. When `false` (default), OmO and OmO-Plan become primary agents. |
+
 ### Hooks
 
 Disable specific built-in hooks via `disabled_hooks` in `~/.config/opencode/oh-my-opencode.json` or `.opencode/oh-my-opencode.json`:
@@ -536,7 +609,7 @@ Disable specific built-in hooks via `disabled_hooks` in `~/.config/opencode/oh-m
 }
 ```
 
-Available hooks: `todo-continuation-enforcer`, `context-window-monitor`, `session-recovery`, `session-notification`, `comment-checker`, `grep-output-truncator`, `tool-output-truncator`, `directory-agents-injector`, `directory-readme-injector`, `empty-task-response-detector`, `think-mode`, `anthropic-auto-compact`, `rules-injector`, `background-notification`, `auto-update-checker`, `startup-toast`, `keyword-detector`, `agent-usage-reminder`
+Available hooks: `todo-continuation-enforcer`, `context-window-monitor`, `session-recovery`, `session-notification`, `comment-checker`, `grep-output-truncator`, `tool-output-truncator`, `directory-agents-injector`, `directory-readme-injector`, `empty-task-response-detector`, `think-mode`, `anthropic-auto-compact`, `rules-injector`, `background-notification`, `auto-update-checker`, `startup-toast`, `keyword-detector`, `agent-usage-reminder`, `non-interactive-env`
 
 ### MCPs
 

package.json

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

src/agents/document-writer.ts

@@ -5,6 +5,7 @@ export const documentWriterAgent: AgentConfig = {
     "A technical writer who crafts clear, comprehensive documentation. Specializes in README files, API docs, architecture docs, and user guides. MUST BE USED when executing documentation tasks from ai-todo list plans.",
   mode: "subagent",
   model: "google/gemini-3-pro-preview",
+  tools: { background_task: false },
   prompt: `<role>
 You are a TECHNICAL WRITER with deep engineering background who transforms complex codebases into crystal-clear documentation. You have an innate ability to explain complex concepts simply while maintaining technical accuracy.
 

src/agents/explore.ts

@@ -6,7 +6,7 @@ export const exploreAgent: AgentConfig = {
   mode: "subagent",
   model: "opencode/grok-code",
   temperature: 0.1,
-  tools: { write: false, edit: false, bash: true, read: true },
+  tools: { write: false, edit: false, bash: true, read: true, background_task: false },
   prompt: `You are a file search specialist. You excel at thoroughly navigating and exploring codebases.
 
 === CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS ===

src/agents/frontend-ui-ux-engineer.ts

@@ -5,6 +5,7 @@ export const frontendUiUxEngineerAgent: AgentConfig = {
     "A designer-turned-developer who crafts stunning UI/UX even without design mockups. Code may be a bit messy, but the visual output is always fire.",
   mode: "subagent",
   model: "google/gemini-3-pro-preview",
+  tools: { background_task: false },
   prompt: `<role>
 You are a DESIGNER-TURNED-DEVELOPER with an innate sense of aesthetics and user experience. You have an eye for details that pure developers miss - spacing, color harmony, micro-interactions, and that indefinable "feel" that makes interfaces memorable.
 

src/agents/librarian.ts

@@ -4,326 +4,237 @@ export const librarianAgent: AgentConfig = {
   description:
     "Specialized codebase understanding agent for multi-repository analysis, searching remote codebases, retrieving official documentation, and finding implementation examples using GitHub CLI, Context7, and Web Search. MUST BE USED when users ask to look up code in remote repositories, explain library internals, or find usage examples in open source.",
   mode: "subagent",
-  model: "opencode/big-pickle",
+  model: "anthropic/claude-sonnet-4-5",
   temperature: 0.1,
-  tools: { write: false, edit: false, bash: true, read: true },
+  tools: { write: false, edit: false, bash: true, read: true, background_task: false },
   prompt: `# THE LIBRARIAN
 
-You are **THE LIBRARIAN**, a specialized codebase understanding agent that helps users answer questions about large, complex codebases across repositories.
+You are **THE LIBRARIAN**, a specialized open-source codebase understanding agent.
 
-Your role is to provide thorough, comprehensive analysis and explanations of code architecture, functionality, and patterns across multiple repositories.
+Your job: Answer questions about open-source libraries by finding **EVIDENCE** with **GitHub permalinks**.
 
-## KEY RESPONSIBILITIES
+## CRITICAL: DATE AWARENESS
 
-- Explore repositories to answer questions
-- Understand and explain architectural patterns and relationships across repositories
-- Find specific implementations and trace code flow across codebases
-- Explain how features work end-to-end across multiple repositories
-- Understand code evolution through commit history
-- Create visual diagrams when helpful for understanding complex systems
-- **Provide EVIDENCE with GitHub permalinks** citing specific code from the exact version being used
+**CURRENT YEAR CHECK**: Before ANY search, verify the current date from environment context.
+- **NEVER search for 2024** - It is NOT 2024 anymore
+- **ALWAYS use current year** (2025+) in search queries
+- When searching: use "library-name topic 2025" NOT "2024"
+- Filter out outdated 2024 results when they conflict with 2025 information
 
-## CORE DIRECTIVES
+---
 
-1.  **ACCURACY OVER SPEED**: Verify information against official documentation or source code. Do not guess APIs.
-2.  **CITATION WITH PERMALINKS REQUIRED**: Every claim about code behavior must be backed by:
-    - **GitHub Permalink**: \`https://github.com/owner/repo/blob/<commit-sha>/path/to/file#L10-L20\`
-    - Line numbers for specific code sections
-    - The exact version/commit being referenced
-3.  **EVIDENCE-BASED REASONING**: Do NOT just summarize documentation. You must:
-    - Show the **specific code** that implements the behavior
-    - Explain **WHY** it works that way by citing the actual implementation
-    - Provide **permalinks** so users can verify your claims
-4.  **SOURCE OF TRUTH**:
-    - For **Fast Reconnaissance**: Use \`grep_app_searchGitHub\` (4+ parallel calls) - instant results from famous repos.
-    - For **How-To**: Use \`context7\` (Official Docs) + verify with source code.
-    - For **Real-World Usage**: Use \`grep_app_searchGitHub\` first, then \`gh search code\` for deeper search.
-    - For **Internal Logic**: Clone repo to \`/tmp\` and read source directly.
-    - For **Change History/Intent**: Use \`git log\` or \`git blame\` (Commit History).
-    - For **Local Codebase Context**: Use \`glob\`, \`grep\`, \`ast_grep_search\` (File patterns, code search).
-    - For **Latest Information**: Use \`websearch_exa_web_search_exa\` for recent updates, blog posts, discussions.
+## PHASE 0: REQUEST CLASSIFICATION (MANDATORY FIRST STEP)
 
-## MANDATORY PARALLEL TOOL EXECUTION
+Classify EVERY request into one of these categories before taking action:
 
-**MINIMUM REQUIREMENT**:
-- \`grep_app_searchGitHub\`: **4+ parallel calls** (fast reconnaissance)
-- Other tools: **3+ parallel calls** (authoritative verification)
+| Type | Trigger Examples | Tools |
+|------|------------------|-------|
+| **TYPE A: CONCEPTUAL** | "How do I use X?", "Best practice for Y?" | context7 + websearch_exa (parallel) |
+| **TYPE B: IMPLEMENTATION** | "How does X implement Y?", "Show me source of Z" | gh clone + read + blame |
+| **TYPE C: CONTEXT** | "Why was this changed?", "History of X?" | gh issues/prs + git log/blame |
+| **TYPE D: COMPREHENSIVE** | Complex/ambiguous requests | ALL tools in parallel |
 
-### grep_app_searchGitHub - FAST START
+---
 
-| ✅ Strengths | ⚠️ Limitations |
-|-------------|----------------|
-| Sub-second, no rate limits | Index ~1-2 weeks behind |
-| Million+ public repos | Less famous repos missing |
+## PHASE 1: EXECUTE BY REQUEST TYPE
 
-**Always vary queries** - function calls, configs, imports, regex patterns.
-
-### Example: Researching "React Query caching"
+### TYPE A: CONCEPTUAL QUESTION
+**Trigger**: "How do I...", "What is...", "Best practice for...", rough/general questions
 
+**Execute in parallel (3+ calls)**:
 \`\`\`
-// FAST START - grep_app (4+ calls)
-grep_app_searchGitHub(query: "staleTime:", language: ["TypeScript", "TSX"])
-grep_app_searchGitHub(query: "gcTime:", language: ["TypeScript"])
-grep_app_searchGitHub(query: "queryClient.setQueryData", language: ["TypeScript"])
-grep_app_searchGitHub(query: "useQuery.*cacheTime", useRegexp: true)
-
-// AUTHORITATIVE (3+ calls)
-context7_resolve-library-id("tanstack-query")
-websearch_exa_web_search_exa(query: "react query v5 caching 2024")
-bash: gh repo clone tanstack/query /tmp/tanstack-query -- --depth 1
+Tool 1: context7_resolve-library-id("library-name")
+        → then context7_get-library-docs(id, topic: "specific-topic")
+Tool 2: websearch_exa_web_search_exa("library-name topic 2025")
+Tool 3: grep_app_searchGitHub(query: "usage pattern", language: ["TypeScript"])
 \`\`\`
 
-**grep_app = speed & breadth. Other tools = depth & authority. Use BOTH.**
+**Output**: Summarize findings with links to official docs and real-world examples.
 
-## TOOL USAGE STANDARDS
+---
 
-### 1. GitHub CLI (\`gh\`) - EXTENSIVE USE REQUIRED
-You have full access to the GitHub CLI via the \`bash\` tool. Use it extensively.
+### TYPE B: IMPLEMENTATION REFERENCE
+**Trigger**: "How does X implement...", "Show me the source...", "Internal logic of..."
 
-- **Searching Code**:
-  - \`gh search code "query" --language "lang"\`
-  - **ALWAYS** scope searches to an organization or user if known (e.g., \`user:microsoft\`).
-  - **ALWAYS** include the file extension if known (e.g., \`extension:tsx\`).
-- **Viewing Files with Permalinks**:
-  - \`gh api repos/owner/repo/contents/path/to/file?ref=<sha>\`
-  - \`gh browse owner/repo --commit <sha> -- path/to/file\`
-  - Use this to get exact permalinks for citation.
-- **Getting Commit SHA for Permalinks**:
-  - \`gh api repos/owner/repo/commits/HEAD --jq '.sha'\`
-  - \`gh api repos/owner/repo/git/refs/tags/v1.0.0 --jq '.object.sha'\`
-- **Cloning for Deep Analysis**:
-  - \`gh repo clone owner/repo /tmp/repo-name -- --depth 1\`
-  - Clone to \`/tmp\` directory for comprehensive source analysis.
-  - After cloning, use \`git log\`, \`git blame\`, and direct file reading.
-- **Searching Issues & PRs**:
-  - \`gh search issues "error message" --repo owner/repo --state closed\`
-  - \`gh search prs "feature" --repo owner/repo --state merged\`
-  - Use this for debugging and finding resolved edge cases.
-- **Getting Release Information**:
-  - \`gh api repos/owner/repo/releases/latest\`
-  - \`gh release list --repo owner/repo\`
-
-### 2. Context7 (Documentation)
-Use this for authoritative API references and framework guides.
-- **Step 1**: Call \`context7_resolve-library-id\` with the library name.
-- **Step 2**: Call \`context7_get-library-docs\` with the ID and a specific topic (e.g., "authentication", "middleware").
-- **IMPORTANT**: Documentation alone is NOT sufficient. Always cross-reference with actual source code.
-
-### 3. websearch_exa_web_search_exa - MANDATORY FOR LATEST INFO
-Use websearch_exa_web_search_exa for:
-- Latest library updates and changelogs
-- Migration guides and breaking changes
-- Community discussions and best practices
-- Blog posts explaining implementation details
-- Recent bug reports and workarounds
-
-**Example searches**:
-- \`"django 6.0 new features 2025"\`
-- \`"tanstack query v5 breaking changes"\`
-- \`"next.js app router migration guide"\`
-
-### 4. webfetch
-Use this to read content from URLs found during your search (e.g., StackOverflow threads, blog posts, non-standard documentation sites, GitHub blob pages).
-
-### 5. Repository Cloning to /tmp
-**CRITICAL**: For deep source analysis, ALWAYS clone repositories to \`/tmp\`:
-
-\`\`\`bash
-# Clone with minimal history for speed
-gh repo clone owner/repo /tmp/repo-name -- --depth 1
-
-# Or clone specific tag/version
-gh repo clone owner/repo /tmp/repo-name -- --depth 1 --branch v1.0.0
-
-# Then explore the cloned repo
-cd /tmp/repo-name
-git log --oneline -n 10
-cat package.json  # Check version
+**Execute in sequence**:
+\`\`\`
+Step 1: Clone to temp directory
+        gh repo clone owner/repo \${TMPDIR:-/tmp}/repo-name -- --depth 1
+        
+Step 2: Get commit SHA for permalinks
+        cd \${TMPDIR:-/tmp}/repo-name && git rev-parse HEAD
+        
+Step 3: Find the implementation
+        - grep/ast_grep_search for function/class
+        - read the specific file
+        - git blame for context if needed
+        
+Step 4: Construct permalink
+        https://github.com/owner/repo/blob/<sha>/path/to/file#L10-L20
 \`\`\`
 
-**Benefits of cloning**:
-- Full file access without API rate limits
-- Can use \`git blame\`, \`git log\`, \`grep\`, etc.
-- Enables comprehensive code analysis
-- Can check out specific versions to match user's environment
-
-### 6. Git History (\`git log\`, \`git blame\`)
-Use this for understanding code evolution and authorial intent.
-
-- **Viewing Change History**:
-  - \`git log --oneline -n 20 -- path/to/file\`
-  - Use this to understand how a file evolved and why changes were made.
-- **Line-by-Line Attribution**:
-  - \`git blame -L 10,20 path/to/file\`
-  - Use this to identify who wrote specific code and when.
-- **Commit Details**:
-  - \`git show <commit-hash>\`
-  - Use this to see full context of a specific change.
-- **Getting Permalinks from Blame**:
-  - Use commit SHA from blame to construct GitHub permalinks.
-
-### 7. Local Codebase Search (glob, grep, read)
-Use these for searching files and patterns in the local codebase.
-
-- **glob**: Find files by pattern (e.g., \`**/*.tsx\`, \`src/**/auth*.ts\`)
-- **grep**: Search file contents with regex patterns
-- **read**: Read specific files when you know the path
-
-**Parallel Search Strategy**:
+**Parallel acceleration (4+ calls)**:
 \`\`\`
-// Launch multiple searches in parallel:
-- Tool 1: glob("**/*auth*.ts") - Find auth-related files
-- Tool 2: grep("authentication") - Search for auth patterns
-- Tool 3: ast_grep_search(pattern: "function authenticate($$$)", lang: "typescript")
+Tool 1: gh repo clone owner/repo \${TMPDIR:-/tmp}/repo -- --depth 1
+Tool 2: grep_app_searchGitHub(query: "function_name", repo: "owner/repo")
+Tool 3: gh api repos/owner/repo/commits/HEAD --jq '.sha'
+Tool 4: context7_get-library-docs(id, topic: "relevant-api")
 \`\`\`
 
-### 8. LSP Tools - DEFINITIONS & REFERENCES
-Use LSP for finding definitions and references - these are its unique strengths over text search.
+---
 
-**Primary LSP Tools**:
-- \`lsp_goto_definition\`: Jump to where a symbol is **defined** (resolves imports, type aliases, etc.)
-  - \`lsp_goto_definition(filePath: "/tmp/repo/src/file.ts", line: 42, character: 10)\`
-- \`lsp_find_references\`: Find **ALL usages** of a symbol across the entire workspace
-  - \`lsp_find_references(filePath: "/tmp/repo/src/file.ts", line: 42, character: 10)\`
+### TYPE C: CONTEXT & HISTORY
+**Trigger**: "Why was this changed?", "What's the history?", "Related issues/PRs?"
 
-**When to Use LSP** (vs Grep/AST-grep):
-- **lsp_goto_definition**: When you need to follow an import or find the source definition
-- **lsp_find_references**: When you need to understand impact of changes (who calls this function?)
-
-**Why LSP for these**:
-- Grep finds text matches but can't resolve imports or type aliases
-- AST-grep finds structural patterns but can't follow cross-file references
-- LSP understands the full type system and can trace through imports
-
-**Parallel Execution**:
+**Execute in parallel (4+ calls)**:
 \`\`\`
-// When tracing code flow, launch in parallel:
-- Tool 1: lsp_goto_definition(filePath, line, char) - Find where it's defined
-- Tool 2: lsp_find_references(filePath, line, char) - Find all usages
-- Tool 3: ast_grep_search(...) - Find similar patterns
-- Tool 4: grep(...) - Text fallback
+Tool 1: gh search issues "keyword" --repo owner/repo --state all --limit 10
+Tool 2: gh search prs "keyword" --repo owner/repo --state merged --limit 10
+Tool 3: gh repo clone owner/repo \${TMPDIR:-/tmp}/repo -- --depth 50
+        → then: git log --oneline -n 20 -- path/to/file
+        → then: git blame -L 10,30 path/to/file
+Tool 4: gh api repos/owner/repo/releases --jq '.[0:5]'
 \`\`\`
 
-### 9. AST-grep - AST-AWARE PATTERN SEARCH
-Use AST-grep for structural code search that understands syntax, not just text.
-
-**Key Features**:
-- Supports 25+ languages (typescript, javascript, python, rust, go, etc.)
-- Uses meta-variables: \`$VAR\` (single node), \`$$$\` (multiple nodes)
-- Patterns must be complete AST nodes (valid code)
-
-**ast_grep_search Examples**:
+**For specific issue/PR context**:
 \`\`\`
-// Find all console.log calls
-ast_grep_search(pattern: "console.log($MSG)", lang: "typescript")
-
-// Find all async functions
-ast_grep_search(pattern: "async function $NAME($$$) { $$$ }", lang: "typescript")
-
-// Find React useState hooks
-ast_grep_search(pattern: "const [$STATE, $SETTER] = useState($$$)", lang: "tsx")
-
-// Find Python class definitions
-ast_grep_search(pattern: "class $NAME($$$)", lang: "python")
-
-// Find all export statements
-ast_grep_search(pattern: "export { $$$ }", lang: "typescript")
-
-// Find function calls with specific argument patterns
-ast_grep_search(pattern: "fetch($URL, { method: $METHOD })", lang: "typescript")
+gh issue view <number> --repo owner/repo --comments
+gh pr view <number> --repo owner/repo --comments
+gh api repos/owner/repo/pulls/<number>/files
 \`\`\`
 
-**When to Use AST-grep vs Grep**:
-- **AST-grep**: When you need structural matching (e.g., "find all function definitions")
-- **grep**: When you need text matching (e.g., "find all occurrences of 'TODO'")
+---
 
-**Parallel AST-grep Execution**:
+### TYPE D: COMPREHENSIVE RESEARCH
+**Trigger**: Complex questions, ambiguous requests, "deep dive into..."
+
+**Execute ALL in parallel (6+ calls)**:
 \`\`\`
-// When analyzing a codebase pattern, launch in parallel:
-- Tool 1: ast_grep_search(pattern: "useQuery($$$)", lang: "tsx") - Find hook usage
-- Tool 2: ast_grep_search(pattern: "export function $NAME($$$)", lang: "typescript") - Find exports
-- Tool 3: grep("useQuery") - Text fallback
-- Tool 4: glob("**/*query*.ts") - Find query-related files
+// Documentation & Web
+Tool 1: context7_resolve-library-id → context7_get-library-docs
+Tool 2: websearch_exa_web_search_exa("topic recent updates")
+
+// Code Search
+Tool 3: grep_app_searchGitHub(query: "pattern1", language: [...])
+Tool 4: grep_app_searchGitHub(query: "pattern2", useRegexp: true)
+
+// Source Analysis
+Tool 5: gh repo clone owner/repo \${TMPDIR:-/tmp}/repo -- --depth 1
+
+// Context
+Tool 6: gh search issues "topic" --repo owner/repo
 \`\`\`
 
-## SEARCH STRATEGY PROTOCOL
+---
 
-When given a request, follow this **STRICT** workflow:
+## PHASE 2: EVIDENCE SYNTHESIS
 
-1.  **ANALYZE CONTEXT**:
-    - If the user references a local file, read it first to understand imports and dependencies.
-    - Identify the specific library or technology version.
+### MANDATORY CITATION FORMAT
 
-2.  **PARALLEL INVESTIGATION** (Launch 5+ tools simultaneously):
-    - \`context7\`: Get official documentation
-    - \`gh search code\`: Find implementation examples
-    - \`websearch_exa_web_search_exa\`: Get latest updates and discussions
-    - \`gh repo clone\`: Clone to /tmp for deep analysis
-    - \`glob\` / \`grep\` / \`ast_grep_search\`: Search local codebase
-    - \`gh api\`: Get release/version information
-
-3.  **DEEP SOURCE ANALYSIS**:
-    - Navigate to the cloned repo in /tmp
-    - Find the specific file implementing the feature
-    - Use \`git blame\` to understand why code is written that way
-    - Get the commit SHA for permalink construction
-
-4.  **SYNTHESIZE WITH EVIDENCE**:
-    - Present findings with **GitHub permalinks**
-    - **FORMAT**:
-      - **CLAIM**: What you're asserting about the code
-      - **EVIDENCE**: The specific code that proves it
-      - **PERMALINK**: \`https://github.com/owner/repo/blob/<sha>/path#L10-L20\`
-      - **EXPLANATION**: Why this code behaves this way
-
-## CITATION FORMAT - MANDATORY
-
-Every code-related claim MUST include:
+Every claim MUST include a permalink:
 
 \`\`\`markdown
 **Claim**: [What you're asserting]
 
-**Evidence** ([permalink](https://github.com/owner/repo/blob/abc123/src/file.ts#L42-L50)):
+**Evidence** ([source](https://github.com/owner/repo/blob/<sha>/path#L10-L20)):
 \\\`\\\`\\\`typescript
-// The actual code from lines 42-50
-function example() {
-  // ...
-}
+// The actual code
+function example() { ... }
 \\\`\\\`\\\`
 
-**Explanation**: This code shows that [reason] because [specific detail from the code].
+**Explanation**: This works because [specific reason from the code].
 \`\`\`
 
+### PERMALINK CONSTRUCTION
+
+\`\`\`
+https://github.com/<owner>/<repo>/blob/<commit-sha>/<filepath>#L<start>-L<end>
+
+Example:
+https://github.com/tanstack/query/blob/abc123def/packages/react-query/src/useQuery.ts#L42-L50
+\`\`\`
+
+**Getting SHA**:
+- From clone: \`git rev-parse HEAD\`
+- From API: \`gh api repos/owner/repo/commits/HEAD --jq '.sha'\`
+- From tag: \`gh api repos/owner/repo/git/refs/tags/v1.0.0 --jq '.object.sha'\`
+
+---
+
+## TOOL REFERENCE
+
+### Primary Tools by Purpose
+
+| Purpose | Tool | Command/Usage |
+|---------|------|---------------|
+| **Official Docs** | context7 | \`context7_resolve-library-id\` → \`context7_get-library-docs\` |
+| **Latest Info** | websearch_exa | \`websearch_exa_web_search_exa("query 2025")\` |
+| **Fast Code Search** | grep_app | \`grep_app_searchGitHub(query, language, useRegexp)\` |
+| **Deep Code Search** | gh CLI | \`gh search code "query" --repo owner/repo\` |
+| **Clone Repo** | gh CLI | \`gh repo clone owner/repo \${TMPDIR:-/tmp}/name -- --depth 1\` |
+| **Issues/PRs** | gh CLI | \`gh search issues/prs "query" --repo owner/repo\` |
+| **View Issue/PR** | gh CLI | \`gh issue/pr view <num> --repo owner/repo --comments\` |
+| **Release Info** | gh CLI | \`gh api repos/owner/repo/releases/latest\` |
+| **Git History** | git | \`git log\`, \`git blame\`, \`git show\` |
+| **Read URL** | webfetch | \`webfetch(url)\` for blog posts, SO threads |
+
+### Temp Directory
+
+Use OS-appropriate temp directory:
+\`\`\`bash
+# Cross-platform
+\${TMPDIR:-/tmp}/repo-name
+
+# Examples:
+# macOS: /var/folders/.../repo-name or /tmp/repo-name
+# Linux: /tmp/repo-name
+# Windows: C:\\Users\\...\\AppData\\Local\\Temp\\repo-name
+\`\`\`
+
+---
+
+## PARALLEL EXECUTION REQUIREMENTS
+
+| Request Type | Minimum Parallel Calls |
+|--------------|----------------------|
+| TYPE A (Conceptual) | 3+ |
+| TYPE B (Implementation) | 4+ |
+| TYPE C (Context) | 4+ |
+| TYPE D (Comprehensive) | 6+ |
+
+**Always vary queries** when using grep_app:
+\`\`\`
+// GOOD: Different angles
+grep_app_searchGitHub(query: "useQuery(", language: ["TypeScript"])
+grep_app_searchGitHub(query: "queryOptions", language: ["TypeScript"])
+grep_app_searchGitHub(query: "staleTime:", language: ["TypeScript"])
+
+// BAD: Same pattern
+grep_app_searchGitHub(query: "useQuery")
+grep_app_searchGitHub(query: "useQuery")
+\`\`\`
+
+---
+
 ## FAILURE RECOVERY
 
-- If \`context7\` fails to find docs, clone the repo to \`/tmp\` and read the source directly.
-- If code search yields nothing, search for the *concept* rather than the specific function name.
-- If GitHub API has rate limits, use cloned repos in \`/tmp\` for analysis.
-- If unsure, **STATE YOUR UNCERTAINTY** and propose a hypothesis based on standard conventions.
+| Failure | Recovery Action |
+|---------|-----------------|
+| context7 not found | Clone repo, read source + README directly |
+| grep_app no results | Broaden query, try concept instead of exact name |
+| gh API rate limit | Use cloned repo in temp directory |
+| Repo not found | Search for forks or mirrors |
+| Uncertain | **STATE YOUR UNCERTAINTY**, propose hypothesis |
 
-## VOICE AND TONE
+---
 
-- **PROFESSIONAL**: You are an expert archivist. Be concise and precise.
-- **OBJECTIVE**: Present facts found in the search. Do not offer personal opinions unless asked.
-- **EVIDENCE-DRIVEN**: Always back claims with permalinks and code snippets.
-- **HELPFUL**: If a direct answer isn't found, provide the closest relevant examples or related documentation.
+## COMMUNICATION RULES
 
-## MULTI-REPOSITORY ANALYSIS GUIDELINES
+1. **NO TOOL NAMES**: Say "I'll search the codebase" not "I'll use grep_app"
+2. **NO PREAMBLE**: Answer directly, skip "I'll help you with..." 
+3. **ALWAYS CITE**: Every code claim needs a permalink
+4. **USE MARKDOWN**: Code blocks with language identifiers
+5. **BE CONCISE**: Facts > opinions, evidence > speculation
 
-- Clone multiple repos to /tmp for cross-repository analysis
-- Execute AT LEAST 5 tools in parallel when possible for efficiency
-- Read files thoroughly to understand implementation details
-- Search for patterns and related code across multiple repositories
-- Use commit search to understand how code evolved over time
-- Focus on thorough understanding and comprehensive explanation across repositories
-- Create mermaid diagrams to visualize complex relationships or flows
-- Always provide permalinks for cross-repository references
-
-## COMMUNICATION
-
-You must use Markdown for formatting your responses.
-
-IMPORTANT: When including code blocks, you MUST ALWAYS specify the language for syntax highlighting. Always add the language identifier after the opening backticks.
-
-**REMEMBER**: Your job is not just to find and summarize documentation. You must provide **EVIDENCE** showing exactly **WHY** the code works the way it does, with **permalinks** to the specific implementation so users can verify your claims.`,
+`,
 }

src/agents/multimodal-looker.ts

@@ -6,7 +6,7 @@ export const multimodalLookerAgent: AgentConfig = {
   mode: "subagent",
   model: "google/gemini-2.5-flash",
   temperature: 0.1,
-  tools: { Read: true },
+  tools: { Read: true, background_task: false },
   prompt: `You interpret media files that cannot be read as plain text.
 
 Your job: examine the attached file and extract ONLY what was requested.

src/agents/oracle.ts

@@ -8,7 +8,7 @@ export const oracleAgent: AgentConfig = {
   temperature: 0.1,
   reasoningEffort: "medium",
   textVerbosity: "high",
-  tools: { write: false, edit: false, read: true, call_omo_agent: true },
+  tools: { write: false, edit: false, read: true, task: false, call_omo_agent: true, background_task: false },
   prompt: `You are a strategic technical advisor with deep reasoning capabilities, operating as a specialized consultant within an AI-assisted development environment.
 
 ## Context

src/agents/utils.ts

@@ -19,6 +19,39 @@ const allBuiltinAgents: Record<BuiltinAgentName, AgentConfig> = {
   "multimodal-looker": multimodalLookerAgent,
 }
 
+export function createEnvContext(directory: string): string {
+  const now = new Date()
+  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone
+  const locale = Intl.DateTimeFormat().resolvedOptions().locale
+
+  const dateStr = now.toLocaleDateString("en-US", {
+    weekday: "short",
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+  })
+
+  const timeStr = now.toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: true,
+  })
+
+  const platform = process.platform as "darwin" | "linux" | "win32" | string
+
+  return `
+Here is some useful information about the environment you are running in:
+<env>
+  Working directory: ${directory}
+  Platform: ${platform}
+  Today's date: ${dateStr} (NOT 2024, NEVEREVER 2024)
+  Current time: ${timeStr}
+  Timezone: ${timezone}
+  Locale: ${locale}
+</env>`
+}
+
 function mergeAgentConfig(
   base: AgentConfig,
   override: AgentOverrideConfig
@@ -28,7 +61,8 @@ function mergeAgentConfig(
 
 export function createBuiltinAgents(
   disabledAgents: BuiltinAgentName[] = [],
-  agentOverrides: AgentOverrides = {}
+  agentOverrides: AgentOverrides = {},
+  directory?: string
 ): Record<string, AgentConfig> {
   const result: Record<string, AgentConfig> = {}
 
@@ -39,11 +73,21 @@ export function createBuiltinAgents(
       continue
     }
 
+    let finalConfig = config
+
+    if ((agentName === "OmO" || agentName === "librarian") && directory && config.prompt) {
+      const envContext = createEnvContext(directory)
+      finalConfig = {
+        ...config,
+        prompt: config.prompt + envContext,
+      }
+    }
+
     const override = agentOverrides[agentName]
     if (override) {
-      result[name] = mergeAgentConfig(config, override)
+      result[name] = mergeAgentConfig(finalConfig, override)
     } else {
-      result[name] = config
+      result[name] = finalConfig
     }
   }
 

src/config/schema.ts

@@ -17,6 +17,7 @@ const AgentPermissionSchema = z.object({
 })
 
 export const BuiltinAgentNameSchema = z.enum([
+  "OmO",
   "oracle",
   "librarian",
   "explore",
@@ -27,6 +28,9 @@ export const BuiltinAgentNameSchema = z.enum([
 
 export const OverridableAgentNameSchema = z.enum([
   "build",
+  "plan",
+  "OmO",
+  "OmO-Plan",
   "oracle",
   "librarian",
   "explore",
@@ -56,6 +60,8 @@ export const HookNameSchema = z.enum([
   "startup-toast",
   "keyword-detector",
   "agent-usage-reminder",
+  "non-interactive-env",
+  "interactive-bash-session",
 ])
 
 export const AgentOverrideConfigSchema = z.object({
@@ -76,6 +82,9 @@ export const AgentOverrideConfigSchema = z.object({
 
 export const AgentOverridesSchema = z.object({
   build: AgentOverrideConfigSchema.optional(),
+  plan: AgentOverrideConfigSchema.optional(),
+  OmO: AgentOverrideConfigSchema.optional(),
+  "OmO-Plan": AgentOverrideConfigSchema.optional(),
   oracle: AgentOverrideConfigSchema.optional(),
   librarian: AgentOverrideConfigSchema.optional(),
   explore: AgentOverrideConfigSchema.optional(),
@@ -93,7 +102,7 @@ export const ClaudeCodeConfigSchema = z.object({
 })
 
 export const OmoAgentConfigSchema = z.object({
-  disable_build: z.boolean().optional(),
+  disabled: z.boolean().optional(),
 })
 
 export const OhMyOpenCodeConfigSchema = z.object({

src/features/background-agent/manager.ts

@@ -1,9 +1,15 @@
+import { existsSync, readdirSync } from "node:fs"
+import { join } from "node:path"
 import type { PluginInput } from "@opencode-ai/plugin"
 import type {
   BackgroundTask,
   LaunchInput,
 } from "./types"
 import { log } from "../../shared/logger"
+import {
+  findNearestMessageWithFields,
+  MESSAGE_STORAGE,
+} from "../hook-message-injector"
 
 type OpencodeClient = PluginInput["client"]
 
@@ -24,6 +30,20 @@ interface Event {
   properties?: EventProperties
 }
 
+function getMessageDir(sessionID: string): string | null {
+  if (!existsSync(MESSAGE_STORAGE)) return null
+
+  const directPath = join(MESSAGE_STORAGE, sessionID)
+  if (existsSync(directPath)) return directPath
+
+  for (const dir of readdirSync(MESSAGE_STORAGE)) {
+    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
+    if (existsSync(sessionPath)) return sessionPath
+  }
+
+  return null
+}
+
 export class BackgroundManager {
   private tasks: Map<string, BackgroundTask>
   private notifications: Map<string, BackgroundTask[]>
@@ -253,9 +273,13 @@ export class BackgroundManager {
 
     setTimeout(async () => {
       try {
+        const messageDir = getMessageDir(task.parentSessionID)
+        const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null
+
         await this.client.session.prompt({
           path: { id: task.parentSessionID },
           body: {
+            agent: prevMessage?.agent,
             parts: [{ type: "text", text: message }],
           },
           query: { directory: this.directory },

src/features/hook-message-injector/index.ts

@@ -1,2 +1,4 @@
-export { injectHookMessage } from "./injector"
+export { injectHookMessage, findNearestMessageWithFields } from "./injector"
+export type { StoredMessage } from "./injector"
 export type { MessageMeta, OriginalMessageContext, TextPart } from "./types"
+export { MESSAGE_STORAGE } from "./constants"

src/features/hook-message-injector/injector.ts

@@ -3,13 +3,13 @@ import { join } from "node:path"
 import { MESSAGE_STORAGE, PART_STORAGE } from "./constants"
 import type { MessageMeta, OriginalMessageContext, TextPart } from "./types"
 
-interface StoredMessage {
+export interface StoredMessage {
   agent?: string
   model?: { providerID?: string; modelID?: string }
   tools?: Record<string, boolean>
 }
 
-function findNearestMessageWithFields(messageDir: string): StoredMessage | null {
+export function findNearestMessageWithFields(messageDir: string): StoredMessage | null {
   try {
     const files = readdirSync(messageDir)
       .filter((f) => f.endsWith(".json"))

src/hooks/auto-update-checker/checker.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs"
 import * as path from "node:path"
+import { fileURLToPath } from "node:url"
 import type { NpmDistTags, OpencodeConfig, PackageJson, UpdateCheckResult } from "./types"
 import {
   PACKAGE_NAME,
@@ -7,6 +8,7 @@ import {
   NPM_FETCH_TIMEOUT,
   INSTALLED_PACKAGE_JSON,
   USER_OPENCODE_CONFIG,
+  USER_OPENCODE_CONFIG_JSONC,
 } from "./constants"
 import { log } from "../../shared/logger"
 
@@ -14,19 +16,36 @@ export function isLocalDevMode(directory: string): boolean {
   return getLocalDevPath(directory) !== null
 }
 
-export function getLocalDevPath(directory: string): string | null {
-  const projectConfig = path.join(directory, ".opencode", "opencode.json")
+function stripJsonComments(json: string): string {
+  return json
+    .replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => (g ? "" : m))
+    .replace(/,(\s*[}\]])/g, "$1")
+}
 
-  for (const configPath of [projectConfig, USER_OPENCODE_CONFIG]) {
+function getConfigPaths(directory: string): string[] {
+  return [
+    path.join(directory, ".opencode", "opencode.json"),
+    path.join(directory, ".opencode", "opencode.jsonc"),
+    USER_OPENCODE_CONFIG,
+    USER_OPENCODE_CONFIG_JSONC,
+  ]
+}
+
+export function getLocalDevPath(directory: string): string | null {
+  for (const configPath of getConfigPaths(directory)) {
     try {
       if (!fs.existsSync(configPath)) continue
       const content = fs.readFileSync(configPath, "utf-8")
-      const config = JSON.parse(content) as OpencodeConfig
+      const config = JSON.parse(stripJsonComments(content)) as OpencodeConfig
       const plugins = config.plugin ?? []
 
       for (const entry of plugins) {
         if (entry.startsWith("file://") && entry.includes(PACKAGE_NAME)) {
-          return entry.replace("file://", "")
+          try {
+            return fileURLToPath(entry)
+          } catch {
+            return entry.replace("file://", "")
+          }
         }
       }
     } catch {
@@ -37,13 +56,35 @@ export function getLocalDevPath(directory: string): string | null {
   return null
 }
 
+function findPackageJsonUp(startPath: string): string | null {
+  try {
+    const stat = fs.statSync(startPath)
+    let dir = stat.isDirectory() ? startPath : path.dirname(startPath)
+    
+    for (let i = 0; i < 10; i++) {
+      const pkgPath = path.join(dir, "package.json")
+      if (fs.existsSync(pkgPath)) {
+        try {
+          const content = fs.readFileSync(pkgPath, "utf-8")
+          const pkg = JSON.parse(content) as PackageJson
+          if (pkg.name === PACKAGE_NAME) return pkgPath
+        } catch {}
+      }
+      const parent = path.dirname(dir)
+      if (parent === dir) break
+      dir = parent
+    }
+  } catch {}
+  return null
+}
+
 export function getLocalDevVersion(directory: string): string | null {
   const localPath = getLocalDevPath(directory)
   if (!localPath) return null
 
   try {
-    const pkgPath = path.join(localPath, "package.json")
-    if (!fs.existsSync(pkgPath)) return null
+    const pkgPath = findPackageJsonUp(localPath)
+    if (!pkgPath) return null
     const content = fs.readFileSync(pkgPath, "utf-8")
     const pkg = JSON.parse(content) as PackageJson
     return pkg.version ?? null
@@ -59,13 +100,11 @@ export interface PluginEntryInfo {
 }
 
 export function findPluginEntry(directory: string): PluginEntryInfo | null {
-  const projectConfig = path.join(directory, ".opencode", "opencode.json")
-
-  for (const configPath of [projectConfig, USER_OPENCODE_CONFIG]) {
+  for (const configPath of getConfigPaths(directory)) {
     try {
       if (!fs.existsSync(configPath)) continue
       const content = fs.readFileSync(configPath, "utf-8")
-      const config = JSON.parse(content) as OpencodeConfig
+      const config = JSON.parse(stripJsonComments(content)) as OpencodeConfig
       const plugins = config.plugin ?? []
 
       for (const entry of plugins) {
@@ -96,13 +135,16 @@ export function getCachedVersion(): string | null {
   } catch {}
 
   try {
-    const pkgPath = path.resolve(import.meta.dirname, "..", "..", "..", "package.json")
-    if (fs.existsSync(pkgPath)) {
+    const currentDir = path.dirname(fileURLToPath(import.meta.url))
+    const pkgPath = findPackageJsonUp(currentDir)
+    if (pkgPath) {
       const content = fs.readFileSync(pkgPath, "utf-8")
       const pkg = JSON.parse(content) as PackageJson
       if (pkg.version) return pkg.version
     }
-  } catch {}
+  } catch (err) {
+    log("[auto-update-checker] Failed to resolve version from current directory:", err)
+  }
 
   return null
 }
@@ -140,7 +182,6 @@ export async function checkForUpdate(directory: string): Promise<UpdateCheckResu
     return { needsUpdate: false, currentVersion: null, latestVersion: null, isLocalDev: false, isPinned: false }
   }
 
-  // Respect version pinning
   if (pluginInfo.isPinned) {
     log(`[auto-update-checker] Version pinned to ${pluginInfo.pinnedVersion}, skipping update check`)
     return { needsUpdate: false, currentVersion: pluginInfo.pinnedVersion, latestVersion: null, isLocalDev: false, isPinned: true }
@@ -160,6 +201,5 @@ export async function checkForUpdate(directory: string): Promise<UpdateCheckResu
 
   const needsUpdate = currentVersion !== latestVersion
   log(`[auto-update-checker] Current: ${currentVersion}, Latest: ${latestVersion}, NeedsUpdate: ${needsUpdate}`)
-
   return { needsUpdate, currentVersion, latestVersion, isLocalDev: false, isPinned: false }
 }

src/hooks/auto-update-checker/constants.ts

@@ -38,3 +38,4 @@ function getUserConfigDir(): string {
 
 export const USER_CONFIG_DIR = getUserConfigDir()
 export const USER_OPENCODE_CONFIG = path.join(USER_CONFIG_DIR, "opencode", "opencode.json")
+export const USER_OPENCODE_CONFIG_JSONC = path.join(USER_CONFIG_DIR, "opencode", "opencode.jsonc")

src/hooks/grep-output-truncator.ts

@@ -75,7 +75,7 @@ function truncateToTokenLimit(output: string, maxTokens: number): { result: stri
 }
 
 export function createGrepOutputTruncatorHook(ctx: PluginInput) {
-  const GREP_TOOLS = ["safe_grep", "Grep"]
+  const GREP_TOOLS = ["grep", "Grep", "safe_grep"]
 
   const toolExecuteAfter = async (
     input: { tool: string; sessionID: string; callID: string },

src/hooks/index.ts

@@ -17,3 +17,5 @@ export { createAutoUpdateCheckerHook } from "./auto-update-checker";
 
 export { createAgentUsageReminderHook } from "./agent-usage-reminder";
 export { createKeywordDetectorHook } from "./keyword-detector";
+export { createNonInteractiveEnvHook } from "./non-interactive-env";
+export { createInteractiveBashSessionHook } from "./interactive-bash-session";

src/hooks/interactive-bash-session/constants.ts

@@ -0,0 +1,15 @@
+import { join } from "node:path";
+import { xdgData } from "xdg-basedir";
+
+export const OPENCODE_STORAGE = join(xdgData ?? "", "opencode", "storage");
+export const INTERACTIVE_BASH_SESSION_STORAGE = join(
+  OPENCODE_STORAGE,
+  "interactive-bash-session",
+);
+
+export const OMO_SESSION_PREFIX = "omo-";
+
+export function buildSessionReminderMessage(sessions: string[]): string {
+  if (sessions.length === 0) return "";
+  return `\n\n[System Reminder] Active omo-* tmux sessions: ${sessions.join(", ")}`;
+}

src/hooks/interactive-bash-session/index.ts

@@ -0,0 +1,262 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import {
+  loadInteractiveBashSessionState,
+  saveInteractiveBashSessionState,
+  clearInteractiveBashSessionState,
+} from "./storage";
+import { OMO_SESSION_PREFIX, buildSessionReminderMessage } from "./constants";
+import type { InteractiveBashSessionState } from "./types";
+
+interface ToolExecuteInput {
+  tool: string;
+  sessionID: string;
+  callID: string;
+  args?: Record<string, unknown>;
+}
+
+interface ToolExecuteOutput {
+  title: string;
+  output: string;
+  metadata: unknown;
+}
+
+interface EventInput {
+  event: {
+    type: string;
+    properties?: unknown;
+  };
+}
+
+/**
+ * Quote-aware command tokenizer with escape handling
+ * Handles single/double quotes and backslash escapes
+ */
+function tokenizeCommand(cmd: string): string[] {
+  const tokens: string[] = []
+  let current = ""
+  let inQuote = false
+  let quoteChar = ""
+  let escaped = false
+
+  for (let i = 0; i < cmd.length; i++) {
+    const char = cmd[i]
+
+    if (escaped) {
+      current += char
+      escaped = false
+      continue
+    }
+
+    if (char === "\\") {
+      escaped = true
+      continue
+    }
+
+    if ((char === "'" || char === '"') && !inQuote) {
+      inQuote = true
+      quoteChar = char
+    } else if (char === quoteChar && inQuote) {
+      inQuote = false
+      quoteChar = ""
+    } else if (char === " " && !inQuote) {
+      if (current) {
+        tokens.push(current)
+        current = ""
+      }
+    } else {
+      current += char
+    }
+  }
+
+  if (current) tokens.push(current)
+  return tokens
+}
+
+/**
+ * Normalize session name by stripping :window and .pane suffixes
+ * e.g., "omo-x:1" -> "omo-x", "omo-x:1.2" -> "omo-x"
+ */
+function normalizeSessionName(name: string): string {
+  return name.split(":")[0].split(".")[0]
+}
+
+function findFlagValue(tokens: string[], flag: string): string | null {
+  for (let i = 0; i < tokens.length - 1; i++) {
+    if (tokens[i] === flag) return tokens[i + 1]
+  }
+  return null
+}
+
+/**
+ * Extract session name from tokens, considering the subCommand
+ * For new-session: prioritize -s over -t
+ * For other commands: use -t
+ */
+function extractSessionNameFromTokens(tokens: string[], subCommand: string): string | null {
+  if (subCommand === "new-session") {
+    const sFlag = findFlagValue(tokens, "-s")
+    if (sFlag) return normalizeSessionName(sFlag)
+    const tFlag = findFlagValue(tokens, "-t")
+    if (tFlag) return normalizeSessionName(tFlag)
+  } else {
+    const tFlag = findFlagValue(tokens, "-t")
+    if (tFlag) return normalizeSessionName(tFlag)
+  }
+  return null
+}
+
+/**
+ * Find the tmux subcommand from tokens, skipping global options.
+ * tmux allows global options before the subcommand:
+ * e.g., `tmux -L socket-name new-session -s omo-x`
+ * Global options with args: -L, -S, -f, -c, -T
+ * Standalone flags: -C, -v, -V, etc.
+ * Special: -- (end of options marker)
+ */
+function findSubcommand(tokens: string[]): string {
+  // Options that require an argument: -L, -S, -f, -c, -T
+  const globalOptionsWithArgs = new Set(["-L", "-S", "-f", "-c", "-T"])
+
+  let i = 0
+  while (i < tokens.length) {
+    const token = tokens[i]
+
+    // Handle end of options marker
+    if (token === "--") {
+      // Next token is the subcommand
+      return tokens[i + 1] ?? ""
+    }
+
+    if (globalOptionsWithArgs.has(token)) {
+      // Skip the option and its argument
+      i += 2
+      continue
+    }
+
+    if (token.startsWith("-")) {
+      // Skip standalone flags like -C, -v, -V
+      i++
+      continue
+    }
+
+    // Found the subcommand
+    return token
+  }
+
+  return ""
+}
+
+export function createInteractiveBashSessionHook(_ctx: PluginInput) {
+  const sessionStates = new Map<string, InteractiveBashSessionState>();
+
+  function getOrCreateState(sessionID: string): InteractiveBashSessionState {
+    if (!sessionStates.has(sessionID)) {
+      const persisted = loadInteractiveBashSessionState(sessionID);
+      const state: InteractiveBashSessionState = persisted ?? {
+        sessionID,
+        tmuxSessions: new Set<string>(),
+        updatedAt: Date.now(),
+      };
+      sessionStates.set(sessionID, state);
+    }
+    return sessionStates.get(sessionID)!;
+  }
+
+  function isOmoSession(sessionName: string | null): boolean {
+    return sessionName !== null && sessionName.startsWith(OMO_SESSION_PREFIX);
+  }
+
+  async function killAllTrackedSessions(
+    state: InteractiveBashSessionState,
+  ): Promise<void> {
+    for (const sessionName of state.tmuxSessions) {
+      try {
+        const proc = Bun.spawn(["tmux", "kill-session", "-t", sessionName], {
+          stdout: "ignore",
+          stderr: "ignore",
+        });
+        await proc.exited;
+      } catch {}
+    }
+  }
+
+  const toolExecuteAfter = async (
+    input: ToolExecuteInput,
+    output: ToolExecuteOutput,
+  ) => {
+    const { tool, sessionID, args } = input;
+    const toolLower = tool.toLowerCase();
+
+    if (toolLower !== "interactive_bash") {
+      return;
+    }
+
+    if (typeof args?.tmux_command !== "string") {
+      return;
+    }
+
+    const tmuxCommand = args.tmux_command;
+    const tokens = tokenizeCommand(tmuxCommand);
+    const subCommand = findSubcommand(tokens);
+    const state = getOrCreateState(sessionID);
+    let stateChanged = false;
+
+    const toolOutput = output?.output ?? ""
+    if (toolOutput.startsWith("Error:")) {
+      return
+    }
+
+    const isNewSession = subCommand === "new-session";
+    const isKillSession = subCommand === "kill-session";
+    const isKillServer = subCommand === "kill-server";
+
+    const sessionName = extractSessionNameFromTokens(tokens, subCommand);
+
+    if (isNewSession && isOmoSession(sessionName)) {
+      state.tmuxSessions.add(sessionName!);
+      stateChanged = true;
+    } else if (isKillSession && isOmoSession(sessionName)) {
+      state.tmuxSessions.delete(sessionName!);
+      stateChanged = true;
+    } else if (isKillServer) {
+      state.tmuxSessions.clear();
+      stateChanged = true;
+    }
+
+    if (stateChanged) {
+      state.updatedAt = Date.now();
+      saveInteractiveBashSessionState(state);
+    }
+
+    const isSessionOperation = isNewSession || isKillSession || isKillServer;
+    if (isSessionOperation) {
+      const reminder = buildSessionReminderMessage(
+        Array.from(state.tmuxSessions),
+      );
+      if (reminder) {
+        output.output += reminder;
+      }
+    }
+  };
+
+  const eventHandler = async ({ event }: EventInput) => {
+    const props = event.properties as Record<string, unknown> | undefined;
+
+    if (event.type === "session.deleted") {
+      const sessionInfo = props?.info as { id?: string } | undefined;
+      const sessionID = sessionInfo?.id;
+
+      if (sessionID) {
+        const state = getOrCreateState(sessionID);
+        await killAllTrackedSessions(state);
+        sessionStates.delete(sessionID);
+        clearInteractiveBashSessionState(sessionID);
+      }
+    }
+  };
+
+  return {
+    "tool.execute.after": toolExecuteAfter,
+    event: eventHandler,
+  };
+}

src/hooks/interactive-bash-session/storage.ts

@@ -0,0 +1,59 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  unlinkSync,
+} from "node:fs";
+import { join } from "node:path";
+import { INTERACTIVE_BASH_SESSION_STORAGE } from "./constants";
+import type {
+  InteractiveBashSessionState,
+  SerializedInteractiveBashSessionState,
+} from "./types";
+
+function getStoragePath(sessionID: string): string {
+  return join(INTERACTIVE_BASH_SESSION_STORAGE, `${sessionID}.json`);
+}
+
+export function loadInteractiveBashSessionState(
+  sessionID: string,
+): InteractiveBashSessionState | null {
+  const filePath = getStoragePath(sessionID);
+  if (!existsSync(filePath)) return null;
+
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const serialized = JSON.parse(content) as SerializedInteractiveBashSessionState;
+    return {
+      sessionID: serialized.sessionID,
+      tmuxSessions: new Set(serialized.tmuxSessions),
+      updatedAt: serialized.updatedAt,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function saveInteractiveBashSessionState(
+  state: InteractiveBashSessionState,
+): void {
+  if (!existsSync(INTERACTIVE_BASH_SESSION_STORAGE)) {
+    mkdirSync(INTERACTIVE_BASH_SESSION_STORAGE, { recursive: true });
+  }
+
+  const filePath = getStoragePath(state.sessionID);
+  const serialized: SerializedInteractiveBashSessionState = {
+    sessionID: state.sessionID,
+    tmuxSessions: Array.from(state.tmuxSessions),
+    updatedAt: state.updatedAt,
+  };
+  writeFileSync(filePath, JSON.stringify(serialized, null, 2));
+}
+
+export function clearInteractiveBashSessionState(sessionID: string): void {
+  const filePath = getStoragePath(sessionID);
+  if (existsSync(filePath)) {
+    unlinkSync(filePath);
+  }
+}

src/hooks/interactive-bash-session/types.ts

@@ -0,0 +1,11 @@
+export interface InteractiveBashSessionState {
+  sessionID: string;
+  tmuxSessions: Set<string>;
+  updatedAt: number;
+}
+
+export interface SerializedInteractiveBashSessionState {
+  sessionID: string;
+  tmuxSessions: string[];
+  updatedAt: number;
+}

src/hooks/keyword-detector/constants.ts

@@ -28,7 +28,7 @@ TELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.
 ## 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
+3. Always Use Plan agent with gathered context to create detailed work breakdown
 4. Execute with continuous verification against original requirements
 
 </ultrawork-mode>

src/hooks/non-interactive-env/constants.ts

@@ -0,0 +1,9 @@
+export const HOOK_NAME = "non-interactive-env"
+
+export const NON_INTERACTIVE_ENV: Record<string, string> = {
+  CI: "true",
+  DEBIAN_FRONTEND: "noninteractive",
+  GIT_TERMINAL_PROMPT: "0",
+  GCM_INTERACTIVE: "never",
+  HOMEBREW_NO_AUTO_UPDATE: "1",
+}

src/hooks/non-interactive-env/index.ts

@@ -0,0 +1,34 @@
+import type { PluginInput } from "@opencode-ai/plugin"
+import { HOOK_NAME, NON_INTERACTIVE_ENV } from "./constants"
+import { log } from "../../shared"
+
+export * from "./constants"
+export * from "./types"
+
+export function createNonInteractiveEnvHook(_ctx: PluginInput) {
+  return {
+    "tool.execute.before": async (
+      input: { tool: string; sessionID: string; callID: string },
+      output: { args: Record<string, unknown> }
+    ): Promise<void> => {
+      if (input.tool.toLowerCase() !== "bash") {
+        return
+      }
+
+      const command = output.args.command as string | undefined
+      if (!command) {
+        return
+      }
+
+      output.args.env = {
+        ...(output.args.env as Record<string, string> | undefined),
+        ...NON_INTERACTIVE_ENV,
+      }
+
+      log(`[${HOOK_NAME}] Set non-interactive environment variables`, {
+        sessionID: input.sessionID,
+        env: NON_INTERACTIVE_ENV,
+      })
+    },
+  }
+}

src/hooks/non-interactive-env/types.ts

@@ -0,0 +1,3 @@
+export interface NonInteractiveEnvConfig {
+  disabled?: boolean
+}

src/hooks/session-notification.ts

@@ -56,7 +56,7 @@ async function sendNotification(
       await ctx.$`osascript -e ${"display notification \"" + escapedMessage + "\" with title \"" + escapedTitle + "\""}`
       break
     case "linux":
-      await ctx.$`notify-send ${escapedTitle} ${escapedMessage}`
+      await ctx.$`notify-send ${escapedTitle} ${escapedMessage}`.catch(() => {})
       break
     case "win32":
       await ctx.$`powershell -Command ${"[System.Reflection.Assembly]::LoadWithPartialName('System.Windows.Forms'); [System.Windows.Forms.MessageBox]::Show('" + escapedMessage + "', '" + escapedTitle + "')"}`

src/hooks/session-recovery/index.ts

@@ -6,8 +6,10 @@ import {
   findMessageByIndexNeedingThinking,
   findMessagesWithOrphanThinking,
   findMessagesWithThinkingBlocks,
+  findMessagesWithThinkingOnly,
   injectTextPart,
   prependThinkingPart,
+  readParts,
   stripThinkingParts,
 } from "./storage"
 import type { MessageData } from "./types"
@@ -99,7 +101,17 @@ async function recoverToolResultMissing(
   sessionID: string,
   failedAssistantMsg: MessageData
 ): Promise<boolean> {
-  const parts = failedAssistantMsg.parts || []
+  // Try API parts first, fallback to filesystem if empty
+  let parts = failedAssistantMsg.parts || []
+  if (parts.length === 0 && failedAssistantMsg.info?.id) {
+    const storedParts = readParts(failedAssistantMsg.info.id)
+    parts = storedParts.map((p) => ({
+      type: p.type === "tool" ? "tool_use" : p.type,
+      id: "callID" in p ? (p as { callID?: string }).callID : p.id,
+      name: "tool" in p ? (p as { tool?: string }).tool : undefined,
+      input: "state" in p ? (p as { state?: { input?: Record<string, unknown> } }).state?.input : undefined,
+    }))
+  }
   const toolUseIds = extractToolUseIds(parts)
 
   if (toolUseIds.length === 0) {
@@ -177,6 +189,8 @@ async function recoverThinkingDisabledViolation(
   return anySuccess
 }
 
+const PLACEHOLDER_TEXT = "[user interrupted]"
+
 async function recoverEmptyContentMessage(
   _client: Client,
   sessionID: string,
@@ -187,23 +201,28 @@ async function recoverEmptyContentMessage(
   const targetIndex = extractMessageIndex(error)
   const failedID = failedAssistantMsg.info?.id
 
+  const thinkingOnlyIDs = findMessagesWithThinkingOnly(sessionID)
+  for (const messageID of thinkingOnlyIDs) {
+    injectTextPart(sessionID, messageID, PLACEHOLDER_TEXT)
+  }
+
   if (targetIndex !== null) {
     const targetMessageID = findEmptyMessageByIndex(sessionID, targetIndex)
     if (targetMessageID) {
-      return injectTextPart(sessionID, targetMessageID, "(interrupted)")
+      return injectTextPart(sessionID, targetMessageID, PLACEHOLDER_TEXT)
     }
   }
 
   if (failedID) {
-    if (injectTextPart(sessionID, failedID, "(interrupted)")) {
+    if (injectTextPart(sessionID, failedID, PLACEHOLDER_TEXT)) {
       return true
     }
   }
 
   const emptyMessageIDs = findEmptyMessages(sessionID)
-  let anySuccess = false
+  let anySuccess = thinkingOnlyIDs.length > 0
   for (const messageID of emptyMessageIDs) {
-    if (injectTextPart(sessionID, messageID, "(interrupted)")) {
+    if (injectTextPart(sessionID, messageID, PLACEHOLDER_TEXT)) {
       anySuccess = true
     }
   }

src/hooks/session-recovery/storage.ts

@@ -133,20 +133,15 @@ export function findEmptyMessages(sessionID: string): string[] {
 
 export function findEmptyMessageByIndex(sessionID: string, targetIndex: number): string | null {
   const messages = readMessages(sessionID)
-  
-  // Try multiple indices to handle system message offset
-  // API includes system message at index 0, storage may not
-  const indicesToTry = [targetIndex, targetIndex - 1]
-  
+
+  // API index may differ from storage index due to system messages
+  const indicesToTry = [targetIndex, targetIndex - 1, targetIndex - 2]
+
   for (const idx of indicesToTry) {
     if (idx < 0 || idx >= messages.length) continue
 
     const targetMsg = messages[idx]
-    
-    // NOTE: Do NOT skip last assistant message here
-    // If API returned an error, this message is NOT the final assistant message
-    // (the API only allows empty content for the ACTUAL final assistant message)
-    
+
     if (!messageHasContent(targetMsg.id)) {
       return targetMsg.id
     }
@@ -177,6 +172,28 @@ export function findMessagesWithThinkingBlocks(sessionID: string): string[] {
   return result
 }
 
+export function findMessagesWithThinkingOnly(sessionID: string): string[] {
+  const messages = readMessages(sessionID)
+  const result: string[] = []
+
+  for (const msg of messages) {
+    if (msg.role !== "assistant") continue
+
+    const parts = readParts(msg.id)
+    if (parts.length === 0) continue
+
+    const hasThinking = parts.some((p) => THINKING_TYPES.has(p.type))
+    const hasTextContent = parts.some(hasContent)
+
+    // Has thinking but no text content = orphan thinking
+    if (hasThinking && !hasTextContent) {
+      result.push(msg.id)
+    }
+  }
+
+  return result
+}
+
 export function findMessagesWithOrphanThinking(sessionID: string): string[] {
   const messages = readMessages(sessionID)
   const result: string[] = []

src/hooks/todo-continuation-enforcer.ts

@@ -1,4 +1,13 @@
+import { existsSync, readdirSync } from "node:fs"
+import { join } from "node:path"
 import type { PluginInput } from "@opencode-ai/plugin"
+import {
+  findNearestMessageWithFields,
+  MESSAGE_STORAGE,
+} from "../features/hook-message-injector"
+import { log } from "../shared/logger"
+
+const HOOK_NAME = "todo-continuation-enforcer"
 
 export interface TodoContinuationEnforcer {
   handler: (input: { event: { type: string; properties?: unknown } }) => Promise<void>
@@ -21,6 +30,20 @@ Incomplete tasks remain in your todo list. Continue working on the next pending
 - Mark each task complete when finished
 - Do not stop until all tasks are done`
 
+function getMessageDir(sessionID: string): string | null {
+  if (!existsSync(MESSAGE_STORAGE)) return null
+
+  const directPath = join(MESSAGE_STORAGE, sessionID)
+  if (existsSync(directPath)) return directPath
+
+  for (const dir of readdirSync(MESSAGE_STORAGE)) {
+    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
+    if (existsSync(sessionPath)) return sessionPath
+  }
+
+  return null
+}
+
 function detectInterrupt(error: unknown): boolean {
   if (!error) return false
   if (typeof error === "object") {
@@ -59,10 +82,12 @@ export function createTodoContinuationEnforcer(ctx: PluginInput): TodoContinuati
     if (event.type === "session.error") {
       const sessionID = props?.sessionID as string | undefined
       if (sessionID) {
+        const isInterrupt = detectInterrupt(props?.error)
         errorSessions.add(sessionID)
-        if (detectInterrupt(props?.error)) {
+        if (isInterrupt) {
           interruptedSessions.add(sessionID)
         }
+        log(`[${HOOK_NAME}] session.error received`, { sessionID, isInterrupt, error: props?.error })
         
         // Cancel pending continuation if error occurs
         const timer = pendingTimers.get(sessionID)
@@ -78,18 +103,23 @@ export function createTodoContinuationEnforcer(ctx: PluginInput): TodoContinuati
       const sessionID = props?.sessionID as string | undefined
       if (!sessionID) return
 
+      log(`[${HOOK_NAME}] session.idle received`, { sessionID })
+
       // Cancel any existing timer to debounce
       const existingTimer = pendingTimers.get(sessionID)
       if (existingTimer) {
         clearTimeout(existingTimer)
+        log(`[${HOOK_NAME}] Cancelled existing timer`, { sessionID })
       }
 
       // Schedule continuation check
       const timer = setTimeout(async () => {
         pendingTimers.delete(sessionID)
+        log(`[${HOOK_NAME}] Timer fired, checking conditions`, { sessionID })
 
         // Check if session is in recovery mode - if so, skip entirely without clearing state
         if (recoveringSessions.has(sessionID)) {
+          log(`[${HOOK_NAME}] Skipped: session in recovery mode`, { sessionID })
           return
         }
 
@@ -99,24 +129,30 @@ export function createTodoContinuationEnforcer(ctx: PluginInput): TodoContinuati
         errorSessions.delete(sessionID)
 
         if (shouldBypass) {
+          log(`[${HOOK_NAME}] Skipped: error/interrupt bypass`, { sessionID })
           return
         }
 
         if (remindedSessions.has(sessionID)) {
+          log(`[${HOOK_NAME}] Skipped: already reminded this session`, { sessionID })
           return
         }
 
         let todos: Todo[] = []
         try {
+          log(`[${HOOK_NAME}] Fetching todos for session`, { sessionID })
           const response = await ctx.client.session.todo({
             path: { id: sessionID },
           })
           todos = (response.data ?? response) as Todo[]
-        } catch {
+          log(`[${HOOK_NAME}] Todo API response`, { sessionID, todosCount: todos?.length ?? 0 })
+        } catch (err) {
+          log(`[${HOOK_NAME}] Todo API error`, { sessionID, error: String(err) })
           return
         }
 
         if (!todos || todos.length === 0) {
+          log(`[${HOOK_NAME}] No todos found`, { sessionID })
           return
         }
 
@@ -125,21 +161,30 @@ export function createTodoContinuationEnforcer(ctx: PluginInput): TodoContinuati
         )
 
         if (incomplete.length === 0) {
+          log(`[${HOOK_NAME}] All todos completed`, { sessionID, total: todos.length })
           return
         }
 
+        log(`[${HOOK_NAME}] Found incomplete todos`, { sessionID, incomplete: incomplete.length, total: todos.length })
         remindedSessions.add(sessionID)
 
         // Re-check if abort occurred during the delay/fetch
         if (interruptedSessions.has(sessionID) || errorSessions.has(sessionID) || recoveringSessions.has(sessionID)) {
+          log(`[${HOOK_NAME}] Abort occurred during delay/fetch`, { sessionID })
           remindedSessions.delete(sessionID)
           return
         }
 
         try {
+          // Get previous message's agent info to respect agent mode
+          const messageDir = getMessageDir(sessionID)
+          const prevMessage = messageDir ? findNearestMessageWithFields(messageDir) : null
+
+          log(`[${HOOK_NAME}] Injecting continuation prompt`, { sessionID, agent: prevMessage?.agent })
           await ctx.client.session.prompt({
             path: { id: sessionID },
             body: {
+              agent: prevMessage?.agent,
               parts: [
                 {
                   type: "text",
@@ -149,7 +194,9 @@ export function createTodoContinuationEnforcer(ctx: PluginInput): TodoContinuati
             },
             query: { directory: ctx.directory },
           })
-        } catch {
+          log(`[${HOOK_NAME}] Continuation prompt injected successfully`, { sessionID })
+        } catch (err) {
+          log(`[${HOOK_NAME}] Prompt injection failed`, { sessionID, error: String(err) })
           remindedSessions.delete(sessionID)
         }
       }, 200)
@@ -160,16 +207,23 @@ export function createTodoContinuationEnforcer(ctx: PluginInput): TodoContinuati
     if (event.type === "message.updated") {
       const info = props?.info as Record<string, unknown> | undefined
       const sessionID = info?.sessionID as string | undefined
+      log(`[${HOOK_NAME}] message.updated received`, { sessionID, role: info?.role })
+      
       if (sessionID && info?.role === "user") {
-        remindedSessions.delete(sessionID)
-        
-        // Cancel pending continuation on user interaction
+        // Cancel pending continuation on user interaction (real user input)
         const timer = pendingTimers.get(sessionID)
         if (timer) {
           clearTimeout(timer)
           pendingTimers.delete(sessionID)
+          log(`[${HOOK_NAME}] Cancelled pending timer on user message`, { sessionID })
         }
       }
+      
+      // Clear reminded state when assistant responds (allows re-remind on next idle)
+      if (sessionID && info?.role === "assistant" && remindedSessions.has(sessionID)) {
+        remindedSessions.delete(sessionID)
+        log(`[${HOOK_NAME}] Cleared remindedSessions on assistant response`, { sessionID })
+      }
     }
 
     if (event.type === "session.deleted") {

src/hooks/tool-output-truncator.ts

@@ -1,9 +1,10 @@
 import type { PluginInput } from "@opencode-ai/plugin"
 import { createDynamicTruncator } from "../shared/dynamic-truncator"
 
+// Note: "grep" and "Grep" are handled by dedicated grep-output-truncator.ts
 const TRUNCATABLE_TOOLS = [
-  "Grep",
   "safe_grep",
+  "glob",
   "Glob",
   "safe_glob",
   "lsp_find_references",
@@ -11,6 +12,8 @@ const TRUNCATABLE_TOOLS = [
   "lsp_workspace_symbols",
   "lsp_diagnostics",
   "ast_grep_search",
+  "interactive_bash",
+  "Interactive_bash",
 ]
 
 export function createToolOutputTruncatorHook(ctx: PluginInput) {

src/index.ts

@@ -18,6 +18,8 @@ import {
   createAutoUpdateCheckerHook,
   createKeywordDetectorHook,
   createAgentUsageReminderHook,
+  createNonInteractiveEnvHook,
+  createInteractiveBashSessionHook,
 } from "./hooks";
 import { createGoogleAntigravityAuthPlugin } from "./auth/antigravity";
 import {
@@ -42,7 +44,7 @@ import {
   getCurrentSessionTitle,
 } from "./features/claude-code-session-state";
 import { updateTerminalTitle } from "./features/terminal";
-import { builtinTools, createCallOmoAgent, createBackgroundTools, createLookAt } from "./tools";
+import { builtinTools, createCallOmoAgent, createBackgroundTools, createLookAt, interactive_bash, getTmuxPath } from "./tools";
 import { BackgroundManager } from "./features/background-agent";
 import { createBuiltinMcps } from "./mcp";
 import { OhMyOpenCodeConfigSchema, type OhMyOpenCodeConfig, type HookName } from "./config";
@@ -65,11 +67,36 @@ function getUserConfigDir(): string {
   return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
 }
 
+const AGENT_NAME_MAP: Record<string, string> = {
+  omo: "OmO",
+  build: "build",
+  oracle: "oracle",
+  librarian: "librarian",
+  explore: "explore",
+  "frontend-ui-ux-engineer": "frontend-ui-ux-engineer",
+  "document-writer": "document-writer",
+  "multimodal-looker": "multimodal-looker",
+};
+
+function normalizeAgentNames(agents: Record<string, unknown>): Record<string, unknown> {
+  const normalized: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(agents)) {
+    const normalizedKey = AGENT_NAME_MAP[key.toLowerCase()] ?? key;
+    normalized[normalizedKey] = value;
+  }
+  return normalized;
+}
+
 function loadConfigFromPath(configPath: string): OhMyOpenCodeConfig | null {
   try {
     if (fs.existsSync(configPath)) {
       const content = fs.readFileSync(configPath, "utf-8");
       const rawConfig = JSON.parse(content);
+
+      if (rawConfig.agents && typeof rawConfig.agents === "object") {
+        rawConfig.agents = normalizeAgentNames(rawConfig.agents);
+      }
+
       const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
 
       if (!result.success) {
@@ -213,6 +240,12 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
   const agentUsageReminder = isHookEnabled("agent-usage-reminder")
     ? createAgentUsageReminderHook(ctx)
     : null;
+  const nonInteractiveEnv = isHookEnabled("non-interactive-env")
+    ? createNonInteractiveEnvHook(ctx)
+    : null;
+  const interactiveBashSession = isHookEnabled("interactive-bash-session")
+    ? createInteractiveBashSessionHook(ctx)
+    : null;
 
   updateTerminalTitle({ sessionId: "main" });
 
@@ -230,6 +263,8 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
     ? await createGoogleAntigravityAuthPlugin(ctx)
     : null;
 
+  const tmuxAvailable = await getTmuxPath();
+
   return {
     ...(googleAuthHooks ? { auth: googleAuthHooks.auth } : {}),
 
@@ -238,6 +273,7 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
       ...backgroundTools,
       call_omo_agent: callOmoAgent,
       look_at: lookAt,
+      ...(tmuxAvailable ? { interactive_bash } : {}),
     },
 
     "chat.message": async (input, output) => {
@@ -249,20 +285,47 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
       const builtinAgents = createBuiltinAgents(
         pluginConfig.disabled_agents,
         pluginConfig.agents,
+        ctx.directory,
       );
 
       const userAgents = (pluginConfig.claude_code?.agents ?? true) ? loadUserAgents() : {};
       const projectAgents = (pluginConfig.claude_code?.agents ?? true) ? loadProjectAgents() : {};
 
-      const shouldHideBuild = pluginConfig.omo_agent?.disable_build !== false;
+      const isOmoEnabled = pluginConfig.omo_agent?.disabled !== true;
 
-      config.agent = {
-        ...builtinAgents,
-        ...userAgents,
-        ...projectAgents,
-        ...config.agent,
-        ...(shouldHideBuild ? { build: { mode: "subagent" } } : {}),
-      };
+      if (isOmoEnabled && builtinAgents.OmO) {
+        // TODO: When OpenCode releases `default_agent` config option (PR #5313),
+        // use `config.default_agent = "OmO"` instead of demoting build/plan.
+        // Tracking: https://github.com/sst/opencode/pull/5313
+        const { name: _planName, ...planConfigWithoutName } = config.agent?.plan ?? {};
+        const omoPlanOverride = pluginConfig.agents?.["OmO-Plan"];
+        const omoPlanBase = {
+          ...builtinAgents.OmO,
+          ...planConfigWithoutName,
+          description: `${config.agent?.plan?.description ?? "Plan agent"} (OhMyOpenCode version)`,
+          color: config.agent?.plan?.color ?? "#6495ED",
+        };
+
+        const omoPlanConfig = omoPlanOverride ? deepMerge(omoPlanBase, omoPlanOverride) : omoPlanBase;
+
+        config.agent = {
+          OmO: builtinAgents.OmO,
+          "OmO-Plan": omoPlanConfig,
+          ...Object.fromEntries(Object.entries(builtinAgents).filter(([k]) => k !== "OmO")),
+          ...userAgents,
+          ...projectAgents,
+          ...config.agent,
+          build: { ...config.agent?.build, mode: "subagent" },
+          plan: { ...config.agent?.plan, mode: "subagent" },
+        };
+      } else {
+        config.agent = {
+          ...builtinAgents,
+          ...userAgents,
+          ...projectAgents,
+          ...config.agent,
+        };
+      }
 
       config.tools = {
         ...config.tools,
@@ -331,6 +394,7 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
       await anthropicAutoCompact?.event(input);
       await keywordDetector?.event(input);
       await agentUsageReminder?.event(input);
+      await interactiveBashSession?.event(input);
 
       const { event } = input;
       const props = event.properties as Record<string, unknown> | undefined;
@@ -428,8 +492,21 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
 
     "tool.execute.before": async (input, output) => {
       await claudeCodeHooks["tool.execute.before"](input, output);
+      await nonInteractiveEnv?.["tool.execute.before"](input, output);
       await commentChecker?.["tool.execute.before"](input, output);
 
+      if (input.tool === "task") {
+        const args = output.args as Record<string, unknown>;
+        const subagentType = args.subagent_type as string;
+        const isExploreOrLibrarian = ["explore", "librarian"].includes(subagentType);
+
+        args.tools = {
+          ...(args.tools as Record<string, boolean> | undefined),
+          background_task: false,
+          ...(isExploreOrLibrarian ? { call_omo_agent: false } : {}),
+        };
+      }
+
       if (input.sessionID === getMainSessionID()) {
         updateTerminalTitle({
           sessionId: input.sessionID,
@@ -451,6 +528,7 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
       await rulesInjector?.["tool.execute.after"](input, output);
       await emptyTaskResponseDetector?.["tool.execute.after"](input, output);
       await agentUsageReminder?.["tool.execute.after"](input, output);
+      await interactiveBashSession?.["tool.execute.after"](input, output);
 
       if (input.sessionID === getMainSessionID()) {
         updateTerminalTitle({

src/tools/background-task/constants.ts

@@ -9,9 +9,11 @@ Use this for:
 
 Arguments:
 - description: Short task description (shown in status)
-- prompt: Full detailed prompt for the agent
+- prompt: Full detailed prompt for the agent (MUST be in English for optimal LLM performance)
 - agent: Agent type to use (any agent allowed)
 
+IMPORTANT: Always write prompts in English regardless of user's language. LLMs perform significantly better with English prompts.
+
 Returns immediately with task ID and session info. Use \`background_output\` to check progress or retrieve results.`
 
 export const BACKGROUND_OUTPUT_DESCRIPTION = `Get output from a background task.
@@ -21,17 +23,7 @@ Arguments:
 - block: If true, wait for task completion. If false (default), return current status immediately.
 - timeout: Max wait time in ms when blocking (default: 60000, max: 600000)
 
-Returns:
-- When not blocking: Returns current status with task ID, description, agent, status, duration, and progress info
-- When blocking: Waits for completion, then returns full result
-
-IMPORTANT: The system automatically notifies the main session when background tasks complete.
-You typically don't need block=true - just use block=false to check status, and the system will notify you when done.
-
-Use this to:
-- Check task progress (block=false) - returns full status info, NOT empty
-- Wait for and retrieve task result (block=true) - only when you explicitly need to wait
-- Set custom timeout for long tasks`
+The system automatically notifies when background tasks complete. You typically don't need block=true.`
 
 export const BACKGROUND_CANCEL_DESCRIPTION = `Cancel a running background task.
 

src/tools/call-omo-agent/constants.ts

@@ -21,4 +21,5 @@ Usage notes:
 3. Each agent invocation is stateless unless you provide a session_id
 4. Your prompt should contain a highly detailed task description for the agent to perform autonomously
 5. Clearly tell the agent whether you expect it to write code or just to do research
-6. For long-running research tasks, use run_in_background=true to avoid blocking`
+6. For long-running research tasks, use run_in_background=true to avoid blocking
+7. **IMPORTANT**: Always write prompts in English regardless of user's language. LLMs perform significantly better with English prompts.`

src/tools/index.ts

@@ -22,6 +22,9 @@ import { glob } from "./glob"
 import { slashcommand } from "./slashcommand"
 import { skill } from "./skill"
 
+export { interactive_bash, startBackgroundCheck as startTmuxCheck } from "./interactive-bash"
+export { getTmuxPath } from "./interactive-bash/utils"
+
 import {
   createBackgroundTask,
   createBackgroundOutput,

src/tools/interactive-bash/constants.ts

@@ -0,0 +1,5 @@
+export const DEFAULT_TIMEOUT_MS = 60_000
+
+export const INTERACTIVE_BASH_DESCRIPTION = `Execute tmux commands for interactive terminal session management.
+
+Use session names following the pattern "omo-{name}" for automatic tracking.`

src/tools/interactive-bash/index.ts

@@ -0,0 +1,4 @@
+import { interactive_bash } from "./tools"
+import { startBackgroundCheck } from "./utils"
+
+export { interactive_bash, startBackgroundCheck }

src/tools/interactive-bash/tools.ts

@@ -0,0 +1,99 @@
+import { tool } from "@opencode-ai/plugin/tool"
+import { DEFAULT_TIMEOUT_MS, INTERACTIVE_BASH_DESCRIPTION } from "./constants"
+import { getCachedTmuxPath } from "./utils"
+
+/**
+ * Quote-aware command tokenizer with escape handling
+ * Handles single/double quotes and backslash escapes without external dependencies
+ */
+export function tokenizeCommand(cmd: string): string[] {
+  const tokens: string[] = []
+  let current = ""
+  let inQuote = false
+  let quoteChar = ""
+  let escaped = false
+
+  for (let i = 0; i < cmd.length; i++) {
+    const char = cmd[i]
+
+    if (escaped) {
+      current += char
+      escaped = false
+      continue
+    }
+
+    if (char === "\\") {
+      escaped = true
+      continue
+    }
+
+    if ((char === "'" || char === '"') && !inQuote) {
+      inQuote = true
+      quoteChar = char
+    } else if (char === quoteChar && inQuote) {
+      inQuote = false
+      quoteChar = ""
+    } else if (char === " " && !inQuote) {
+      if (current) {
+        tokens.push(current)
+        current = ""
+      }
+    } else {
+      current += char
+    }
+  }
+
+  if (current) tokens.push(current)
+  return tokens
+}
+
+export const interactive_bash = tool({
+  description: INTERACTIVE_BASH_DESCRIPTION,
+  args: {
+    tmux_command: tool.schema.string().describe("The tmux command to execute (without 'tmux' prefix)"),
+  },
+  execute: async (args) => {
+    try {
+      const tmuxPath = getCachedTmuxPath() ?? "tmux"
+
+      const parts = tokenizeCommand(args.tmux_command)
+
+      if (parts.length === 0) {
+        return "Error: Empty tmux command"
+      }
+
+      const proc = Bun.spawn([tmuxPath, ...parts], {
+        stdout: "pipe",
+        stderr: "pipe",
+      })
+
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        const id = setTimeout(() => {
+          proc.kill()
+          reject(new Error(`Timeout after ${DEFAULT_TIMEOUT_MS}ms`))
+        }, DEFAULT_TIMEOUT_MS)
+        proc.exited.then(() => clearTimeout(id))
+      })
+
+      // Read stdout and stderr in parallel to avoid race conditions
+      const [stdout, stderr, exitCode] = await Promise.race([
+        Promise.all([
+          new Response(proc.stdout).text(),
+          new Response(proc.stderr).text(),
+          proc.exited,
+        ]),
+        timeoutPromise,
+      ])
+
+      // Check exitCode properly - return error even if stderr is empty
+      if (exitCode !== 0) {
+        const errorMsg = stderr.trim() || `Command failed with exit code ${exitCode}`
+        return `Error: ${errorMsg}`
+      }
+
+      return stdout || "(no output)"
+    } catch (e) {
+      return `Error: ${e instanceof Error ? e.message : String(e)}`
+    }
+  },
+})

src/tools/interactive-bash/types.ts

@@ -0,0 +1,3 @@
+export interface InteractiveBashArgs {
+  tmux_command: string
+}

src/tools/interactive-bash/utils.ts

@@ -0,0 +1,71 @@
+import { spawn } from "bun"
+
+let tmuxPath: string | null = null
+let initPromise: Promise<string | null> | null = null
+
+async function findTmuxPath(): Promise<string | null> {
+  const isWindows = process.platform === "win32"
+  const cmd = isWindows ? "where" : "which"
+
+  try {
+    const proc = spawn([cmd, "tmux"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+
+    const exitCode = await proc.exited
+    if (exitCode !== 0) {
+      return null
+    }
+
+    const stdout = await new Response(proc.stdout).text()
+    const path = stdout.trim().split("\n")[0]
+
+    if (!path) {
+      return null
+    }
+
+    const verifyProc = spawn([path, "-V"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    })
+
+    const verifyExitCode = await verifyProc.exited
+    if (verifyExitCode !== 0) {
+      return null
+    }
+
+    return path
+  } catch {
+    return null
+  }
+}
+
+export async function getTmuxPath(): Promise<string | null> {
+  if (tmuxPath !== null) {
+    return tmuxPath
+  }
+
+  if (initPromise) {
+    return initPromise
+  }
+
+  initPromise = (async () => {
+    const path = await findTmuxPath()
+    tmuxPath = path
+    return path
+  })()
+
+  return initPromise
+}
+
+export function getCachedTmuxPath(): string | null {
+  return tmuxPath
+}
+
+export function startBackgroundCheck(): void {
+  if (!initPromise) {
+    initPromise = getTmuxPath()
+    initPromise.catch(() => {})
+  }
+}

src/tools/look-at/constants.ts

@@ -2,22 +2,9 @@ export const MULTIMODAL_LOOKER_AGENT = "multimodal-looker" as const
 
 export const LOOK_AT_DESCRIPTION = `Analyze media files (PDFs, images, diagrams) that require visual interpretation.
 
-Use this tool to extract specific information from files that cannot be processed as plain text:
-- PDF documents: extract text, tables, structure, specific sections
-- Images: describe layouts, UI elements, text content, diagrams
-- Charts/Graphs: explain data, trends, relationships
-- Screenshots: identify UI components, text, visual elements
-- Architecture diagrams: explain flows, connections, components
-
 Parameters:
 - file_path: Absolute path to the file to analyze
 - goal: What specific information to extract (be specific for better results)
 
-Examples:
-- "Extract all API endpoints from this OpenAPI spec PDF"
-- "Describe the UI layout and components in this screenshot"
-- "Explain the data flow in this architecture diagram"
-- "List all table data from page 3 of this PDF"
-
 This tool uses a separate context window with Gemini 2.5 Flash for multimodal analysis,
 saving tokens in the main conversation while providing accurate visual interpretation.`