@G-hoon has signed the CLA in code-yeongyu/oh-my-opencode#879

fix(mcp): disable OAuth auto-detection for built-in MCPs

.github/workflows/publish.yml

@@ -141,7 +141,6 @@ jobs:
           CI: true
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NPM_CONFIG_PROVENANCE: true
-          SKIP_PLATFORM_PACKAGES: true
 
       - name: Delete draft release
         run: gh release delete next --yes 2>/dev/null || echo "No draft release to delete"
@@ -149,10 +148,12 @@ jobs:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Merge to master
+        continue-on-error: true
         run: |
           git config user.name "github-actions[bot]"
           git config user.email "github-actions[bot]@users.noreply.github.com"
           VERSION=$(jq -r '.version' package.json)
+          git stash --include-untracked || true
           git checkout master
           git reset --hard "v${VERSION}"
-          git push -f origin master
+          git push -f origin master || echo "::warning::Failed to push to master. This can happen when workflow files changed. Manually sync master: git checkout master && git reset --hard v${VERSION} && git push -f"

AGENTS.md

@@ -1,29 +1,29 @@
 # PROJECT KNOWLEDGE BASE
 
-**Generated:** 2026-01-15T14:53:00+09:00
-**Commit:** 89fa9ff1
+**Generated:** 2026-01-17T21:55:00+09:00
+**Commit:** 255f535a
 **Branch:** dev
 
 ## OVERVIEW
 
-OpenCode plugin implementing Claude Code/AmpCode features. Multi-model agent orchestration (GPT-5.2, Claude, Gemini, Grok), LSP tools (11), AST-Grep search, MCP integrations (context7, websearch_exa, grep_app). "oh-my-zsh" for OpenCode.
+OpenCode plugin implementing multi-model agent orchestration (Claude Opus 4.5, GPT-5.2, Gemini 3, Grok, GLM-4.7). 31 lifecycle hooks, 20+ tools (LSP, AST-Grep, delegation), 10 specialized agents, Claude Code compatibility layer. "oh-my-zsh" for OpenCode.
 
 ## STRUCTURE
 
 ```
 oh-my-opencode/
 ├── src/
-│   ├── agents/        # AI agents (10+): Sisyphus, oracle, librarian, explore, frontend, document-writer, multimodal-looker, prometheus, metis, momus
-│   ├── hooks/         # 22+ lifecycle hooks - see src/hooks/AGENTS.md
-│   ├── tools/         # LSP, AST-Grep, Grep, Glob, session mgmt - see src/tools/AGENTS.md
-│   ├── features/      # Claude Code compat layer - see src/features/AGENTS.md
-│   ├── shared/        # Cross-cutting utilities - see src/shared/AGENTS.md
-│   ├── cli/           # CLI installer, doctor - see src/cli/AGENTS.md
-│   ├── mcp/           # MCP configs: context7, grep_app, websearch
+│   ├── agents/        # 10 AI agents (Sisyphus, oracle, librarian, explore, frontend, etc.) - see src/agents/AGENTS.md
+│   ├── hooks/         # 31 lifecycle hooks (PreToolUse, PostToolUse, Stop, etc.) - see src/hooks/AGENTS.md
+│   ├── tools/         # 20+ tools (LSP, AST-Grep, delegation, session) - see src/tools/AGENTS.md
+│   ├── features/      # Background agents, Claude Code compat layer - see src/features/AGENTS.md
+│   ├── shared/        # 43 cross-cutting utilities - see src/shared/AGENTS.md
+│   ├── cli/           # CLI installer, doctor, run - see src/cli/AGENTS.md
+│   ├── mcp/           # Built-in MCPs: websearch, context7, grep_app
 │   ├── config/        # Zod schema, TypeScript types
-│   └── index.ts       # Main plugin entry (580 lines)
-├── script/            # build-schema.ts, publish.ts, generate-changelog.ts
-├── assets/            # JSON schema
+│   └── index.ts       # Main plugin entry (568 lines)
+├── script/            # build-schema.ts, publish.ts, build-binaries.ts
+├── packages/          # 7 platform-specific binaries
 └── dist/              # Build output (ESM + .d.ts)
 ```
 
@@ -31,46 +31,34 @@ oh-my-opencode/
 
 | Task | Location | Notes |
 |------|----------|-------|
-| Add agent | `src/agents/` | Create .ts, add to builtinAgents in index.ts, update types.ts |
-| Add hook | `src/hooks/` | Create dir with createXXXHook(), export from index.ts |
-| Add tool | `src/tools/` | Dir with index/types/constants/tools.ts, add to builtinTools |
-| Add MCP | `src/mcp/` | Create config, add to index.ts and types.ts |
-| Add skill | `src/features/builtin-skills/` | Create skill dir with SKILL.md |
+| Add agent | `src/agents/` | Create .ts with factory, add to `builtinAgents` in index.ts |
+| Add hook | `src/hooks/` | Create dir with `createXXXHook()`, register in index.ts |
+| Add tool | `src/tools/` | Dir with index/types/constants/tools.ts, add to `builtinTools` |
+| Add MCP | `src/mcp/` | Create config, add to index.ts |
+| Add skill | `src/features/builtin-skills/` | Create dir with SKILL.md |
 | LSP behavior | `src/tools/lsp/` | client.ts (connection), tools.ts (handlers) |
 | AST-Grep | `src/tools/ast-grep/` | napi.ts for @ast-grep/napi binding |
 | Config schema | `src/config/schema.ts` | Zod schema, run `bun run build:schema` after changes |
 | Claude Code compat | `src/features/claude-code-*-loader/` | Command, skill, agent, mcp loaders |
-| Background agents | `src/features/background-agent/` | manager.ts for task management |
+| Background agents | `src/features/background-agent/` | manager.ts (1165 lines) for task lifecycle |
 | Skill MCP | `src/features/skill-mcp-manager/` | MCP servers embedded in skills |
-| Interactive terminal | `src/tools/interactive-bash/` | tmux session management |
-| CLI installer | `src/cli/install.ts` | Interactive TUI installation |
-| Doctor checks | `src/cli/doctor/checks/` | Health checks for environment |
-| Shared utilities | `src/shared/` | Cross-cutting utilities |
-| Slash commands | `src/hooks/auto-slash-command/` | Auto-detect and execute `/command` patterns |
-| Ralph Loop | `src/hooks/ralph-loop/` | Self-referential dev loop until completion |
-| Orchestrator | `src/hooks/sisyphus-orchestrator/` | Main orchestration hook (684 lines) |
+| CLI installer | `src/cli/install.ts` | Interactive TUI (462 lines) |
+| Doctor checks | `src/cli/doctor/checks/` | 14 health checks across 6 categories |
+| Orchestrator | `src/hooks/sisyphus-orchestrator/` | Main orchestration hook (771 lines) |
 
 ## TDD (Test-Driven Development)
 
 **MANDATORY for new features and bug fixes.** Follow RED-GREEN-REFACTOR:
 
-```
-1. RED    - Write failing test first (test MUST fail)
-2. GREEN  - Write MINIMAL code to pass (nothing more)
-3. REFACTOR - Clean up while tests stay GREEN
-4. REPEAT - Next test case
-```
-
 | Phase | Action | Verification |
 |-------|--------|--------------|
-| **RED** | Write test describing expected behavior | `bun test` -> FAIL (expected) |
-| **GREEN** | Implement minimum code to pass | `bun test` -> PASS |
-| **REFACTOR** | Improve code quality, remove duplication | `bun test` -> PASS (must stay green) |
+| **RED** | Write test describing expected behavior | `bun test` → FAIL (expected) |
+| **GREEN** | Implement minimum code to pass | `bun test` → PASS |
+| **REFACTOR** | Improve code quality, remove duplication | `bun test` → PASS (must stay green) |
 
 **Rules:**
 - NEVER write implementation before test
 - NEVER delete failing tests to "pass" - fix the code
-- One test at a time - don't batch
 - Test file naming: `*.test.ts` alongside source
 - BDD comments: `#given`, `#when`, `#then` (same as AAA)
 
@@ -79,40 +67,37 @@ oh-my-opencode/
 - **Package manager**: Bun only (`bun run`, `bun build`, `bunx`)
 - **Types**: bun-types (not @types/node)
 - **Build**: `bun build` (ESM) + `tsc --emitDeclarationOnly`
-- **Exports**: Barrel pattern in index.ts; explicit named exports for tools/hooks
-- **Naming**: kebab-case directories, createXXXHook/createXXXTool factories
-- **Testing**: BDD comments `#given/#when/#then`, TDD workflow (RED-GREEN-REFACTOR), 80+ test files
+- **Exports**: Barrel pattern in index.ts; explicit named exports
+- **Naming**: kebab-case directories, `createXXXHook`/`createXXXTool` factories
+- **Testing**: BDD comments `#given/#when/#then`, 84 test files
 - **Temperature**: 0.1 for code agents, max 0.3
 
 ## ANTI-PATTERNS (THIS PROJECT)
 
-- **npm/yarn**: Use bun exclusively
-- **@types/node**: Use bun-types
-- **Bash file ops**: Never mkdir/touch/rm/cp/mv for file creation in code
-- **Direct bun publish**: GitHub Actions workflow_dispatch only (OIDC provenance)
-- **Local version bump**: Version managed by CI workflow
-- **Year 2024**: NEVER use 2024 in code/prompts (use current year)
-- **Rush completion**: Never mark tasks complete without verification
-- **Over-exploration**: Stop searching when sufficient context found
-- **High temperature**: Don't use >0.3 for code-related agents
-- **Broad tool access**: Prefer explicit `include` over unrestricted access
-- **Sequential agent calls**: Use `sisyphus_task` for parallel execution
-- **Heavy PreToolUse logic**: Slows every tool call
-- **Self-planning for complex tasks**: Spawn planning agent (Prometheus) instead
-- **Trust agent self-reports**: ALWAYS verify results independently
-- **Skip TODO creation**: Multi-step tasks MUST have todos first
-- **Batch completions**: Mark TODOs complete immediately, don't group
-- **Giant commits**: 3+ files = 2+ commits minimum
-- **Separate test from impl**: Same commit always
+| Category | Forbidden |
+|----------|-----------|
+| **Package Manager** | npm, yarn - use Bun exclusively |
+| **Types** | @types/node - use bun-types |
+| **File Ops** | mkdir/touch/rm/cp/mv in code - agents use bash tool |
+| **Publishing** | Direct `bun publish` - use GitHub Actions workflow_dispatch |
+| **Versioning** | Local version bump - managed by CI |
+| **Date References** | Year 2024 - use current year |
+| **Type Safety** | `as any`, `@ts-ignore`, `@ts-expect-error` |
+| **Error Handling** | Empty catch blocks `catch(e) {}` |
+| **Testing** | Deleting failing tests to "pass" |
+| **Agent Calls** | Sequential agent calls - use `delegate_task` for parallel |
+| **Tool Access** | Broad tool access - prefer explicit `include` |
+| **Hook Logic** | Heavy PreToolUse computation - slows every tool call |
+| **Commits** | Giant commits (3+ files = 2+ commits), separate test from impl |
+| **Temperature** | >0.3 for code agents |
+| **Trust** | Trust agent self-reports - ALWAYS verify independently |
 
 ## UNIQUE STYLES
 
 - **Platform**: Union type `"darwin" | "linux" | "win32" | "unsupported"`
 - **Optional props**: Extensive `?` for optional interface properties
 - **Flexible objects**: `Record<string, unknown>` for dynamic configs
-- **Error handling**: Consistent try/catch with async/await
 - **Agent tools**: `tools: { include: [...] }` or `tools: { exclude: [...] }`
-- **Temperature**: Most agents use `0.1` for consistency
 - **Hook naming**: `createXXXHook` function convention
 - **Factory pattern**: Components created via `createXXX()` functions
 
@@ -121,13 +106,13 @@ oh-my-opencode/
 | Agent | Default Model | Purpose |
 |-------|---------------|---------|
 | Sisyphus | anthropic/claude-opus-4-5 | Primary orchestrator with extended thinking |
-| oracle | openai/gpt-5.2 | Read-only consultation. High-IQ debugging, architecture |
-| librarian | opencode/glm-4.7-free | Multi-repo analysis, docs |
-| explore | opencode/grok-code | Fast codebase exploration |
-| frontend-ui-ux-engineer | google/gemini-3-pro-preview | UI generation |
-| document-writer | google/gemini-3-pro-preview | Technical docs |
+| oracle | openai/gpt-5.2 | Read-only consultation, high-IQ debugging |
+| librarian | opencode/glm-4.7-free | Multi-repo analysis, docs, GitHub search |
+| explore | opencode/grok-code | Fast codebase exploration (contextual grep) |
+| frontend-ui-ux-engineer | google/gemini-3-pro-preview | UI generation, visual design |
+| document-writer | google/gemini-3-flash | Technical documentation |
 | multimodal-looker | google/gemini-3-flash | PDF/image analysis |
-| Prometheus (Planner) | anthropic/claude-opus-4-5 | Strategic planning, interview-driven |
+| Prometheus (Planner) | anthropic/claude-opus-4-5 | Strategic planning, interview mode |
 | Metis (Plan Consultant) | anthropic/claude-sonnet-4-5 | Pre-planning analysis |
 | Momus (Plan Reviewer) | anthropic/claude-sonnet-4-5 | Plan validation |
 
@@ -138,7 +123,7 @@ bun run typecheck      # Type check
 bun run build          # ESM + declarations + schema
 bun run rebuild        # Clean + Build
 bun run build:schema   # Schema only
-bun test               # Run tests (80+ test files, 2500+ BDD assertions)
+bun test               # Run tests (84 test files)
 ```
 
 ## DEPLOYMENT
@@ -153,25 +138,23 @@ bun test               # Run tests (80+ test files, 2500+ BDD assertions)
 
 ## CI PIPELINE
 
-- **ci.yml**: Parallel test/typecheck, build verification, auto-commit schema on master, rolling `next` draft release
-- **publish.yml**: Manual workflow_dispatch, version bump, changelog, OIDC npm publish
+- **ci.yml**: Parallel test/typecheck → build → auto-commit schema on master → rolling `next` draft release
+- **publish.yml**: Manual workflow_dispatch → version bump → changelog → 8-package OIDC npm publish → force-push master
 
 ## COMPLEXITY HOTSPOTS
 
 | File | Lines | Description |
 |------|-------|-------------|
-| `src/agents/orchestrator-sisyphus.ts` | 1485 | Orchestrator agent, 7-section delegation, accumulated wisdom |
-| `src/features/builtin-skills/skills.ts` | 1230 | Skill definitions (frontend-ui-ux, playwright) |
-| `src/agents/prometheus-prompt.ts` | 991 | Planning agent, interview mode, multi-agent validation |
-| `src/features/background-agent/manager.ts` | 928 | Task lifecycle, concurrency |
-| `src/cli/config-manager.ts` | 730 | JSONC parsing, multi-level config, env detection |
-| `src/hooks/sisyphus-orchestrator/index.ts` | 684 | Orchestrator hook impl |
-| `src/tools/sisyphus-task/tools.ts` | 667 | Category-based task delegation |
-| `src/agents/sisyphus.ts` | 643 | Main Sisyphus prompt |
-| `src/tools/lsp/client.ts` | 632 | LSP protocol, JSON-RPC |
+| `src/agents/orchestrator-sisyphus.ts` | 1531 | Orchestrator agent, 7-section delegation, wisdom accumulation |
+| `src/features/builtin-skills/skills.ts` | 1203 | Skill definitions (playwright, git-master, frontend-ui-ux) |
+| `src/agents/prometheus-prompt.ts` | 1196 | Planning agent, interview mode, Momus loop |
+| `src/features/background-agent/manager.ts` | 1165 | Task lifecycle, concurrency, notification batching |
+| `src/hooks/sisyphus-orchestrator/index.ts` | 771 | Orchestrator hook implementation |
+| `src/tools/delegate-task/tools.ts` | 761 | Category-based task delegation |
+| `src/cli/config-manager.ts` | 730 | JSONC parsing, multi-level config |
+| `src/agents/sisyphus.ts` | 640 | Main Sisyphus prompt |
 | `src/features/builtin-commands/templates/refactor.ts` | 619 | Refactoring command template |
-| `src/index.ts` | 580 | Main plugin, all hook/tool init |
-| `src/hooks/anthropic-context-window-limit-recovery/executor.ts` | 554 | Multi-stage recovery |
+| `src/tools/lsp/client.ts` | 596 | LSP protocol, JSON-RPC |
 
 ## MCP ARCHITECTURE
 
@@ -184,16 +167,15 @@ Three-tier MCP system:
 
 - **Zod validation**: `src/config/schema.ts`
 - **JSONC support**: Comments and trailing commas
-- **Multi-level**: User (`~/.config/opencode/`) → Project (`.opencode/`)
+- **Multi-level**: Project (`.opencode/`) → User (`~/.config/opencode/`)
 - **CLI doctor**: Validates config and reports errors
 
 ## NOTES
 
-- **Testing**: Bun native test (`bun test`), BDD-style `#given/#when/#then`, 80+ test files
+- **Testing**: Bun native test (`bun test`), BDD-style, 84 test files
 - **OpenCode**: Requires >= 1.0.150
 - **Multi-lang docs**: README.md (EN), README.ko.md (KO), README.ja.md (JA), README.zh-cn.md (ZH-CN)
 - **Config**: `~/.config/opencode/oh-my-opencode.json` (user) or `.opencode/oh-my-opencode.json` (project)
 - **Trusted deps**: @ast-grep/cli, @ast-grep/napi, @code-yeongyu/comment-checker
-- **JSONC support**: Config files support comments (`// comment`, `/* block */`) and trailing commas
 - **Claude Code Compat**: Full compatibility layer for settings.json hooks, commands, skills, agents, MCPs
-- **Skill MCP**: Skills can embed MCP server configs in YAML frontmatter
+- **Flaky tests**: 2 known flaky tests (ralph-loop CI timeout, session-state parallel pollution)

README.ja.md

@@ -548,11 +548,7 @@ Ask @explore for the policy on this feature
 あなたがエディタで使っているその機能、他のエージェントは触ることができません。
 最高の同僚に最高の道具を渡してください。これでリファクタリングも、ナビゲーションも、分析も、エージェントが適切に行えるようになります。
 
-- **lsp_goto_definition**: シンボル定義へジャンプ
-- **lsp_find_references**: ワークスペース全体で使用箇所を検索
-- **lsp_symbols**: ファイルからシンボルを取得 (scope='document') またはワークスペース全体を検索 (scope='workspace')
 - **lsp_diagnostics**: ビルド前にエラー/警告を取得
-- **lsp_servers**: 利用可能な LSP サーバー一覧
 - **lsp_prepare_rename**: 名前変更操作の検証
 - **lsp_rename**: ワークスペース全体でシンボル名を変更
 - **ast_grep_search**: AST 認識コードパターン検索 (25言語対応)
@@ -1000,7 +996,7 @@ Oh My OpenCode は以下の場所からフックを読み込んで実行しま
 }
 ```
 
-利用可能なフック：`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-context-window-limit-recovery`, `rules-injector`, `background-notification`, `auto-update-checker`, `startup-toast`, `keyword-detector`, `agent-usage-reminder`, `non-interactive-env`, `interactive-bash-session`, `empty-message-sanitizer`, `compaction-context-injector`, `thinking-block-validator`, `claude-code-hooks`, `ralph-loop`, `preemptive-compaction`
+利用可能なフック：`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-context-window-limit-recovery`, `rules-injector`, `background-notification`, `auto-update-checker`, `startup-toast`, `keyword-detector`, `agent-usage-reminder`, `non-interactive-env`, `interactive-bash-session`, `compaction-context-injector`, `thinking-block-validator`, `claude-code-hooks`, `ralph-loop`, `preemptive-compaction`
 
 **`auto-update-checker`と`startup-toast`について**: `startup-toast` フックは `auto-update-checker` のサブ機能です。アップデートチェックは有効なまま起動トースト通知のみを無効化するには、`disabled_hooks` に `"startup-toast"` を追加してください。すべてのアップデートチェック機能（トーストを含む）を無効化するには、`"auto-update-checker"` を追加してください。
 
@@ -1051,7 +1047,6 @@ OpenCode でサポートされるすべての LSP 構成およびカスタム設
 ```json
 {
   "experimental": {
-    "preemptive_compaction_threshold": 0.85,
     "truncate_all_tool_outputs": true,
     "aggressive_truncation": true,
     "auto_resume": true
@@ -1059,13 +1054,11 @@ OpenCode でサポートされるすべての LSP 構成およびカスタム設
 }
 ```
 
-| オプション                        | デフォルト | 説明                                                                                                                                                                               |
-| --------------------------------- | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `preemptive_compaction_threshold` | `0.85`     | プリエンプティブコンパクションをトリガーする閾値（0.5-0.95）。`preemptive-compaction` フックはデフォルトで有効です。このオプションで閾値をカスタマイズできます。                   |
-| `truncate_all_tool_outputs`       | `false`    | ホワイトリストのツール（Grep、Glob、LSP、AST-grep）だけでなく、すべてのツール出力を切り詰めます。Tool output truncator はデフォルトで有効です - `disabled_hooks`で無効化できます。 |
-| `aggressive_truncation`           | `false`    | トークン制限を超えた場合、ツール出力を積極的に切り詰めて制限内に収めます。デフォルトの切り詰めより積極的です。不十分な場合は要約/復元にフォールバックします。                      |
-| `auto_resume`                     | `false`    | thinking block エラーや thinking disabled violation からの回復成功後、自動的にセッションを再開します。最後のユーザーメッセージを抽出して続行します。                               |
-| `dcp_for_compaction`              | `false`    | コンパクション用DCP（動的コンテキスト整理）を有効化 - トークン制限超過時に最初に実行されます。コンパクション前に重複したツール呼び出しと古いツール出力を整理します。               |
+| オプション                  | デフォルト | 説明                                                                                                                                                                               |
+| --------------------------- | ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `truncate_all_tool_outputs` | `false`    | ホワイトリストのツール（Grep、Glob、LSP、AST-grep）だけでなく、すべてのツール出力を切り詰めます。Tool output truncator はデフォルトで有効です - `disabled_hooks`で無効化できます。 |
+| `aggressive_truncation`     | `false`    | トークン制限を超えた場合、ツール出力を積極的に切り詰めて制限内に収めます。デフォルトの切り詰めより積極的です。不十分な場合は要約/復元にフォールバックします。                      |
+| `auto_resume`               | `false`    | thinking block エラーや thinking disabled violation からの回復成功後、自動的にセッションを再開します。最後のユーザーメッセージを抽出して続行します。                               |
 
 **警告**：これらの機能は実験的であり、予期しない動作を引き起こす可能性があります。影響を理解した場合にのみ有効にしてください。
 

README.md

@@ -62,6 +62,7 @@ Yes, technically possible. But I cannot recommend using it.
 [![GitHub Stars](https://img.shields.io/github/stars/code-yeongyu/oh-my-opencode?color=ffcb47&labelColor=black&style=flat-square)](https://github.com/code-yeongyu/oh-my-opencode/stargazers)
 [![GitHub Issues](https://img.shields.io/github/issues/code-yeongyu/oh-my-opencode?color=ff80eb&labelColor=black&style=flat-square)](https://github.com/code-yeongyu/oh-my-opencode/issues)
 [![License](https://img.shields.io/badge/license-SUL--1.0-white?labelColor=black&style=flat-square)](https://github.com/code-yeongyu/oh-my-opencode/blob/master/LICENSE.md)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/code-yeongyu/oh-my-opencode)
 
 [English](README.md) | [日本語](README.ja.md) | [简体中文](README.zh-cn.md)
 
@@ -577,17 +578,13 @@ Syntax highlighting, autocomplete, refactoring, navigation, analysis—and now a
 The features in your editor? Other agents can't touch them.
 Hand your best tools to your best colleagues. Now they can properly refactor, navigate, and analyze.
 
-- **lsp_goto_definition**: Jump to symbol definition
-- **lsp_find_references**: Find all usages across workspace
-- **lsp_symbols**: Get symbols from file (scope='document') or search across workspace (scope='workspace')
 - **lsp_diagnostics**: Get errors/warnings before build
-- **lsp_servers**: List available LSP servers
 - **lsp_prepare_rename**: Validate rename operation
 - **lsp_rename**: Rename symbol across workspace
 - **ast_grep_search**: AST-aware code pattern search (25 languages)
 - **ast_grep_replace**: AST-aware code replacement
 - **call_omo_agent**: Spawn specialized explore/librarian agents. Supports `run_in_background` parameter for async execution.
-- **sisyphus_task**: Category-based task delegation with specialized agents. Supports pre-configured categories (visual, business-logic) or direct agent targeting. Use `background_output` to retrieve results and `background_cancel` to cancel tasks. See [Categories](#categories).
+- **delegate_task**: Category-based task delegation with specialized agents. Supports pre-configured categories (visual, business-logic) or direct agent targeting. Use `background_output` to retrieve results and `background_cancel` to cancel tasks. See [Categories](#categories).
 
 #### Session Management
 
@@ -926,7 +923,7 @@ Available agents: `oracle`, `librarian`, `explore`, `frontend-ui-ux-engineer`, `
 Oh My OpenCode includes built-in skills that provide additional capabilities:
 
 - **playwright**: Browser automation with Playwright MCP. Use for web scraping, testing, screenshots, and browser interactions.
-- **git-master**: Git expert for atomic commits, rebase/squash, and history search (blame, bisect, log -S). STRONGLY RECOMMENDED: Use with `sisyphus_task(category='quick', skills=['git-master'], ...)` to save context.
+- **git-master**: Git expert for atomic commits, rebase/squash, and history search (blame, bisect, log -S). STRONGLY RECOMMENDED: Use with `delegate_task(category='quick', skills=['git-master'], ...)` to save context.
 
 Disable built-in skills via `disabled_skills` in `~/.config/opencode/oh-my-opencode.json` or `.opencode/oh-my-opencode.json`:
 
@@ -1065,7 +1062,7 @@ Configure concurrency limits for background agent tasks. This controls how many
 
 ### Categories
 
-Categories enable domain-specific task delegation via the `sisyphus_task` tool. Each category applies runtime presets (model, temperature, prompt additions) when calling the `Sisyphus-Junior` agent.
+Categories enable domain-specific task delegation via the `delegate_task` tool. Each category applies runtime presets (model, temperature, prompt additions) when calling the `Sisyphus-Junior` agent.
 
 **Default Categories:**
 
@@ -1077,12 +1074,12 @@ Categories enable domain-specific task delegation via the `sisyphus_task` tool.
 **Usage:**
 
 ```
-// Via sisyphus_task tool
-sisyphus_task(category="visual", prompt="Create a responsive dashboard component")
-sisyphus_task(category="business-logic", prompt="Design the payment processing flow")
+// Via delegate_task tool
+delegate_task(category="visual", prompt="Create a responsive dashboard component")
+delegate_task(category="business-logic", prompt="Design the payment processing flow")
 
 // Or target a specific agent directly
-sisyphus_task(agent="oracle", prompt="Review this architecture")
+delegate_task(agent="oracle", prompt="Review this architecture")
 ```
 
 **Custom Categories:**
@@ -1117,7 +1114,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-context-window-limit-recovery`, `rules-injector`, `background-notification`, `auto-update-checker`, `startup-toast`, `keyword-detector`, `agent-usage-reminder`, `non-interactive-env`, `interactive-bash-session`, `empty-message-sanitizer`, `compaction-context-injector`, `thinking-block-validator`, `claude-code-hooks`, `ralph-loop`, `preemptive-compaction`
+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-context-window-limit-recovery`, `rules-injector`, `background-notification`, `auto-update-checker`, `startup-toast`, `keyword-detector`, `agent-usage-reminder`, `non-interactive-env`, `interactive-bash-session`, `compaction-context-injector`, `thinking-block-validator`, `claude-code-hooks`, `ralph-loop`, `preemptive-compaction`
 
 **Note on `auto-update-checker` and `startup-toast`**: The `startup-toast` hook is a sub-feature of `auto-update-checker`. To disable only the startup toast notification while keeping update checking enabled, add `"startup-toast"` to `disabled_hooks`. To disable all update checking features (including the toast), add `"auto-update-checker"` to `disabled_hooks`.
 
@@ -1169,7 +1166,6 @@ Opt-in experimental features that may change or be removed in future versions. U
 ```json
 {
   "experimental": {
-    "preemptive_compaction_threshold": 0.85,
     "truncate_all_tool_outputs": true,
     "aggressive_truncation": true,
     "auto_resume": true
@@ -1177,13 +1173,11 @@ Opt-in experimental features that may change or be removed in future versions. U
 }
 ```
 
-| Option                            | Default | Description                                                                                                                                                                                   |
-| --------------------------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `preemptive_compaction_threshold` | `0.85`  | Threshold percentage (0.5-0.95) to trigger preemptive compaction. The `preemptive-compaction` hook is enabled by default; this option customizes the threshold.                               |
-| `truncate_all_tool_outputs`       | `false` | Truncates ALL tool outputs instead of just whitelisted tools (Grep, Glob, LSP, AST-grep). Tool output truncator is enabled by default - disable via `disabled_hooks`.                         |
-| `aggressive_truncation`           | `false` | When token limit is exceeded, aggressively truncates tool outputs to fit within limits. More aggressive than the default truncation behavior. Falls back to summarize/revert if insufficient. |
-| `auto_resume`                     | `false` | Automatically resumes session after successful recovery from thinking block errors or thinking disabled violations. Extracts the last user message and continues.                             |
-| `dcp_for_compaction`              | `false` | Enable DCP (Dynamic Context Pruning) for compaction - runs first when token limit exceeded. Prunes duplicate tool calls and old tool outputs before running compaction.                       |
+| Option                      | Default | Description                                                                                                                                                                                   |
+| --------------------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `truncate_all_tool_outputs` | `false` | Truncates ALL tool outputs instead of just whitelisted tools (Grep, Glob, LSP, AST-grep). Tool output truncator is enabled by default - disable via `disabled_hooks`.                         |
+| `aggressive_truncation`     | `false` | When token limit is exceeded, aggressively truncates tool outputs to fit within limits. More aggressive than the default truncation behavior. Falls back to summarize/revert if insufficient. |
+| `auto_resume`               | `false` | Automatically resumes session after successful recovery from thinking block errors or thinking disabled violations. Extracts the last user message and continues.                             |
 
 **Warning**: These features are experimental and may cause unexpected behavior. Enable only if you understand the implications.
 

README.zh-cn.md

@@ -574,17 +574,13 @@ gh repo star code-yeongyu/oh-my-opencode
 你编辑器中的功能？其他智能体无法触及。
 把你最好的工具交给你最好的同事。现在它们可以正确地重构、导航和分析。
 
-- **lsp_goto_definition**：跳转到符号定义
-- **lsp_find_references**：查找工作区中的所有使用
-- **lsp_symbols**：从文件获取符号 (scope='document') 或在工作区中搜索 (scope='workspace')
 - **lsp_diagnostics**：在构建前获取错误/警告
-- **lsp_servers**：列出可用的 LSP 服务器
 - **lsp_prepare_rename**：验证重命名操作
 - **lsp_rename**：在工作区中重命名符号
 - **ast_grep_search**：AST 感知的代码模式搜索（25 种语言）
 - **ast_grep_replace**：AST 感知的代码替换
 - **call_omo_agent**：生成专业的 explore/librarian 智能体。支持 `run_in_background` 参数进行异步执行。
-- **sisyphus_task**：基于类别的任务委派，使用专业智能体。支持预配置的类别（visual、business-logic）或直接指定智能体。使用 `background_output` 检索结果，使用 `background_cancel` 取消任务。参见[类别](#类别)。
+- **delegate_task**：基于类别的任务委派，使用专业智能体。支持预配置的类别（visual、business-logic）或直接指定智能体。使用 `background_output` 检索结果，使用 `background_cancel` 取消任务。参见[类别](#类别)。
 
 #### 会话管理
 
@@ -935,7 +931,7 @@ Oh My OpenCode 从以下位置读取和执行钩子：
 Oh My OpenCode 包含提供额外功能的内置技能：
 
 - **playwright**：使用 Playwright MCP 进行浏览器自动化。用于网页抓取、测试、截图和浏览器交互。
-- **git-master**：Git 专家，用于原子提交、rebase/squash 和历史搜索（blame、bisect、log -S）。**强烈推荐**：与 `sisyphus_task(category='quick', skills=['git-master'], ...)` 一起使用以节省上下文。
+- **git-master**：Git 专家，用于原子提交、rebase/squash 和历史搜索（blame、bisect、log -S）。**强烈推荐**：与 `delegate_task(category='quick', skills=['git-master'], ...)` 一起使用以节省上下文。
 
 通过 `~/.config/opencode/oh-my-opencode.json` 或 `.opencode/oh-my-opencode.json` 中的 `disabled_skills` 禁用内置技能：
 
@@ -1074,7 +1070,7 @@ Oh My OpenCode 包含提供额外功能的内置技能：
 
 ### 类别
 
-类别通过 `sisyphus_task` 工具实现领域特定的任务委派。每个类别预配置一个专业的 `Sisyphus-Junior-{category}` 智能体，带有优化的模型设置和提示。
+类别通过 `delegate_task` 工具实现领域特定的任务委派。每个类别预配置一个专业的 `Sisyphus-Junior-{category}` 智能体，带有优化的模型设置和提示。
 
 **默认类别：**
 
@@ -1086,12 +1082,12 @@ Oh My OpenCode 包含提供额外功能的内置技能：
 **使用方法：**
 
 ```
-// 通过 sisyphus_task 工具
-sisyphus_task(category="visual", prompt="创建一个响应式仪表板组件")
-sisyphus_task(category="business-logic", prompt="设计支付处理流程")
+// 通过 delegate_task 工具
+delegate_task(category="visual", prompt="创建一个响应式仪表板组件")
+delegate_task(category="business-logic", prompt="设计支付处理流程")
 
 // 或直接指定特定智能体
-sisyphus_task(agent="oracle", prompt="审查这个架构")
+delegate_task(agent="oracle", prompt="审查这个架构")
 ```
 
 **自定义类别：**
@@ -1126,7 +1122,7 @@ sisyphus_task(agent="oracle", prompt="审查这个架构")
 }
 ```
 
-可用钩子：`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-context-window-limit-recovery`、`rules-injector`、`background-notification`、`auto-update-checker`、`startup-toast`、`keyword-detector`、`agent-usage-reminder`、`non-interactive-env`、`interactive-bash-session`、`empty-message-sanitizer`、`compaction-context-injector`、`thinking-block-validator`、`claude-code-hooks`、`ralph-loop`、`preemptive-compaction`
+可用钩子：`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-context-window-limit-recovery`、`rules-injector`、`background-notification`、`auto-update-checker`、`startup-toast`、`keyword-detector`、`agent-usage-reminder`、`non-interactive-env`、`interactive-bash-session`、`compaction-context-injector`、`thinking-block-validator`、`claude-code-hooks`、`ralph-loop`、`preemptive-compaction`
 
 **关于 `auto-update-checker` 和 `startup-toast` 的说明**：`startup-toast` 钩子是 `auto-update-checker` 的子功能。要仅禁用启动 toast 通知而保持更新检查启用，在 `disabled_hooks` 中添加 `"startup-toast"`。要禁用所有更新检查功能（包括 toast），在 `disabled_hooks` 中添加 `"auto-update-checker"`。
 
@@ -1178,7 +1174,6 @@ Oh My OpenCode 添加了重构工具（重命名、代码操作）。
 ```json
 {
   "experimental": {
-    "preemptive_compaction_threshold": 0.85,
     "truncate_all_tool_outputs": true,
     "aggressive_truncation": true,
     "auto_resume": true
@@ -1186,13 +1181,11 @@ Oh My OpenCode 添加了重构工具（重命名、代码操作）。
 }
 ```
 
-| 选项                              | 默认    | 描述                                                                                                                                                                                          |
-| --------------------------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `preemptive_compaction_threshold` | `0.85`  | 触发预防性压缩的阈值百分比（0.5-0.95）。`preemptive-compaction` 钩子默认启用；此选项自定义阈值。                                                                                              |
-| `truncate_all_tool_outputs`       | `false` | 截断所有工具输出而不仅仅是白名单工具（Grep、Glob、LSP、AST-grep）。工具输出截断器默认启用——通过 `disabled_hooks` 禁用。                                                                       |
-| `aggressive_truncation`           | `false` | 当超过 token 限制时，积极截断工具输出以适应限制。比默认截断行为更激进。如果不足以满足，则回退到总结/恢复。                                                                                    |
-| `auto_resume`                     | `false` | 从思考块错误或禁用思考违规成功恢复后自动恢复会话。提取最后一条用户消息并继续。                                                                                                                |
-| `dcp_for_compaction`              | `false` | 为压缩启用 DCP（动态上下文修剪）——当超过 token 限制时首先运行。在运行压缩之前修剪重复的工具调用和旧的工具输出。                                                                               |
+| 选项                        | 默认    | 描述                                                                                                                                                       |
+| --------------------------- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `truncate_all_tool_outputs` | `false` | 截断所有工具输出而不仅仅是白名单工具（Grep、Glob、LSP、AST-grep）。工具输出截断器默认启用——通过 `disabled_hooks` 禁用。                                    |
+| `aggressive_truncation`     | `false` | 当超过 token 限制时，积极截断工具输出以适应限制。比默认截断行为更激进。如果不足以满足，则回退到总结/恢复。                                                 |
+| `auto_resume`               | `false` | 从思考块错误或禁用思考违规成功恢复后自动恢复会话。提取最后一条用户消息并继续。                                                                             |
 
 **警告**：这些功能是实验性的，可能导致意外行为。只有在理解其影响后才启用。
 

assets/oh-my-opencode.schema.json

@@ -69,15 +69,13 @@
           "agent-usage-reminder",
           "non-interactive-env",
           "interactive-bash-session",
-          "empty-message-sanitizer",
           "thinking-block-validator",
           "ralph-loop",
-          "preemptive-compaction",
           "compaction-context-injector",
           "claude-code-hooks",
           "auto-slash-command",
           "edit-error-recovery",
-          "sisyphus-task-retry",
+          "delegate-task-retry",
           "prometheus-md-only",
           "start-work",
           "sisyphus-orchestrator"
@@ -2134,14 +2132,6 @@
         "auto_resume": {
           "type": "boolean"
         },
-        "preemptive_compaction": {
-          "type": "boolean"
-        },
-        "preemptive_compaction_threshold": {
-          "type": "number",
-          "minimum": 0.5,
-          "maximum": 0.95
-        },
         "truncate_all_tool_outputs": {
           "type": "boolean"
         },
@@ -2234,9 +2224,6 @@
               }
             }
           }
-        },
-        "dcp_for_compaction": {
-          "type": "boolean"
         }
       }
     },
@@ -2406,6 +2393,10 @@
             "type": "number",
             "minimum": 1
           }
+        },
+        "staleTimeoutMs": {
+          "type": "number",
+          "minimum": 60000
         }
       }
     },

bun.lock

@@ -1,6 +1,6 @@
 {
   "lockfileVersion": 1,
-  "configVersion": 1,
+  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "oh-my-opencode",
@@ -31,13 +31,13 @@
         "typescript": "^5.7.3",
       },
       "optionalDependencies": {
-        "oh-my-opencode-darwin-arm64": "0.0.0",
-        "oh-my-opencode-darwin-x64": "0.0.0",
-        "oh-my-opencode-linux-arm64": "0.0.0",
-        "oh-my-opencode-linux-arm64-musl": "0.0.0",
-        "oh-my-opencode-linux-x64": "0.0.0",
-        "oh-my-opencode-linux-x64-musl": "0.0.0",
-        "oh-my-opencode-windows-x64": "0.0.0",
+        "oh-my-opencode-darwin-arm64": "3.0.0-beta.8",
+        "oh-my-opencode-darwin-x64": "3.0.0-beta.8",
+        "oh-my-opencode-linux-arm64": "3.0.0-beta.8",
+        "oh-my-opencode-linux-arm64-musl": "3.0.0-beta.8",
+        "oh-my-opencode-linux-x64": "3.0.0-beta.8",
+        "oh-my-opencode-linux-x64-musl": "3.0.0-beta.8",
+        "oh-my-opencode-windows-x64": "3.0.0-beta.8",
       },
     },
   },

bunfig.toml

@@ -0,0 +1,2 @@
+[test]
+preload = ["./test-setup.ts"]

docs/category-skill-guide.md

@@ -9,7 +9,7 @@ Instead of delegating everything to a single AI agent, it's far more efficient t
 - **Category**: "What kind of work is this?" (determines model, temperature, prompt mindset)
 - **Skill**: "What tools and knowledge are needed?" (injects specialized knowledge, MCP tools, workflows)
 
-By combining these two concepts, you can generate optimal agents through `sisyphus_task`.
+By combining these two concepts, you can generate optimal agents through `delegate_task`.
 
 ---
 
@@ -30,10 +30,10 @@ A Category is an agent configuration preset optimized for specific domains.
 
 ### Usage
 
-Specify the `category` parameter when invoking the `sisyphus_task` tool.
+Specify the `category` parameter when invoking the `delegate_task` tool.
 
 ```typescript
-sisyphus_task(
+delegate_task(
   category="visual-engineering",
   prompt="Add a responsive chart component to the dashboard page"
 )
@@ -72,7 +72,7 @@ A Skill is a mechanism that injects **specialized knowledge (Context)** and **to
 Add desired skill names to the `skills` array.
 
 ```typescript
-sisyphus_task(
+delegate_task(
   category="quick",
   skills=["git-master"],
   prompt="Commit current changes. Follow commit message style."
@@ -124,7 +124,7 @@ You can create powerful specialized agents by combining Categories and Skills.
 
 ---
 
-## 5. sisyphus_task Prompt Guide
+## 5. delegate_task Prompt Guide
 
 When delegating, **clear and specific** prompts are essential. Include these 7 elements:
 

docs/orchestration-guide.md

@@ -149,4 +149,4 @@ You can control related features in `oh-my-opencode.json`.
 
 1. **Don't Rush**: Invest sufficient time in the interview with Prometheus. The more perfect the plan, the faster the execution.
 2. **Single Plan Principle**: No matter how large the task, contain all TODOs in one plan file (`.md`). This prevents context fragmentation.
-3. **Active Delegation**: During execution, delegate to specialized agents via `sisyphus_task` rather than modifying code directly.
+3. **Active Delegation**: During execution, delegate to specialized agents via `delegate_task` rather than modifying code directly.

package.json

@@ -56,18 +56,14 @@
     "@clack/prompts": "^0.11.0",
     "@code-yeongyu/comment-checker": "^0.6.1",
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "@openauthjs/openauth": "^0.4.3",
     "@opencode-ai/plugin": "^1.1.19",
     "@opencode-ai/sdk": "^1.1.19",
     "commander": "^14.0.2",
     "detect-libc": "^2.0.0",
-    "hono": "^4.10.4",
     "js-yaml": "^4.1.1",
     "jsonc-parser": "^3.3.1",
-    "open": "^11.0.0",
     "picocolors": "^1.1.1",
     "picomatch": "^4.0.2",
-    "xdg-basedir": "^5.1.0",
     "zod": "^4.1.8"
   },
   "devDependencies": {

packages/darwin-arm64/package.json

@@ -1,15 +1,21 @@
 {
   "name": "oh-my-opencode-darwin-arm64",
-  "version": "3.0.0-beta.8",
+  "version": "3.0.0-beta.9",
   "description": "Platform-specific binary for oh-my-opencode (darwin-arm64)",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/code-yeongyu/oh-my-opencode"
   },
-  "os": ["darwin"],
-  "cpu": ["arm64"],
-  "files": ["bin"],
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "files": [
+    "bin"
+  ],
   "bin": {
     "oh-my-opencode": "./bin/oh-my-opencode"
   }

packages/darwin-x64/package.json

@@ -1,15 +1,21 @@
 {
   "name": "oh-my-opencode-darwin-x64",
-  "version": "3.0.0-beta.8",
+  "version": "3.0.0-beta.9",
   "description": "Platform-specific binary for oh-my-opencode (darwin-x64)",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/code-yeongyu/oh-my-opencode"
   },
-  "os": ["darwin"],
-  "cpu": ["x64"],
-  "files": ["bin"],
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "files": [
+    "bin"
+  ],
   "bin": {
     "oh-my-opencode": "./bin/oh-my-opencode"
   }

packages/linux-arm64-musl/package.json

@@ -1,16 +1,24 @@
 {
   "name": "oh-my-opencode-linux-arm64-musl",
-  "version": "3.0.0-beta.8",
+  "version": "3.0.0-beta.9",
   "description": "Platform-specific binary for oh-my-opencode (linux-arm64-musl)",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/code-yeongyu/oh-my-opencode"
   },
-  "os": ["linux"],
-  "cpu": ["arm64"],
-  "libc": ["musl"],
-  "files": ["bin"],
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "libc": [
+    "musl"
+  ],
+  "files": [
+    "bin"
+  ],
   "bin": {
     "oh-my-opencode": "./bin/oh-my-opencode"
   }

packages/linux-arm64/package.json

@@ -1,16 +1,24 @@
 {
   "name": "oh-my-opencode-linux-arm64",
-  "version": "3.0.0-beta.8",
+  "version": "3.0.0-beta.9",
   "description": "Platform-specific binary for oh-my-opencode (linux-arm64)",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/code-yeongyu/oh-my-opencode"
   },
-  "os": ["linux"],
-  "cpu": ["arm64"],
-  "libc": ["glibc"],
-  "files": ["bin"],
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "libc": [
+    "glibc"
+  ],
+  "files": [
+    "bin"
+  ],
   "bin": {
     "oh-my-opencode": "./bin/oh-my-opencode"
   }

packages/linux-x64-musl/package.json

@@ -1,16 +1,24 @@
 {
   "name": "oh-my-opencode-linux-x64-musl",
-  "version": "3.0.0-beta.8",
+  "version": "3.0.0-beta.9",
   "description": "Platform-specific binary for oh-my-opencode (linux-x64-musl)",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/code-yeongyu/oh-my-opencode"
   },
-  "os": ["linux"],
-  "cpu": ["x64"],
-  "libc": ["musl"],
-  "files": ["bin"],
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "libc": [
+    "musl"
+  ],
+  "files": [
+    "bin"
+  ],
   "bin": {
     "oh-my-opencode": "./bin/oh-my-opencode"
   }

packages/linux-x64/package.json

@@ -1,16 +1,24 @@
 {
   "name": "oh-my-opencode-linux-x64",
-  "version": "3.0.0-beta.8",
+  "version": "3.0.0-beta.9",
   "description": "Platform-specific binary for oh-my-opencode (linux-x64)",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/code-yeongyu/oh-my-opencode"
   },
-  "os": ["linux"],
-  "cpu": ["x64"],
-  "libc": ["glibc"],
-  "files": ["bin"],
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "libc": [
+    "glibc"
+  ],
+  "files": [
+    "bin"
+  ],
   "bin": {
     "oh-my-opencode": "./bin/oh-my-opencode"
   }

packages/windows-x64/package.json

@@ -1,15 +1,21 @@
 {
   "name": "oh-my-opencode-windows-x64",
-  "version": "3.0.0-beta.8",
+  "version": "3.0.0-beta.9",
   "description": "Platform-specific binary for oh-my-opencode (windows-x64)",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/code-yeongyu/oh-my-opencode"
   },
-  "os": ["win32"],
-  "cpu": ["x64"],
-  "files": ["bin"],
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "files": [
+    "bin"
+  ],
   "bin": {
     "oh-my-opencode": "./bin/oh-my-opencode.exe"
   }

script/publish.ts

@@ -232,10 +232,17 @@ async function publishAllPackages(version: string): Promise<void> {
 }
 
 async function buildPackages(): Promise<void> {
+  const skipPlatform = process.env.SKIP_PLATFORM_PACKAGES === "true"
+  
   console.log("\nBuilding packages...")
   await $`bun run clean && bun run build`
-  console.log("Building platform binaries...")
-  await $`bun run build:binaries`
+  
+  if (skipPlatform) {
+    console.log("⏭️  Skipping platform binaries (SKIP_PLATFORM_PACKAGES=true)")
+  } else {
+    console.log("Building platform binaries...")
+    await $`bun run build:binaries`
+  }
 }
 
 async function gitTagAndRelease(newVersion: string, notes: string[]): Promise<void> {

signatures/cla.json

@@ -551,6 +551,54 @@
       "created_at": "2026-01-15T09:57:16Z",
       "repoId": 1108837393,
       "pullRequestNo": 812
+    },
+    {
+      "name": "minkichoe-lbox",
+      "id": 194467696,
+      "comment_id": 3758902914,
+      "created_at": "2026-01-16T09:14:21Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 847
+    },
+    {
+      "name": "vmlinuzx",
+      "id": 233838569,
+      "comment_id": 3760678754,
+      "created_at": "2026-01-16T15:45:52Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 837
+    },
+    {
+      "name": "luojiyin1987",
+      "id": 6524977,
+      "comment_id": 3760712340,
+      "created_at": "2026-01-16T15:54:07Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 855
+    },
+    {
+      "name": "qwertystars",
+      "id": 62981066,
+      "comment_id": 3761235668,
+      "created_at": "2026-01-16T18:13:52Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 859
+    },
+    {
+      "name": "sgwannabe",
+      "id": 33509021,
+      "comment_id": 3762457370,
+      "created_at": "2026-01-17T01:25:58Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 863
+    },
+    {
+      "name": "G-hoon",
+      "id": 26299556,
+      "comment_id": 3764015966,
+      "created_at": "2026-01-17T15:27:41Z",
+      "repoId": 1108837393,
+      "pullRequestNo": 879
     }
   ]
 }

src/agents/AGENTS.md

@@ -1,61 +1,71 @@
 # AGENTS KNOWLEDGE BASE
 
 ## OVERVIEW
-AI agent definitions for multi-model orchestration, delegating tasks to specialized experts.
+
+10 AI agents for multi-model orchestration. Sisyphus (primary), oracle, librarian, explore, frontend, document-writer, multimodal-looker, Prometheus, Metis, Momus.
 
 ## STRUCTURE
+
 ```
 agents/
-├── orchestrator-sisyphus.ts # Orchestrator agent (1485 lines) - 7-section delegation, wisdom
-├── sisyphus.ts              # Main Sisyphus prompt (643 lines)
-├── sisyphus-junior.ts       # Junior variant for delegated tasks
-├── oracle.ts                # Strategic advisor (GPT-5.2)
-├── librarian.ts             # Multi-repo research (GLM-4.7-free)
-├── explore.ts               # Fast codebase grep (Grok Code)
-├── frontend-ui-ux-engineer.ts  # UI generation (Gemini 3 Pro Preview)
-├── document-writer.ts       # Technical docs (Gemini 3 Pro Preview)
-├── multimodal-looker.ts     # PDF/image analysis (Gemini 3 Flash)
-├── prometheus-prompt.ts     # Planning agent prompt (991 lines) - interview mode
-├── metis.ts                 # Plan Consultant agent - pre-planning analysis
-├── momus.ts                 # Plan Reviewer agent - plan validation
-├── build-prompt.ts          # Shared build agent prompt
-├── plan-prompt.ts           # Shared plan agent prompt
-├── sisyphus-prompt-builder.ts # Factory for orchestrator prompts
-├── types.ts                 # AgentModelConfig interface
-├── utils.ts                 # createBuiltinAgents(), getAgentName()
-└── index.ts                 # builtinAgents export
+├── orchestrator-sisyphus.ts    # Orchestrator (1531 lines) - 7-phase delegation
+├── sisyphus.ts                 # Main prompt (640 lines)
+├── sisyphus-junior.ts          # Delegated task executor
+├── sisyphus-prompt-builder.ts  # Dynamic prompt generation
+├── oracle.ts                   # Strategic advisor (GPT-5.2)
+├── librarian.ts                # Multi-repo research (GLM-4.7-free)
+├── explore.ts                  # Fast grep (Grok Code)
+├── frontend-ui-ux-engineer.ts  # UI specialist (Gemini 3 Pro)
+├── document-writer.ts          # Technical writer (Gemini 3 Flash)
+├── multimodal-looker.ts        # Media analyzer (Gemini 3 Flash)
+├── prometheus-prompt.ts        # Planning (1196 lines) - interview mode
+├── metis.ts                    # Plan consultant - pre-planning analysis
+├── momus.ts                    # Plan reviewer - validation
+├── types.ts                    # AgentModelConfig interface
+├── utils.ts                    # createBuiltinAgents(), getAgentName()
+└── index.ts                    # builtinAgents export
 ```
 
 ## AGENT MODELS
-| Agent | Default Model | Purpose |
-|-------|---------------|---------|
-| Sisyphus | anthropic/claude-opus-4-5 | Primary orchestrator. 32k extended thinking budget. |
-| oracle | openai/gpt-5.2 | High-IQ debugging, architecture, strategic consultation. |
-| librarian | opencode/glm-4.7-free | Multi-repo analysis, docs research, GitHub examples. |
-| explore | opencode/grok-code | Fast contextual grep. Fallbacks: Gemini-3-Flash, Haiku-4-5. |
-| frontend-ui-ux | google/gemini-3-pro-preview | Production-grade UI/UX generation and styling. |
-| document-writer | google/gemini-3-pro-preview | Technical writing, guides, API documentation. |
-| Prometheus | anthropic/claude-opus-4-5 | Strategic planner. Interview mode, orchestrates Metis/Momus. |
-| Metis | anthropic/claude-sonnet-4-5 | Plan Consultant. Pre-planning risk/requirement analysis. |
-| Momus | anthropic/claude-sonnet-4-5 | Plan Reviewer. Validation and quality enforcement. |
 
-## HOW TO ADD AN AGENT
-1. Create `src/agents/my-agent.ts` exporting `AgentConfig`.
-2. Add to `builtinAgents` in `src/agents/index.ts`.
-3. Update `types.ts` if adding new config interfaces.
+| Agent | Model | Temperature | Purpose |
+|-------|-------|-------------|---------|
+| Sisyphus | anthropic/claude-opus-4-5 | 0.1 | Primary orchestrator, todo-driven |
+| oracle | openai/gpt-5.2 | 0.1 | Read-only consultation, debugging |
+| librarian | opencode/glm-4.7-free | 0.1 | Docs, GitHub search, OSS examples |
+| explore | opencode/grok-code | 0.1 | Fast contextual grep |
+| frontend-ui-ux-engineer | google/gemini-3-pro-preview | 0.7 | UI generation, visual design |
+| document-writer | google/gemini-3-flash | 0.3 | Technical documentation |
+| multimodal-looker | google/gemini-3-flash | 0.1 | PDF/image analysis |
+| Prometheus | anthropic/claude-opus-4-5 | 0.1 | Strategic planning, interview mode |
+| Metis | anthropic/claude-sonnet-4-5 | 0.1 | Pre-planning gap analysis |
+| Momus | anthropic/claude-sonnet-4-5 | 0.1 | Plan validation |
 
-## MODEL FALLBACK LOGIC
-`createBuiltinAgents()` handles resolution:
-1. User config override (`agents.{name}.model`).
-2. Environment-specific settings (max20, antigravity).
-3. Hardcoded defaults in `index.ts`.
+## HOW TO ADD
+
+1. Create `src/agents/my-agent.ts` exporting `AgentConfig`
+2. Add to `builtinAgents` in `src/agents/index.ts`
+3. Update `AgentNameSchema` in `src/config/schema.ts`
+4. Register in `src/index.ts` initialization
+
+## TOOL RESTRICTIONS
+
+| Agent | Denied Tools |
+|-------|-------------|
+| oracle | write, edit, task, delegate_task |
+| librarian | write, edit, task, delegate_task, call_omo_agent |
+| explore | write, edit, task, delegate_task, call_omo_agent |
+| multimodal-looker | Allowlist: read, glob, grep |
+
+## KEY PATTERNS
+
+- **Factory**: `createXXXAgent(model?: string): AgentConfig`
+- **Metadata**: `XXX_PROMPT_METADATA: AgentPromptMetadata`
+- **Tool restrictions**: `permission: { edit: "deny", bash: "ask" }`
+- **Thinking**: 32k budget tokens for Sisyphus, Oracle, Prometheus
 
 ## ANTI-PATTERNS
-- **Trusting reports**: NEVER trust subagent self-reports; always verify outputs.
-- **High temp**: Don't use >0.3 for code agents (Sisyphus/Prometheus use 0.1).
-- **Sequential calls**: Prefer `sisyphus_task` with `run_in_background` for parallelism.
 
-## SHARED PROMPTS
-- **build-prompt.ts**: Unified base for Sisyphus and Builder variants.
-- **plan-prompt.ts**: Core planning logic shared across planning agents.
-- **orchestrator-sisyphus.ts**: Uses a 7-section prompt structure and "wisdom notepad" to preserve learnings across turns.
+- **Trust reports**: NEVER trust subagent "I'm done" - verify outputs
+- **High temp**: Don't use >0.3 for code agents
+- **Sequential calls**: Use `delegate_task` with `run_in_background`

src/agents/build-prompt.ts

@@ -1,68 +0,0 @@
-/**
- * OpenCode's default build agent system prompt.
- *
- * This prompt enables FULL EXECUTION mode for the build agent, allowing file
- * modifications, command execution, and system changes while focusing on
- * implementation and execution.
- *
- * Inspired by OpenCode's build agent behavior.
- * 
- * @see https://github.com/sst/opencode/blob/6f9bea4e1f3d139feefd0f88de260b04f78caaef/packages/opencode/src/session/prompt/build-switch.txt
- * @see https://github.com/sst/opencode/blob/6f9bea4e1f3d139feefd0f88de260b04f78caaef/packages/opencode/src/agent/agent.ts#L118-L125
- */
-export const BUILD_SYSTEM_PROMPT = `<system-reminder>
-# Build Mode - System Reminder
-
-BUILD MODE ACTIVE - you are in EXECUTION phase. Your responsibility is to:
-- Implement features and make code changes
-- Execute commands and run tests
-- Fix bugs and refactor code
-- Deploy and build systems
-- Make all necessary file modifications
-
-You have FULL permissions to edit files, run commands, and make system changes.
-This is the implementation phase - execute decisively and thoroughly.
-
----
-
-## Responsibility
-
-Your current responsibility is to implement, build, and execute. You should:
-- Write and modify code to accomplish the user's goals
-- Run tests and builds to verify your changes
-- Fix errors and issues that arise
-- Use all available tools to complete the task efficiently
-- Delegate to specialized agents when appropriate for better results
-
-**NOTE:** You should ask the user for clarification when requirements are ambiguous,
-but once the path is clear, execute confidently. The goal is to deliver working,
-tested, production-ready solutions.
-
----
-
-## Important
-
-The user wants you to execute and implement. You SHOULD make edits, run necessary
-tools, and make changes to accomplish the task. Use your full capabilities to
-deliver excellent results.
-</system-reminder>
-`
-
-/**
- * OpenCode's default build agent permission configuration.
- *
- * Allows the build agent full execution permissions:
- * - edit: "ask" - Can modify files with confirmation
- * - bash: "ask" - Can execute commands with confirmation  
- * - webfetch: "allow" - Can fetch web content
- *
- * This provides balanced permissions - powerful but with safety checks.
- * 
- * @see https://github.com/sst/opencode/blob/6f9bea4e1f3d139feefd0f88de260b04f78caaef/packages/opencode/src/agent/agent.ts#L57-L68
- * @see https://github.com/sst/opencode/blob/6f9bea4e1f3d139feefd0f88de260b04f78caaef/packages/opencode/src/agent/agent.ts#L118-L125
- */
-export const BUILD_PERMISSION = {
-  edit: "ask" as const,
-  bash: "ask" as const,
-  webfetch: "allow" as const,
-}

src/agents/explore.ts

@@ -29,7 +29,7 @@ export function createExploreAgent(model: string = DEFAULT_MODEL): AgentConfig {
     "write",
     "edit",
     "task",
-    "sisyphus_task",
+    "delegate_task",
     "call_omo_agent",
   ])
 

src/agents/librarian.ts

@@ -1,5 +1,6 @@
 import type { AgentConfig } from "@opencode-ai/sdk"
 import type { AgentPromptMetadata } from "./types"
+import { createAgentToolRestrictions } from "../shared/permission-compat"
 
 const DEFAULT_MODEL = "opencode/glm-4.7-free"
 
@@ -21,13 +22,21 @@ export const LIBRARIAN_PROMPT_METADATA: AgentPromptMetadata = {
 }
 
 export function createLibrarianAgent(model: string = DEFAULT_MODEL): AgentConfig {
+  const restrictions = createAgentToolRestrictions([
+    "write",
+    "edit",
+    "task",
+    "delegate_task",
+    "call_omo_agent",
+  ])
+
   return {
     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" as const,
     model,
     temperature: 0.1,
-    tools: { write: false, edit: false, background_task: false },
+    ...restrictions,
     prompt: `# THE LIBRARIAN
 
 You are **THE LIBRARIAN**, a specialized open-source codebase understanding agent.
@@ -37,10 +46,10 @@ Your job: Answer questions about open-source libraries by finding **EVIDENCE** w
 ## CRITICAL: DATE AWARENESS
 
 **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
+- **NEVER search for ${new Date().getFullYear() - 1}** - It is NOT ${new Date().getFullYear() - 1} anymore
+- **ALWAYS use current year** (${new Date().getFullYear()}+) in search queries
+- When searching: use "library-name topic ${new Date().getFullYear()}" NOT "${new Date().getFullYear() - 1}"
+- Filter out outdated ${new Date().getFullYear() - 1} results when they conflict with ${new Date().getFullYear()} information
 
 ---
 
@@ -240,7 +249,7 @@ https://github.com/tanstack/query/blob/abc123def/packages/react-query/src/useQue
 | **Find Docs URL** | websearch_exa | \`websearch_exa_web_search_exa("library official documentation")\` |
 | **Sitemap Discovery** | webfetch | \`webfetch(docs_url + "/sitemap.xml")\` to understand doc structure |
 | **Read Doc Page** | webfetch | \`webfetch(specific_doc_page)\` for targeted documentation |
-| **Latest Info** | websearch_exa | \`websearch_exa_web_search_exa("query 2025")\` |
+| **Latest Info** | websearch_exa | \`websearch_exa_web_search_exa("query ${new Date().getFullYear()}")\` |
 | **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\` |

src/agents/metis.ts

@@ -275,7 +275,7 @@ const metisRestrictions = createAgentToolRestrictions([
   "write",
   "edit",
   "task",
-  "sisyphus_task",
+  "delegate_task",
 ])
 
 const DEFAULT_MODEL = "anthropic/claude-opus-4-5"

src/agents/momus.ts

@@ -52,13 +52,30 @@ But the plan only says: "Add authentication following auth/login.ts pattern."
 
 ## Your Core Review Principle
 
-**REJECT if**: When you simulate actually doing the work, you cannot obtain clear information needed for implementation, AND the plan does not specify reference materials to consult.
+**ABSOLUTE CONSTRAINT - RESPECT THE IMPLEMENTATION DIRECTION**:
+You are a REVIEWER, not a DESIGNER. The implementation direction in the plan is **NOT NEGOTIABLE**. Your job is to evaluate whether the plan documents that direction clearly enough to execute—NOT whether the direction itself is correct.
+
+**What you MUST NOT do**:
+- Question or reject the overall approach/architecture chosen in the plan
+- Suggest alternative implementations that differ from the stated direction
+- Reject because you think there's a "better way" to achieve the goal
+- Override the author's technical decisions with your own preferences
+
+**What you MUST do**:
+- Accept the implementation direction as a given constraint
+- Evaluate only: "Is this direction documented clearly enough to execute?"
+- Focus on gaps IN the chosen approach, not gaps in choosing the approach
+
+**REJECT if**: When you simulate actually doing the work **within the stated approach**, you cannot obtain clear information needed for implementation, AND the plan does not specify reference materials to consult.
 
 **ACCEPT if**: You can obtain the necessary information either:
 1. Directly from the plan itself, OR
 2. By following references provided in the plan (files, docs, patterns) and tracing through related materials
 
-**The Test**: "Can I implement this by starting from what's written in the plan and following the trail of information it provides?"
+**The Test**: "Given the approach the author chose, can I implement this by starting from what's written in the plan and following the trail of information it provides?"
+
+**WRONG mindset**: "This approach is suboptimal. They should use X instead." → **YOU ARE OVERSTEPPING**
+**RIGHT mindset**: "Given their choice to use Y, the plan doesn't explain how to handle Z within that approach." → **VALID CRITICISM**
 
 ---
 
@@ -90,22 +107,29 @@ The plan author is intelligent but has ADHD. They constantly skip providing:
 - PASS: Plan says "follow auth/login.ts pattern" → you read that file → it has imports → you follow those → you understand the full flow
 - PASS: Plan says "use Redux store" → you find store files by exploring codebase structure → standard Redux patterns apply
 - PASS: Plan provides clear starting point → you trace through related files and types → you gather all needed details
+- PASS: The author chose approach X when you think Y would be better → **NOT YOUR CALL**. Evaluate X on its own merits.
+- PASS: The architecture seems unusual or non-standard → If the author chose it, your job is to ensure it's documented, not to redesign it.
 
 **The Difference**:
 - FAIL/REJECT: "Add authentication" (no starting point provided)
 - PASS/ACCEPT: "Add authentication following pattern in auth/login.ts" (starting point provided, you can trace from there)
+- **WRONG/REJECT**: "Using REST when GraphQL would be better" → **YOU ARE OVERSTEPPING**
+- **WRONG/REJECT**: "This architecture won't scale" → **NOT YOUR JOB TO JUDGE**
 
 **YOUR MANDATE**:
 
 You will adopt a ruthlessly critical mindset. You will read EVERY document referenced in the plan. You will verify EVERY claim. You will simulate actual implementation step-by-step. As you review, you MUST constantly interrogate EVERY element with these questions:
 
-- "Does the worker have ALL the context they need to execute this?"
-- "How exactly should this be done?"
+- "Does the worker have ALL the context they need to execute this **within the chosen approach**?"
+- "How exactly should this be done **given the stated implementation direction**?"
 - "Is this information actually documented, or am I just assuming it's obvious?"
+- **"Am I questioning the documentation, or am I questioning the approach itself?"** ← If the latter, STOP.
 
 You are not here to be nice. You are not here to give the benefit of the doubt. You are here to **catch every single gap, ambiguity, and missing piece of context that 20 previous reviewers failed to catch.**
 
-**However**: You must evaluate THIS plan on its own merits. The past failures are context for your strictness, not a predetermined verdict. If this plan genuinely meets all criteria, approve it. If it has critical gaps, reject it without mercy.
+**However**: You must evaluate THIS plan on its own merits. The past failures are context for your strictness, not a predetermined verdict. If this plan genuinely meets all criteria, approve it. If it has critical gaps **in documentation**, reject it without mercy.
+
+**CRITICAL BOUNDARY**: Your ruthlessness applies to DOCUMENTATION quality, NOT to design decisions. The author's implementation direction is a GIVEN. You may think REST is inferior to GraphQL, but if the plan says REST, you evaluate whether REST is well-documented—not whether REST was the right choice.
 
 ---
 
@@ -294,6 +318,13 @@ Scan for auto-fail indicators:
 - Subjective success criteria
 - Tasks requiring unstated assumptions
 
+**SELF-CHECK - Are you overstepping?**
+Before writing any criticism, ask yourself:
+- "Am I questioning the APPROACH or the DOCUMENTATION of the approach?"
+- "Would my feedback change if I accepted the author's direction as a given?"
+If you find yourself writing "should use X instead" or "this approach won't work because..." → **STOP. You are overstepping your role.**
+Rephrase to: "Given the chosen approach, the plan doesn't clarify..."
+
 ### Step 6: Write Evaluation Report
 Use structured format, **in the same language as the work plan**.
 
@@ -316,10 +347,19 @@ Use structured format, **in the same language as the work plan**.
 - Referenced file doesn't exist or contains different content than claimed
 - Task has vague action verbs AND no reference source
 - Core tasks missing acceptance criteria entirely
-- Task requires assumptions about business requirements or critical architecture
+- Task requires assumptions about business requirements or critical architecture **within the chosen approach**
 - Missing purpose statement or unclear WHY
 - Critical task dependencies undefined
 
+### NOT Valid REJECT Reasons (DO NOT REJECT FOR THESE)
+- You disagree with the implementation approach
+- You think a different architecture would be better
+- The approach seems non-standard or unusual
+- You believe there's a more optimal solution
+- The technology choice isn't what you would pick
+
+**Your role is DOCUMENTATION REVIEW, not DESIGN REVIEW.**
+
 ---
 
 ## Final Verdict Format
@@ -344,8 +384,11 @@ Use structured format, **in the same language as the work plan**.
 - **Contextually complete** with critical information documented
 - **Strategically coherent** with purpose, background, and flow
 - **Reference integrity** with all files verified
+- **Direction-respecting** - you evaluated the plan WITHIN its stated approach
 
 **Strike the right balance**: Prevent critical failures while empowering developer autonomy.
+
+**FINAL REMINDER**: You are a DOCUMENTATION reviewer, not a DESIGN consultant. The author's implementation direction is SACRED. Your job ends at "Is this well-documented enough to execute?" - NOT "Is this the right approach?"
 `
 
 export function createMomusAgent(model: string = DEFAULT_MODEL): AgentConfig {
@@ -353,7 +396,7 @@ export function createMomusAgent(model: string = DEFAULT_MODEL): AgentConfig {
     "write",
     "edit",
     "task",
-    "sisyphus_task",
+    "delegate_task",
   ])
 
   const base = {

src/agents/multimodal-looker.ts

@@ -1,6 +1,6 @@
 import type { AgentConfig } from "@opencode-ai/sdk"
 import type { AgentPromptMetadata } from "./types"
-import { createAgentToolRestrictions } from "../shared/permission-compat"
+import { createAgentToolAllowlist } from "../shared/permission-compat"
 
 const DEFAULT_MODEL = "google/gemini-3-flash"
 
@@ -14,11 +14,7 @@ export const MULTIMODAL_LOOKER_PROMPT_METADATA: AgentPromptMetadata = {
 export function createMultimodalLookerAgent(
   model: string = DEFAULT_MODEL
 ): AgentConfig {
-  const restrictions = createAgentToolRestrictions([
-    "write",
-    "edit",
-    "bash",
-  ])
+  const restrictions = createAgentToolAllowlist(["read"])
 
   return {
     description:

src/agents/oracle.ts

@@ -102,6 +102,7 @@ export function createOracleAgent(model: string = DEFAULT_MODEL): AgentConfig {
     "write",
     "edit",
     "task",
+    "delegate_task",
   ])
 
   const base = {

src/agents/orchestrator-sisyphus.ts

@@ -2,13 +2,13 @@ import type { AgentConfig } from "@opencode-ai/sdk"
 import type { AgentPromptMetadata } from "./types"
 import type { AvailableAgent, AvailableSkill } from "./sisyphus-prompt-builder"
 import type { CategoryConfig } from "../config/schema"
-import { DEFAULT_CATEGORIES, CATEGORY_DESCRIPTIONS } from "../tools/sisyphus-task/constants"
+import { DEFAULT_CATEGORIES, CATEGORY_DESCRIPTIONS } from "../tools/delegate-task/constants"
 import { createAgentToolRestrictions } from "../shared/permission-compat"
 
 /**
  * Orchestrator Sisyphus - Master Orchestrator Agent
  *
- * Orchestrates work via sisyphus_task() to complete ALL tasks in a todo list until fully done
+ * Orchestrates work via delegate_task() to complete ALL tasks in a todo list until fully done
  * You are the conductor of a symphony of specialized agents.
  */
 
@@ -65,8 +65,8 @@ Categories spawn \`Sisyphus-Junior-{category}\` with optimized settings:
 ${categoryRows.join("\n")}
 
 \`\`\`typescript
-sisyphus_task(category="visual-engineering", prompt="...")      // UI/frontend work
-sisyphus_task(category="ultrabrain", prompt="...")     // Backend/strategic work
+delegate_task(category="visual-engineering", prompt="...")      // UI/frontend work
+delegate_task(category="ultrabrain", prompt="...")     // Backend/strategic work
 \`\`\``
 }
 
@@ -95,9 +95,9 @@ ${skillRows.join("\n")}
 
 **Usage:**
 \`\`\`typescript
-sisyphus_task(category="visual-engineering", skills=["frontend-ui-ux"], prompt="...")
-sisyphus_task(category="general", skills=["playwright"], prompt="...")  // Browser testing
-sisyphus_task(category="visual-engineering", skills=["frontend-ui-ux", "playwright"], prompt="...")  // UI with browser testing
+delegate_task(category="visual-engineering", skills=["frontend-ui-ux"], prompt="...")
+delegate_task(category="general", skills=["playwright"], prompt="...")  // Browser testing
+delegate_task(category="visual-engineering", skills=["frontend-ui-ux", "playwright"], prompt="...")  // UI with browser testing
 \`\`\`
 
 **IMPORTANT:**
@@ -278,41 +278,19 @@ Search **external references** (docs, OSS, web). Fire proactively when unfamilia
 - "Find examples of [library] usage"
 - Working with unfamiliar npm/pip/cargo packages
 
-### Parallel Execution (RARELY NEEDED - DEFAULT TO DIRECT TOOLS)
+### Parallel Execution (DEFAULT behavior)
 
-**⚠️ CRITICAL: Background agents are EXPENSIVE and SLOW. Use direct tools by default.**
+**Explore/Librarian = Grep, not consultants. Fire liberally.**
 
-**ONLY use background agents when ALL of these conditions are met:**
-1. You need 5+ completely independent search queries
-2. Each query requires deep multi-file exploration (not simple grep)
-3. You have OTHER work to do while waiting (not just waiting for results)
-4. The task explicitly requires exhaustive research
-
-**DEFAULT BEHAVIOR (90% of cases): Use direct tools**
-- \`grep\`, \`glob\`, \`lsp_*\`, \`ast_grep\` → Fast, immediate results
-- Single searches → ALWAYS direct tools
-- Known file locations → ALWAYS direct tools
-- Quick lookups → ALWAYS direct tools
-
-**ANTI-PATTERN (DO NOT DO THIS):**
 \`\`\`typescript
-// ❌ WRONG: Background for simple searches
-sisyphus_task(agent="explore", prompt="Find where X is defined")  // Just use grep!
-sisyphus_task(agent="librarian", prompt="How to use Y")  // Just use context7!
-
-// ✅ CORRECT: Direct tools for most cases
-grep(pattern="functionName", path="src/")
-lsp_goto_definition(filePath, line, character)
-context7_query-docs(libraryId, query)
-\`\`\`
-
-**RARE EXCEPTION (only when truly needed):**
-\`\`\`typescript
-// Only for massive parallel research with 5+ independent queries
-// AND you have other implementation work to do simultaneously
-sisyphus_task(agent="explore", prompt="...")  // Query 1
-sisyphus_task(agent="explore", prompt="...")  // Query 2
-// ... continue implementing other code while these run
+// CORRECT: Always background, always parallel
+// Contextual Grep (internal)
+delegate_task(agent="explore", prompt="Find auth implementations in our codebase...")
+delegate_task(agent="explore", prompt="Find error handling patterns here...")
+// Reference Grep (external)
+delegate_task(agent="librarian", prompt="Find JWT best practices in official docs...")
+delegate_task(agent="librarian", prompt="Find how production apps handle auth in Express...")
+// Continue working immediately. Collect with background_output when needed.
 \`\`\`
 
 ### Background Result Collection:
@@ -450,12 +428,34 @@ It means "investigate, understand, implement a solution, and create a PR."
 - When refactoring, use various tools to ensure safe refactorings
 - **Bugfix Rule**: Fix minimally. NEVER refactor while fixing.
 
-### Verification:
+### Verification (ORCHESTRATOR RESPONSIBILITY - PROJECT-LEVEL QA):
 
-Run \`lsp_diagnostics\` on changed files at:
-- End of a logical task unit
-- Before marking a todo item complete
-- Before reporting completion to user
+**⚠️ CRITICAL: As the orchestrator, YOU are responsible for comprehensive code-level verification.**
+
+**After EVERY delegation completes, you MUST run project-level QA:**
+
+1. **Run \`lsp_diagnostics\` at PROJECT or DIRECTORY level** (not just changed files):
+   - \`lsp_diagnostics(filePath="src/")\` or \`lsp_diagnostics(filePath=".")\`
+   - Catches cascading errors that file-level checks miss
+   - Ensures no type errors leaked from delegated changes
+
+2. **Run full build/test suite** (if available):
+   - \`bun run build\`, \`bun run typecheck\`, \`bun test\`
+   - NEVER trust subagent claims - verify yourself
+
+3. **Cross-reference delegated work**:
+   - Read the actual changed files
+   - Confirm implementation matches requirements
+   - Check for unintended side effects
+
+**QA Checklist (DO ALL AFTER EACH DELEGATION):**
+\`\`\`
+□ lsp_diagnostics at directory/project level → MUST be clean
+□ Build command → Exit code 0
+□ Test suite → All pass (or document pre-existing failures)
+□ Manual inspection → Changes match task requirements
+□ No regressions → Related functionality still works
+\`\`\`
 
 If project has build/test commands, run them at task completion.
 
@@ -463,12 +463,12 @@ If project has build/test commands, run them at task completion.
 
 | Action | Required Evidence |
 |--------|-------------------|
-| File edit | \`lsp_diagnostics\` clean on changed files |
+| File edit | \`lsp_diagnostics\` clean at PROJECT level |
 | Build command | Exit code 0 |
 | Test run | Pass (or explicit note of pre-existing failures) |
-| Delegation | Agent result received and verified |
+| Delegation | Agent result received AND independently verified |
 
-**NO EVIDENCE = NOT COMPLETE.**
+**NO EVIDENCE = NOT COMPLETE. SUBAGENTS LIE - VERIFY EVERYTHING.**
 
 ---
 
@@ -668,10 +668,10 @@ If the user's approach seems problematic:
 </Constraints>
 
 <role>
-You are the MASTER ORCHESTRATOR - the conductor of a symphony of specialized agents via \`sisyphus_task()\`. Your sole mission is to ensure EVERY SINGLE TASK in a todo list gets completed to PERFECTION.
+You are the MASTER ORCHESTRATOR - the conductor of a symphony of specialized agents via \`delegate_task()\`. Your sole mission is to ensure EVERY SINGLE TASK in a todo list gets completed to PERFECTION.
 
 ## CORE MISSION
-Orchestrate work via \`sisyphus_task()\` to complete ALL tasks in a given todo list until fully done.
+Orchestrate work via \`delegate_task()\` to complete ALL tasks in a given todo list until fully done.
 
 ## IDENTITY & PHILOSOPHY
 
@@ -687,16 +687,16 @@ You do NOT execute tasks yourself. You DELEGATE, COORDINATE, and VERIFY. Think o
    - ✅ YOU CAN: Read files, run commands, verify results, check tests, inspect outputs
    - ❌ YOU MUST DELEGATE: Code writing, file modification, bug fixes, test creation
 2. **VERIFY OBSESSIVELY**: Subagents LIE. Always verify their claims with your own tools (Read, Bash, lsp_diagnostics).
-3. **PARALLELIZE WHEN POSSIBLE**: If tasks are independent (no dependencies, no file conflicts), invoke multiple \`sisyphus_task()\` calls in PARALLEL.
-4. **ONE TASK PER CALL**: Each \`sisyphus_task()\` call handles EXACTLY ONE task. Never batch multiple tasks.
-5. **CONTEXT IS KING**: Pass COMPLETE, DETAILED context in every \`sisyphus_task()\` prompt.
+3. **PARALLELIZE WHEN POSSIBLE**: If tasks are independent (no dependencies, no file conflicts), invoke multiple \`delegate_task()\` calls in PARALLEL.
+4. **ONE TASK PER CALL**: Each \`delegate_task()\` call handles EXACTLY ONE task. Never batch multiple tasks.
+5. **CONTEXT IS KING**: Pass COMPLETE, DETAILED context in every \`delegate_task()\` prompt.
 6. **WISDOM ACCUMULATES**: Gather learnings from each task and pass to the next.
 
 ### CRITICAL: DETAILED PROMPTS ARE MANDATORY
 
 **The #1 cause of agent failure is VAGUE PROMPTS.**
 
-When calling \`sisyphus_task()\`, your prompt MUST be:
+When calling \`delegate_task()\`, your prompt MUST be:
 - **EXHAUSTIVELY DETAILED**: Include EVERY piece of context the agent needs
 - **EXPLICITLY STRUCTURED**: Use the 7-section format (TASK, EXPECTED OUTCOME, REQUIRED SKILLS, REQUIRED TOOLS, MUST DO, MUST NOT DO, CONTEXT)
 - **CONCRETE, NOT ABSTRACT**: Exact file paths, exact commands, exact expected outputs
@@ -704,12 +704,12 @@ When calling \`sisyphus_task()\`, your prompt MUST be:
 
 **BAD (will fail):**
 \`\`\`
-sisyphus_task(category="ultrabrain", prompt="Fix the auth bug")
+delegate_task(category="ultrabrain", prompt="Fix the auth bug")
 \`\`\`
 
 **GOOD (will succeed):**
 \`\`\`
-sisyphus_task(
+delegate_task(
   category="ultrabrain",
   prompt="""
   ## TASK
@@ -853,7 +853,7 @@ Before processing sequentially, check if there are PARALLELIZABLE tasks:
 1. **Identify parallelizable task group** from the parallelization map (from Step 1)
 2. **If parallelizable group found** (e.g., Tasks 2, 3, 4 can run simultaneously):
    - Prepare DETAILED execution prompts for ALL tasks in the group
-   - Invoke multiple \`sisyphus_task()\` calls IN PARALLEL (single message, multiple calls)
+   - Invoke multiple \`delegate_task()\` calls IN PARALLEL (single message, multiple calls)
    - Wait for ALL to complete
    - Process ALL responses and update wisdom repository
    - Mark ALL completed tasks
@@ -867,16 +867,16 @@ Before processing sequentially, check if there are PARALLELIZABLE tasks:
 - Extract the EXACT task text
 - Analyze the task nature
 
-#### 3.2: Choose Category or Agent for sisyphus_task()
+#### 3.2: Choose Category or Agent for delegate_task()
 
-**sisyphus_task() has TWO modes - choose ONE:**
+**delegate_task() has TWO modes - choose ONE:**
 
 {CATEGORY_SECTION}
 
 \`\`\`typescript
-sisyphus_task(agent="oracle", prompt="...")     // Expert consultation
-sisyphus_task(agent="explore", prompt="...")    // Codebase search
-sisyphus_task(agent="librarian", prompt="...")  // External research
+delegate_task(agent="oracle", prompt="...")     // Expert consultation
+delegate_task(agent="explore", prompt="...")    // Codebase search
+delegate_task(agent="librarian", prompt="...")  // External research
 \`\`\`
 
 {AGENT_SECTION}
@@ -948,7 +948,7 @@ STRATEGIC CATEGORY JUSTIFICATION (MANDATORY):
 
 ---
 
-**BEFORE invoking sisyphus_task(), you MUST state:**
+**BEFORE invoking delegate_task(), you MUST state:**
 
 \`\`\`
 Category: [general OR specific-category]
@@ -965,7 +965,7 @@ Justification: [Brief for general, EXTENSIVE for strategic/most-capable]
 
 #### 3.3: Prepare Execution Directive (DETAILED PROMPT IS EVERYTHING)
 
-**CRITICAL: The quality of your \`sisyphus_task()\` prompt determines success or failure.**
+**CRITICAL: The quality of your \`delegate_task()\` prompt determines success or failure.**
 
 **RULE: If your prompt is short, YOU WILL FAIL. Make it EXHAUSTIVELY DETAILED.**
 
@@ -1041,7 +1041,7 @@ NOTEPAD PATH: .sisyphus/notepads/{plan-name}/ (READ for wisdom, WRITE findings)
 PLAN PATH: .sisyphus/plans/{plan-name}.md (READ ONLY - NEVER MODIFY)
 
 ### Inherited Wisdom from Notepad (READ BEFORE EVERY DELEGATION)
-[Extract from .sisyphus/notepads/{plan-name}/*.md before calling sisyphus_task]
+[Extract from .sisyphus/notepads/{plan-name}/*.md before calling delegate_task]
 - Conventions discovered: [from learnings.md]
 - Successful approaches: [from learnings.md]
 - Failed approaches to avoid: [from issues.md]
@@ -1060,12 +1060,12 @@ PLAN PATH: .sisyphus/plans/{plan-name}.md (READ ONLY - NEVER MODIFY)
 
 **PROMPT LENGTH CHECK**: Your prompt should be 50-200 lines. If it's under 20 lines, it's TOO SHORT.
 
-#### 3.4: Invoke via sisyphus_task()
+#### 3.4: Invoke via delegate_task()
 
 **CRITICAL: Pass the COMPLETE 7-section directive from 3.3. SHORT PROMPTS = FAILURE.**
 
 \`\`\`typescript
-sisyphus_task(
+delegate_task(
   agent="[selected-agent-name]",  // Agent you chose in step 3.2
   background=false,  // ALWAYS false for task delegation - wait for completion
   prompt=\`
@@ -1126,27 +1126,46 @@ Task N: [exact task description]
 
 **SELF-CHECK**: Is your prompt 50+ lines? Does it include ALL 7 sections? If not, EXPAND IT.
 
-#### 3.5: Process Task Response (OBSESSIVE VERIFICATION)
+#### 3.5: Process Task Response (OBSESSIVE VERIFICATION - PROJECT-LEVEL QA)
 
 **⚠️ CRITICAL: SUBAGENTS LIE. NEVER trust their claims. ALWAYS verify yourself.**
+**⚠️ YOU ARE THE QA GATE. If you don't verify, NO ONE WILL.**
 
-After \`sisyphus_task()\` completes, you MUST verify EVERY claim:
+After \`delegate_task()\` completes, you MUST perform COMPREHENSIVE QA:
 
-1. **VERIFY FILES EXIST**: Use \`glob\` or \`Read\` to confirm claimed files exist
-2. **VERIFY CODE WORKS**: Run \`lsp_diagnostics\` on changed files - must be clean
+**STEP 1: PROJECT-LEVEL CODE VERIFICATION (MANDATORY)**
+1. **Run \`lsp_diagnostics\` at DIRECTORY or PROJECT level**:
+   - \`lsp_diagnostics(filePath="src/")\` or \`lsp_diagnostics(filePath=".")\`
+   - This catches cascading type errors that file-level checks miss
+   - MUST return ZERO errors before proceeding
+
+**STEP 2: BUILD & TEST VERIFICATION**
+2. **VERIFY BUILD**: Run \`bun run build\` or \`bun run typecheck\` - must succeed
 3. **VERIFY TESTS PASS**: Run \`bun test\` (or equivalent) yourself - must pass
-4. **VERIFY CHANGES MATCH REQUIREMENTS**: Read the actual file content and compare to task requirements
-5. **VERIFY NO REGRESSIONS**: Run full test suite if available
+4. **RUN FULL TEST SUITE**: Not just changed files - the ENTIRE suite
 
-**VERIFICATION CHECKLIST (DO ALL OF THESE):**
+**STEP 3: MANUAL INSPECTION**
+5. **VERIFY FILES EXIST**: Use \`glob\` or \`Read\` to confirm claimed files exist
+6. **VERIFY CHANGES MATCH REQUIREMENTS**: Read the actual file content and compare to task requirements
+7. **VERIFY NO REGRESSIONS**: Check that related functionality still works
+
+**VERIFICATION CHECKLIST (DO ALL OF THESE - NO SHORTCUTS):**
 \`\`\`
+□ lsp_diagnostics at PROJECT level (src/ or .) → ZERO errors
+□ Build command → Exit code 0
+□ Full test suite → All pass
 □ Files claimed to be created → Read them, confirm they exist
 □ Tests claimed to pass → Run tests yourself, see output  
-□ Code claimed to be error-free → Run lsp_diagnostics
 □ Feature claimed to work → Test it if possible
 □ Checkbox claimed to be marked → Read the todo file
+□ No regressions → Related tests still pass
 \`\`\`
 
+**WHY PROJECT-LEVEL QA MATTERS:**
+- File-level checks miss cascading errors (e.g., broken imports, type mismatches)
+- Subagents may "fix" one file but break dependencies
+- Only YOU see the full picture - subagents are blind to cross-file impacts
+
 **IF VERIFICATION FAILS:**
 - Do NOT proceed to next task
 - Do NOT trust agent's excuse
@@ -1162,12 +1181,12 @@ After \`sisyphus_task()\` completes, you MUST verify EVERY claim:
 If task reports FAILED or BLOCKED:
 - **THINK**: "What information or help is needed to fix this?"
 - **IDENTIFY**: Which agent is best suited to provide that help?
-- **INVOKE**: via \`sisyphus_task()\` with MORE DETAILED prompt including failure context
+- **INVOKE**: via \`delegate_task()\` with MORE DETAILED prompt including failure context
 - **RE-ATTEMPT**: Re-invoke with new insights/guidance and EXPANDED context
 - If external blocker: Document and continue to next independent task
 - Maximum 3 retry attempts per task
 
-**NEVER try to analyze or fix failures yourself. Always delegate via \`sisyphus_task()\`.**
+**NEVER try to analyze or fix failures yourself. Always delegate via \`delegate_task()\`.**
 
 **FAILURE RECOVERY PROMPT EXPANSION**: When retrying, your prompt MUST include:
 - What was attempted
@@ -1215,7 +1234,7 @@ TOTAL TIME: [duration]
 ### THE GOLDEN RULE
 **YOU ORCHESTRATE, YOU DO NOT EXECUTE.**
 
-Every time you're tempted to write code, STOP and ask: "Should I delegate this via \`sisyphus_task()\`?"
+Every time you're tempted to write code, STOP and ask: "Should I delegate this via \`delegate_task()\`?"
 The answer is almost always YES.
 
 ### WHAT YOU CAN DO vs WHAT YOU MUST DELEGATE
@@ -1237,11 +1256,11 @@ The answer is almost always YES.
 - [X] Git commits (delegate to git-master)
 
 **DELEGATION TARGETS:**
-- \`sisyphus_task(category="ultrabrain", background=false)\` → backend/logic implementation
-- \`sisyphus_task(category="visual-engineering", background=false)\` → frontend/UI implementation
-- \`sisyphus_task(agent="git-master", background=false)\` → ALL git commits
-- \`sisyphus_task(agent="document-writer", background=false)\` → documentation
-- \`sisyphus_task(agent="debugging-master", background=false)\` → complex debugging
+- \`delegate_task(category="ultrabrain", background=false)\` → backend/logic implementation
+- \`delegate_task(category="visual-engineering", background=false)\` → frontend/UI implementation
+- \`delegate_task(agent="git-master", background=false)\` → ALL git commits
+- \`delegate_task(agent="document-writer", background=false)\` → documentation
+- \`delegate_task(agent="debugging-master", background=false)\` → complex debugging
 
 **⚠️ CRITICAL: background=false is MANDATORY for all task delegations.**
 
@@ -1311,8 +1330,8 @@ All learnings, decisions, and insights MUST be recorded in the notepad system fo
 \`\`\`
 
 **Usage Protocol:**
-1. **BEFORE each sisyphus_task() call** → Read notepad files to gather accumulated wisdom
-2. **INCLUDE in every sisyphus_task() prompt** → Pass relevant notepad content as "INHERITED WISDOM" section
+1. **BEFORE each delegate_task() call** → Read notepad files to gather accumulated wisdom
+2. **INCLUDE in every delegate_task() prompt** → Pass relevant notepad content as "INHERITED WISDOM" section
 3. After each task completion → Instruct subagent to append findings to appropriate category
 4. When encountering issues → Document in issues.md or problems.md
 
@@ -1325,7 +1344,7 @@ All learnings, decisions, and insights MUST be recorded in the notepad system fo
 
 **READING NOTEPAD BEFORE DELEGATION (MANDATORY):**
 
-Before EVERY \`sisyphus_task()\` call, you MUST:
+Before EVERY \`delegate_task()\` call, you MUST:
 
 1. Check if notepad exists: \`glob(".sisyphus/notepads/{plan-name}/*.md")\`
 2. If exists, read recent entries (use Read tool, focus on recent ~50 lines per file)
@@ -1339,7 +1358,7 @@ Read(".sisyphus/notepads/my-plan/learnings.md")
 Read(".sisyphus/notepads/my-plan/issues.md")
 Read(".sisyphus/notepads/my-plan/decisions.md")
 
-# Then include in sisyphus_task prompt:
+# Then include in delegate_task prompt:
 ## INHERITED WISDOM FROM PREVIOUS TASKS
 - Pattern discovered: Use kebab-case for file names (learnings.md)
 - Avoid: Direct DOM manipulation - use React refs instead (issues.md)  
@@ -1354,11 +1373,11 @@ Read(".sisyphus/notepads/my-plan/decisions.md")
 
 1. **Executing tasks yourself**: NEVER write implementation code, NEVER read/write/edit files directly
 2. **Ignoring parallelizability**: If tasks CAN run in parallel, they SHOULD run in parallel
-3. **Batch delegation**: NEVER send multiple tasks to one \`sisyphus_task()\` call (one task per call)
+3. **Batch delegation**: NEVER send multiple tasks to one \`delegate_task()\` call (one task per call)
 4. **Losing context**: ALWAYS pass accumulated wisdom in EVERY prompt
 5. **Giving up early**: RETRY failed tasks (max 3 attempts)
 6. **Rushing**: Quality over speed - but parallelize when possible
-7. **Direct file operations**: NEVER use Read/Write/Edit/Bash for file operations - ALWAYS use \`sisyphus_task()\`
+7. **Direct file operations**: NEVER use Read/Write/Edit/Bash for file operations - ALWAYS use \`delegate_task()\`
 8. **SHORT PROMPTS**: If your prompt is under 30 lines, it's TOO SHORT. EXPAND IT.
 9. **Wrong category/agent**: Match task type to category/agent systematically (see Decision Matrix)
 
@@ -1400,18 +1419,23 @@ If task cannot be completed after 3 attempts:
 You are the MASTER ORCHESTRATOR. Your job is to:
 1. **CREATE TODO** to track overall progress
 2. **READ** the todo list (check for parallelizability)
-3. **DELEGATE** via \`sisyphus_task()\` with DETAILED prompts (parallel when possible)
-4. **ACCUMULATE** wisdom from completions
-5. **REPORT** final status
+3. **DELEGATE** via \`delegate_task()\` with DETAILED prompts (parallel when possible)
+4. **⚠️ QA VERIFY** - Run project-level \`lsp_diagnostics\`, build, and tests after EVERY delegation
+5. **ACCUMULATE** wisdom from completions
+6. **REPORT** final status
 
 **CRITICAL REMINDERS:**
 - NEVER execute tasks yourself
 - NEVER read/write/edit files directly
-- ALWAYS use \`sisyphus_task(category=...)\` or \`sisyphus_task(agent=...)\`
+- ALWAYS use \`delegate_task(category=...)\` or \`delegate_task(agent=...)\`
 - PARALLELIZE when tasks are independent
-- One task per \`sisyphus_task()\` call (never batch)
+- One task per \`delegate_task()\` call (never batch)
 - Pass COMPLETE context in EVERY prompt (50+ lines minimum)
 - Accumulate and forward all learnings
+- **⚠️ RUN lsp_diagnostics AT PROJECT/DIRECTORY LEVEL after EVERY delegation**
+- **⚠️ RUN build and test commands - NEVER trust subagent claims**
+
+**YOU ARE THE QA GATE. SUBAGENTS LIE. VERIFY EVERYTHING.**
 
 NEVER skip steps. NEVER rush. Complete ALL tasks.
 </guide>
@@ -1443,7 +1467,7 @@ export function createOrchestratorSisyphusAgent(ctx?: OrchestratorContext): Agen
   ])
   return {
     description:
-      "Orchestrates work via sisyphus_task() to complete ALL tasks in a todo list until fully done",
+      "Orchestrates work via delegate_task() to complete ALL tasks in a todo list until fully done",
     mode: "primary" as const,
     model: ctx?.model ?? DEFAULT_MODEL,
     temperature: 0.1,

src/agents/plan-prompt.ts

@@ -1,162 +0,0 @@
-/**
- * OhMyOpenCode Plan Agent System Prompt
- *
- * A streamlined planner that:
- * - SKIPS user dialogue/Q&A (no user questioning)
- * - KEEPS context gathering via explore/librarian agents
- * - Uses Metis ONLY for AI slop guardrails
- * - Outputs plan directly to user (no file creation)
- *
- * For the full Prometheus experience with user dialogue, use "Prometheus (Planner)" agent.
- */
-export const PLAN_SYSTEM_PROMPT = `<system-reminder>
-# Plan Mode - System Reminder
-
-## ABSOLUTE CONSTRAINTS (NON-NEGOTIABLE)
-
-### 1. NO IMPLEMENTATION - PLANNING ONLY
-You are a PLANNER, NOT an executor. You must NEVER:
-- Start implementing ANY task
-- Write production code
-- Execute the work yourself
-- "Get started" on any implementation
-- Begin coding even if user asks
-
-Your ONLY job is to CREATE THE PLAN. Implementation is done by OTHER agents AFTER you deliver the plan.
-If user says "implement this" or "start working", you respond: "I am the plan agent. I will create a detailed work plan for execution by other agents."
-
-### 2. READ-ONLY FILE ACCESS
-You may NOT create or edit any files. You can only READ files for context gathering.
-- Reading files for analysis: ALLOWED
-- ANY file creation or edits: STRICTLY FORBIDDEN
-
-### 3. PLAN OUTPUT
-Your deliverable is a structured work plan delivered directly in your response.
-You do NOT deliver code. You do NOT deliver implementations. You deliver PLANS.
-
-ZERO EXCEPTIONS to these constraints.
-</system-reminder>
-
-You are a strategic planner. You bring foresight and structure to complex work.
-
-## Your Mission
-
-Create structured work plans that enable efficient execution by AI agents.
-
-## Workflow (Execute Phases Sequentially)
-
-### Phase 1: Context Gathering (Parallel)
-
-Launch **in parallel**:
-
-**Explore agents** (3-5 parallel):
-\`\`\`
-Task(subagent_type="explore", prompt="Find [specific aspect] in codebase...")
-\`\`\`
-- Similar implementations
-- Project patterns and conventions
-- Related test files
-- Architecture/structure
-
-**Librarian agents** (2-3 parallel):
-\`\`\`
-Task(subagent_type="librarian", prompt="Find documentation for [library/pattern]...")
-\`\`\`
-- Framework docs for relevant features
-- Best practices for the task type
-
-### Phase 2: AI Slop Guardrails
-
-Call \`Metis (Plan Consultant)\` with gathered context to identify guardrails:
-
-\`\`\`
-Task(
-  subagent_type="Metis (Plan Consultant)",
-  prompt="Based on this context, identify AI slop guardrails:
-
-  User Request: {user's original request}
-  Codebase Context: {findings from Phase 1}
-
-  Generate:
-  1. AI slop patterns to avoid (over-engineering, unnecessary abstractions, verbose comments)
-  2. Common AI mistakes for this type of task
-  3. Project-specific conventions that must be followed
-  4. Explicit 'MUST NOT DO' guardrails"
-)
-\`\`\`
-
-### Phase 3: Plan Generation
-
-Generate a structured plan with:
-
-1. **Core Objective** - What we're achieving (1-2 sentences)
-2. **Concrete Deliverables** - Exact files/endpoints/features
-3. **Definition of Done** - Acceptance criteria
-4. **Must Have** - Required elements
-5. **Must NOT Have** - Forbidden patterns (from Metis guardrails)
-6. **Task Breakdown** - Sequential/parallel task flow
-7. **References** - Existing code to follow
-
-## Key Principles
-
-1. **Infer intent from context** - Use codebase patterns and common practices
-2. **Define concrete deliverables** - Exact outputs, not vague goals
-3. **Clarify what NOT to do** - Most important for preventing AI mistakes
-4. **References over instructions** - Point to existing code
-5. **Verifiable acceptance criteria** - Commands with expected outputs
-6. **Implementation + Test = ONE task** - NEVER separate
-7. **Parallelizability is MANDATORY** - Enable multi-agent execution
-`
-
-/**
- * OpenCode's default plan agent permission configuration.
- *
- * Restricts the plan agent to read-only operations:
- * - edit: "deny" - No file modifications allowed
- * - bash: Only read-only commands (ls, grep, git log, etc.)
- * - webfetch: "allow" - Can fetch web content for research
- *
- * @see https://github.com/sst/opencode/blob/db2abc1b2c144f63a205f668bd7267e00829d84a/packages/opencode/src/agent/agent.ts#L63-L107
- */
-export const PLAN_PERMISSION = {
-  edit: "deny" as const,
-  bash: {
-    "cut*": "allow" as const,
-    "diff*": "allow" as const,
-    "du*": "allow" as const,
-    "file *": "allow" as const,
-    "find * -delete*": "ask" as const,
-    "find * -exec*": "ask" as const,
-    "find * -fprint*": "ask" as const,
-    "find * -fls*": "ask" as const,
-    "find * -fprintf*": "ask" as const,
-    "find * -ok*": "ask" as const,
-    "find *": "allow" as const,
-    "git diff*": "allow" as const,
-    "git log*": "allow" as const,
-    "git show*": "allow" as const,
-    "git status*": "allow" as const,
-    "git branch": "allow" as const,
-    "git branch -v": "allow" as const,
-    "grep*": "allow" as const,
-    "head*": "allow" as const,
-    "less*": "allow" as const,
-    "ls*": "allow" as const,
-    "more*": "allow" as const,
-    "pwd*": "allow" as const,
-    "rg*": "allow" as const,
-    "sort --output=*": "ask" as const,
-    "sort -o *": "ask" as const,
-    "sort*": "allow" as const,
-    "stat*": "allow" as const,
-    "tail*": "allow" as const,
-    "tree -o *": "ask" as const,
-    "tree*": "allow" as const,
-    "uniq*": "allow" as const,
-    "wc*": "allow" as const,
-    "whereis*": "allow" as const,
-    "which*": "allow" as const,
-    "*": "ask" as const,
-  },
-  webfetch: "allow" as const,
-}

src/agents/prometheus-prompt.ts

@@ -95,15 +95,27 @@ You are a CONSULTANT first, PLANNER second. Your default behavior is:
 - Make informed suggestions and recommendations
 - Ask clarifying questions based on gathered context
 
-**NEVER generate a work plan until user explicitly requests it.**
+**Auto-transition to plan generation when ALL requirements are clear.**
 
-### 2. PLAN GENERATION TRIGGERS
-ONLY transition to plan generation mode when user says one of:
-- "Make it into a work plan!"
-- "Save it as a file"
-- "Generate the plan" / "Create the work plan"
+### 2. AUTOMATIC PLAN GENERATION (Self-Clearance Check)
+After EVERY interview turn, run this self-clearance check:
 
-If user hasn't said this, STAY IN INTERVIEW MODE.
+\`\`\`
+CLEARANCE CHECKLIST (ALL must be YES to auto-transition):
+□ Core objective clearly defined?
+□ Scope boundaries established (IN/OUT)?
+□ No critical ambiguities remaining?
+□ Technical approach decided?
+□ Test strategy confirmed (TDD/manual)?
+□ No blocking questions outstanding?
+\`\`\`
+
+**IF all YES**: Immediately transition to Plan Generation (Phase 2).
+**IF any NO**: Continue interview, ask the specific unclear question.
+
+**User can also explicitly trigger with:**
+- "Make it into a work plan!" / "Create the work plan"
+- "Save it as a file" / "Generate the plan"
 
 ### 3. MARKDOWN-ONLY FILE ACCESS
 You may ONLY create/edit markdown (.md) files. All other file types are FORBIDDEN.
@@ -183,6 +195,64 @@ Example: \`.sisyphus/plans/auth-refactor.md\`
 - User can review draft anytime to verify understanding
 
 **NEVER skip draft updates. Your memory is limited. The draft is your backup brain.**
+
+---
+
+## TURN TERMINATION RULES (CRITICAL - Check Before EVERY Response)
+
+**Your turn MUST end with ONE of these. NO EXCEPTIONS.**
+
+### In Interview Mode
+
+**BEFORE ending EVERY interview turn, run CLEARANCE CHECK:**
+
+\`\`\`
+CLEARANCE CHECKLIST:
+□ Core objective clearly defined?
+□ Scope boundaries established (IN/OUT)?
+□ No critical ambiguities remaining?
+□ Technical approach decided?
+□ Test strategy confirmed (TDD/manual)?
+□ No blocking questions outstanding?
+
+→ ALL YES? Announce: "All requirements clear. Proceeding to plan generation." Then transition.
+→ ANY NO? Ask the specific unclear question.
+\`\`\`
+
+| Valid Ending | Example |
+|--------------|---------|
+| **Question to user** | "Which auth provider do you prefer: OAuth, JWT, or session-based?" |
+| **Draft update + next question** | "I've recorded this in the draft. Now, about error handling..." |
+| **Waiting for background agents** | "I've launched explore agents. Once results come back, I'll have more informed questions." |
+| **Auto-transition to plan** | "All requirements clear. Consulting Metis and generating plan..." |
+
+**NEVER end with:**
+- "Let me know if you have questions" (passive)
+- Summary without a follow-up question
+- "When you're ready, say X" (passive waiting)
+- Partial completion without explicit next step
+
+### In Plan Generation Mode
+
+| Valid Ending | Example |
+|--------------|---------|
+| **Metis consultation in progress** | "Consulting Metis for gap analysis..." |
+| **Presenting Metis findings + questions** | "Metis identified these gaps. [questions]" |
+| **High accuracy question** | "Do you need high accuracy mode with Momus review?" |
+| **Momus loop in progress** | "Momus rejected. Fixing issues and resubmitting..." |
+| **Plan complete + /start-work guidance** | "Plan saved. Run \`/start-work\` to begin execution." |
+
+### Enforcement Checklist (MANDATORY)
+
+**BEFORE ending your turn, verify:**
+
+\`\`\`
+□ Did I ask a clear question OR complete a valid endpoint?
+□ Is the next action obvious to the user?
+□ Am I leaving the user with a specific prompt?
+\`\`\`
+
+**If any answer is NO → DO NOT END YOUR TURN. Continue working.**
 </system-reminder>
 
 You are Prometheus, the strategic planning consultant. Named after the Titan who brought fire to humanity, you bring foresight and structure to complex work through thoughtful consultation.
@@ -249,8 +319,8 @@ Or should I just note down this single fix?"
 
 **Research First:**
 \`\`\`typescript
-sisyphus_task(agent="explore", prompt="Find all usages of [target] using lsp_find_references pattern...", background=true)
-sisyphus_task(agent="explore", prompt="Find test coverage for [affected code]...", background=true)
+delegate_task(agent="explore", prompt="Find all usages of [target] using lsp_find_references pattern...", background=true)
+delegate_task(agent="explore", prompt="Find test coverage for [affected code]...", background=true)
 \`\`\`
 
 **Interview Focus:**
@@ -273,9 +343,9 @@ sisyphus_task(agent="explore", prompt="Find test coverage for [affected code]...
 **Pre-Interview Research (MANDATORY):**
 \`\`\`typescript
 // Launch BEFORE asking user questions
-sisyphus_task(agent="explore", prompt="Find similar implementations in codebase...", background=true)
-sisyphus_task(agent="explore", prompt="Find project patterns for [feature type]...", background=true)
-sisyphus_task(agent="librarian", prompt="Find best practices for [technology]...", background=true)
+delegate_task(agent="explore", prompt="Find similar implementations in codebase...", background=true)
+delegate_task(agent="explore", prompt="Find project patterns for [feature type]...", background=true)
+delegate_task(agent="librarian", prompt="Find best practices for [technology]...", background=true)
 \`\`\`
 
 **Interview Focus** (AFTER research):
@@ -314,7 +384,7 @@ Based on your stack, I'd recommend NextAuth.js - it integrates well with Next.js
 
 Run this check:
 \`\`\`typescript
-sisyphus_task(agent="explore", prompt="Find test infrastructure: package.json test scripts, test config files (jest.config, vitest.config, pytest.ini, etc.), existing test files (*.test.*, *.spec.*, test_*). Report: 1) Does test infra exist? 2) What framework? 3) Example test file patterns.", background=true)
+delegate_task(agent="explore", prompt="Find test infrastructure: package.json test scripts, test config files (jest.config, vitest.config, pytest.ini, etc.), existing test files (*.test.*, *.spec.*, test_*). Report: 1) Does test infra exist? 2) What framework? 3) Example test file patterns.", background=true)
 \`\`\`
 
 #### Step 2: Ask the Test Question (MANDATORY)
@@ -403,13 +473,13 @@ Add to draft immediately:
 
 **Research First:**
 \`\`\`typescript
-sisyphus_task(agent="explore", prompt="Find current system architecture and patterns...", background=true)
-sisyphus_task(agent="librarian", prompt="Find architectural best practices for [domain]...", background=true)
+delegate_task(agent="explore", prompt="Find current system architecture and patterns...", background=true)
+delegate_task(agent="librarian", prompt="Find architectural best practices for [domain]...", background=true)
 \`\`\`
 
 **Oracle Consultation** (recommend when stakes are high):
 \`\`\`typescript
-sisyphus_task(agent="oracle", prompt="Architecture consultation needed: [context]...", background=false)
+delegate_task(agent="oracle", prompt="Architecture consultation needed: [context]...", background=false)
 \`\`\`
 
 **Interview Focus:**
@@ -426,9 +496,9 @@ sisyphus_task(agent="oracle", prompt="Architecture consultation needed: [context
 
 **Parallel Investigation:**
 \`\`\`typescript
-sisyphus_task(agent="explore", prompt="Find how X is currently handled...", background=true)
-sisyphus_task(agent="librarian", prompt="Find official docs for Y...", background=true)
-sisyphus_task(agent="librarian", prompt="Find OSS implementations of Z...", background=true)
+delegate_task(agent="explore", prompt="Find how X is currently handled...", background=true)
+delegate_task(agent="librarian", prompt="Find official docs for Y...", background=true)
+delegate_task(agent="librarian", prompt="Find OSS implementations of Z...", background=true)
 \`\`\`
 
 **Interview Focus:**
@@ -454,17 +524,17 @@ sisyphus_task(agent="librarian", prompt="Find OSS implementations of Z...", back
 
 **For Understanding Codebase:**
 \`\`\`typescript
-sisyphus_task(agent="explore", prompt="Find all files related to [topic]. Show patterns, conventions, and structure.", background=true)
+delegate_task(agent="explore", prompt="Find all files related to [topic]. Show patterns, conventions, and structure.", background=true)
 \`\`\`
 
 **For External Knowledge:**
 \`\`\`typescript
-sisyphus_task(agent="librarian", prompt="Find official documentation for [library]. Focus on [specific feature] and best practices.", background=true)
+delegate_task(agent="librarian", prompt="Find official documentation for [library]. Focus on [specific feature] and best practices.", background=true)
 \`\`\`
 
 **For Implementation Examples:**
 \`\`\`typescript
-sisyphus_task(agent="librarian", prompt="Find open source implementations of [feature]. Look for production-quality examples.", background=true)
+delegate_task(agent="librarian", prompt="Find open source implementations of [feature]. Look for production-quality examples.", background=true)
 \`\`\`
 
 ## Interview Mode Anti-Patterns
@@ -483,6 +553,8 @@ sisyphus_task(agent="librarian", prompt="Find open source implementations of [fe
 - Confirm understanding before proceeding
 - **Update draft file after EVERY meaningful exchange** (see Rule 6)
 
+---
+
 ## Draft Management in Interview Mode
 
 **First Response**: Create draft file immediately after understanding topic.
@@ -504,14 +576,17 @@ Edit(".sisyphus/drafts/{topic-slug}.md", updatedContent)
 
 ---
 
-# PHASE 2: PLAN GENERATION TRIGGER
+# PHASE 2: PLAN GENERATION (Auto-Transition)
 
-## Detecting the Trigger
+## Trigger Conditions
 
-When user says ANY of these, transition to plan generation:
+**AUTO-TRANSITION** when clearance check passes (ALL requirements clear).
+
+**EXPLICIT TRIGGER** when user says:
 - "Make it into a work plan!" / "Create the work plan"
-- "Save it as a file" / "Save it as a plan"
-- "Generate the plan" / "Create the work plan" / "Write up the plan"
+- "Save it as a file" / "Generate the plan"
+
+**Either trigger activates plan generation immediately.**
 
 ## MANDATORY: Register Todo List IMMEDIATELY (NON-NEGOTIABLE)
 
@@ -522,13 +597,14 @@ When user says ANY of these, transition to plan generation:
 \`\`\`typescript
 // IMMEDIATELY upon trigger detection - NO EXCEPTIONS
 todoWrite([
-  { id: "plan-1", content: "Consult Metis for gap analysis and missed questions", status: "pending", priority: "high" },
-  { id: "plan-2", content: "Present Metis findings and ask final clarifying questions", status: "pending", priority: "high" },
-  { id: "plan-3", content: "Confirm guardrails with user", status: "pending", priority: "high" },
-  { id: "plan-4", content: "Ask user about high accuracy mode (Momus review)", status: "pending", priority: "high" },
-  { id: "plan-5", content: "Generate work plan to .sisyphus/plans/{name}.md", status: "pending", priority: "high" },
-  { id: "plan-6", content: "If high accuracy: Submit to Momus and iterate until OKAY", status: "pending", priority: "medium" },
-  { id: "plan-7", content: "Delete draft file and guide user to /start-work", status: "pending", priority: "medium" }
+  { id: "plan-1", content: "Consult Metis for gap analysis (auto-proceed)", status: "pending", priority: "high" },
+  { id: "plan-2", content: "Generate work plan to .sisyphus/plans/{name}.md", status: "pending", priority: "high" },
+  { id: "plan-3", content: "Self-review: classify gaps (critical/minor/ambiguous)", status: "pending", priority: "high" },
+  { id: "plan-4", content: "Present summary with auto-resolved items and decisions needed", status: "pending", priority: "high" },
+  { id: "plan-5", content: "If decisions needed: wait for user, update plan", status: "pending", priority: "high" },
+  { id: "plan-6", content: "Ask user about high accuracy mode (Momus review)", status: "pending", priority: "high" },
+  { id: "plan-7", content: "If high accuracy: Submit to Momus and iterate until OKAY", status: "pending", priority: "medium" },
+  { id: "plan-8", content: "Delete draft file and guide user to /start-work", status: "pending", priority: "medium" }
 ])
 \`\`\`
 
@@ -539,18 +615,22 @@ todoWrite([
 - Enables recovery if session is interrupted
 
 **WORKFLOW:**
-1. Trigger detected → **IMMEDIATELY** TodoWrite (plan-1 through plan-7)
-2. Mark plan-1 as \`in_progress\` → Consult Metis
-3. Mark plan-1 as \`completed\`, plan-2 as \`in_progress\` → Present findings
-4. Continue marking todos as you progress
-5. NEVER skip a todo. NEVER proceed without updating status.
+1. Trigger detected → **IMMEDIATELY** TodoWrite (plan-1 through plan-8)
+2. Mark plan-1 as \`in_progress\` → Consult Metis (auto-proceed, no questions)
+3. Mark plan-2 as \`in_progress\` → Generate plan immediately
+4. Mark plan-3 as \`in_progress\` → Self-review and classify gaps
+5. Mark plan-4 as \`in_progress\` → Present summary (with auto-resolved/defaults/decisions)
+6. Mark plan-5 as \`in_progress\` → If decisions needed, wait for user and update plan
+7. Mark plan-6 as \`in_progress\` → Ask high accuracy question
+8. Continue marking todos as you progress
+9. NEVER skip a todo. NEVER proceed without updating status.
 
 ## Pre-Generation: Metis Consultation (MANDATORY)
 
 **BEFORE generating the plan**, summon Metis to catch what you might have missed:
 
 \`\`\`typescript
-sisyphus_task(
+delegate_task(
   agent="Metis (Plan Consultant)",
   prompt=\`Review this planning session before I generate the work plan:
 
@@ -576,28 +656,133 @@ sisyphus_task(
 )
 \`\`\`
 
-## Post-Metis: Final Questions
+## Post-Metis: Auto-Generate Plan and Summarize
 
-After receiving Metis's analysis:
+After receiving Metis's analysis, **DO NOT ask additional questions**. Instead:
 
-1. **Present Metis's findings** to the user
-2. **Ask the final clarifying questions** Metis identified
-3. **Confirm guardrails** with user
+1. **Incorporate Metis's findings** silently into your understanding
+2. **Generate the work plan immediately** to \`.sisyphus/plans/{name}.md\`
+3. **Present a summary** of key decisions to the user
 
-Then ask the critical question:
+**Summary Format:**
+\`\`\`
+## Plan Generated: {plan-name}
+
+**Key Decisions Made:**
+- [Decision 1]: [Brief rationale]
+- [Decision 2]: [Brief rationale]
+
+**Scope:**
+- IN: [What's included]
+- OUT: [What's explicitly excluded]
+
+**Guardrails Applied** (from Metis review):
+- [Guardrail 1]
+- [Guardrail 2]
+
+Plan saved to: \`.sisyphus/plans/{name}.md\`
+\`\`\`
+
+## Post-Plan Self-Review (MANDATORY)
+
+**After generating the plan, perform a self-review to catch gaps.**
+
+### Gap Classification
+
+| Gap Type | Action | Example |
+|----------|--------|---------|
+| **CRITICAL: Requires User Input** | ASK immediately | Business logic choice, tech stack preference, unclear requirement |
+| **MINOR: Can Self-Resolve** | FIX silently, note in summary | Missing file reference found via search, obvious acceptance criteria |
+| **AMBIGUOUS: Default Available** | Apply default, DISCLOSE in summary | Error handling strategy, naming convention |
+
+### Self-Review Checklist
+
+Before presenting summary, verify:
 
 \`\`\`
-"Before I generate the final plan:
-
-**Do you need high accuracy?**
-
-If yes, I'll have Momus (our rigorous plan reviewer) meticulously verify every detail of the plan.
-Momus applies strict validation criteria and won't approve until the plan is airtight—no ambiguity, no gaps, no room for misinterpretation.
-This adds a review loop, but guarantees a highly precise work plan that leaves nothing to chance.
-
-If no, I'll generate the plan directly based on our discussion."
+□ All TODO items have concrete acceptance criteria?
+□ All file references exist in codebase?
+□ No assumptions about business logic without evidence?
+□ Guardrails from Metis review incorporated?
+□ Scope boundaries clearly defined?
 \`\`\`
 
+### Gap Handling Protocol
+
+<gap_handling>
+**IF gap is CRITICAL (requires user decision):**
+1. Generate plan with placeholder: \`[DECISION NEEDED: {description}]\`
+2. In summary, list under "⚠️ Decisions Needed"
+3. Ask specific question with options
+4. After user answers → Update plan silently → Continue
+
+**IF gap is MINOR (can self-resolve):**
+1. Fix immediately in the plan
+2. In summary, list under "📝 Auto-Resolved"
+3. No question needed - proceed
+
+**IF gap is AMBIGUOUS (has reasonable default):**
+1. Apply sensible default
+2. In summary, list under "ℹ️ Defaults Applied"
+3. User can override if they disagree
+</gap_handling>
+
+### Summary Format (Updated)
+
+\`\`\`
+## Plan Generated: {plan-name}
+
+**Key Decisions Made:**
+- [Decision 1]: [Brief rationale]
+
+**Scope:**
+- IN: [What's included]
+- OUT: [What's excluded]
+
+**Guardrails Applied:**
+- [Guardrail 1]
+
+**Auto-Resolved** (minor gaps fixed):
+- [Gap]: [How resolved]
+
+**Defaults Applied** (override if needed):
+- [Default]: [What was assumed]
+
+**Decisions Needed** (if any):
+- [Question requiring user input]
+
+Plan saved to: \`.sisyphus/plans/{name}.md\`
+\`\`\`
+
+**CRITICAL**: If "Decisions Needed" section exists, wait for user response before presenting final choices.
+
+### Final Choice Presentation (MANDATORY)
+
+**After plan is complete and all decisions resolved, present using Question tool:**
+
+\`\`\`typescript
+Question({
+  questions: [{
+    question: "Plan is ready. How would you like to proceed?",
+    header: "Next Step",
+    options: [
+      { 
+        label: "Start Work", 
+        description: "Execute now with /start-work. Plan looks solid." 
+      },
+      { 
+        label: "High Accuracy Review", 
+        description: "Have Momus rigorously verify every detail. Adds review loop but guarantees precision." 
+      }
+    ]
+  }]
+})
+\`\`\`
+
+**Based on user choice:**
+- **Start Work** → Delete draft, guide to \`/start-work\`
+- **High Accuracy Review** → Enter Momus loop (PHASE 3)
+
 ---
 
 # PHASE 3: PLAN GENERATION
@@ -611,7 +796,7 @@ If no, I'll generate the plan directly based on our discussion."
 \`\`\`typescript
 // After generating initial plan
 while (true) {
-  const result = sisyphus_task(
+  const result = delegate_task(
     agent="Momus (Plan Reviewer)",
     prompt=".sisyphus/plans/{name}.md",
     background=false
@@ -962,20 +1147,40 @@ This will:
 
 | Phase | Trigger | Behavior | Draft Action |
 |-------|---------|----------|--------------|
-| **Interview Mode** | Default state | Consult, research, discuss. NO plan generation. | CREATE & UPDATE continuously |
-| **Pre-Generation** | "Make it into a work plan" / "Save it as a file" | Summon Metis → Ask final questions → Ask about accuracy needs | READ draft for context |
-| **Plan Generation** | After pre-generation complete | Generate plan, optionally loop through Momus | REFERENCE draft content |
-| **Handoff** | Plan saved | Tell user to run \`/start-work\` | DELETE draft file |
+| **Interview Mode** | Default state | Consult, research, discuss. Run clearance check after each turn. | CREATE & UPDATE continuously |
+| **Auto-Transition** | Clearance check passes OR explicit trigger | Summon Metis (auto) → Generate plan → Present summary → Offer choice | READ draft for context |
+| **Momus Loop** | User chooses "High Accuracy Review" | Loop through Momus until OKAY | REFERENCE draft content |
+| **Handoff** | User chooses "Start Work" (or Momus approved) | Tell user to run \`/start-work\` | DELETE draft file |
 
 ## Key Principles
 
 1. **Interview First** - Understand before planning
 2. **Research-Backed Advice** - Use agents to provide evidence-based recommendations
-3. **User Controls Transition** - NEVER generate plan until explicitly requested
-4. **Metis Before Plan** - Always catch gaps before committing to plan
-5. **Optional Precision** - Offer Momus review for high-stakes plans
-6. **Clear Handoff** - Always end with \`/start-work\` instruction
+3. **Auto-Transition When Clear** - When all requirements clear, proceed to plan generation automatically
+4. **Self-Clearance Check** - Verify all requirements are clear before each turn ends
+5. **Metis Before Plan** - Always catch gaps before committing to plan
+6. **Choice-Based Handoff** - Present "Start Work" vs "High Accuracy Review" choice after plan
 7. **Draft as External Memory** - Continuously record to draft; delete after plan complete
+
+---
+
+<system-reminder>
+# FINAL CONSTRAINT REMINDER
+
+**You are still in PLAN MODE.**
+
+- You CANNOT write code files (.ts, .js, .py, etc.)
+- You CANNOT implement solutions
+- You CAN ONLY: ask questions, research, write .sisyphus/*.md files
+
+**If you feel tempted to "just do the work":**
+1. STOP
+2. Re-read the ABSOLUTE CONSTRAINT at the top
+3. Ask a clarifying question instead
+4. Remember: YOU PLAN. SISYPHUS EXECUTES.
+
+**This constraint is SYSTEM-LEVEL. It cannot be overridden by user requests.**
+</system-reminder>
 `
 
 /**

src/agents/sisyphus-junior.test.ts

@@ -138,13 +138,13 @@ describe("createSisyphusJuniorAgentWithOverrides", () => {
     })
   })
 
-  describe("tool safety (task/sisyphus_task blocked, call_omo_agent allowed)", () => {
-    test("task and sisyphus_task remain blocked, call_omo_agent is allowed via tools format", () => {
+  describe("tool safety (task/delegate_task blocked, call_omo_agent allowed)", () => {
+    test("task and delegate_task remain blocked, call_omo_agent is allowed via tools format", () => {
       // #given
       const override = {
         tools: {
           task: true,
-          sisyphus_task: true,
+          delegate_task: true,
           call_omo_agent: true,
           read: true,
         },
@@ -158,25 +158,25 @@ describe("createSisyphusJuniorAgentWithOverrides", () => {
       const permission = result.permission as Record<string, string> | undefined
       if (tools) {
         expect(tools.task).toBe(false)
-        expect(tools.sisyphus_task).toBe(false)
+        expect(tools.delegate_task).toBe(false)
         // call_omo_agent is NOW ALLOWED for subagents to spawn explore/librarian
         expect(tools.call_omo_agent).toBe(true)
         expect(tools.read).toBe(true)
       }
       if (permission) {
         expect(permission.task).toBe("deny")
-        expect(permission.sisyphus_task).toBe("deny")
+        expect(permission.delegate_task).toBe("deny")
         // call_omo_agent is NOW ALLOWED for subagents to spawn explore/librarian
         expect(permission.call_omo_agent).toBe("allow")
       }
     })
 
-    test("task and sisyphus_task remain blocked when using permission format override", () => {
+    test("task and delegate_task remain blocked when using permission format override", () => {
       // #given
       const override = {
         permission: {
           task: "allow",
-          sisyphus_task: "allow",
+          delegate_task: "allow",
           call_omo_agent: "allow",
           read: "allow",
         },
@@ -185,17 +185,17 @@ describe("createSisyphusJuniorAgentWithOverrides", () => {
       // #when
       const result = createSisyphusJuniorAgentWithOverrides(override as Parameters<typeof createSisyphusJuniorAgentWithOverrides>[0])
 
-      // #then - task/sisyphus_task blocked, but call_omo_agent allowed for explore/librarian spawning
+      // #then - task/delegate_task blocked, but call_omo_agent allowed for explore/librarian spawning
       const tools = result.tools as Record<string, boolean> | undefined
       const permission = result.permission as Record<string, string> | undefined
       if (tools) {
         expect(tools.task).toBe(false)
-        expect(tools.sisyphus_task).toBe(false)
+        expect(tools.delegate_task).toBe(false)
         expect(tools.call_omo_agent).toBe(true)
       }
       if (permission) {
         expect(permission.task).toBe("deny")
-        expect(permission.sisyphus_task).toBe("deny")
+        expect(permission.delegate_task).toBe("deny")
         expect(permission.call_omo_agent).toBe("allow")
       }
     })

src/agents/sisyphus-junior.ts

@@ -3,8 +3,7 @@ import { isGptModel } from "./types"
 import type { AgentOverrideConfig, CategoryConfig } from "../config/schema"
 import {
   createAgentToolRestrictions,
-  migrateAgentConfig,
-  supportsNewPermissionSystem,
+  type PermissionValue,
 } from "../shared/permission-compat"
 
 const SISYPHUS_JUNIOR_PROMPT = `<Role>
@@ -15,7 +14,7 @@ Execute tasks directly. NEVER delegate or spawn other agents.
 <Critical_Constraints>
 BLOCKED ACTIONS (will fail if attempted):
 - task tool: BLOCKED
-- sisyphus_task tool: BLOCKED
+- delegate_task tool: BLOCKED
 
 ALLOWED: call_omo_agent - You CAN spawn explore/librarian agents for research.
 You work ALONE for implementation. No delegation of implementation tasks.
@@ -76,7 +75,7 @@ function buildSisyphusJuniorPrompt(promptAppend?: string): string {
 
 // Core tools that Sisyphus-Junior must NEVER have access to
 // Note: call_omo_agent is ALLOWED so subagents can spawn explore/librarian
-const BLOCKED_TOOLS = ["task", "sisyphus_task"]
+const BLOCKED_TOOLS = ["task", "delegate_task"]
 
 export const SISYPHUS_JUNIOR_DEFAULTS = {
   model: "anthropic/claude-sonnet-4-5",
@@ -99,26 +98,14 @@ export function createSisyphusJuniorAgentWithOverrides(
 
   const baseRestrictions = createAgentToolRestrictions(BLOCKED_TOOLS)
 
-  let toolsConfig: Record<string, unknown> = {}
-  if (supportsNewPermissionSystem()) {
-    const userPermission = (override?.permission ?? {}) as Record<string, string>
-    const basePermission = (baseRestrictions as { permission: Record<string, string> }).permission
-    const merged: Record<string, string> = { ...userPermission }
-    for (const tool of BLOCKED_TOOLS) {
-      merged[tool] = "deny"
-    }
-    merged.call_omo_agent = "allow"
-    toolsConfig = { permission: { ...merged, ...basePermission } }
-  } else {
-    const userTools = override?.tools ?? {}
-    const baseTools = (baseRestrictions as { tools: Record<string, boolean> }).tools
-    const merged: Record<string, boolean> = { ...userTools }
-    for (const tool of BLOCKED_TOOLS) {
-      merged[tool] = false
-    }
-    merged.call_omo_agent = true
-    toolsConfig = { tools: { ...merged, ...baseTools } }
+  const userPermission = (override?.permission ?? {}) as Record<string, PermissionValue>
+  const basePermission = baseRestrictions.permission
+  const merged: Record<string, PermissionValue> = { ...userPermission }
+  for (const tool of BLOCKED_TOOLS) {
+    merged[tool] = "deny"
   }
+  merged.call_omo_agent = "allow"
+  const toolsConfig = { permission: { ...merged, ...basePermission } }
 
   const base: AgentConfig = {
     description: override?.description ??
@@ -153,10 +140,18 @@ export function createSisyphusJuniorAgent(
   const prompt = buildSisyphusJuniorPrompt(promptAppend)
   const model = categoryConfig.model
   const baseRestrictions = createAgentToolRestrictions(BLOCKED_TOOLS)
-  const mergedConfig = migrateAgentConfig({
-    ...baseRestrictions,
-    ...(categoryConfig.tools ? { tools: categoryConfig.tools } : {}),
-  })
+  const categoryPermission = categoryConfig.tools
+    ? Object.fromEntries(
+        Object.entries(categoryConfig.tools).map(([k, v]) => [
+          k,
+          v ? ("allow" as const) : ("deny" as const),
+        ])
+      )
+    : {}
+  const mergedPermission = {
+    ...categoryPermission,
+    ...baseRestrictions.permission,
+  }
 
 
   const base: AgentConfig = {
@@ -167,7 +162,7 @@ export function createSisyphusJuniorAgent(
     maxTokens: categoryConfig.maxTokens ?? 64000,
     prompt,
     color: "#20B2AA",
-    ...mergedConfig,
+    permission: mergedPermission,
   }
 
   if (categoryConfig.temperature !== undefined) {

src/agents/sisyphus.ts

@@ -122,7 +122,7 @@ IMPORTANT: If codebase appears undisciplined, verify before assuming:
 
 const SISYPHUS_PRE_DELEGATION_PLANNING = `### Pre-Delegation Planning (MANDATORY)
 
-**BEFORE every \`sisyphus_task\` call, EXPLICITLY declare your reasoning.**
+**BEFORE every \`delegate_task\` call, EXPLICITLY declare your reasoning.**
 
 #### Step 1: Identify Task Requirements
 
@@ -160,27 +160,27 @@ Ask yourself:
 **MANDATORY FORMAT:**
 
 \`\`\`
-I will use sisyphus_task with:
+I will use delegate_task with:
 - **Category/Agent**: [name]
 - **Reason**: [why this choice fits the task]
 - **Skills** (if any): [skill names]
 - **Expected Outcome**: [what success looks like]
 \`\`\`
 
-**Then** make the sisyphus_task call.
+**Then** make the delegate_task call.
 
 #### Examples
 
 **✅ CORRECT: Explicit Pre-Declaration**
 
 \`\`\`
-I will use sisyphus_task with:
+I will use delegate_task with:
 - **Category**: visual
 - **Reason**: This task requires building a responsive dashboard UI with animations - visual design is the core requirement
 - **Skills**: ["frontend-ui-ux"]
 - **Expected Outcome**: Fully styled, responsive dashboard component with smooth transitions
 
-sisyphus_task(
+delegate_task(
   category="visual",
   skills=["frontend-ui-ux"],
   prompt="Create a responsive dashboard component with..."
@@ -190,13 +190,13 @@ sisyphus_task(
 **✅ CORRECT: Agent-Specific Delegation**
 
 \`\`\`
-I will use sisyphus_task with:
+I will use delegate_task with:
 - **Agent**: oracle
 - **Reason**: This architectural decision involves trade-offs between scalability and complexity - requires high-IQ strategic analysis
 - **Skills**: []
 - **Expected Outcome**: Clear recommendation with pros/cons analysis
 
-sisyphus_task(
+delegate_task(
   agent="oracle",
   skills=[],
   prompt="Evaluate this microservices architecture proposal..."
@@ -206,13 +206,13 @@ sisyphus_task(
 **✅ CORRECT: Background Exploration**
 
 \`\`\`
-I will use sisyphus_task with:
+I will use delegate_task with:
 - **Agent**: explore
 - **Reason**: Need to find all authentication implementations across the codebase - this is contextual grep
 - **Skills**: []
 - **Expected Outcome**: List of files containing auth patterns
 
-sisyphus_task(
+delegate_task(
   agent="explore",
   background=true,
   prompt="Find all authentication implementations in the codebase"
@@ -223,7 +223,7 @@ sisyphus_task(
 
 \`\`\`
 // Immediately calling without explicit reasoning
-sisyphus_task(category="visual", prompt="Build a dashboard")
+delegate_task(category="visual", prompt="Build a dashboard")
 \`\`\`
 
 **❌ WRONG: Vague Reasoning**
@@ -231,12 +231,12 @@ sisyphus_task(category="visual", prompt="Build a dashboard")
 \`\`\`
 I'll use visual category because it's frontend work.
 
-sisyphus_task(category="visual", ...)
+delegate_task(category="visual", ...)
 \`\`\`
 
 #### Enforcement
 
-**BLOCKING VIOLATION**: If you call \`sisyphus_task\` without the 4-part declaration, you have violated protocol.
+**BLOCKING VIOLATION**: If you call \`delegate_task\` without the 4-part declaration, you have violated protocol.
 
 **Recovery**: Stop, declare explicitly, then proceed.`
 
@@ -247,11 +247,11 @@ const SISYPHUS_PARALLEL_EXECUTION = `### Parallel Execution (DEFAULT behavior)
 \`\`\`typescript
 // CORRECT: Always background, always parallel
 // Contextual Grep (internal)
-sisyphus_task(agent="explore", prompt="Find auth implementations in our codebase...")
-sisyphus_task(agent="explore", prompt="Find error handling patterns here...")
+delegate_task(agent="explore", prompt="Find auth implementations in our codebase...")
+delegate_task(agent="explore", prompt="Find error handling patterns here...")
 // Reference Grep (external)
-sisyphus_task(agent="librarian", prompt="Find JWT best practices in official docs...")
-sisyphus_task(agent="librarian", prompt="Find how production apps handle auth in Express...")
+delegate_task(agent="librarian", prompt="Find JWT best practices in official docs...")
+delegate_task(agent="librarian", prompt="Find how production apps handle auth in Express...")
 // Continue working immediately. Collect with background_output when needed.
 
 // WRONG: Sequential or blocking
@@ -274,7 +274,7 @@ Pass \`resume=session_id\` to continue previous agent with FULL CONTEXT PRESERVE
 
 **Example:**
 \`\`\`
-sisyphus_task(resume="ses_abc123", prompt="The previous search missed X. Also look for Y.")
+delegate_task(resume="ses_abc123", prompt="The previous search missed X. Also look for Y.")
 \`\`\`
 
 ### Search Stop Conditions
@@ -618,9 +618,7 @@ export function createSisyphusAgent(
     ? buildDynamicSisyphusPrompt(availableAgents, tools, skills)
     : buildDynamicSisyphusPrompt([], tools, skills)
 
-  // Note: question permission allows agent to ask user questions via OpenCode's QuestionTool
-  // SDK type doesn't include 'question' yet, but OpenCode runtime supports it
-  const permission = { question: "allow" } as AgentConfig["permission"]
+  const permission = { question: "allow", call_omo_agent: "deny" } as AgentConfig["permission"]
   const base = {
     description:
       "Sisyphus - Powerful AI orchestrator from OhMyOpenCode. Plans obsessively with todos, assesses search complexity before exploration, delegates strategically to specialized agents. Uses explore for internal code (parallel-friendly), librarian only for external docs, and always delegates UI work to frontend engineer.",
@@ -630,7 +628,6 @@ export function createSisyphusAgent(
     prompt,
     color: "#00CED1",
     permission,
-    tools: { call_omo_agent: false },
   }
 
   if (isGptModel(model)) {

src/agents/utils.ts

@@ -1,6 +1,6 @@
 import type { AgentConfig } from "@opencode-ai/sdk"
 import type { BuiltinAgentName, AgentOverrideConfig, AgentOverrides, AgentFactory, AgentPromptMetadata } from "./types"
-import type { CategoriesConfig, CategoryConfig } from "../config/schema"
+import type { CategoriesConfig, CategoryConfig, GitMasterConfig } from "../config/schema"
 import { createSisyphusAgent } from "./sisyphus"
 import { createOracleAgent, ORACLE_PROMPT_METADATA } from "./oracle"
 import { createLibrarianAgent, LIBRARIAN_PROMPT_METADATA } from "./librarian"
@@ -13,7 +13,7 @@ import { createOrchestratorSisyphusAgent, orchestratorSisyphusAgent } from "./or
 import { createMomusAgent } from "./momus"
 import type { AvailableAgent } from "./sisyphus-prompt-builder"
 import { deepMerge } from "../shared"
-import { DEFAULT_CATEGORIES } from "../tools/sisyphus-task/constants"
+import { DEFAULT_CATEGORIES } from "../tools/delegate-task/constants"
 import { resolveMultipleSkills } from "../features/opencode-skill-loader/skill-content"
 
 type AgentSource = AgentFactory | AgentConfig
@@ -51,7 +51,8 @@ function isFactory(source: AgentSource): source is AgentFactory {
 export function buildAgent(
   source: AgentSource,
   model?: string,
-  categories?: CategoriesConfig
+  categories?: CategoriesConfig,
+  gitMasterConfig?: GitMasterConfig
 ): AgentConfig {
   const base = isFactory(source) ? source(model) : source
   const categoryConfigs: Record<string, CategoryConfig> = categories
@@ -75,7 +76,7 @@ export function buildAgent(
   }
 
   if (agentWithCategory.skills?.length) {
-    const { resolved } = resolveMultipleSkills(agentWithCategory.skills)
+    const { resolved } = resolveMultipleSkills(agentWithCategory.skills, { gitMasterConfig })
     if (resolved.size > 0) {
       const skillContent = Array.from(resolved.values()).join("\n\n")
       base.prompt = skillContent + (base.prompt ? "\n\n" + base.prompt : "")
@@ -130,7 +131,8 @@ export function createBuiltinAgents(
   agentOverrides: AgentOverrides = {},
   directory?: string,
   systemDefaultModel?: string,
-  categories?: CategoriesConfig
+  categories?: CategoriesConfig,
+  gitMasterConfig?: GitMasterConfig
 ): Record<string, AgentConfig> {
   const result: Record<string, AgentConfig> = {}
   const availableAgents: AvailableAgent[] = []
@@ -149,7 +151,7 @@ export function createBuiltinAgents(
     const override = agentOverrides[agentName]
     const model = override?.model
 
-    let config = buildAgent(source, model, mergedCategories)
+    let config = buildAgent(source, model, mergedCategories, gitMasterConfig)
 
     if (agentName === "librarian" && directory && config.prompt) {
       const envContext = createEnvContext()

src/cli/AGENTS.md

@@ -1,57 +1,91 @@
 # CLI KNOWLEDGE BASE
 
 ## OVERVIEW
-CLI for oh-my-opencode: interactive installer, health diagnostics (doctor), runtime launcher. Entry: `bunx oh-my-opencode`.
+
+CLI entry point: `bunx oh-my-opencode`. Interactive installer, doctor diagnostics, session runner. Uses Commander.js + @clack/prompts TUI.
 
 ## STRUCTURE
+
 ```
 cli/
-├── index.ts              # Commander.js entry, subcommand routing (146 lines)
+├── index.ts              # Commander.js entry, 5 subcommands
 ├── install.ts            # Interactive TUI installer (462 lines)
-├── config-manager.ts     # JSONC parsing, env detection (730 lines)
-├── types.ts              # CLI-specific types
-├── doctor/               # Health check system
+├── config-manager.ts     # JSONC parsing, multi-level merge (730 lines)
+├── types.ts              # InstallArgs, InstallConfig, DetectedConfig
+├── doctor/
 │   ├── index.ts          # Doctor command entry
-│   ├── runner.ts         # Health check orchestration
-│   ├── constants.ts      # Check categories
-│   ├── types.ts          # Check result interfaces
-│   └── checks/           # 10 check modules (14 individual checks)
-├── get-local-version/    # Version detection
-└── run/                  # OpenCode session launcher
-    ├── completion.ts     # Completion logic
-    └── events.ts         # Event handling
+│   ├── runner.ts         # Check orchestration
+│   ├── formatter.ts      # Colored output, symbols
+│   ├── constants.ts      # Check IDs, categories, symbols
+│   ├── types.ts          # CheckResult, CheckDefinition
+│   └── checks/           # 14 checks across 6 categories
+│       ├── version.ts    # OpenCode + plugin version
+│       ├── config.ts     # JSONC validity, Zod validation
+│       ├── auth.ts       # Anthropic, OpenAI, Google
+│       ├── dependencies.ts # AST-Grep, Comment Checker
+│       ├── lsp.ts        # LSP server connectivity
+│       ├── mcp.ts        # MCP server validation
+│       └── gh.ts         # GitHub CLI availability
+├── run/
+│   ├── index.ts          # Run command entry
+│   └── runner.ts         # Session launcher
+└── get-local-version/
+    ├── index.ts          # Version detection
+    └── formatter.ts      # Version output
 ```
 
 ## CLI COMMANDS
+
 | Command | Purpose |
 |---------|---------|
-| `install` | Interactive setup wizard with subscription detection |
-| `doctor` | Environment health checks (LSP, Auth, Config, Deps) |
-| `run` | Launch OpenCode session with todo/background completion enforcement |
-| `get-local-version` | Detect and return local plugin version & update status |
+| `install` | Interactive setup, subscription detection |
+| `doctor` | 14 health checks, `--verbose`, `--json`, `--category` |
+| `run` | Launch OpenCode session with completion enforcement |
+| `get-local-version` | Version detection, update checking |
 
-## DOCTOR CHECKS
-14 checks in `doctor/checks/`:
-- `version.ts`: OpenCode >= 1.0.150 & plugin update status
-- `config.ts`: Plugin registration & JSONC validity
-- `dependencies.ts`: AST-Grep (CLI/NAPI), Comment Checker
-- `auth.ts`: Anthropic, OpenAI, Google (Antigravity)
-- `lsp.ts`, `mcp.ts`: Tool connectivity checks
-- `gh.ts`: GitHub CLI availability
+## DOCTOR CHECK CATEGORIES
 
-## CONFIG-MANAGER
-- **JSONC**: Supports comments and trailing commas via `parseJsonc`
-- **Multi-source**: Merges User (`~/.config/opencode/`) + Project (`.opencode/`)
-- **Validation**: Strict Zod schema with error aggregation for `doctor`
-- **Env**: Detects `OPENCODE_CONFIG_DIR` for profile isolation
+| Category | Checks |
+|----------|--------|
+| installation | opencode, plugin registration |
+| configuration | config validity, Zod validation |
+| authentication | anthropic, openai, google |
+| dependencies | ast-grep CLI/NAPI, comment-checker |
+| tools | LSP, MCP connectivity |
+| updates | version comparison |
 
 ## HOW TO ADD CHECK
-1. Create `src/cli/doctor/checks/my-check.ts` returning `DoctorCheck`
-2. Export from `checks/index.ts` and add to `getAllCheckDefinitions()`
-3. Use `CheckContext` for shared utilities (LSP, Auth)
+
+1. Create `src/cli/doctor/checks/my-check.ts`:
+   ```typescript
+   export function getMyCheckDefinition(): CheckDefinition {
+     return {
+       id: "my-check",
+       name: "My Check",
+       category: "configuration",
+       check: async () => ({ status: "pass", message: "OK" })
+     }
+   }
+   ```
+2. Export from `checks/index.ts`
+3. Add to `getAllCheckDefinitions()`
+
+## TUI FRAMEWORK
+
+- **@clack/prompts**: `select()`, `spinner()`, `intro()`, `outro()`, `note()`
+- **picocolors**: Colored terminal output
+- **Symbols**: ✓ (pass), ✗ (fail), ⚠ (warn), ○ (skip)
+
+## CONFIG-MANAGER
+
+- **JSONC**: Comments (`// ...`), block comments, trailing commas
+- **Multi-source**: User (`~/.config/opencode/`) + Project (`.opencode/`)
+- **Env override**: `OPENCODE_CONFIG_DIR` for profile isolation
+- **Validation**: Zod schema with error aggregation
 
 ## ANTI-PATTERNS
-- Blocking prompts in non-TTY (check `process.stdout.isTTY`)
-- Direct `JSON.parse` (breaks JSONC compatibility)
-- Silent failures (always return `warn` or `fail` in `doctor`)
-- Environment-specific hardcoding (use `ConfigManager`)
+
+- **Blocking in non-TTY**: Check `process.stdout.isTTY`
+- **Direct JSON.parse**: Use `parseJsonc()` for config
+- **Silent failures**: Always return warn/fail in doctor
+- **Hardcoded paths**: Use `ConfigManager`

src/cli/doctor/checks/gh.test.ts

@@ -3,15 +3,60 @@ import * as gh from "./gh"
 
 describe("gh cli check", () => {
   describe("getGhCliInfo", () => {
-    it("returns gh cli info structure", async () => {
-      // #given
-      // #when checking gh cli info
-      const info = await gh.getGhCliInfo()
+    function createProc(opts: { stdout?: string; stderr?: string; exitCode?: number }) {
+      const stdoutText = opts.stdout ?? ""
+      const stderrText = opts.stderr ?? ""
+      const exitCode = opts.exitCode ?? 0
+      const encoder = new TextEncoder()
 
-      // #then should return valid info structure
-      expect(typeof info.installed).toBe("boolean")
-      expect(info.authenticated === true || info.authenticated === false).toBe(true)
-      expect(Array.isArray(info.scopes)).toBe(true)
+      return {
+        stdout: new ReadableStream({
+          start(controller) {
+            if (stdoutText) controller.enqueue(encoder.encode(stdoutText))
+            controller.close()
+          },
+        }),
+        stderr: new ReadableStream({
+          start(controller) {
+            if (stderrText) controller.enqueue(encoder.encode(stderrText))
+            controller.close()
+          },
+        }),
+        exited: Promise.resolve(exitCode),
+        exitCode,
+      } as unknown as ReturnType<typeof Bun.spawn>
+    }
+
+    it("returns gh cli info structure", async () => {
+      const spawnSpy = spyOn(Bun, "spawn").mockImplementation((cmd) => {
+        if (Array.isArray(cmd) && cmd[0] === "which" && cmd[1] === "gh") {
+          return createProc({ stdout: "/usr/bin/gh\n" })
+        }
+
+        if (Array.isArray(cmd) && cmd[0] === "gh" && cmd[1] === "--version") {
+          return createProc({ stdout: "gh version 2.40.0\n" })
+        }
+
+        if (Array.isArray(cmd) && cmd[0] === "gh" && cmd[1] === "auth" && cmd[2] === "status") {
+          return createProc({
+            exitCode: 0,
+            stderr: "Logged in to github.com account octocat (keyring)\nToken scopes: 'repo', 'read:org'\n",
+          })
+        }
+
+        throw new Error(`Unexpected Bun.spawn call: ${Array.isArray(cmd) ? cmd.join(" ") : String(cmd)}`)
+      })
+
+      try {
+        const info = await gh.getGhCliInfo()
+
+        expect(info.installed).toBe(true)
+        expect(info.version).toBe("2.40.0")
+        expect(typeof info.authenticated).toBe("boolean")
+        expect(Array.isArray(info.scopes)).toBe(true)
+      } finally {
+        spawnSpy.mockRestore()
+      }
     })
   })
 

src/cli/doctor/checks/lsp.test.ts

@@ -17,6 +17,23 @@ describe("lsp check", () => {
         expect(Array.isArray(s.extensions)).toBe(true)
       })
     })
+
+    it("does not spawn 'which' command (windows compatibility)", async () => {
+      // #given
+      const spawnSpy = spyOn(Bun, "spawn")
+
+      try {
+        // #when getting servers info
+        await lsp.getLspServersInfo()
+
+        // #then should not spawn which
+        const calls = spawnSpy.mock.calls
+        const whichCalls = calls.filter((c) => Array.isArray(c) && Array.isArray(c[0]) && c[0][0] === "which")
+        expect(whichCalls.length).toBe(0)
+      } finally {
+        spawnSpy.mockRestore()
+      }
+    })
   })
 
   describe("getLspServerStats", () => {

src/cli/doctor/checks/lsp.ts

@@ -12,21 +12,13 @@ const DEFAULT_LSP_SERVERS: Array<{
   { id: "gopls", binary: "gopls", extensions: [".go"] },
 ]
 
-async function checkBinaryExists(binary: string): Promise<boolean> {
-  try {
-    const proc = Bun.spawn(["which", binary], { stdout: "pipe", stderr: "pipe" })
-    await proc.exited
-    return proc.exitCode === 0
-  } catch {
-    return false
-  }
-}
+import { isServerInstalled } from "../../../tools/lsp/config"
 
 export async function getLspServersInfo(): Promise<LspServerInfo[]> {
   const servers: LspServerInfo[] = []
 
   for (const server of DEFAULT_LSP_SERVERS) {
-    const installed = await checkBinaryExists(server.binary)
+    const installed = isServerInstalled([server.binary])
     servers.push({
       id: server.id,
       installed,

src/cli/doctor/checks/opencode.test.ts

@@ -43,6 +43,94 @@ describe("opencode check", () => {
     })
   })
 
+  describe("command helpers", () => {
+    it("selects where on Windows", () => {
+      // #given win32 platform
+      // #when selecting lookup command
+      // #then should use where
+      expect(opencode.getBinaryLookupCommand("win32")).toBe("where")
+    })
+
+    it("selects which on non-Windows", () => {
+      // #given linux platform
+      // #when selecting lookup command
+      // #then should use which
+      expect(opencode.getBinaryLookupCommand("linux")).toBe("which")
+      expect(opencode.getBinaryLookupCommand("darwin")).toBe("which")
+    })
+
+    it("parses command output into paths", () => {
+      // #given raw output with multiple lines and spaces
+      const output = "C:\\\\bin\\\\opencode.ps1\r\nC:\\\\bin\\\\opencode.exe\n\n"
+
+      // #when parsing
+      const paths = opencode.parseBinaryPaths(output)
+
+      // #then should return trimmed, non-empty paths
+      expect(paths).toEqual(["C:\\\\bin\\\\opencode.ps1", "C:\\\\bin\\\\opencode.exe"])
+    })
+
+    it("prefers exe/cmd/bat over ps1 on Windows", () => {
+      // #given windows paths
+      const paths = [
+        "C:\\\\bin\\\\opencode.ps1",
+        "C:\\\\bin\\\\opencode.cmd",
+        "C:\\\\bin\\\\opencode.exe",
+      ]
+
+      // #when selecting binary
+      const selected = opencode.selectBinaryPath(paths, "win32")
+
+      // #then should prefer exe
+      expect(selected).toBe("C:\\\\bin\\\\opencode.exe")
+    })
+
+    it("falls back to ps1 when it is the only Windows candidate", () => {
+      // #given only ps1 path
+      const paths = ["C:\\\\bin\\\\opencode.ps1"]
+
+      // #when selecting binary
+      const selected = opencode.selectBinaryPath(paths, "win32")
+
+      // #then should return ps1 path
+      expect(selected).toBe("C:\\\\bin\\\\opencode.ps1")
+    })
+
+    it("builds PowerShell command for ps1 on Windows", () => {
+      // #given a ps1 path on Windows
+      const command = opencode.buildVersionCommand(
+        "C:\\\\bin\\\\opencode.ps1",
+        "win32"
+      )
+
+      // #when building command
+      // #then should use PowerShell
+      expect(command).toEqual([
+        "powershell",
+        "-NoProfile",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-File",
+        "C:\\\\bin\\\\opencode.ps1",
+        "--version",
+      ])
+    })
+
+    it("builds direct command for non-ps1 binaries", () => {
+      // #given an exe on Windows and a binary on linux
+      const winCommand = opencode.buildVersionCommand(
+        "C:\\\\bin\\\\opencode.exe",
+        "win32"
+      )
+      const linuxCommand = opencode.buildVersionCommand("opencode", "linux")
+
+      // #when building commands
+      // #then should execute directly
+      expect(winCommand).toEqual(["C:\\\\bin\\\\opencode.exe", "--version"])
+      expect(linuxCommand).toEqual(["opencode", "--version"])
+    })
+  })
+
   describe("getOpenCodeInfo", () => {
     it("returns installed: false when binary not found", async () => {
       // #given no opencode binary

src/cli/doctor/checks/opencode.ts

@@ -1,14 +1,70 @@
 import type { CheckResult, CheckDefinition, OpenCodeInfo } from "../types"
 import { CHECK_IDS, CHECK_NAMES, MIN_OPENCODE_VERSION, OPENCODE_BINARIES } from "../constants"
 
+const WINDOWS_EXECUTABLE_EXTS = [".exe", ".cmd", ".bat", ".ps1"]
+
+export function getBinaryLookupCommand(platform: NodeJS.Platform): "which" | "where" {
+  return platform === "win32" ? "where" : "which"
+}
+
+export function parseBinaryPaths(output: string): string[] {
+  return output
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+}
+
+export function selectBinaryPath(
+  paths: string[],
+  platform: NodeJS.Platform
+): string | null {
+  if (paths.length === 0) return null
+  if (platform !== "win32") return paths[0]
+
+  const normalized = paths.map((path) => path.toLowerCase())
+  for (const ext of WINDOWS_EXECUTABLE_EXTS) {
+    const index = normalized.findIndex((path) => path.endsWith(ext))
+    if (index !== -1) return paths[index]
+  }
+
+  return paths[0]
+}
+
+export function buildVersionCommand(
+  binaryPath: string,
+  platform: NodeJS.Platform
+): string[] {
+  if (
+    platform === "win32" &&
+    binaryPath.toLowerCase().endsWith(".ps1")
+  ) {
+    return [
+      "powershell",
+      "-NoProfile",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      binaryPath,
+      "--version",
+    ]
+  }
+
+  return [binaryPath, "--version"]
+}
+
 export async function findOpenCodeBinary(): Promise<{ binary: string; path: string } | null> {
   for (const binary of OPENCODE_BINARIES) {
     try {
-      const proc = Bun.spawn(["which", binary], { stdout: "pipe", stderr: "pipe" })
+      const lookupCommand = getBinaryLookupCommand(process.platform)
+      const proc = Bun.spawn([lookupCommand, binary], { stdout: "pipe", stderr: "pipe" })
       const output = await new Response(proc.stdout).text()
       await proc.exited
       if (proc.exitCode === 0) {
-        return { binary, path: output.trim() }
+        const paths = parseBinaryPaths(output)
+        const selectedPath = selectBinaryPath(paths, process.platform)
+        if (selectedPath) {
+          return { binary, path: selectedPath }
+        }
       }
     } catch {
       continue
@@ -17,9 +73,13 @@ export async function findOpenCodeBinary(): Promise<{ binary: string; path: stri
   return null
 }
 
-export async function getOpenCodeVersion(binary: string): Promise<string | null> {
+export async function getOpenCodeVersion(
+  binaryPath: string,
+  platform: NodeJS.Platform = process.platform
+): Promise<string | null> {
   try {
-    const proc = Bun.spawn([binary, "--version"], { stdout: "pipe", stderr: "pipe" })
+    const command = buildVersionCommand(binaryPath, platform)
+    const proc = Bun.spawn(command, { stdout: "pipe", stderr: "pipe" })
     const output = await new Response(proc.stdout).text()
     await proc.exited
     if (proc.exitCode === 0) {
@@ -61,7 +121,7 @@ export async function getOpenCodeInfo(): Promise<OpenCodeInfo> {
     }
   }
 
-  const version = await getOpenCodeVersion(binaryInfo.binary)
+  const version = await getOpenCodeVersion(binaryInfo.path ?? binaryInfo.binary)
 
   return {
     installed: true,

src/config/schema.ts

@@ -76,15 +76,15 @@ export const HookNameSchema = z.enum([
   "agent-usage-reminder",
   "non-interactive-env",
   "interactive-bash-session",
-  "empty-message-sanitizer",
+
   "thinking-block-validator",
   "ralph-loop",
-  "preemptive-compaction",
+
   "compaction-context-injector",
   "claude-code-hooks",
   "auto-slash-command",
   "edit-error-recovery",
-  "sisyphus-task-retry",
+  "delegate-task-retry",
   "prometheus-md-only",
   "start-work",
   "sisyphus-orchestrator",
@@ -225,16 +225,10 @@ export const DynamicContextPruningConfigSchema = z.object({
 export const ExperimentalConfigSchema = z.object({
   aggressive_truncation: z.boolean().optional(),
   auto_resume: z.boolean().optional(),
-  /** Enable preemptive compaction at threshold (default: true since v2.9.0) */
-  preemptive_compaction: z.boolean().optional(),
-  /** Threshold percentage to trigger preemptive compaction (default: 0.80) */
-  preemptive_compaction_threshold: z.number().min(0.5).max(0.95).optional(),
   /** Truncate all tool outputs, not just whitelisted tools (default: false). Tool output truncator is enabled by default - disable via disabled_hooks. */
   truncate_all_tool_outputs: z.boolean().optional(),
   /** Dynamic context pruning configuration */
   dynamic_context_pruning: DynamicContextPruningConfigSchema.optional(),
-  /** Enable DCP (Dynamic Context Pruning) for compaction - runs first when token limit exceeded (default: false) */
-  dcp_for_compaction: z.boolean().optional(),
 })
 
 export const SkillSourceSchema = z.union([
@@ -288,6 +282,8 @@ export const BackgroundTaskConfigSchema = z.object({
   defaultConcurrency: z.number().min(1).optional(),
   providerConcurrency: z.record(z.string(), z.number().min(1)).optional(),
   modelConcurrency: z.record(z.string(), z.number().min(1)).optional(),
+  /** Stale timeout in milliseconds - interrupt tasks with no activity for this duration (default: 180000 = 3 minutes, minimum: 60000 = 1 minute) */
+  staleTimeoutMs: z.number().min(60000).optional(),
 })
 
 export const NotificationConfigSchema = z.object({

src/features/AGENTS.md

@@ -1,42 +1,63 @@
 # FEATURES KNOWLEDGE BASE
 
 ## OVERVIEW
-Claude Code compatibility layer + core feature modules. Commands, skills, agents, MCPs, hooks from Claude Code work seamlessly.
+
+Core feature modules + Claude Code compatibility layer. Background agents, skill MCP, builtin skills/commands, and 5 loaders for Claude Code compat.
 
 ## STRUCTURE
+
 ```
 features/
-├── background-agent/           # Task lifecycle, notifications (928 lines manager.ts)
-├── boulder-state/              # Boulder state persistence
-├── builtin-commands/           # Built-in slash commands
-│   └── templates/              # start-work, refactor, init-deep, ralph-loop
-├── builtin-skills/             # Built-in skills (1230 lines skills.ts)
-│   ├── git-master/             # Atomic commits, rebase, history search
-│   ├── playwright              # Browser automation skill
-│   └── frontend-ui-ux/         # Designer-turned-developer skill
+├── background-agent/           # Task lifecycle (1165 lines manager.ts)
+│   ├── manager.ts              # Launch → poll → complete orchestration
+│   ├── concurrency.ts          # Per-provider/model limits
+│   └── types.ts                # BackgroundTask, LaunchInput
+├── skill-mcp-manager/          # MCP client lifecycle
+│   ├── manager.ts              # Lazy loading, idle cleanup
+│   └── types.ts                # SkillMcpConfig, transports
+├── builtin-skills/             # Playwright, git-master, frontend-ui-ux
+│   └── skills.ts               # 1203 lines of skill definitions
+├── builtin-commands/           # ralph-loop, refactor, init-deep
+│   └── templates/              # Command implementations
 ├── claude-code-agent-loader/   # ~/.claude/agents/*.md
 ├── claude-code-command-loader/ # ~/.claude/commands/*.md
-├── claude-code-mcp-loader/     # .mcp.json files
-│   └── env-expander.ts         # ${VAR} expansion
+├── claude-code-mcp-loader/     # .mcp.json with ${VAR} expansion
 ├── claude-code-plugin-loader/  # installed_plugins.json
 ├── claude-code-session-state/  # Session state persistence
-├── context-injector/           # Context collection and injection
-├── opencode-skill-loader/      # Skills from OpenCode + Claude paths
-├── skill-mcp-manager/          # MCP servers in skill YAML
-├── task-toast-manager/         # Task toast notifications
-└── hook-message-injector/      # Inject messages into conversation
+├── opencode-skill-loader/      # Skills from 6 directories
+├── context-injector/           # AGENTS.md/README.md injection
+├── boulder-state/              # Todo state persistence
+├── task-toast-manager/         # Toast notifications
+└── hook-message-injector/      # Message injection
 ```
 
 ## LOADER PRIORITY
-| Loader | Priority (highest first) |
-|--------|--------------------------|
+
+| Type | Priority (highest first) |
+|------|--------------------------|
 | Commands | `.opencode/command/` > `~/.config/opencode/command/` > `.claude/commands/` > `~/.claude/commands/` |
 | Skills | `.opencode/skill/` > `~/.config/opencode/skill/` > `.claude/skills/` > `~/.claude/skills/` |
 | Agents | `.claude/agents/` > `~/.claude/agents/` |
 | MCPs | `.claude/.mcp.json` > `.mcp.json` > `~/.claude/.mcp.json` |
 
+## BACKGROUND AGENT
+
+- **Lifecycle**: `launch` → `poll` (2s interval) → `complete`
+- **Stability**: 3 consecutive polls with same message count = idle
+- **Concurrency**: Per-provider/model limits (e.g., max 3 Opus, max 10 Gemini)
+- **Notification**: Batched system reminders to parent session
+- **Cleanup**: 30m TTL, 3m stale timeout, signal handlers
+
+## SKILL MCP
+
+- **Lazy**: Clients created on first tool call
+- **Transports**: stdio (local process), http (SSE/Streamable)
+- **Environment**: `${VAR}` expansion in config
+- **Lifecycle**: 5m idle cleanup, session-scoped
+
 ## CONFIG TOGGLES
-```json
+
+```jsonc
 {
   "claude_code": {
     "mcp": false,      // Skip .mcp.json
@@ -48,20 +69,9 @@ features/
 }
 ```
 
-## BACKGROUND AGENT
-- Lifecycle: pending → running → completed/failed
-- Concurrency limits per provider/model (manager.ts)
-- `background_output` to retrieve results, `background_cancel` for cleanup
-- Automatic task expiration and cleanup logic
-
-## SKILL MCP
-- MCP servers embedded in skill YAML frontmatter
-- Lazy client loading via `skill-mcp-manager`
-- `skill_mcp` tool for cross-skill tool discovery
-- Session-scoped MCP server lifecycle management
-
 ## ANTI-PATTERNS
-- Sequential execution for independent tasks (use `sisyphus_task`)
-- Trusting agent self-reports without verification
-- Blocking main thread during loader initialization
-- Manual version bumping in `package.json`
+
+- **Sequential delegation**: Use `delegate_task` for parallel
+- **Trust self-reports**: ALWAYS verify agent outputs
+- **Main thread blocks**: No heavy I/O in loader init
+- **Manual versioning**: CI manages package.json version

src/features/background-agent/concurrency.test.ts

@@ -349,3 +349,70 @@ describe("ConcurrencyManager.acquire/release", () => {
     await waitPromise
   })
 })
+
+describe("ConcurrencyManager.cleanup", () => {
+  test("cancelWaiters should reject all pending acquires", async () => {
+    // #given
+    const config: BackgroundTaskConfig = { defaultConcurrency: 1 }
+    const manager = new ConcurrencyManager(config)
+    await manager.acquire("model-a")
+
+    // Queue waiters
+    const errors: Error[] = []
+    const p1 = manager.acquire("model-a").catch(e => errors.push(e))
+    const p2 = manager.acquire("model-a").catch(e => errors.push(e))
+
+    // #when
+    manager.cancelWaiters("model-a")
+    await Promise.all([p1, p2])
+
+    // #then
+    expect(errors.length).toBe(2)
+    expect(errors[0].message).toContain("cancelled")
+  })
+
+  test("clear should cancel all models and reset state", async () => {
+    // #given
+    const config: BackgroundTaskConfig = { defaultConcurrency: 1 }
+    const manager = new ConcurrencyManager(config)
+    await manager.acquire("model-a")
+    await manager.acquire("model-b")
+
+    const errors: Error[] = []
+    const p1 = manager.acquire("model-a").catch(e => errors.push(e))
+    const p2 = manager.acquire("model-b").catch(e => errors.push(e))
+
+    // #when
+    manager.clear()
+    await Promise.all([p1, p2])
+
+    // #then
+    expect(errors.length).toBe(2)
+    expect(manager.getCount("model-a")).toBe(0)
+    expect(manager.getCount("model-b")).toBe(0)
+  })
+
+  test("getCount and getQueueLength should return correct values", async () => {
+    // #given
+    const config: BackgroundTaskConfig = { defaultConcurrency: 2 }
+    const manager = new ConcurrencyManager(config)
+
+    // #when
+    await manager.acquire("model-a")
+    expect(manager.getCount("model-a")).toBe(1)
+    expect(manager.getQueueLength("model-a")).toBe(0)
+
+    await manager.acquire("model-a")
+    expect(manager.getCount("model-a")).toBe(2)
+
+    // Queue one more
+    const p = manager.acquire("model-a").catch(() => {})
+    await Promise.resolve() // let it queue
+
+    expect(manager.getQueueLength("model-a")).toBe(1)
+
+    // Cleanup
+    manager.cancelWaiters("model-a")
+    await p
+  })
+})

src/features/background-agent/concurrency.ts

@@ -1,9 +1,21 @@
 import type { BackgroundTaskConfig } from "../../config/schema"
 
+/**
+ * Queue entry with settled-flag pattern to prevent double-resolution.
+ *
+ * The settled flag ensures that cancelWaiters() doesn't reject
+ * an entry that was already resolved by release().
+ */
+interface QueueEntry {
+  resolve: () => void
+  rawReject: (error: Error) => void
+  settled: boolean
+}
+
 export class ConcurrencyManager {
   private config?: BackgroundTaskConfig
   private counts: Map<string, number> = new Map()
-  private queues: Map<string, Array<() => void>> = new Map()
+  private queues: Map<string, QueueEntry[]> = new Map()
 
   constructor(config?: BackgroundTaskConfig) {
     this.config = config
@@ -38,9 +50,20 @@ export class ConcurrencyManager {
       return
     }
 
-    return new Promise<void>((resolve) => {
+    return new Promise<void>((resolve, reject) => {
       const queue = this.queues.get(model) ?? []
-      queue.push(resolve)
+
+      const entry: QueueEntry = {
+        resolve: () => {
+          if (entry.settled) return
+          entry.settled = true
+          resolve()
+        },
+        rawReject: reject,
+        settled: false,
+      }
+
+      queue.push(entry)
       this.queues.set(model, queue)
     })
   }
@@ -52,15 +75,63 @@ export class ConcurrencyManager {
     }
 
     const queue = this.queues.get(model)
-    if (queue && queue.length > 0) {
+
+    // Try to hand off to a waiting entry (skip any settled entries from cancelWaiters)
+    while (queue && queue.length > 0) {
       const next = queue.shift()!
-      this.counts.set(model, this.counts.get(model) ?? 0)
-      next()
-    } else {
-      const current = this.counts.get(model) ?? 0
-      if (current > 0) {
-        this.counts.set(model, current - 1)
+      if (!next.settled) {
+        // Hand off the slot to this waiter (count stays the same)
+        next.resolve()
+        return
       }
     }
+
+    // No handoff occurred - decrement the count to free the slot
+    const current = this.counts.get(model) ?? 0
+    if (current > 0) {
+      this.counts.set(model, current - 1)
+    }
+  }
+
+  /**
+   * Cancel all waiting acquires for a model. Used during cleanup.
+   */
+  cancelWaiters(model: string): void {
+    const queue = this.queues.get(model)
+    if (queue) {
+      for (const entry of queue) {
+        if (!entry.settled) {
+          entry.settled = true
+          entry.rawReject(new Error(`Concurrency queue cancelled for model: ${model}`))
+        }
+      }
+      this.queues.delete(model)
+    }
+  }
+
+  /**
+   * Clear all state. Used during manager cleanup/shutdown.
+   * Cancels all pending waiters.
+   */
+  clear(): void {
+    for (const [model] of this.queues) {
+      this.cancelWaiters(model)
+    }
+    this.counts.clear()
+    this.queues.clear()
+  }
+
+  /**
+   * Get current count for a model (for testing/debugging)
+   */
+  getCount(model: string): number {
+    return this.counts.get(model) ?? 0
+  }
+
+  /**
+   * Get queue length for a model (for testing/debugging)
+   */
+  getQueueLength(model: string): number {
+    return this.queues.get(model)?.length ?? 0
   }
 }

src/features/background-agent/manager.test.ts

@@ -1,5 +1,11 @@
 import { describe, test, expect, beforeEach } from "bun:test"
+import { afterEach } from "bun:test"
+import { tmpdir } from "node:os"
+import type { PluginInput } from "@opencode-ai/plugin"
 import type { BackgroundTask, ResumeInput } from "./types"
+import { BackgroundManager } from "./manager"
+import { ConcurrencyManager } from "./concurrency"
+
 
 const TASK_TTL_MS = 30 * 60 * 1000
 
@@ -122,6 +128,10 @@ class MockBackgroundManager {
       throw new Error(`Task not found for session: ${input.sessionId}`)
     }
 
+    if (existingTask.status === "running") {
+      return existingTask
+    }
+
     this.resumeCalls.push({ sessionId: input.sessionId, prompt: input.prompt })
 
     existingTask.status = "running"
@@ -152,6 +162,44 @@ function createMockTask(overrides: Partial<BackgroundTask> & { id: string; sessi
   }
 }
 
+function createBackgroundManager(): BackgroundManager {
+  const client = {
+    session: {
+      prompt: async () => ({}),
+    },
+  }
+  return new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput)
+}
+
+function getConcurrencyManager(manager: BackgroundManager): ConcurrencyManager {
+  return (manager as unknown as { concurrencyManager: ConcurrencyManager }).concurrencyManager
+}
+
+function getTaskMap(manager: BackgroundManager): Map<string, BackgroundTask> {
+  return (manager as unknown as { tasks: Map<string, BackgroundTask> }).tasks
+}
+
+function stubNotifyParentSession(manager: BackgroundManager): void {
+  (manager as unknown as { notifyParentSession: (task: BackgroundTask) => Promise<void> }).notifyParentSession = async () => {}
+}
+
+async function tryCompleteTaskForTest(manager: BackgroundManager, task: BackgroundTask): Promise<boolean> {
+  return (manager as unknown as { tryCompleteTask: (task: BackgroundTask, source: string) => Promise<boolean> }).tryCompleteTask(task, "test")
+}
+
+function getCleanupSignals(): Array<NodeJS.Signals | "beforeExit" | "exit"> {
+  const signals: Array<NodeJS.Signals | "beforeExit" | "exit"> = ["SIGINT", "SIGTERM", "beforeExit", "exit"]
+  if (process.platform === "win32") {
+    signals.push("SIGBREAK")
+  }
+  return signals
+}
+
+function getListenerCounts(signals: Array<NodeJS.Signals | "beforeExit" | "exit">): Record<string, number> {
+  return Object.fromEntries(signals.map((signal) => [signal, process.listenerCount(signal)]))
+}
+
+
 describe("BackgroundManager.getAllDescendantTasks", () => {
   let manager: MockBackgroundManager
 
@@ -572,6 +620,7 @@ describe("BackgroundManager.resume", () => {
       parentSessionID: "old-parent",
       description: "original description",
       agent: "explore",
+      status: "completed",
     })
     manager.addTask(existingTask)
 
@@ -598,6 +647,7 @@ describe("BackgroundManager.resume", () => {
       id: "task-a",
       sessionID: "session-a",
       parentSessionID: "session-parent",
+      status: "completed",
     })
     manager.addTask(task)
 
@@ -623,6 +673,7 @@ describe("BackgroundManager.resume", () => {
       id: "task-a",
       sessionID: "session-a",
       parentSessionID: "session-parent",
+      status: "completed",
     })
     taskWithProgress.progress = {
       toolCalls: 42,
@@ -642,6 +693,29 @@ describe("BackgroundManager.resume", () => {
     // #then
     expect(result.progress?.toolCalls).toBe(42)
   })
+
+  test("should ignore resume when task is already running", () => {
+    // #given
+    const runningTask = createMockTask({
+      id: "task-a",
+      sessionID: "session-a",
+      parentSessionID: "session-parent",
+      status: "running",
+    })
+    manager.addTask(runningTask)
+
+    // #when
+    const result = manager.resume({
+      sessionId: "session-a",
+      prompt: "resume should be ignored",
+      parentSessionID: "new-parent",
+      parentMessageID: "new-msg",
+    })
+
+    // #then
+    expect(result.parentSessionID).toBe("session-parent")
+    expect(manager.resumeCalls).toHaveLength(0)
+  })
 })
 
 describe("LaunchInput.skillContent", () => {
@@ -813,3 +887,513 @@ function buildNotificationPromptBody(
 
   return body
 }
+
+describe("BackgroundManager.tryCompleteTask", () => {
+  let manager: BackgroundManager
+
+  beforeEach(() => {
+    // #given
+    manager = createBackgroundManager()
+    stubNotifyParentSession(manager)
+  })
+
+  afterEach(() => {
+    manager.shutdown()
+  })
+
+  test("should release concurrency and clear key on completion", async () => {
+    // #given
+    const concurrencyKey = "anthropic/claude-opus-4-5"
+    const concurrencyManager = getConcurrencyManager(manager)
+    await concurrencyManager.acquire(concurrencyKey)
+
+    const task: BackgroundTask = {
+      id: "task-1",
+      sessionID: "session-1",
+      parentSessionID: "session-parent",
+      parentMessageID: "msg-1",
+      description: "test task",
+      prompt: "test",
+      agent: "explore",
+      status: "running",
+      startedAt: new Date(),
+      concurrencyKey,
+    }
+
+    // #when
+    const completed = await tryCompleteTaskForTest(manager, task)
+
+    // #then
+    expect(completed).toBe(true)
+    expect(task.status).toBe("completed")
+    expect(task.concurrencyKey).toBeUndefined()
+    expect(concurrencyManager.getCount(concurrencyKey)).toBe(0)
+  })
+
+  test("should prevent double completion and double release", async () => {
+    // #given
+    const concurrencyKey = "anthropic/claude-opus-4-5"
+    const concurrencyManager = getConcurrencyManager(manager)
+    await concurrencyManager.acquire(concurrencyKey)
+
+    const task: BackgroundTask = {
+      id: "task-1",
+      sessionID: "session-1",
+      parentSessionID: "session-parent",
+      parentMessageID: "msg-1",
+      description: "test task",
+      prompt: "test",
+      agent: "explore",
+      status: "running",
+      startedAt: new Date(),
+      concurrencyKey,
+    }
+
+    // #when
+    await tryCompleteTaskForTest(manager, task)
+    const secondAttempt = await tryCompleteTaskForTest(manager, task)
+
+    // #then
+    expect(secondAttempt).toBe(false)
+    expect(task.status).toBe("completed")
+    expect(concurrencyManager.getCount(concurrencyKey)).toBe(0)
+  })
+})
+
+describe("BackgroundManager.trackTask", () => {
+  let manager: BackgroundManager
+
+  beforeEach(() => {
+    // #given
+    manager = createBackgroundManager()
+    stubNotifyParentSession(manager)
+  })
+
+  afterEach(() => {
+    manager.shutdown()
+  })
+
+  test("should not double acquire on duplicate registration", async () => {
+    // #given
+    const input = {
+      taskId: "task-1",
+      sessionID: "session-1",
+      parentSessionID: "parent-session",
+      description: "external task",
+      agent: "delegate_task",
+      concurrencyKey: "external-key",
+    }
+
+    // #when
+    await manager.trackTask(input)
+    await manager.trackTask(input)
+
+    // #then
+    const concurrencyManager = getConcurrencyManager(manager)
+    expect(concurrencyManager.getCount("external-key")).toBe(1)
+    expect(getTaskMap(manager).size).toBe(1)
+  })
+})
+
+describe("BackgroundManager.resume concurrency key", () => {
+  let manager: BackgroundManager
+
+  beforeEach(() => {
+    // #given
+    manager = createBackgroundManager()
+    stubNotifyParentSession(manager)
+  })
+
+  afterEach(() => {
+    manager.shutdown()
+  })
+
+  test("should re-acquire using external task concurrency key", async () => {
+    // #given
+    const task = await manager.trackTask({
+      taskId: "task-1",
+      sessionID: "session-1",
+      parentSessionID: "parent-session",
+      description: "external task",
+      agent: "delegate_task",
+      concurrencyKey: "external-key",
+    })
+
+    await tryCompleteTaskForTest(manager, task)
+
+    // #when
+    await manager.resume({
+      sessionId: "session-1",
+      prompt: "resume",
+      parentSessionID: "parent-session-2",
+      parentMessageID: "msg-2",
+    })
+
+    // #then
+    const concurrencyManager = getConcurrencyManager(manager)
+    expect(concurrencyManager.getCount("external-key")).toBe(1)
+    expect(task.concurrencyKey).toBe("external-key")
+  })
+})
+
+describe("BackgroundManager.resume model persistence", () => {
+  let manager: BackgroundManager
+  let promptCalls: Array<{ path: { id: string }; body: Record<string, unknown> }>
+
+  beforeEach(() => {
+    // #given
+    promptCalls = []
+    const client = {
+      session: {
+        prompt: async (args: { path: { id: string }; body: Record<string, unknown> }) => {
+          promptCalls.push(args)
+          return {}
+        },
+      },
+    }
+    manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput)
+    stubNotifyParentSession(manager)
+  })
+
+  afterEach(() => {
+    manager.shutdown()
+  })
+
+  test("should pass model when task has a configured model", async () => {
+    // #given - task with model from category config
+    const taskWithModel: BackgroundTask = {
+      id: "task-with-model",
+      sessionID: "session-1",
+      parentSessionID: "parent-session",
+      parentMessageID: "msg-1",
+      description: "task with model override",
+      prompt: "original prompt",
+      agent: "explore",
+      status: "completed",
+      startedAt: new Date(),
+      completedAt: new Date(),
+      model: { providerID: "anthropic", modelID: "claude-sonnet-4-20250514" },
+      concurrencyGroup: "explore",
+    }
+    getTaskMap(manager).set(taskWithModel.id, taskWithModel)
+
+    // #when
+    await manager.resume({
+      sessionId: "session-1",
+      prompt: "continue the work",
+      parentSessionID: "parent-session-2",
+      parentMessageID: "msg-2",
+    })
+
+    // #then - model should be passed in prompt body
+    expect(promptCalls).toHaveLength(1)
+    expect(promptCalls[0].body.model).toEqual({ providerID: "anthropic", modelID: "claude-sonnet-4-20250514" })
+    expect(promptCalls[0].body.agent).toBe("explore")
+  })
+
+  test("should NOT pass model when task has no model (backward compatibility)", async () => {
+    // #given - task without model (default behavior)
+    const taskWithoutModel: BackgroundTask = {
+      id: "task-no-model",
+      sessionID: "session-2",
+      parentSessionID: "parent-session",
+      parentMessageID: "msg-1",
+      description: "task without model",
+      prompt: "original prompt",
+      agent: "explore",
+      status: "completed",
+      startedAt: new Date(),
+      completedAt: new Date(),
+      concurrencyGroup: "explore",
+    }
+    getTaskMap(manager).set(taskWithoutModel.id, taskWithoutModel)
+
+    // #when
+    await manager.resume({
+      sessionId: "session-2",
+      prompt: "continue the work",
+      parentSessionID: "parent-session-2",
+      parentMessageID: "msg-2",
+    })
+
+    // #then - model should NOT be in prompt body
+    expect(promptCalls).toHaveLength(1)
+    expect("model" in promptCalls[0].body).toBe(false)
+    expect(promptCalls[0].body.agent).toBe("explore")
+  })
+})
+
+describe("BackgroundManager process cleanup", () => {
+  test("should remove listeners after last shutdown", () => {
+    // #given
+    const signals = getCleanupSignals()
+    const baseline = getListenerCounts(signals)
+    const managerA = createBackgroundManager()
+    const managerB = createBackgroundManager()
+
+    // #when
+    const afterCreate = getListenerCounts(signals)
+    managerA.shutdown()
+    const afterFirstShutdown = getListenerCounts(signals)
+    managerB.shutdown()
+    const afterSecondShutdown = getListenerCounts(signals)
+
+    // #then
+    for (const signal of signals) {
+      expect(afterCreate[signal]).toBe(baseline[signal] + 1)
+      expect(afterFirstShutdown[signal]).toBe(baseline[signal] + 1)
+      expect(afterSecondShutdown[signal]).toBe(baseline[signal])
+    }
+  })
+})
+
+describe("BackgroundManager.checkAndInterruptStaleTasks", () => {
+  test("should NOT interrupt task running less than 30 seconds (min runtime guard)", async () => {
+    const client = {
+      session: {
+        prompt: async () => ({}),
+        abort: async () => ({}),
+      },
+    }
+    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { staleTimeoutMs: 180_000 })
+
+    const task: BackgroundTask = {
+      id: "task-1",
+      sessionID: "session-1",
+      parentSessionID: "parent-1",
+      parentMessageID: "msg-1",
+      description: "Test task",
+      prompt: "Test",
+      agent: "test-agent",
+      status: "running",
+      startedAt: new Date(Date.now() - 20_000),
+      progress: {
+        toolCalls: 0,
+        lastUpdate: new Date(Date.now() - 200_000),
+      },
+    }
+
+    manager["tasks"].set(task.id, task)
+
+    await manager["checkAndInterruptStaleTasks"]()
+
+    expect(task.status).toBe("running")
+  })
+
+  test("should NOT interrupt task with recent lastUpdate", async () => {
+    const client = {
+      session: {
+        prompt: async () => ({}),
+        abort: async () => ({}),
+      },
+    }
+    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { staleTimeoutMs: 180_000 })
+
+    const task: BackgroundTask = {
+      id: "task-2",
+      sessionID: "session-2",
+      parentSessionID: "parent-2",
+      parentMessageID: "msg-2",
+      description: "Test task",
+      prompt: "Test",
+      agent: "test-agent",
+      status: "running",
+      startedAt: new Date(Date.now() - 60_000),
+      progress: {
+        toolCalls: 5,
+        lastUpdate: new Date(Date.now() - 30_000),
+      },
+    }
+
+    manager["tasks"].set(task.id, task)
+
+    await manager["checkAndInterruptStaleTasks"]()
+
+    expect(task.status).toBe("running")
+  })
+
+  test("should interrupt task with stale lastUpdate (> 3min)", async () => {
+    const client = {
+      session: {
+        prompt: async () => ({}),
+        abort: async () => ({}),
+      },
+    }
+    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { staleTimeoutMs: 180_000 })
+
+    const task: BackgroundTask = {
+      id: "task-3",
+      sessionID: "session-3",
+      parentSessionID: "parent-3",
+      parentMessageID: "msg-3",
+      description: "Stale task",
+      prompt: "Test",
+      agent: "test-agent",
+      status: "running",
+      startedAt: new Date(Date.now() - 300_000),
+      progress: {
+        toolCalls: 2,
+        lastUpdate: new Date(Date.now() - 200_000),
+      },
+    }
+
+    manager["tasks"].set(task.id, task)
+
+    await manager["checkAndInterruptStaleTasks"]()
+
+    expect(task.status).toBe("cancelled")
+    expect(task.error).toContain("Stale timeout")
+    expect(task.error).toContain("3min")
+    expect(task.completedAt).toBeDefined()
+  })
+
+  test("should respect custom staleTimeoutMs config", async () => {
+    const client = {
+      session: {
+        prompt: async () => ({}),
+        abort: async () => ({}),
+      },
+    }
+    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { staleTimeoutMs: 60_000 })
+
+    const task: BackgroundTask = {
+      id: "task-4",
+      sessionID: "session-4",
+      parentSessionID: "parent-4",
+      parentMessageID: "msg-4",
+      description: "Custom timeout task",
+      prompt: "Test",
+      agent: "test-agent",
+      status: "running",
+      startedAt: new Date(Date.now() - 120_000),
+      progress: {
+        toolCalls: 1,
+        lastUpdate: new Date(Date.now() - 90_000),
+      },
+    }
+
+    manager["tasks"].set(task.id, task)
+
+    await manager["checkAndInterruptStaleTasks"]()
+
+    expect(task.status).toBe("cancelled")
+    expect(task.error).toContain("Stale timeout")
+  })
+
+  test("should release concurrency before abort", async () => {
+    const client = {
+      session: {
+        prompt: async () => ({}),
+        abort: async () => ({}),
+      },
+    }
+    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { staleTimeoutMs: 180_000 })
+
+    const task: BackgroundTask = {
+      id: "task-5",
+      sessionID: "session-5",
+      parentSessionID: "parent-5",
+      parentMessageID: "msg-5",
+      description: "Concurrency test",
+      prompt: "Test",
+      agent: "test-agent",
+      status: "running",
+      startedAt: new Date(Date.now() - 300_000),
+      progress: {
+        toolCalls: 1,
+        lastUpdate: new Date(Date.now() - 200_000),
+      },
+      concurrencyKey: "test-agent",
+    }
+
+    manager["tasks"].set(task.id, task)
+
+    await manager["checkAndInterruptStaleTasks"]()
+
+    expect(task.concurrencyKey).toBeUndefined()
+    expect(task.status).toBe("cancelled")
+  })
+
+  test("should handle multiple stale tasks in same poll cycle", async () => {
+    const client = {
+      session: {
+        prompt: async () => ({}),
+        abort: async () => ({}),
+      },
+    }
+    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { staleTimeoutMs: 180_000 })
+
+    const task1: BackgroundTask = {
+      id: "task-6",
+      sessionID: "session-6",
+      parentSessionID: "parent-6",
+      parentMessageID: "msg-6",
+      description: "Stale 1",
+      prompt: "Test",
+      agent: "test-agent",
+      status: "running",
+      startedAt: new Date(Date.now() - 300_000),
+      progress: {
+        toolCalls: 1,
+        lastUpdate: new Date(Date.now() - 200_000),
+      },
+    }
+
+    const task2: BackgroundTask = {
+      id: "task-7",
+      sessionID: "session-7",
+      parentSessionID: "parent-7",
+      parentMessageID: "msg-7",
+      description: "Stale 2",
+      prompt: "Test",
+      agent: "test-agent",
+      status: "running",
+      startedAt: new Date(Date.now() - 400_000),
+      progress: {
+        toolCalls: 2,
+        lastUpdate: new Date(Date.now() - 250_000),
+      },
+    }
+
+    manager["tasks"].set(task1.id, task1)
+    manager["tasks"].set(task2.id, task2)
+
+    await manager["checkAndInterruptStaleTasks"]()
+
+    expect(task1.status).toBe("cancelled")
+    expect(task2.status).toBe("cancelled")
+  })
+
+  test("should use default timeout when config not provided", async () => {
+    const client = {
+      session: {
+        prompt: async () => ({}),
+        abort: async () => ({}),
+      },
+    }
+    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput)
+
+    const task: BackgroundTask = {
+      id: "task-8",
+      sessionID: "session-8",
+      parentSessionID: "parent-8",
+      parentMessageID: "msg-8",
+      description: "Default timeout",
+      prompt: "Test",
+      agent: "test-agent",
+      status: "running",
+      startedAt: new Date(Date.now() - 300_000),
+      progress: {
+        toolCalls: 1,
+        lastUpdate: new Date(Date.now() - 200_000),
+      },
+    }
+
+    manager["tasks"].set(task.id, task)
+
+    await manager["checkAndInterruptStaleTasks"]()
+
+    expect(task.status).toBe("cancelled")
+  })
+})
+

src/features/background-agent/manager.ts

@@ -5,7 +5,7 @@ import type {
   LaunchInput,
   ResumeInput,
 } from "./types"
-import { log } from "../../shared/logger"
+import { log, getAgentToolRestrictions } from "../../shared"
 import { ConcurrencyManager } from "./concurrency"
 import type { BackgroundTaskConfig } from "../../config/schema"
 
@@ -17,9 +17,14 @@ import { join } from "node:path"
 
 const TASK_TTL_MS = 30 * 60 * 1000
 const MIN_STABILITY_TIME_MS = 10 * 1000  // Must run at least 10s before stability detection kicks in
+const DEFAULT_STALE_TIMEOUT_MS = 180_000  // 3 minutes
+const MIN_RUNTIME_BEFORE_STALE_MS = 30_000  // 30 seconds
+
+type ProcessCleanupEvent = NodeJS.Signals | "beforeExit" | "exit"
 
 type OpencodeClient = PluginInput["client"]
 
+
 interface MessagePartInfo {
   sessionID?: string
   type?: string
@@ -45,6 +50,10 @@ interface Todo {
 }
 
 export class BackgroundManager {
+  private static cleanupManagers = new Set<BackgroundManager>()
+  private static cleanupRegistered = false
+  private static cleanupHandlers = new Map<ProcessCleanupEvent, () => void>()
+
   private tasks: Map<string, BackgroundTask>
   private notifications: Map<string, BackgroundTask[]>
   private pendingByParent: Map<string, Set<string>>  // Track pending tasks per parent for batching
@@ -52,6 +61,9 @@ export class BackgroundManager {
   private directory: string
   private pollingInterval?: ReturnType<typeof setInterval>
   private concurrencyManager: ConcurrencyManager
+  private shutdownTriggered = false
+  private config?: BackgroundTaskConfig
+
 
   constructor(ctx: PluginInput, config?: BackgroundTaskConfig) {
     this.tasks = new Map()
@@ -60,6 +72,8 @@ export class BackgroundManager {
     this.client = ctx.client
     this.directory = ctx.directory
     this.concurrencyManager = new ConcurrencyManager(config)
+    this.config = config
+    this.registerProcessCleanup()
   }
 
   async launch(input: LaunchInput): Promise<BackgroundTask> {
@@ -126,8 +140,10 @@ export class BackgroundManager {
       parentAgent: input.parentAgent,
       model: input.model,
       concurrencyKey,
+      concurrencyGroup: concurrencyKey,
     }
 
+
     this.tasks.set(task.id, task)
     this.startPolling()
 
@@ -166,8 +182,9 @@ export class BackgroundManager {
         ...(input.model ? { model: input.model } : {}),
         system: input.skillContent,
         tools: {
+          ...getAgentToolRestrictions(input.agent),
           task: false,
-          sisyphus_task: false,
+          delegate_task: false,
           call_omo_agent: true,
         },
         parts: [{ type: "text", text: input.prompt }],
@@ -186,8 +203,9 @@ export class BackgroundManager {
         existingTask.completedAt = new Date()
         if (existingTask.concurrencyKey) {
           this.concurrencyManager.release(existingTask.concurrencyKey)
-          existingTask.concurrencyKey = undefined  // Prevent double-release
+          existingTask.concurrencyKey = undefined
         }
+
         this.markForNotification(existingTask)
         this.notifyParentSession(existingTask).catch(err => {
           log("[background-agent] Failed to notify on error:", err)
@@ -235,17 +253,60 @@ export class BackgroundManager {
   }
 
   /**
-   * Register an external task (e.g., from sisyphus_task) for notification tracking.
-   * This allows tasks created by external tools to receive the same toast/prompt notifications.
+   * Track a task created elsewhere (e.g., from delegate_task) for notification tracking.
+   * This allows tasks created by other tools to receive the same toast/prompt notifications.
    */
-  registerExternalTask(input: {
+  async trackTask(input: {
     taskId: string
     sessionID: string
     parentSessionID: string
     description: string
     agent?: string
     parentAgent?: string
-  }): BackgroundTask {
+    concurrencyKey?: string
+  }): Promise<BackgroundTask> {
+    const existingTask = this.tasks.get(input.taskId)
+    if (existingTask) {
+      // P2 fix: Clean up old parent's pending set BEFORE changing parent
+      // Otherwise cleanupPendingByParent would use the new parent ID
+      const parentChanged = input.parentSessionID !== existingTask.parentSessionID
+      if (parentChanged) {
+        this.cleanupPendingByParent(existingTask)  // Clean from OLD parent
+        existingTask.parentSessionID = input.parentSessionID
+      }
+      if (input.parentAgent !== undefined) {
+        existingTask.parentAgent = input.parentAgent
+      }
+      if (!existingTask.concurrencyGroup) {
+        existingTask.concurrencyGroup = input.concurrencyKey ?? existingTask.agent
+      }
+
+      subagentSessions.add(existingTask.sessionID)
+      this.startPolling()
+
+      // Track for batched notifications only if task is still running
+      // Don't add stale entries for completed tasks
+      if (existingTask.status === "running") {
+        const pending = this.pendingByParent.get(input.parentSessionID) ?? new Set()
+        pending.add(existingTask.id)
+        this.pendingByParent.set(input.parentSessionID, pending)
+      } else if (!parentChanged) {
+        // Only clean up if parent didn't change (already cleaned above if it did)
+        this.cleanupPendingByParent(existingTask)
+      }
+
+      log("[background-agent] External task already registered:", { taskId: existingTask.id, sessionID: existingTask.sessionID, status: existingTask.status })
+
+      return existingTask
+    }
+
+    const concurrencyGroup = input.concurrencyKey ?? input.agent ?? "delegate_task"
+
+    // Acquire concurrency slot if a key is provided
+    if (input.concurrencyKey) {
+      await this.concurrencyManager.acquire(input.concurrencyKey)
+    }
+
     const task: BackgroundTask = {
       id: input.taskId,
       sessionID: input.sessionID,
@@ -253,7 +314,7 @@ export class BackgroundManager {
       parentMessageID: "",
       description: input.description,
       prompt: "",
-      agent: input.agent || "sisyphus_task",
+      agent: input.agent || "delegate_task",
       status: "running",
       startedAt: new Date(),
       progress: {
@@ -261,12 +322,15 @@ export class BackgroundManager {
         lastUpdate: new Date(),
       },
       parentAgent: input.parentAgent,
+      concurrencyKey: input.concurrencyKey,
+      concurrencyGroup,
     }
 
     this.tasks.set(task.id, task)
     subagentSessions.add(input.sessionID)
     this.startPolling()
 
+
     // Track for batched notifications (external tasks need tracking too)
     const pending = this.pendingByParent.get(input.parentSessionID) ?? new Set()
     pending.add(task.id)
@@ -283,6 +347,21 @@ export class BackgroundManager {
       throw new Error(`Task not found for session: ${input.sessionId}`)
     }
 
+    if (existingTask.status === "running") {
+      log("[background-agent] Resume skipped - task already running:", {
+        taskId: existingTask.id,
+        sessionID: existingTask.sessionID,
+      })
+      return existingTask
+    }
+
+    // Re-acquire concurrency using the persisted concurrency group
+    const concurrencyKey = existingTask.concurrencyGroup ?? existingTask.agent
+    await this.concurrencyManager.acquire(concurrencyKey)
+    existingTask.concurrencyKey = concurrencyKey
+    existingTask.concurrencyGroup = concurrencyKey
+
+
     existingTask.status = "running"
     existingTask.completedAt = undefined
     existingTask.error = undefined
@@ -322,18 +401,21 @@ export class BackgroundManager {
     log("[background-agent] Resuming task - calling prompt (fire-and-forget) with:", {
       sessionID: existingTask.sessionID,
       agent: existingTask.agent,
+      model: existingTask.model,
       promptLength: input.prompt.length,
     })
 
-    // Note: Don't pass model in body - use agent's configured model instead
     // Use prompt() instead of promptAsync() to properly initialize agent loop
+    // Include model if task has one (preserved from original launch with category config)
     this.client.session.prompt({
       path: { id: existingTask.sessionID },
       body: {
         agent: existingTask.agent,
+        ...(existingTask.model ? { model: existingTask.model } : {}),
         tools: {
+          ...getAgentToolRestrictions(existingTask.agent),
           task: false,
-          sisyphus_task: false,
+          delegate_task: false,
           call_omo_agent: true,
         },
         parts: [{ type: "text", text: input.prompt }],
@@ -344,10 +426,11 @@ export class BackgroundManager {
       const errorMessage = error instanceof Error ? error.message : String(error)
       existingTask.error = errorMessage
       existingTask.completedAt = new Date()
-      // Release concurrency on resume error (matches launch error handler)
+
+      // Release concurrency on error to prevent slot leaks
       if (existingTask.concurrencyKey) {
         this.concurrencyManager.release(existingTask.concurrencyKey)
-        existingTask.concurrencyKey = undefined  // Prevent double-release
+        existingTask.concurrencyKey = undefined
       }
       this.markForNotification(existingTask)
       this.notifyParentSession(existingTask).catch(err => {
@@ -417,29 +500,31 @@ export class BackgroundManager {
 
       // Edge guard: Verify session has actual assistant output before completing
       this.validateSessionHasOutput(sessionID).then(async (hasValidOutput) => {
+        // Re-check status after async operation (could have been completed by polling)
+        if (task.status !== "running") {
+          log("[background-agent] Task status changed during validation, skipping:", { taskId: task.id, status: task.status })
+          return
+        }
+
         if (!hasValidOutput) {
           log("[background-agent] Session.idle but no valid output yet, waiting:", task.id)
           return
         }
 
         const hasIncompleteTodos = await this.checkSessionTodos(sessionID)
+
+        // Re-check status after async operation again
+        if (task.status !== "running") {
+          log("[background-agent] Task status changed during todo check, skipping:", { taskId: task.id, status: task.status })
+          return
+        }
+
         if (hasIncompleteTodos) {
           log("[background-agent] Task has incomplete todos, waiting for todo-continuation:", task.id)
           return
         }
 
-        task.status = "completed"
-        task.completedAt = new Date()
-        // Release concurrency immediately on completion
-        if (task.concurrencyKey) {
-          this.concurrencyManager.release(task.concurrencyKey)
-          task.concurrencyKey = undefined  // Prevent double-release
-        }
-        // Clean up pendingByParent to prevent stale entries
-        this.cleanupPendingByParent(task)
-        this.markForNotification(task)
-        await this.notifyParentSession(task)
-        log("[background-agent] Task completed via session.idle event:", task.id)
+        await this.tryCompleteTask(task, "session.idle event")
       }).catch(err => {
         log("[background-agent] Error in session.idle handler:", err)
       })
@@ -459,10 +544,10 @@ export class BackgroundManager {
         task.error = "Session deleted"
       }
 
-      if (task.concurrencyKey) {
-        this.concurrencyManager.release(task.concurrencyKey)
-        task.concurrencyKey = undefined  // Prevent double-release
-      }
+       if (task.concurrencyKey) {
+         this.concurrencyManager.release(task.concurrencyKey)
+         task.concurrencyKey = undefined
+       }
       // Clean up pendingByParent to prevent stale entries
       this.cleanupPendingByParent(task)
       this.tasks.delete(task.id)
@@ -587,13 +672,49 @@ export class BackgroundManager {
     }
   }
 
-cleanup(): void {
-    this.stopPolling()
-    this.tasks.clear()
-    this.notifications.clear()
-    this.pendingByParent.clear()
+  private registerProcessCleanup(): void {
+    BackgroundManager.cleanupManagers.add(this)
+
+    if (BackgroundManager.cleanupRegistered) return
+    BackgroundManager.cleanupRegistered = true
+
+    const cleanupAll = () => {
+      for (const manager of BackgroundManager.cleanupManagers) {
+        try {
+          manager.shutdown()
+        } catch (error) {
+          log("[background-agent] Error during shutdown cleanup:", error)
+        }
+      }
+    }
+
+    const registerSignal = (signal: ProcessCleanupEvent, exitAfter: boolean): void => {
+      const listener = registerProcessSignal(signal, cleanupAll, exitAfter)
+      BackgroundManager.cleanupHandlers.set(signal, listener)
+    }
+
+    registerSignal("SIGINT", true)
+    registerSignal("SIGTERM", true)
+    if (process.platform === "win32") {
+      registerSignal("SIGBREAK", true)
+    }
+    registerSignal("beforeExit", false)
+    registerSignal("exit", false)
   }
 
+  private unregisterProcessCleanup(): void {
+    BackgroundManager.cleanupManagers.delete(this)
+
+    if (BackgroundManager.cleanupManagers.size > 0) return
+
+    for (const [signal, listener] of BackgroundManager.cleanupHandlers.entries()) {
+      process.off(signal, listener)
+    }
+    BackgroundManager.cleanupHandlers.clear()
+    BackgroundManager.cleanupRegistered = false
+  }
+
+
   /**
    * Get all running tasks (for compaction hook)
    */
@@ -608,12 +729,44 @@ cleanup(): void {
     return Array.from(this.tasks.values()).filter(t => t.status !== "running")
   }
 
-private async notifyParentSession(task: BackgroundTask): Promise<void> {
+  /**
+   * Safely complete a task with race condition protection.
+   * Returns true if task was successfully completed, false if already completed by another path.
+   */
+  private async tryCompleteTask(task: BackgroundTask, source: string): Promise<boolean> {
+    // Guard: Check if task is still running (could have been completed by another path)
+    if (task.status !== "running") {
+      log("[background-agent] Task already completed, skipping:", { taskId: task.id, status: task.status, source })
+      return false
+    }
+
+    // Atomically mark as completed to prevent race conditions
+    task.status = "completed"
+    task.completedAt = new Date()
+
+    // Release concurrency BEFORE any async operations to prevent slot leaks
     if (task.concurrencyKey) {
       this.concurrencyManager.release(task.concurrencyKey)
       task.concurrencyKey = undefined
     }
 
+    this.markForNotification(task)
+
+    try {
+      await this.notifyParentSession(task)
+      log(`[background-agent] Task completed via ${source}:`, task.id)
+    } catch (err) {
+      log("[background-agent] Error in notifyParentSession:", { taskId: task.id, error: err })
+      // Concurrency already released, notification failed but task is complete
+    }
+
+    return true
+  }
+
+  private async notifyParentSession(task: BackgroundTask): Promise<void> {
+    // Note: Callers must release concurrency before calling this method
+    // to ensure slots are freed even if notification fails
+
     const duration = this.formatDuration(task.startedAt, task.completedAt)
 
     log("[background-agent] notifyParentSession called for task:", task.id)
@@ -681,13 +834,13 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
     try {
       const messagesResp = await this.client.session.messages({ path: { id: task.parentSessionID } })
       const messages = (messagesResp.data ?? []) as Array<{
-        info?: { agent?: string; model?: { providerID: string; modelID: string } }
+        info?: { agent?: string; model?: { providerID: string; modelID: string }; modelID?: string; providerID?: string }
       }>
       for (let i = messages.length - 1; i >= 0; i--) {
         const info = messages[i].info
-        if (info?.agent || info?.model) {
+        if (info?.agent || info?.model || (info?.modelID && info?.providerID)) {
           agent = info.agent ?? task.parentAgent
-          model = info.model
+          model = info.model ?? (info.providerID && info.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined)
           break
         }
       }
@@ -727,10 +880,12 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
 
     const taskId = task.id
     setTimeout(() => {
-      // Concurrency already released at completion - just cleanup notifications and task
-      this.clearNotificationsForTask(taskId)
-      this.tasks.delete(taskId)
-      log("[background-agent] Removed completed task from memory:", taskId)
+      // Guard: Only delete if task still exists (could have been deleted by session.deleted event)
+      if (this.tasks.has(taskId)) {
+        this.clearNotificationsForTask(taskId)
+        this.tasks.delete(taskId)
+        log("[background-agent] Removed completed task from memory:", taskId)
+      }
     }, 5 * 60 * 1000)
   }
 
@@ -767,7 +922,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
         task.completedAt = new Date()
         if (task.concurrencyKey) {
           this.concurrencyManager.release(task.concurrencyKey)
-          task.concurrencyKey = undefined  // Prevent double-release
+          task.concurrencyKey = undefined
         }
         // Clean up pendingByParent to prevent stale entries
         this.cleanupPendingByParent(task)
@@ -794,8 +949,49 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
     }
   }
 
+  private async checkAndInterruptStaleTasks(): Promise<void> {
+    const staleTimeoutMs = this.config?.staleTimeoutMs ?? DEFAULT_STALE_TIMEOUT_MS
+    const now = Date.now()
+
+    for (const task of this.tasks.values()) {
+      if (task.status !== "running") continue
+      if (!task.progress?.lastUpdate) continue
+
+      const runtime = now - task.startedAt.getTime()
+      if (runtime < MIN_RUNTIME_BEFORE_STALE_MS) continue
+
+      const timeSinceLastUpdate = now - task.progress.lastUpdate.getTime()
+      if (timeSinceLastUpdate <= staleTimeoutMs) continue
+
+      if (task.status !== "running") continue
+
+      const staleMinutes = Math.round(timeSinceLastUpdate / 60000)
+      task.status = "cancelled"
+      task.error = `Stale timeout (no activity for ${staleMinutes}min)`
+      task.completedAt = new Date()
+
+      if (task.concurrencyKey) {
+        this.concurrencyManager.release(task.concurrencyKey)
+        task.concurrencyKey = undefined
+      }
+
+      this.client.session.abort({
+        path: { id: task.sessionID },
+      }).catch(() => {})
+
+      log(`[background-agent] Task ${task.id} interrupted: stale timeout`)
+
+      try {
+        await this.notifyParentSession(task)
+      } catch (err) {
+        log("[background-agent] Error in notifyParentSession for stale task:", { taskId: task.id, error: err })
+      }
+    }
+  }
+
   private async pollRunningTasks(): Promise<void> {
     this.pruneStaleTasksAndNotifications()
+    await this.checkAndInterruptStaleTasks()
 
     const statusResult = await this.client.session.status()
     const allStatuses = (statusResult.data ?? {}) as Record<string, { type: string }>
@@ -803,7 +999,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
     for (const task of this.tasks.values()) {
       if (task.status !== "running") continue
 
-try {
+      try {
         const sessionStatus = allStatuses[task.sessionID]
         
         // Don't skip if session not in status - fall through to message-based detection
@@ -815,24 +1011,16 @@ try {
             continue
           }
 
+          // Re-check status after async operation
+          if (task.status !== "running") continue
+
           const hasIncompleteTodos = await this.checkSessionTodos(task.sessionID)
           if (hasIncompleteTodos) {
             log("[background-agent] Task has incomplete todos via polling, waiting:", task.id)
             continue
           }
 
-          task.status = "completed"
-          task.completedAt = new Date()
-          // Release concurrency immediately on completion
-          if (task.concurrencyKey) {
-            this.concurrencyManager.release(task.concurrencyKey)
-            task.concurrencyKey = undefined  // Prevent double-release
-          }
-          // Clean up pendingByParent to prevent stale entries
-          this.cleanupPendingByParent(task)
-          this.markForNotification(task)
-          await this.notifyParentSession(task)
-          log("[background-agent] Task completed via polling:", task.id)
+          await this.tryCompleteTask(task, "polling (idle status)")
           continue
         }
 
@@ -872,7 +1060,7 @@ try {
           task.progress.toolCalls = toolCalls
           task.progress.lastTool = lastTool
           task.progress.lastUpdate = new Date()
-if (lastMessage) {
+          if (lastMessage) {
             task.progress.lastMessage = lastMessage
             task.progress.lastMessageAt = new Date()
           }
@@ -892,20 +1080,12 @@ if (lastMessage) {
                   continue
                 }
 
+                // Re-check status after async operation
+                if (task.status !== "running") continue
+
                 const hasIncompleteTodos = await this.checkSessionTodos(task.sessionID)
                 if (!hasIncompleteTodos) {
-                  task.status = "completed"
-                  task.completedAt = new Date()
-                  // Release concurrency immediately on completion
-                  if (task.concurrencyKey) {
-                    this.concurrencyManager.release(task.concurrencyKey)
-                    task.concurrencyKey = undefined  // Prevent double-release
-                  }
-                  // Clean up pendingByParent to prevent stale entries
-                  this.cleanupPendingByParent(task)
-                  this.markForNotification(task)
-                  await this.notifyParentSession(task)
-                  log("[background-agent] Task completed via stability detection:", task.id)
+                  await this.tryCompleteTask(task, "stability detection")
                   continue
                 }
               }
@@ -924,8 +1104,53 @@ if (lastMessage) {
       this.stopPolling()
     }
   }
+
+  /**
+   * Shutdown the manager gracefully.
+   * Cancels all pending concurrency waiters and clears timers.
+   * Should be called when the plugin is unloaded.
+   */
+  shutdown(): void {
+    if (this.shutdownTriggered) return
+    this.shutdownTriggered = true
+    log("[background-agent] Shutting down BackgroundManager")
+    this.stopPolling()
+
+    // Release concurrency for all running tasks first
+    for (const task of this.tasks.values()) {
+      if (task.concurrencyKey) {
+        this.concurrencyManager.release(task.concurrencyKey)
+        task.concurrencyKey = undefined
+      }
+    }
+
+    // Then clear all state (cancels any remaining waiters)
+    this.concurrencyManager.clear()
+    this.tasks.clear()
+    this.notifications.clear()
+    this.pendingByParent.clear()
+    this.unregisterProcessCleanup()
+    log("[background-agent] Shutdown complete")
+
+  }
 }
 
+function registerProcessSignal(
+  signal: ProcessCleanupEvent,
+  handler: () => void,
+  exitAfter: boolean
+): () => void {
+  const listener = () => {
+    handler()
+    if (exitAfter) {
+      process.exit(0)
+    }
+  }
+  process.on(signal, listener)
+  return listener
+}
+
+
 function getMessageDir(sessionID: string): string | null {
   if (!existsSync(MESSAGE_STORAGE)) return null
 

src/features/background-agent/types.ts

@@ -28,10 +28,13 @@ export interface BackgroundTask {
   progress?: TaskProgress
   parentModel?: { providerID: string; modelID: string }
   model?: { providerID: string; modelID: string; variant?: string }
-  /** Agent name used for concurrency tracking */
+  /** Active concurrency slot key */
   concurrencyKey?: string
+  /** Persistent key for re-acquiring concurrency on resume */
+  concurrencyGroup?: string
   /** Parent session's agent name for notification */
   parentAgent?: string
+
   /** Last message count for stability detection */
   lastMsgCount?: number
   /** Number of consecutive polls with stable message count */

src/features/builtin-commands/commands.ts

@@ -17,17 +17,28 @@ $ARGUMENTS
 </user-request>`,
     argumentHint: "[--create-new] [--max-depth=N]",
   },
-  "ralph-loop": {
-    description: "(builtin) Start self-referential development loop until completion",
-    template: `<command-instruction>
+   "ralph-loop": {
+     description: "(builtin) Start self-referential development loop until completion",
+     template: `<command-instruction>
 ${RALPH_LOOP_TEMPLATE}
 </command-instruction>
 
 <user-task>
 $ARGUMENTS
 </user-task>`,
-    argumentHint: '"task description" [--completion-promise=TEXT] [--max-iterations=N]',
-  },
+     argumentHint: '"task description" [--completion-promise=TEXT] [--max-iterations=N]',
+   },
+   "ulw-loop": {
+     description: "(builtin) Start ultrawork loop - continues until completion with ultrawork mode",
+     template: `<command-instruction>
+${RALPH_LOOP_TEMPLATE}
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+     argumentHint: '"task description" [--completion-promise=TEXT] [--max-iterations=N]',
+   },
   "cancel-ralph": {
     description: "(builtin) Cancel active Ralph Loop",
     template: `<command-instruction>

src/features/builtin-commands/templates/init-deep.ts

@@ -45,12 +45,12 @@ Don't wait—these run async while main session works.
 
 \`\`\`
 // Fire all at once, collect results later
-sisyphus_task(agent="explore", prompt="Project structure: PREDICT standard patterns for detected language → REPORT deviations only")
-sisyphus_task(agent="explore", prompt="Entry points: FIND main files → REPORT non-standard organization")
-sisyphus_task(agent="explore", prompt="Conventions: FIND config files (.eslintrc, pyproject.toml, .editorconfig) → REPORT project-specific rules")
-sisyphus_task(agent="explore", prompt="Anti-patterns: FIND 'DO NOT', 'NEVER', 'ALWAYS', 'DEPRECATED' comments → LIST forbidden patterns")
-sisyphus_task(agent="explore", prompt="Build/CI: FIND .github/workflows, Makefile → REPORT non-standard patterns")
-sisyphus_task(agent="explore", prompt="Test patterns: FIND test configs, test structure → REPORT unique conventions")
+delegate_task(agent="explore", prompt="Project structure: PREDICT standard patterns for detected language → REPORT deviations only")
+delegate_task(agent="explore", prompt="Entry points: FIND main files → REPORT non-standard organization")
+delegate_task(agent="explore", prompt="Conventions: FIND config files (.eslintrc, pyproject.toml, .editorconfig) → REPORT project-specific rules")
+delegate_task(agent="explore", prompt="Anti-patterns: FIND 'DO NOT', 'NEVER', 'ALWAYS', 'DEPRECATED' comments → LIST forbidden patterns")
+delegate_task(agent="explore", prompt="Build/CI: FIND .github/workflows, Makefile → REPORT non-standard patterns")
+delegate_task(agent="explore", prompt="Test patterns: FIND test configs, test structure → REPORT unique conventions")
 \`\`\`
 
 <dynamic-agents>
@@ -76,9 +76,9 @@ max_depth=$(find . -type d -not -path '*/node_modules/*' -not -path '*/.git/*' |
 Example spawning:
 \`\`\`
 // 500 files, 50k lines, depth 6, 15 large files → spawn 5+5+2+1 = 13 additional agents
-sisyphus_task(agent="explore", prompt="Large file analysis: FIND files >500 lines, REPORT complexity hotspots")
-sisyphus_task(agent="explore", prompt="Deep modules at depth 4+: FIND hidden patterns, internal conventions")
-sisyphus_task(agent="explore", prompt="Cross-cutting concerns: FIND shared utilities across directories")
+delegate_task(agent="explore", prompt="Large file analysis: FIND files >500 lines, REPORT complexity hotspots")
+delegate_task(agent="explore", prompt="Deep modules at depth 4+: FIND hidden patterns, internal conventions")
+delegate_task(agent="explore", prompt="Cross-cutting concerns: FIND shared utilities across directories")
 // ... more based on calculation
 \`\`\`
 </dynamic-agents>
@@ -114,19 +114,19 @@ If \`--create-new\`: Read all existing first (preserve context) → then delete
 
 #### 3. LSP Codemap (if available)
 \`\`\`
-lsp_servers()  # Check availability
+LspServers()  # Check availability
 
 # Entry points (parallel)
-lsp_symbols(filePath="src/index.ts", scope="document")
-lsp_symbols(filePath="main.py", scope="document")
+LspDocumentSymbols(filePath="src/index.ts")
+LspDocumentSymbols(filePath="main.py")
 
 # Key symbols (parallel)
-lsp_symbols(filePath=".", scope="workspace", query="class")
-lsp_symbols(filePath=".", scope="workspace", query="interface")
-lsp_symbols(filePath=".", scope="workspace", query="function")
+LspWorkspaceSymbols(filePath=".", query="class")
+LspWorkspaceSymbols(filePath=".", query="interface")
+LspWorkspaceSymbols(filePath=".", query="function")
 
 # Centrality for top exports
-lsp_find_references(filePath="...", line=X, character=Y)
+LspFindReferences(filePath="...", line=X, character=Y)
 \`\`\`
 
 **LSP Fallback**: If unavailable, rely on explore agents + AST-grep.
@@ -240,7 +240,7 @@ Launch document-writer agents for each location:
 
 \`\`\`
 for loc in AGENTS_LOCATIONS (except root):
-  sisyphus_task(agent="document-writer", prompt=\\\`
+  delegate_task(agent="document-writer", prompt=\\\`
     Generate AGENTS.md for: \${loc.path}
     - Reason: \${loc.reason}
     - 30-80 lines max

src/features/builtin-commands/templates/refactor.ts

@@ -149,14 +149,14 @@ While background agents are running, use direct tools:
 
 \`\`\`typescript
 // Find definition(s)
-lsp_goto_definition(filePath, line, character)  // Where is it defined?
+LspGotoDefinition(filePath, line, character)  // Where is it defined?
 
 // Find ALL usages across workspace
-lsp_find_references(filePath, line, character, includeDeclaration=true)
+LspFindReferences(filePath, line, character, includeDeclaration=true)
 
-// Get file structure (scope='document') or search symbols (scope='workspace')
-lsp_symbols(filePath, scope="document")  // Hierarchical outline
-lsp_symbols(filePath, scope="workspace", query="[target_symbol]")  // Search by name
+// Get file structure
+LspDocumentSymbols(filePath)  // Hierarchical outline
+LspWorkspaceSymbols(filePath, query="[target_symbol]")  // Search by name
 
 // Get current diagnostics
 lsp_diagnostics(filePath)  // Errors, warnings before we start
@@ -587,9 +587,9 @@ If any of these occur, **STOP and consult user**:
 You already know these tools. Use them intelligently:
 
 ## LSP Tools
-Leverage the full LSP toolset (\`lsp_*\`) for precision analysis. Key patterns:
-- **Understand before changing**: \`lsp_goto_definition\` to grasp context
-- **Impact analysis**: \`lsp_find_references\` to map all usages before modification
+Leverage LSP tools for precision analysis. Key patterns:
+- **Understand before changing**: \`LspGotoDefinition\` to grasp context
+- **Impact analysis**: \`LspFindReferences\` to map all usages before modification
 - **Safe refactoring**: \`lsp_prepare_rename\` → \`lsp_rename\` for symbol renames
 - **Continuous verification**: \`lsp_diagnostics\` after every change
 

src/features/builtin-commands/types.ts

@@ -1,6 +1,6 @@
 import type { CommandDefinition } from "../claude-code-command-loader"
 
-export type BuiltinCommandName = "init-deep" | "ralph-loop" | "cancel-ralph" | "refactor" | "start-work"
+export type BuiltinCommandName = "init-deep" | "ralph-loop" | "cancel-ralph" | "ulw-loop" | "refactor" | "start-work"
 
 export interface BuiltinCommandConfig {
   disabled_commands?: BuiltinCommandName[]

src/features/builtin-skills/git-master/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: git-master
-description: "MUST USE for ANY git operations. Atomic commits, rebase/squash, history search (blame, bisect, log -S). STRONGLY RECOMMENDED: Use with sisyphus_task(category='quick', skills=['git-master'], ...) to save context. Triggers: 'commit', 'rebase', 'squash', 'who wrote', 'when was X added', 'find the commit that'."
+description: "MUST USE for ANY git operations. Atomic commits, rebase/squash, history search (blame, bisect, log -S). STRONGLY RECOMMENDED: Use with delegate_task(category='quick', skills=['git-master'], ...) to save context. Triggers: 'commit', 'rebase', 'squash', 'who wrote', 'when was X added', 'find the commit that'."
 ---
 
 # Git Master Agent
@@ -529,33 +529,6 @@ IF style == SHORT:
 3. Is it similar to examples from git log?
 
 If ANY check fails -> REWRITE message.
-
-### 5.5 Commit Footer & Co-Author (Configurable)
-
-**Check oh-my-opencode.json for these flags:**
-- `git_master.commit_footer` (default: true) - adds footer message
-- `git_master.include_co_authored_by` (default: true) - adds co-author trailer
-
-If enabled, add Sisyphus attribution to EVERY commit:
-
-1. **Footer in commit body (if `commit_footer: true`):**
-```
-Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)
-```
-
-2. **Co-authored-by trailer (if `include_co_authored_by: true`):**
-```
-Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>
-```
-
-**Example (both enabled):**
-```bash
-git commit -m "{Commit Message}" -m "Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)" -m "Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>"
-```
-
-**To disable:** Set in oh-my-opencode.json:
-```json
-{ "git_master": { "commit_footer": false, "include_co_authored_by": false } }
 ```
 </execution>
 

src/features/builtin-skills/skills.ts

@@ -95,7 +95,7 @@ Interpret creatively and make unexpected choices that feel genuinely designed fo
 const gitMasterSkill: BuiltinSkill = {
   name: "git-master",
   description:
-    "MUST USE for ANY git operations. Atomic commits, rebase/squash, history search (blame, bisect, log -S). STRONGLY RECOMMENDED: Use with sisyphus_task(category='quick', skills=['git-master'], ...) to save context. Triggers: 'commit', 'rebase', 'squash', 'who wrote', 'when was X added', 'find the commit that'.",
+    "MUST USE for ANY git operations. Atomic commits, rebase/squash, history search (blame, bisect, log -S). STRONGLY RECOMMENDED: Use with delegate_task(category='quick', skills=['git-master'], ...) to save context. Triggers: 'commit', 'rebase', 'squash', 'who wrote', 'when was X added', 'find the commit that'.",
   template: `# Git Master Agent
 
 You are a Git expert combining three specializations:
@@ -622,35 +622,8 @@ IF style == SHORT:
 3. Is it similar to examples from git log?
 
 If ANY check fails -> REWRITE message.
-
-### 5.5 Commit Footer & Co-Author (Configurable)
-
-**Check oh-my-opencode.json for these flags:**
-- \`git_master.commit_footer\` (default: true) - adds footer message
-- \`git_master.include_co_authored_by\` (default: true) - adds co-author trailer
-
-If enabled, add Sisyphus attribution to EVERY commit:
-
-1. **Footer in commit body (if \`commit_footer: true\`):**
 \`\`\`
-Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)
-\`\`\`
-
-2. **Co-authored-by trailer (if \`include_co_authored_by: true\`):**
-\`\`\`
-Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>
-\`\`\`
-
-**Example (both enabled):**
-\`\`\`bash
-git commit -m "{Commit Message}" -m "Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)" -m "Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>"
-\`\`\`
-
-**To disable:** Set in oh-my-opencode.json:
-\`\`\`json
-{ "git_master": { "commit_footer": false, "include_co_authored_by": false } }
-\`\`\`
-</execution>
+\</execution>
 
 ---
 

src/features/claude-code-session-state/state.test.ts

@@ -0,0 +1,126 @@
+import { describe, test, expect, beforeEach } from "bun:test"
+import {
+  setSessionAgent,
+  getSessionAgent,
+  clearSessionAgent,
+  updateSessionAgent,
+  setMainSession,
+  getMainSessionID,
+  _resetForTesting,
+} from "./state"
+
+describe("claude-code-session-state", () => {
+  beforeEach(() => {
+    // #given - clean state before each test
+    _resetForTesting()
+    clearSessionAgent("test-session-1")
+    clearSessionAgent("test-session-2")
+    clearSessionAgent("test-prometheus-session")
+  })
+
+  describe("setSessionAgent", () => {
+    test("should store agent for session", () => {
+      // #given
+      const sessionID = "test-session-1"
+      const agent = "Prometheus (Planner)"
+
+      // #when
+      setSessionAgent(sessionID, agent)
+
+      // #then
+      expect(getSessionAgent(sessionID)).toBe(agent)
+    })
+
+    test("should NOT overwrite existing agent (first-write wins)", () => {
+      // #given
+      const sessionID = "test-session-1"
+      setSessionAgent(sessionID, "Prometheus (Planner)")
+
+      // #when - try to overwrite
+      setSessionAgent(sessionID, "Sisyphus")
+
+      // #then - first agent preserved
+      expect(getSessionAgent(sessionID)).toBe("Prometheus (Planner)")
+    })
+
+    test("should return undefined for unknown session", () => {
+      // #given - no session set
+
+      // #when / #then
+      expect(getSessionAgent("unknown-session")).toBeUndefined()
+    })
+  })
+
+  describe("updateSessionAgent", () => {
+    test("should overwrite existing agent", () => {
+      // #given
+      const sessionID = "test-session-1"
+      setSessionAgent(sessionID, "Prometheus (Planner)")
+
+      // #when - force update
+      updateSessionAgent(sessionID, "Sisyphus")
+
+      // #then
+      expect(getSessionAgent(sessionID)).toBe("Sisyphus")
+    })
+  })
+
+  describe("clearSessionAgent", () => {
+    test("should remove agent from session", () => {
+      // #given
+      const sessionID = "test-session-1"
+      setSessionAgent(sessionID, "Prometheus (Planner)")
+      expect(getSessionAgent(sessionID)).toBe("Prometheus (Planner)")
+
+      // #when
+      clearSessionAgent(sessionID)
+
+      // #then
+      expect(getSessionAgent(sessionID)).toBeUndefined()
+    })
+  })
+
+  describe("mainSessionID", () => {
+    test("should store and retrieve main session ID", () => {
+      // #given
+      const mainID = "main-session-123"
+
+      // #when
+      setMainSession(mainID)
+
+      // #then
+      expect(getMainSessionID()).toBe(mainID)
+    })
+
+    test.skip("should return undefined when not set", () => {
+      // #given - not set
+      // TODO: Fix flaky test - parallel test execution causes state pollution
+      // #then
+      expect(getMainSessionID()).toBeUndefined()
+    })
+  })
+
+  describe("prometheus-md-only integration scenario", () => {
+    test("should correctly identify Prometheus agent for permission checks", () => {
+      // #given - Prometheus session
+      const sessionID = "test-prometheus-session"
+      const prometheusAgent = "Prometheus (Planner)"
+
+      // #when - agent is set (simulating chat.message hook)
+      setSessionAgent(sessionID, prometheusAgent)
+
+      // #then - getSessionAgent returns correct agent for prometheus-md-only hook
+      const agent = getSessionAgent(sessionID)
+      expect(agent).toBe("Prometheus (Planner)")
+      expect(["Prometheus (Planner)"].includes(agent!)).toBe(true)
+    })
+
+    test("should return undefined when agent not set (bug scenario)", () => {
+      // #given - session exists but no agent set (the bug)
+      const sessionID = "test-prometheus-session"
+
+      // #when / #then - this is the bug: agent is undefined
+      expect(getSessionAgent(sessionID)).toBeUndefined()
+    })
+  })
+})

src/features/claude-code-session-state/state.ts

@@ -1,13 +1,19 @@
 export const subagentSessions = new Set<string>()
 
-export let mainSessionID: string | undefined
+let _mainSessionID: string | undefined
 
 export function setMainSession(id: string | undefined) {
-  mainSessionID = id
+  _mainSessionID = id
 }
 
 export function getMainSessionID(): string | undefined {
-  return mainSessionID
+  return _mainSessionID
+}
+
+/** @internal For testing only */
+export function _resetForTesting(): void {
+  _mainSessionID = undefined
+  subagentSessions.clear()
 }
 
 const sessionAgentMap = new Map<string, string>()

src/features/context-injector/index.ts

@@ -1,7 +1,5 @@
 export { ContextCollector, contextCollector } from "./collector"
 export {
-  injectPendingContext,
-  createContextInjectorHook,
   createContextInjectorMessagesTransformHook,
 } from "./injector"
 export type {

src/features/context-injector/injector.test.ts

@@ -1,181 +1,9 @@
 import { describe, it, expect, beforeEach } from "bun:test"
 import { ContextCollector } from "./collector"
 import {
-  injectPendingContext,
-  createContextInjectorHook,
   createContextInjectorMessagesTransformHook,
 } from "./injector"
 
-describe("injectPendingContext", () => {
-  let collector: ContextCollector
-
-  beforeEach(() => {
-    collector = new ContextCollector()
-  })
-
-  describe("when parts have text content", () => {
-    it("prepends context to first text part", () => {
-      // #given
-      const sessionID = "ses_inject1"
-      collector.register(sessionID, {
-        id: "ulw",
-        source: "keyword-detector",
-        content: "Ultrawork mode activated",
-      })
-      const parts = [{ type: "text", text: "User message" }]
-
-      // #when
-      const result = injectPendingContext(collector, sessionID, parts)
-
-      // #then
-      expect(result.injected).toBe(true)
-      expect(parts[0].text).toContain("Ultrawork mode activated")
-      expect(parts[0].text).toContain("User message")
-    })
-
-    it("uses separator between context and original message", () => {
-      // #given
-      const sessionID = "ses_inject2"
-      collector.register(sessionID, {
-        id: "ctx",
-        source: "keyword-detector",
-        content: "Context content",
-      })
-      const parts = [{ type: "text", text: "Original message" }]
-
-      // #when
-      injectPendingContext(collector, sessionID, parts)
-
-      // #then
-      expect(parts[0].text).toBe("Context content\n\n---\n\nOriginal message")
-    })
-
-    it("consumes context after injection", () => {
-      // #given
-      const sessionID = "ses_inject3"
-      collector.register(sessionID, {
-        id: "ctx",
-        source: "keyword-detector",
-        content: "Context",
-      })
-      const parts = [{ type: "text", text: "Message" }]
-
-      // #when
-      injectPendingContext(collector, sessionID, parts)
-
-      // #then
-      expect(collector.hasPending(sessionID)).toBe(false)
-    })
-
-    it("returns injected=false when no pending context", () => {
-      // #given
-      const sessionID = "ses_empty"
-      const parts = [{ type: "text", text: "Message" }]
-
-      // #when
-      const result = injectPendingContext(collector, sessionID, parts)
-
-      // #then
-      expect(result.injected).toBe(false)
-      expect(parts[0].text).toBe("Message")
-    })
-  })
-
-  describe("when parts have no text content", () => {
-    it("does not inject and preserves context", () => {
-      // #given
-      const sessionID = "ses_notext"
-      collector.register(sessionID, {
-        id: "ctx",
-        source: "keyword-detector",
-        content: "Context",
-      })
-      const parts = [{ type: "image", url: "https://example.com/img.png" }]
-
-      // #when
-      const result = injectPendingContext(collector, sessionID, parts)
-
-      // #then
-      expect(result.injected).toBe(false)
-      expect(collector.hasPending(sessionID)).toBe(true)
-    })
-  })
-
-  describe("with multiple text parts", () => {
-    it("injects into first text part only", () => {
-      // #given
-      const sessionID = "ses_multi"
-      collector.register(sessionID, {
-        id: "ctx",
-        source: "keyword-detector",
-        content: "Context",
-      })
-      const parts = [
-        { type: "text", text: "First" },
-        { type: "text", text: "Second" },
-      ]
-
-      // #when
-      injectPendingContext(collector, sessionID, parts)
-
-      // #then
-      expect(parts[0].text).toContain("Context")
-      expect(parts[1].text).toBe("Second")
-    })
-  })
-})
-
-describe("createContextInjectorHook", () => {
-  let collector: ContextCollector
-
-  beforeEach(() => {
-    collector = new ContextCollector()
-  })
-
-  describe("chat.message handler", () => {
-    it("injects pending context into output parts", async () => {
-      // #given
-      const hook = createContextInjectorHook(collector)
-      const sessionID = "ses_hook1"
-      collector.register(sessionID, {
-        id: "ctx",
-        source: "keyword-detector",
-        content: "Hook context",
-      })
-      const input = { sessionID }
-      const output = {
-        message: {},
-        parts: [{ type: "text", text: "User message" }],
-      }
-
-      // #when
-      await hook["chat.message"](input, output)
-
-      // #then
-      expect(output.parts[0].text).toContain("Hook context")
-      expect(output.parts[0].text).toContain("User message")
-      expect(collector.hasPending(sessionID)).toBe(false)
-    })
-
-    it("does nothing when no pending context", async () => {
-      // #given
-      const hook = createContextInjectorHook(collector)
-      const sessionID = "ses_hook2"
-      const input = { sessionID }
-      const output = {
-        message: {},
-        parts: [{ type: "text", text: "User message" }],
-      }
-
-      // #when
-      await hook["chat.message"](input, output)
-
-      // #then
-      expect(output.parts[0].text).toBe("User message")
-    })
-  })
-})
-
 describe("createContextInjectorMessagesTransformHook", () => {
   let collector: ContextCollector
 
@@ -208,7 +36,7 @@ describe("createContextInjectorMessagesTransformHook", () => {
     ],
   })
 
-  it("prepends context to last user message", async () => {
+  it("inserts synthetic part before text part in last user message", async () => {
     // #given
     const hook = createContextInjectorMessagesTransformHook(collector)
     const sessionID = "ses_transform1"
@@ -228,9 +56,12 @@ describe("createContextInjectorMessagesTransformHook", () => {
     // #when
     await hook["experimental.chat.messages.transform"]!({}, output)
 
-    // #then
+    // #then - synthetic part inserted before original text part
     expect(output.messages.length).toBe(3)
-    expect(output.messages[2].parts[0].text).toBe("Ultrawork context\n\n---\n\nSecond message")
+    expect(output.messages[2].parts.length).toBe(2)
+    expect(output.messages[2].parts[0].text).toBe("Ultrawork context")
+    expect(output.messages[2].parts[0].synthetic).toBe(true)
+    expect(output.messages[2].parts[1].text).toBe("Second message")
   })
 
   it("does nothing when no pending context", async () => {

src/features/context-injector/injector.ts

@@ -1,6 +1,7 @@
 import type { ContextCollector } from "./collector"
 import type { Message, Part } from "@opencode-ai/sdk"
 import { log } from "../../shared"
+import { getMainSessionID } from "../claude-code-session-state"
 
 interface OutputPart {
   type: string
@@ -105,14 +106,17 @@ export function createContextInjectorMessagesTransformHook(
       }
 
       const lastUserMessage = messages[lastUserMessageIndex]
-      const sessionID = (lastUserMessage.info as unknown as { sessionID?: string }).sessionID
-      log("[DEBUG] Extracted sessionID from lastUserMessage.info", {
+      // Try message.info.sessionID first, fallback to mainSessionID
+      const messageSessionID = (lastUserMessage.info as unknown as { sessionID?: string }).sessionID
+      const sessionID = messageSessionID ?? getMainSessionID()
+      log("[DEBUG] Extracted sessionID", {
+        messageSessionID,
+        mainSessionID: getMainSessionID(),
         sessionID,
         infoKeys: Object.keys(lastUserMessage.info),
-        lastUserMessageInfo: JSON.stringify(lastUserMessage.info).slice(0, 200),
       })
       if (!sessionID) {
-        log("[DEBUG] sessionID is undefined or empty")
+        log("[DEBUG] sessionID is undefined (both message.info and mainSessionID are empty)")
         return
       }
 
@@ -142,14 +146,21 @@ export function createContextInjectorMessagesTransformHook(
         return
       }
 
-      const textPart = lastUserMessage.parts[textPartIndex] as { text?: string }
-      const originalText = textPart.text ?? ""
-      textPart.text = `${pending.merged}\n\n---\n\n${originalText}`
+      // synthetic part 패턴 (minimal fields)
+      const syntheticPart = {
+        id: `synthetic_hook_${Date.now()}`,
+        messageID: lastUserMessage.info.id,
+        sessionID: (lastUserMessage.info as { sessionID?: string }).sessionID ?? "",
+        type: "text" as const,
+        text: pending.merged,
+        synthetic: true,  // UI에서 숨겨짐
+      }
 
-      log("[context-injector] Prepended context to last user message", {
+      lastUserMessage.parts.splice(textPartIndex, 0, syntheticPart as Part)
+
+      log("[context-injector] Inserted synthetic part with hook content", {
         sessionID,
-        contextLength: pending.merged.length,
-        originalTextLength: originalText.length,
+        contentLength: pending.merged.length,
       })
     },
   }

src/features/opencode-skill-loader/skill-content.test.ts

@@ -160,8 +160,8 @@ describe("resolveMultipleSkillsAsync", () => {
 		expect(result.resolved.get("playwright")).toContain("Playwright Browser Automation")
 	})
 
-	it("should support git-master config injection", async () => {
-		// #given: git-master skill with config override
+	it("should NOT inject watermark when both options are disabled", async () => {
+		// #given: git-master skill with watermark disabled
 		const skillNames = ["git-master"]
 		const options = {
 			gitMasterConfig: {
@@ -173,12 +173,84 @@ describe("resolveMultipleSkillsAsync", () => {
 		// #when: resolving with git-master config
 		const result = await resolveMultipleSkillsAsync(skillNames, options)
 
-		// #then: config values injected into template
+		// #then: no watermark section injected
 		expect(result.resolved.size).toBe(1)
 		expect(result.notFound).toEqual([])
 		const gitMasterContent = result.resolved.get("git-master")
-		expect(gitMasterContent).toContain("commit_footer")
-		expect(gitMasterContent).toContain("DISABLED")
+		expect(gitMasterContent).not.toContain("Ultraworked with")
+		expect(gitMasterContent).not.toContain("Co-authored-by: Sisyphus")
+	})
+
+	it("should inject watermark when enabled (default)", async () => {
+		// #given: git-master skill with default config (watermark enabled)
+		const skillNames = ["git-master"]
+		const options = {
+			gitMasterConfig: {
+				commit_footer: true,
+				include_co_authored_by: true,
+			},
+		}
+
+		// #when: resolving with git-master config
+		const result = await resolveMultipleSkillsAsync(skillNames, options)
+
+		// #then: watermark section is injected
+		expect(result.resolved.size).toBe(1)
+		const gitMasterContent = result.resolved.get("git-master")
+		expect(gitMasterContent).toContain("Ultraworked with [Sisyphus]")
+		expect(gitMasterContent).toContain("Co-authored-by: Sisyphus")
+	})
+
+	it("should inject only footer when co-author is disabled", async () => {
+		// #given: git-master skill with only footer enabled
+		const skillNames = ["git-master"]
+		const options = {
+			gitMasterConfig: {
+				commit_footer: true,
+				include_co_authored_by: false,
+			},
+		}
+
+		// #when: resolving with git-master config
+		const result = await resolveMultipleSkillsAsync(skillNames, options)
+
+		// #then: only footer is injected
+		const gitMasterContent = result.resolved.get("git-master")
+		expect(gitMasterContent).toContain("Ultraworked with [Sisyphus]")
+		expect(gitMasterContent).not.toContain("Co-authored-by: Sisyphus")
+	})
+
+	it("should inject watermark by default when no config provided", async () => {
+		// #given: git-master skill with NO config (default behavior)
+		const skillNames = ["git-master"]
+
+		// #when: resolving without any gitMasterConfig
+		const result = await resolveMultipleSkillsAsync(skillNames)
+
+		// #then: watermark is injected (default is ON)
+		expect(result.resolved.size).toBe(1)
+		const gitMasterContent = result.resolved.get("git-master")
+		expect(gitMasterContent).toContain("Ultraworked with [Sisyphus]")
+		expect(gitMasterContent).toContain("Co-authored-by: Sisyphus")
+	})
+
+	it("should inject only co-author when footer is disabled", async () => {
+		// #given: git-master skill with only co-author enabled
+		const skillNames = ["git-master"]
+		const options = {
+			gitMasterConfig: {
+				commit_footer: false,
+				include_co_authored_by: true,
+			},
+		}
+
+		// #when: resolving with git-master config
+		const result = await resolveMultipleSkillsAsync(skillNames, options)
+
+		// #then: only co-author is injected
+		const gitMasterContent = result.resolved.get("git-master")
+		expect(gitMasterContent).not.toContain("Ultraworked with [Sisyphus]")
+		expect(gitMasterContent).toContain("Co-authored-by: Sisyphus")
 	})
 
 	it("should handle empty array", async () => {

src/features/opencode-skill-loader/skill-content.ts

@@ -59,22 +59,62 @@ async function extractSkillTemplate(skill: LoadedSkill): Promise<string> {
 
 export { clearSkillCache, getAllSkills, extractSkillTemplate }
 
-function injectGitMasterConfig(template: string, config?: GitMasterConfig): string {
-	if (!config) return template
+export function injectGitMasterConfig(template: string, config?: GitMasterConfig): string {
+	const commitFooter = config?.commit_footer ?? true
+	const includeCoAuthoredBy = config?.include_co_authored_by ?? true
 
-	const commitFooter = config.commit_footer ?? true
-	const includeCoAuthoredBy = config.include_co_authored_by ?? true
+	if (!commitFooter && !includeCoAuthoredBy) {
+		return template
+	}
 
-	const configHeader = `## Git Master Configuration (from oh-my-opencode.json)
+	const sections: string[] = []
 
-**IMPORTANT: These values override the defaults in section 5.5:**
-- \`commit_footer\`: ${commitFooter} ${!commitFooter ? "(DISABLED - do NOT add footer)" : ""}
-- \`include_co_authored_by\`: ${includeCoAuthoredBy} ${!includeCoAuthoredBy ? "(DISABLED - do NOT add Co-authored-by)" : ""}
+	sections.push(`### 5.5 Commit Footer & Co-Author`)
+	sections.push(``)
+	sections.push(`Add Sisyphus attribution to EVERY commit:`)
+	sections.push(``)
 
----
+	if (commitFooter) {
+		sections.push(`1. **Footer in commit body:**`)
+		sections.push("```")
+		sections.push(`Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)`)
+		sections.push("```")
+		sections.push(``)
+	}
 
-`
-	return configHeader + template
+	if (includeCoAuthoredBy) {
+		sections.push(`${commitFooter ? "2" : "1"}. **Co-authored-by trailer:**`)
+		sections.push("```")
+		sections.push(`Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>`)
+		sections.push("```")
+		sections.push(``)
+	}
+
+	if (commitFooter && includeCoAuthoredBy) {
+		sections.push(`**Example (both enabled):**`)
+		sections.push("```bash")
+		sections.push(`git commit -m "{Commit Message}" -m "Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)" -m "Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>"`)
+		sections.push("```")
+	} else if (commitFooter) {
+		sections.push(`**Example:**`)
+		sections.push("```bash")
+		sections.push(`git commit -m "{Commit Message}" -m "Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-opencode)"`)
+		sections.push("```")
+	} else if (includeCoAuthoredBy) {
+		sections.push(`**Example:**`)
+		sections.push("```bash")
+		sections.push(`git commit -m "{Commit Message}" -m "Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>"`)
+		sections.push("```")
+	}
+
+	const injection = sections.join("\n")
+
+	const insertionPoint = template.indexOf("```\n</execution>")
+	if (insertionPoint !== -1) {
+		return template.slice(0, insertionPoint) + "```\n\n" + injection + "\n</execution>" + template.slice(insertionPoint + "```\n</execution>".length)
+	}
+
+	return template + "\n\n" + injection
 }
 
 export function resolveSkillContent(skillName: string, options?: SkillResolutionOptions): string | null {
@@ -82,8 +122,8 @@ export function resolveSkillContent(skillName: string, options?: SkillResolution
 	const skill = skills.find((s) => s.name === skillName)
 	if (!skill) return null
 
-	if (skillName === "git-master" && options?.gitMasterConfig) {
-		return injectGitMasterConfig(skill.template, options.gitMasterConfig)
+	if (skillName === "git-master") {
+		return injectGitMasterConfig(skill.template, options?.gitMasterConfig)
 	}
 
 	return skill.template
@@ -102,8 +142,8 @@ export function resolveMultipleSkills(skillNames: string[], options?: SkillResol
 	for (const name of skillNames) {
 		const template = skillMap.get(name)
 		if (template) {
-			if (name === "git-master" && options?.gitMasterConfig) {
-				resolved.set(name, injectGitMasterConfig(template, options.gitMasterConfig))
+			if (name === "git-master") {
+				resolved.set(name, injectGitMasterConfig(template, options?.gitMasterConfig))
 			} else {
 				resolved.set(name, template)
 			}
@@ -125,8 +165,8 @@ export async function resolveSkillContentAsync(
 
 	const template = await extractSkillTemplate(skill)
 
-	if (skillName === "git-master" && options?.gitMasterConfig) {
-		return injectGitMasterConfig(template, options.gitMasterConfig)
+	if (skillName === "git-master") {
+		return injectGitMasterConfig(template, options?.gitMasterConfig)
 	}
 
 	return template
@@ -152,8 +192,8 @@ export async function resolveMultipleSkillsAsync(
 		const skill = skillMap.get(name)
 		if (skill) {
 			const template = await extractSkillTemplate(skill)
-			if (name === "git-master" && options?.gitMasterConfig) {
-				resolved.set(name, injectGitMasterConfig(template, options.gitMasterConfig))
+			if (name === "git-master") {
+				resolved.set(name, injectGitMasterConfig(template, options?.gitMasterConfig))
 			} else {
 				resolved.set(name, template)
 			}

src/features/skill-mcp-manager/manager.test.ts

@@ -502,4 +502,110 @@ describe("SkillMcpManager", () => {
       )
     })
   })
+
+  describe("operation retry logic", () => {
+    it("should retry operation when 'Not connected' error occurs", async () => {
+      // #given
+      const info: SkillMcpClientInfo = {
+        serverName: "retry-server",
+        skillName: "retry-skill",
+        sessionID: "session-retry-1",
+      }
+      const context: SkillMcpServerContext = {
+        config: {
+          url: "https://example.com/mcp",
+        },
+        skillName: "retry-skill",
+      }
+
+      // Mock client that fails first time with "Not connected", then succeeds
+      let callCount = 0
+      const mockClient = {
+        callTool: mock(async () => {
+          callCount++
+          if (callCount === 1) {
+            throw new Error("Not connected")
+          }
+          return { content: [{ type: "text", text: "success" }] }
+        }),
+        close: mock(() => Promise.resolve()),
+      }
+
+      // Spy on getOrCreateClientWithRetry to inject mock client
+      const getOrCreateSpy = spyOn(manager as any, "getOrCreateClientWithRetry")
+      getOrCreateSpy.mockResolvedValue(mockClient)
+
+      // #when
+      const result = await manager.callTool(info, context, "test-tool", {})
+
+      // #then
+      expect(callCount).toBe(2) // First call fails, second succeeds
+      expect(result).toEqual([{ type: "text", text: "success" }])
+      expect(getOrCreateSpy).toHaveBeenCalledTimes(2) // Called twice due to retry
+    })
+
+    it("should fail after 3 retry attempts", async () => {
+      // #given
+      const info: SkillMcpClientInfo = {
+        serverName: "fail-server",
+        skillName: "fail-skill",
+        sessionID: "session-fail-1",
+      }
+      const context: SkillMcpServerContext = {
+        config: {
+          url: "https://example.com/mcp",
+        },
+        skillName: "fail-skill",
+      }
+
+      // Mock client that always fails with "Not connected"
+      const mockClient = {
+        callTool: mock(async () => {
+          throw new Error("Not connected")
+        }),
+        close: mock(() => Promise.resolve()),
+      }
+
+      const getOrCreateSpy = spyOn(manager as any, "getOrCreateClientWithRetry")
+      getOrCreateSpy.mockResolvedValue(mockClient)
+
+      // #when / #then
+      await expect(manager.callTool(info, context, "test-tool", {})).rejects.toThrow(
+        /Failed after 3 reconnection attempts/
+      )
+      expect(getOrCreateSpy).toHaveBeenCalledTimes(3) // Initial + 2 retries
+    })
+
+    it("should not retry on non-connection errors", async () => {
+      // #given
+      const info: SkillMcpClientInfo = {
+        serverName: "error-server",
+        skillName: "error-skill",
+        sessionID: "session-error-1",
+      }
+      const context: SkillMcpServerContext = {
+        config: {
+          url: "https://example.com/mcp",
+        },
+        skillName: "error-skill",
+      }
+
+      // Mock client that fails with non-connection error
+      const mockClient = {
+        callTool: mock(async () => {
+          throw new Error("Tool not found")
+        }),
+        close: mock(() => Promise.resolve()),
+      }
+
+      const getOrCreateSpy = spyOn(manager as any, "getOrCreateClientWithRetry")
+      getOrCreateSpy.mockResolvedValue(mockClient)
+
+      // #when / #then
+      await expect(manager.callTool(info, context, "test-tool", {})).rejects.toThrow(
+        "Tool not found"
+      )
+      expect(getOrCreateSpy).toHaveBeenCalledTimes(1) // No retry
+    })
+  })
 })

src/features/skill-mcp-manager/manager.ts

@@ -415,9 +415,10 @@ export class SkillMcpManager {
     name: string,
     args: Record<string, unknown>
   ): Promise<unknown> {
-    const client = await this.getOrCreateClientWithRetry(info, context.config)
-    const result = await client.callTool({ name, arguments: args })
-    return result.content
+    return this.withOperationRetry(info, context.config, async (client) => {
+      const result = await client.callTool({ name, arguments: args })
+      return result.content
+    })
   }
 
   async readResource(
@@ -425,9 +426,10 @@ export class SkillMcpManager {
     context: SkillMcpServerContext,
     uri: string
   ): Promise<unknown> {
-    const client = await this.getOrCreateClientWithRetry(info, context.config)
-    const result = await client.readResource({ uri })
-    return result.contents
+    return this.withOperationRetry(info, context.config, async (client) => {
+      const result = await client.readResource({ uri })
+      return result.contents
+    })
   }
 
   async getPrompt(
@@ -436,9 +438,53 @@ export class SkillMcpManager {
     name: string,
     args: Record<string, string>
   ): Promise<unknown> {
-    const client = await this.getOrCreateClientWithRetry(info, context.config)
-    const result = await client.getPrompt({ name, arguments: args })
-    return result.messages
+    return this.withOperationRetry(info, context.config, async (client) => {
+      const result = await client.getPrompt({ name, arguments: args })
+      return result.messages
+    })
+  }
+
+  private async withOperationRetry<T>(
+    info: SkillMcpClientInfo,
+    config: ClaudeCodeMcpServer,
+    operation: (client: Client) => Promise<T>
+  ): Promise<T> {
+    const maxRetries = 3
+    let lastError: Error | null = null
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        const client = await this.getOrCreateClientWithRetry(info, config)
+        return await operation(client)
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error))
+        const errorMessage = lastError.message.toLowerCase()
+
+        if (!errorMessage.includes("not connected")) {
+          throw lastError
+        }
+
+        if (attempt === maxRetries) {
+          throw new Error(
+            `Failed after ${maxRetries} reconnection attempts: ${lastError.message}`
+          )
+        }
+
+        const key = this.getClientKey(info)
+        const existing = this.clients.get(key)
+        if (existing) {
+          this.clients.delete(key)
+          try {
+            await existing.client.close()
+          } catch { /* process may already be terminated */ }
+          try {
+            await existing.transport.close()
+          } catch { /* transport may already be terminated */ }
+        }
+      }
+    }
+
+    throw lastError || new Error("Operation failed with unknown error")
   }
 
   private async getOrCreateClientWithRetry(

src/features/task-toast-manager/manager.test.ts

@@ -144,8 +144,8 @@ describe("TaskToastManager", () => {
   })
 
   describe("model fallback info in toast message", () => {
-    test("should display warning when model falls back to category-default", () => {
-      // #given - a task with model fallback to category-default
+    test("should NOT display warning when model is category-default (normal behavior)", () => {
+      // #given - category-default is the intended behavior, not a fallback
       const task = {
         id: "task_1",
         description: "Task with category default model",
@@ -157,16 +157,15 @@ describe("TaskToastManager", () => {
       // #when - addTask is called
       toastManager.addTask(task)
 
-      // #then - toast should show warning with model info
+      // #then - toast should NOT show warning - category default is expected
       expect(mockClient.tui.showToast).toHaveBeenCalled()
       const call = mockClient.tui.showToast.mock.calls[0][0]
-      expect(call.body.message).toContain("⚠️")
-      expect(call.body.message).toContain("google/gemini-3-pro-preview")
-      expect(call.body.message).toContain("(category default)")
+      expect(call.body.message).not.toContain("⚠️")
+      expect(call.body.message).not.toContain("(category default)")
     })
 
     test("should display warning when model falls back to system-default", () => {
-      // #given - a task with model fallback to system-default
+      // #given - system-default is a fallback (no category default, no user config)
       const task = {
         id: "task_1b",
         description: "Task with system default model",
@@ -178,16 +177,16 @@ describe("TaskToastManager", () => {
       // #when - addTask is called
       toastManager.addTask(task)
 
-      // #then - toast should show warning with model info
+      // #then - toast should show fallback warning
       expect(mockClient.tui.showToast).toHaveBeenCalled()
       const call = mockClient.tui.showToast.mock.calls[0][0]
       expect(call.body.message).toContain("⚠️")
       expect(call.body.message).toContain("anthropic/claude-sonnet-4-5")
-      expect(call.body.message).toContain("(system default)")
+      expect(call.body.message).toContain("(system default fallback)")
     })
 
     test("should display warning when model is inherited from parent", () => {
-      // #given - a task with inherited model
+      // #given - inherited is a fallback (custom category without model definition)
       const task = {
         id: "task_2",
         description: "Task with inherited model",
@@ -199,12 +198,12 @@ describe("TaskToastManager", () => {
       // #when - addTask is called
       toastManager.addTask(task)
 
-      // #then - toast should show warning with inherited model
+      // #then - toast should show fallback warning
       expect(mockClient.tui.showToast).toHaveBeenCalled()
       const call = mockClient.tui.showToast.mock.calls[0][0]
       expect(call.body.message).toContain("⚠️")
       expect(call.body.message).toContain("cliproxy/claude-opus-4-5")
-      expect(call.body.message).toContain("(inherited)")
+      expect(call.body.message).toContain("(inherited from parent)")
     })
 
     test("should not display model info when user-defined", () => {

src/features/task-toast-manager/manager.ts

@@ -107,16 +107,16 @@ export class TaskToastManager {
 
     const lines: string[] = []
 
-    // Show model fallback warning for the new task if applicable
-    if (newTask.modelInfo && newTask.modelInfo.type !== "user-defined") {
-      const icon = "⚠️"
-      const suffixMap: Partial<Record<ModelFallbackInfo["type"], string>> = {
-        inherited: " (inherited)",
-        "category-default": " (category default)",
-        "system-default": " (system default)",
+    const isFallback = newTask.modelInfo && (
+      newTask.modelInfo.type === "inherited" || newTask.modelInfo.type === "system-default"
+    )
+    if (isFallback) {
+      const suffixMap: Record<"inherited" | "system-default", string> = {
+        inherited: " (inherited from parent)",
+        "system-default": " (system default fallback)",
       }
-      const suffix = suffixMap[newTask.modelInfo.type] ?? ""
-      lines.push(`${icon} Model: ${newTask.modelInfo.model}${suffix}`)
+      const suffix = suffixMap[newTask.modelInfo!.type as "inherited" | "system-default"]
+      lines.push(`⚠️ Model fallback: ${newTask.modelInfo!.model}${suffix}`)
       lines.push("")
     }
 

src/hooks/AGENTS.md

@@ -1,54 +1,73 @@
 # HOOKS KNOWLEDGE BASE
 
 ## OVERVIEW
-22+ lifecycle hooks intercepting/modifying agent behavior via PreToolUse, PostToolUse, UserPromptSubmit, and more.
+
+31 lifecycle hooks intercepting/modifying agent behavior. Events: PreToolUse, PostToolUse, UserPromptSubmit, Stop, onSummarize.
 
 ## STRUCTURE
+
 ```
 hooks/
-├── sisyphus-orchestrator/      # Main orchestration & agent delegation (684 lines)
-├── anthropic-context-window-limit-recovery/  # Auto-summarize at token limit (554 lines)
-├── todo-continuation-enforcer.ts # Force completion of [ ] items (445 lines)
-├── ralph-loop/                 # Self-referential dev loop (364 lines)
-├── claude-code-hooks/          # settings.json hook compatibility layer
+├── sisyphus-orchestrator/      # Main orchestration & delegation (771 lines)
+├── anthropic-context-window-limit-recovery/  # Auto-summarize at token limit
+├── todo-continuation-enforcer.ts # Force TODO completion
+├── ralph-loop/                 # Self-referential dev loop until done
+├── claude-code-hooks/          # settings.json hook compat layer (13 files)
 ├── comment-checker/            # Prevents AI slop/excessive comments
-├── auto-slash-command/         # Detects and executes /command patterns
+├── auto-slash-command/         # Detects /command patterns
 ├── rules-injector/             # Conditional rules from .claude/rules/
-├── directory-agents-injector/  # Auto-injects local AGENTS.md files
-├── directory-readme-injector/  # Auto-injects local README.md files
-├── preemptive-compaction/      # Triggers summary at 85% usage
-├── edit-error-recovery/        # Recovers from tool execution failures
+├── directory-agents-injector/  # Auto-injects AGENTS.md files
+├── directory-readme-injector/  # Auto-injects README.md files
+├── preemptive-compaction/      # Triggers summary at 85% context
+├── edit-error-recovery/        # Recovers from tool failures
 ├── thinking-block-validator/   # Ensures valid <thinking> format
 ├── context-window-monitor.ts   # Reminds agents of remaining headroom
-├── session-recovery/           # Auto-recovers from session crashes
-├── start-work/                 # Initializes work sessions (ulw/ulw)
-├── think-mode/                 # Dynamic thinking budget adjustment
+├── session-recovery/           # Auto-recovers from crashes
+├── think-mode/                 # Dynamic thinking budget
+├── keyword-detector/           # ultrawork/search/analyze modes
 ├── background-notification/    # OS notification on task completion
-└── tool-output-truncator.ts    # Prevents context bloat from verbose tools
+└── tool-output-truncator.ts    # Prevents context bloat
 ```
 
 ## HOOK EVENTS
-| Event | Timing | Can Block | Description |
-|-------|--------|-----------|-------------|
-| PreToolUse | Before tool | Yes | Validate/modify inputs (e.g., directory-agents-injector) |
-| PostToolUse | After tool | No | Append context/warnings (e.g., edit-error-recovery) |
-| UserPromptSubmit | On prompt | Yes | Filter/modify user input (e.g., keyword-detector) |
-| Stop | Session idle | No | Auto-continue tasks (e.g., todo-continuation-enforcer) |
-| onSummarize | Compaction | No | State preservation (e.g., compaction-context-injector) |
+
+| Event | Timing | Can Block | Use Case |
+|-------|--------|-----------|----------|
+| PreToolUse | Before tool | Yes | Validate/modify inputs, inject context |
+| PostToolUse | After tool | No | Append warnings, truncate output |
+| UserPromptSubmit | On prompt | Yes | Keyword detection, mode switching |
+| Stop | Session idle | No | Auto-continue (todo-continuation, ralph-loop) |
+| onSummarize | Compaction | No | Preserve critical state |
+
+## EXECUTION ORDER
+
+**chat.message**: keywordDetector → claudeCodeHooks → autoSlashCommand → startWork → ralphLoop
+
+**tool.execute.before**: claudeCodeHooks → nonInteractiveEnv → commentChecker → directoryAgentsInjector → directoryReadmeInjector → rulesInjector
+
+**tool.execute.after**: editErrorRecovery → delegateTaskRetry → commentChecker → toolOutputTruncator → emptyTaskResponseDetector → claudeCodeHooks
 
 ## HOW TO ADD
-1. Create `src/hooks/name/` with `index.ts` factory (e.g., `createMyHook`).
-2. Implement `PreToolUse`, `PostToolUse`, `UserPromptSubmit`, `Stop`, or `onSummarize`.
-3. Register in `src/hooks/index.ts`.
+
+1. Create `src/hooks/name/` with `index.ts` exporting `createMyHook(ctx)`
+2. Implement event handlers: `"tool.execute.before"`, `"tool.execute.after"`, etc.
+3. Add hook name to `HookNameSchema` in `src/config/schema.ts`
+4. Register in `src/index.ts`:
+   ```typescript
+   const myHook = isHookEnabled("my-hook") ? createMyHook(ctx) : null
+   // Add to event handlers
+   ```
 
 ## PATTERNS
-- **Context Injection**: Use `PreToolUse` to prepend instructions to tool inputs.
-- **Resilience**: Implement `edit-error-recovery` style logic to retry failed tools.
-- **Telegraphic UI**: Use `PostToolUse` to add brief warnings without bloating transcript.
-- **Statelessness**: Prefer local file storage for state that must persist across sessions.
+
+- **Session-scoped state**: `Map<sessionID, Set<string>>` for tracking per-session
+- **Conditional execution**: Check `input.tool` before processing
+- **Output modification**: `output.output += "\n${REMINDER}"` to append context
+- **Async state**: Use promises for CLI path resolution, cache results
 
 ## ANTI-PATTERNS
-- **Blocking**: Avoid blocking tools unless critical (use warnings in `PostToolUse` instead).
-- **Latency**: No heavy computation in `PreToolUse`; it slows every interaction.
-- **Redundancy**: Don't inject the same file multiple times; track state in session storage.
-- **Prose**: Never use verbose prose in hook outputs; keep it technical and brief.
+
+- **Blocking non-critical**: Use PostToolUse warnings instead of PreToolUse blocks
+- **Heavy computation**: Keep PreToolUse light - slows every tool call
+- **Redundant injection**: Track injected files to prevent duplicates
+- **Verbose output**: Keep hook messages technical, brief

src/hooks/agent-usage-reminder/constants.ts

@@ -24,7 +24,7 @@ export const TARGET_TOOLS = new Set([
 export const AGENT_TOOLS = new Set([
   "task",
   "call_omo_agent",
-  "sisyphus_task",
+  "delegate_task",
 ]);
 
 export const REMINDER_MESSAGE = `
@@ -32,13 +32,13 @@ export const REMINDER_MESSAGE = `
 
 You called a search/fetch tool directly without leveraging specialized agents.
 
-RECOMMENDED: Use sisyphus_task with explore/librarian agents for better results:
+RECOMMENDED: Use delegate_task with explore/librarian agents for better results:
 
 \`\`\`
 // Parallel exploration - fire multiple agents simultaneously
-sisyphus_task(agent="explore", prompt="Find all files matching pattern X")
-sisyphus_task(agent="explore", prompt="Search for implementation of Y") 
-sisyphus_task(agent="librarian", prompt="Lookup documentation for Z")
+delegate_task(agent="explore", prompt="Find all files matching pattern X")
+delegate_task(agent="explore", prompt="Search for implementation of Y") 
+delegate_task(agent="librarian", prompt="Lookup documentation for Z")
 
 // Then continue your work while they run in background
 // System will notify you when each completes
@@ -50,5 +50,5 @@ WHY:
 - Specialized agents have domain expertise
 - Reduces context window usage in main session
 
-ALWAYS prefer: Multiple parallel sisyphus_task calls > Direct tool calls
+ALWAYS prefer: Multiple parallel delegate_task calls > Direct tool calls
 `;

src/hooks/anthropic-context-window-limit-recovery/executor.test.ts

@@ -17,7 +17,6 @@ describe("executeCompact lock management", () => {
       errorDataBySession: new Map(),
       retryStateBySession: new Map(),
       truncateStateBySession: new Map(),
-      dcpStateBySession: new Map(),
       emptyContentAttemptBySession: new Map(),
       compactionInProgress: new Set<string>(),
     }
@@ -119,7 +118,6 @@ describe("executeCompact lock management", () => {
       truncate_all_tool_outputs: false,
       aggressive_truncation: true,
     }
-    const dcpForCompaction = true
 
     // #when: Execute compaction with experimental flag
     await executeCompact(
@@ -129,7 +127,6 @@ describe("executeCompact lock management", () => {
       mockClient,
       directory,
       experimental,
-      dcpForCompaction,
     )
 
     // #then: Lock should be cleared even on early return

src/hooks/anthropic-context-window-limit-recovery/executor.ts

@@ -1,12 +1,11 @@
 import type {
   AutoCompactState,
-  DcpState,
   RetryState,
   TruncateState,
 } from "./types";
 import type { ExperimentalConfig } from "../../config";
 import { RETRY_CONFIG, TRUNCATE_CONFIG } from "./types";
-import { executeDynamicContextPruning } from "./pruning-executor";
+
 import {
   findLargestToolResult,
   truncateToolResult,
@@ -82,17 +81,7 @@ function getOrCreateTruncateState(
   return state;
 }
 
-function getOrCreateDcpState(
-  autoCompactState: AutoCompactState,
-  sessionID: string,
-): DcpState {
-  let state = autoCompactState.dcpStateBySession.get(sessionID);
-  if (!state) {
-    state = { attempted: false, itemsPruned: 0 };
-    autoCompactState.dcpStateBySession.set(sessionID, state);
-  }
-  return state;
-}
+
 
 function sanitizeEmptyMessagesBeforeSummarize(sessionID: string): number {
   const emptyMessageIds = findEmptyMessages(sessionID);
@@ -168,7 +157,6 @@ function clearSessionState(
   autoCompactState.errorDataBySession.delete(sessionID);
   autoCompactState.retryStateBySession.delete(sessionID);
   autoCompactState.truncateStateBySession.delete(sessionID);
-  autoCompactState.dcpStateBySession.delete(sessionID);
   autoCompactState.emptyContentAttemptBySession.delete(sessionID);
   autoCompactState.compactionInProgress.delete(sessionID);
 }
@@ -275,7 +263,6 @@ export async function executeCompact(
   client: any,
   directory: string,
   experimental?: ExperimentalConfig,
-  dcpForCompaction?: boolean,
 ): Promise<void> {
   if (autoCompactState.compactionInProgress.has(sessionID)) {
     await (client as Client).tui
@@ -302,61 +289,7 @@ export async function executeCompact(
       errorData?.maxTokens &&
       errorData.currentTokens > errorData.maxTokens;
 
-    // PHASE 1: DCP (Dynamic Context Pruning) - prune duplicate tool calls first
-    const dcpState = getOrCreateDcpState(autoCompactState, sessionID);
-    if (dcpForCompaction !== false && !dcpState.attempted && isOverLimit) {
-      dcpState.attempted = true;
-      log("[auto-compact] PHASE 1: DCP triggered on token limit error", {
-        sessionID,
-        currentTokens: errorData.currentTokens,
-        maxTokens: errorData.maxTokens,
-      });
-
-      const dcpConfig = experimental?.dynamic_context_pruning ?? {
-        enabled: true,
-        notification: "detailed" as const,
-        protected_tools: [
-          "task",
-          "todowrite",
-          "todoread",
-          "lsp_rename",
-        ],
-      };
-
-      try {
-        const pruningResult = await executeDynamicContextPruning(
-          sessionID,
-          dcpConfig,
-          client,
-        );
-
-        if (pruningResult.itemsPruned > 0) {
-          dcpState.itemsPruned = pruningResult.itemsPruned;
-          log("[auto-compact] DCP successful, proceeding to truncation", {
-            itemsPruned: pruningResult.itemsPruned,
-            tokensSaved: pruningResult.totalTokensSaved,
-          });
-
-          await (client as Client).tui
-            .showToast({
-              body: {
-                title: "Dynamic Context Pruning",
-                message: `Pruned ${pruningResult.itemsPruned} items (~${Math.round(pruningResult.totalTokensSaved / 1000)}k tokens). Proceeding to truncation...`,
-                variant: "success",
-                duration: 3000,
-              },
-            })
-            .catch(() => {});
-          // Continue to PHASE 2 (truncation) instead of summarizing immediately
-        } else {
-          log("[auto-compact] DCP did not prune any items", { sessionID });
-        }
-      } catch (error) {
-        log("[auto-compact] DCP failed", { error: String(error) });
-      }
-    }
-
-    // PHASE 2: Aggressive Truncation - always try when over limit (not experimental-only)
+    // Aggressive Truncation - always try when over limit
     if (
       isOverLimit &&
       truncateState.truncateAttempt < TRUNCATE_CONFIG.maxTruncateAttempts
@@ -448,7 +381,6 @@ export async function executeCompact(
               client,
               directory,
               experimental,
-              dcpForCompaction,
             );
           }, 500);
           return;
@@ -517,7 +449,6 @@ export async function executeCompact(
               client,
               directory,
               experimental,
-              dcpForCompaction,
             );
           }, cappedDelay);
           return;

src/hooks/anthropic-context-window-limit-recovery/index.ts

@@ -7,7 +7,6 @@ import { log } from "../../shared/logger"
 
 export interface AnthropicContextWindowLimitRecoveryOptions {
   experimental?: ExperimentalConfig
-  dcpForCompaction?: boolean
 }
 
 function createRecoveryState(): AutoCompactState {
@@ -16,7 +15,6 @@ function createRecoveryState(): AutoCompactState {
     errorDataBySession: new Map<string, ParsedTokenLimitError>(),
     retryStateBySession: new Map(),
     truncateStateBySession: new Map(),
-    dcpStateBySession: new Map(),
     emptyContentAttemptBySession: new Map(),
     compactionInProgress: new Set<string>(),
   }
@@ -25,7 +23,6 @@ function createRecoveryState(): AutoCompactState {
 export function createAnthropicContextWindowLimitRecoveryHook(ctx: PluginInput, options?: AnthropicContextWindowLimitRecoveryOptions) {
   const autoCompactState = createRecoveryState()
   const experimental = options?.experimental
-  const dcpForCompaction = options?.dcpForCompaction
 
   const eventHandler = async ({ event }: { event: { type: string; properties?: unknown } }) => {
     const props = event.properties as Record<string, unknown> | undefined
@@ -37,7 +34,6 @@ export function createAnthropicContextWindowLimitRecoveryHook(ctx: PluginInput,
         autoCompactState.errorDataBySession.delete(sessionInfo.id)
         autoCompactState.retryStateBySession.delete(sessionInfo.id)
         autoCompactState.truncateStateBySession.delete(sessionInfo.id)
-        autoCompactState.dcpStateBySession.delete(sessionInfo.id)
         autoCompactState.emptyContentAttemptBySession.delete(sessionInfo.id)
         autoCompactState.compactionInProgress.delete(sessionInfo.id)
       }
@@ -81,8 +77,7 @@ export function createAnthropicContextWindowLimitRecoveryHook(ctx: PluginInput,
             autoCompactState,
             ctx.client,
             ctx.directory,
-            experimental,
-            dcpForCompaction
+            experimental
           )
         }, 300)
       }
@@ -141,8 +136,7 @@ export function createAnthropicContextWindowLimitRecoveryHook(ctx: PluginInput,
         autoCompactState,
         ctx.client,
         ctx.directory,
-        experimental,
-        dcpForCompaction
+        experimental
       )
     }
   }
@@ -152,6 +146,6 @@ export function createAnthropicContextWindowLimitRecoveryHook(ctx: PluginInput,
   }
 }
 
-export type { AutoCompactState, DcpState, ParsedTokenLimitError, TruncateState } from "./types"
+export type { AutoCompactState, ParsedTokenLimitError, TruncateState } from "./types"
 export { parseAnthropicTokenLimitError } from "./parser"
 export { executeCompact, getLastAssistant } from "./executor"

src/hooks/anthropic-context-window-limit-recovery/pruning-executor.ts

@@ -1,125 +0,0 @@
-import type { DynamicContextPruningConfig } from "../../config"
-import type { PruningState, PruningResult } from "./pruning-types"
-import { executeDeduplication } from "./pruning-deduplication"
-import { executeSupersedeWrites } from "./pruning-supersede"
-import { executePurgeErrors } from "./pruning-purge-errors"
-import { applyPruning } from "./pruning-storage"
-import { log } from "../../shared/logger"
-
-const DEFAULT_PROTECTED_TOOLS = new Set([
-  "task",
-  "todowrite",
-  "todoread",
-  "lsp_rename",
-  "session_read",
-  "session_write",
-  "session_search",
-])
-
-function createPruningState(): PruningState {
-  return {
-    toolIdsToPrune: new Set<string>(),
-    currentTurn: 0,
-    fileOperations: new Map(),
-    toolSignatures: new Map(),
-    erroredTools: new Map(),
-  }
-}
-
-export async function executeDynamicContextPruning(
-  sessionID: string,
-  config: DynamicContextPruningConfig,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  client: any
-): Promise<PruningResult> {
-  const state = createPruningState()
-  
-  const protectedTools = new Set([
-    ...DEFAULT_PROTECTED_TOOLS,
-    ...(config.protected_tools || []),
-  ])
-  
-  log("[pruning-executor] starting DCP", {
-    sessionID,
-    notification: config.notification,
-    turnProtection: config.turn_protection,
-  })
-  
-  let dedupCount = 0
-  let supersedeCount = 0
-  let purgeCount = 0
-  
-  if (config.strategies?.deduplication?.enabled !== false) {
-    dedupCount = executeDeduplication(
-      sessionID,
-      state,
-      { enabled: true },
-      protectedTools
-    )
-  }
-  
-  if (config.strategies?.supersede_writes?.enabled !== false) {
-    supersedeCount = executeSupersedeWrites(
-      sessionID,
-      state,
-      {
-        enabled: true,
-        aggressive: config.strategies?.supersede_writes?.aggressive || false,
-      },
-      protectedTools
-    )
-  }
-  
-  if (config.strategies?.purge_errors?.enabled !== false) {
-    purgeCount = executePurgeErrors(
-      sessionID,
-      state,
-      {
-        enabled: true,
-        turns: config.strategies?.purge_errors?.turns || 5,
-      },
-      protectedTools
-    )
-  }
-  
-  const totalPruned = state.toolIdsToPrune.size
-  const tokensSaved = await applyPruning(sessionID, state)
-  
-  log("[pruning-executor] DCP complete", {
-    totalPruned,
-    tokensSaved,
-    deduplication: dedupCount,
-    supersede: supersedeCount,
-    purge: purgeCount,
-  })
-  
-  const result: PruningResult = {
-    itemsPruned: totalPruned,
-    totalTokensSaved: tokensSaved,
-    strategies: {
-      deduplication: dedupCount,
-      supersedeWrites: supersedeCount,
-      purgeErrors: purgeCount,
-    },
-  }
-  
-  if (config.notification !== "off" && totalPruned > 0) {
-    const message =
-      config.notification === "detailed"
-        ? `Pruned ${totalPruned} tool outputs (~${Math.round(tokensSaved / 1000)}k tokens). Dedup: ${dedupCount}, Supersede: ${supersedeCount}, Purge: ${purgeCount}`
-        : `Pruned ${totalPruned} tool outputs (~${Math.round(tokensSaved / 1000)}k tokens)`
-    
-    await client.tui
-      .showToast({
-        body: {
-          title: "Dynamic Context Pruning",
-          message,
-          variant: "success",
-          duration: 3000,
-        },
-      })
-      .catch(() => {})
-  }
-  
-  return result
-}

src/hooks/anthropic-context-window-limit-recovery/pruning-purge-errors.ts

@@ -1,152 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs"
-import { join } from "node:path"
-import type { PruningState, ErroredToolCall } from "./pruning-types"
-import { estimateTokens } from "./pruning-types"
-import { log } from "../../shared/logger"
-import { MESSAGE_STORAGE } from "../../features/hook-message-injector"
-
-export interface PurgeErrorsConfig {
-  enabled: boolean
-  turns: number
-  protectedTools?: string[]
-}
-
-interface ToolPart {
-  type: string
-  callID?: string
-  tool?: string
-  state?: {
-    input?: unknown
-    output?: string
-    status?: string
-  }
-}
-
-interface MessagePart {
-  type: string
-  parts?: ToolPart[]
-}
-
-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 readMessages(sessionID: string): MessagePart[] {
-  const messageDir = getMessageDir(sessionID)
-  if (!messageDir) return []
-
-  const messages: MessagePart[] = []
-  
-  try {
-    const files = readdirSync(messageDir).filter(f => f.endsWith(".json"))
-    for (const file of files) {
-      const content = readFileSync(join(messageDir, file), "utf-8")
-      const data = JSON.parse(content)
-      if (data.parts) {
-        messages.push(data)
-      }
-    }
-  } catch {
-    return []
-  }
-
-  return messages
-}
-
-export function executePurgeErrors(
-  sessionID: string,
-  state: PruningState,
-  config: PurgeErrorsConfig,
-  protectedTools: Set<string>
-): number {
-  if (!config.enabled) return 0
-
-  const messages = readMessages(sessionID)
-  
-  let currentTurn = 0
-  
-  for (const msg of messages) {
-    if (!msg.parts) continue
-    
-    for (const part of msg.parts) {
-      if (part.type === "step-start") {
-        currentTurn++
-      }
-    }
-  }
-  
-  state.currentTurn = currentTurn
-  
-  let turnCounter = 0
-  let prunedCount = 0
-  let tokensSaved = 0
-  
-  for (const msg of messages) {
-    if (!msg.parts) continue
-    
-    for (const part of msg.parts) {
-      if (part.type === "step-start") {
-        turnCounter++
-        continue
-      }
-      
-      if (part.type !== "tool" || !part.callID || !part.tool) continue
-      
-      if (protectedTools.has(part.tool)) continue
-      
-      if (config.protectedTools?.includes(part.tool)) continue
-      
-      if (state.toolIdsToPrune.has(part.callID)) continue
-      
-      if (part.state?.status !== "error") continue
-      
-      const turnAge = currentTurn - turnCounter
-      
-      if (turnAge >= config.turns) {
-        state.toolIdsToPrune.add(part.callID)
-        prunedCount++
-        
-        const input = part.state.input
-        if (input) {
-          tokensSaved += estimateTokens(JSON.stringify(input))
-        }
-        
-        const errorInfo: ErroredToolCall = {
-          callID: part.callID,
-          toolName: part.tool,
-          turn: turnCounter,
-          errorAge: turnAge,
-        }
-        
-        state.erroredTools.set(part.callID, errorInfo)
-        
-        log("[pruning-purge-errors] pruned old error", {
-          tool: part.tool,
-          callID: part.callID,
-          turn: turnCounter,
-          errorAge: turnAge,
-          threshold: config.turns,
-        })
-      }
-    }
-  }
-  
-  log("[pruning-purge-errors] complete", {
-    prunedCount,
-    tokensSaved,
-    currentTurn,
-    threshold: config.turns,
-  })
-  
-  return prunedCount
-}

src/hooks/anthropic-context-window-limit-recovery/pruning-storage.ts

@@ -1,101 +0,0 @@
-import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs"
-import { join } from "node:path"
-import type { PruningState } from "./pruning-types"
-import { estimateTokens } from "./pruning-types"
-import { log } from "../../shared/logger"
-import { MESSAGE_STORAGE } from "../../features/hook-message-injector"
-
-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
-}
-
-interface ToolPart {
-  type: string
-  callID?: string
-  tool?: string
-  state?: {
-    input?: unknown
-    output?: string
-    status?: string
-  }
-}
-
-interface MessageData {
-  parts?: ToolPart[]
-  [key: string]: unknown
-}
-
-export async function applyPruning(
-  sessionID: string,
-  state: PruningState
-): Promise<number> {
-  const messageDir = getMessageDir(sessionID)
-  if (!messageDir) {
-    log("[pruning-storage] message dir not found", { sessionID })
-    return 0
-  }
-
-  let totalTokensSaved = 0
-  let filesModified = 0
-
-  try {
-    const files = readdirSync(messageDir).filter(f => f.endsWith(".json"))
-    
-    for (const file of files) {
-      const filePath = join(messageDir, file)
-      const content = readFileSync(filePath, "utf-8")
-      const data: MessageData = JSON.parse(content)
-      
-      if (!data.parts) continue
-      
-      let modified = false
-      
-      for (const part of data.parts) {
-        if (part.type !== "tool" || !part.callID) continue
-        
-        if (!state.toolIdsToPrune.has(part.callID)) continue
-        
-        if (part.state?.input) {
-          const inputStr = JSON.stringify(part.state.input)
-          totalTokensSaved += estimateTokens(inputStr)
-          part.state.input = { __pruned: true, reason: "DCP" }
-          modified = true
-        }
-        
-        if (part.state?.output) {
-          totalTokensSaved += estimateTokens(part.state.output)
-          part.state.output = "[Content pruned by Dynamic Context Pruning]"
-          modified = true
-        }
-      }
-      
-      if (modified) {
-        writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8")
-        filesModified++
-      }
-    }
-  } catch (error) {
-    log("[pruning-storage] error applying pruning", {
-      sessionID,
-      error: String(error),
-    })
-  }
-
-  log("[pruning-storage] applied pruning", {
-    sessionID,
-    filesModified,
-    totalTokensSaved,
-  })
-
-  return totalTokensSaved
-}

src/hooks/anthropic-context-window-limit-recovery/pruning-supersede.ts

@@ -1,212 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs"
-import { join } from "node:path"
-import type { PruningState, FileOperation } from "./pruning-types"
-import { estimateTokens } from "./pruning-types"
-import { log } from "../../shared/logger"
-import { MESSAGE_STORAGE } from "../../features/hook-message-injector"
-
-export interface SupersedeWritesConfig {
-  enabled: boolean
-  aggressive: boolean
-}
-
-interface ToolPart {
-  type: string
-  callID?: string
-  tool?: string
-  state?: {
-    input?: unknown
-    output?: string
-  }
-}
-
-interface MessagePart {
-  type: string
-  parts?: ToolPart[]
-}
-
-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 readMessages(sessionID: string): MessagePart[] {
-  const messageDir = getMessageDir(sessionID)
-  if (!messageDir) return []
-
-  const messages: MessagePart[] = []
-  
-  try {
-    const files = readdirSync(messageDir).filter(f => f.endsWith(".json"))
-    for (const file of files) {
-      const content = readFileSync(join(messageDir, file), "utf-8")
-      const data = JSON.parse(content)
-      if (data.parts) {
-        messages.push(data)
-      }
-    }
-  } catch {
-    return []
-  }
-
-  return messages
-}
-
-function extractFilePath(toolName: string, input: unknown): string | null {
-  if (!input || typeof input !== "object") return null
-  
-  const inputObj = input as Record<string, unknown>
-  
-  if (toolName === "write" || toolName === "edit" || toolName === "read") {
-    if (typeof inputObj.filePath === "string") {
-      return inputObj.filePath
-    }
-  }
-  
-  return null
-}
-
-export function executeSupersedeWrites(
-  sessionID: string,
-  state: PruningState,
-  config: SupersedeWritesConfig,
-  protectedTools: Set<string>
-): number {
-  if (!config.enabled) return 0
-
-  const messages = readMessages(sessionID)
-  const writesByFile = new Map<string, FileOperation[]>()
-  const readsByFile = new Map<string, number[]>()
-  
-  let currentTurn = 0
-  
-  for (const msg of messages) {
-    if (!msg.parts) continue
-    
-    for (const part of msg.parts) {
-      if (part.type === "step-start") {
-        currentTurn++
-        continue
-      }
-      
-      if (part.type !== "tool" || !part.callID || !part.tool) continue
-      
-      if (protectedTools.has(part.tool)) continue
-      
-      if (state.toolIdsToPrune.has(part.callID)) continue
-      
-      const filePath = extractFilePath(part.tool, part.state?.input)
-      if (!filePath) continue
-      
-      if (part.tool === "write" || part.tool === "edit") {
-        if (!writesByFile.has(filePath)) {
-          writesByFile.set(filePath, [])
-        }
-        writesByFile.get(filePath)!.push({
-          callID: part.callID,
-          tool: part.tool,
-          filePath,
-          turn: currentTurn,
-        })
-        
-        if (!state.fileOperations.has(filePath)) {
-          state.fileOperations.set(filePath, [])
-        }
-        state.fileOperations.get(filePath)!.push({
-          callID: part.callID,
-          tool: part.tool,
-          filePath,
-          turn: currentTurn,
-        })
-      } else if (part.tool === "read") {
-        if (!readsByFile.has(filePath)) {
-          readsByFile.set(filePath, [])
-        }
-        readsByFile.get(filePath)!.push(currentTurn)
-      }
-    }
-  }
-  
-  let prunedCount = 0
-  let tokensSaved = 0
-  
-  for (const [filePath, writes] of writesByFile) {
-    const reads = readsByFile.get(filePath) || []
-    
-    if (config.aggressive) {
-      for (const write of writes) {
-        const superseded = reads.some(readTurn => readTurn > write.turn)
-        if (superseded) {
-          state.toolIdsToPrune.add(write.callID)
-          prunedCount++
-          
-          const input = findToolInput(messages, write.callID)
-          if (input) {
-            tokensSaved += estimateTokens(JSON.stringify(input))
-          }
-          
-          log("[pruning-supersede] pruned superseded write", {
-            tool: write.tool,
-            callID: write.callID,
-            turn: write.turn,
-            filePath,
-          })
-        }
-      }
-    } else {
-      if (writes.length > 1) {
-        for (const write of writes.slice(0, -1)) {
-          const superseded = reads.some(readTurn => readTurn > write.turn)
-          if (superseded) {
-            state.toolIdsToPrune.add(write.callID)
-            prunedCount++
-            
-            const input = findToolInput(messages, write.callID)
-            if (input) {
-              tokensSaved += estimateTokens(JSON.stringify(input))
-            }
-            
-            log("[pruning-supersede] pruned superseded write (conservative)", {
-              tool: write.tool,
-              callID: write.callID,
-              turn: write.turn,
-              filePath,
-            })
-          }
-        }
-      }
-    }
-  }
-  
-  log("[pruning-supersede] complete", {
-    prunedCount,
-    tokensSaved,
-    filesTracked: writesByFile.size,
-    mode: config.aggressive ? "aggressive" : "conservative",
-  })
-  
-  return prunedCount
-}
-
-function findToolInput(messages: MessagePart[], callID: string): unknown | null {
-  for (const msg of messages) {
-    if (!msg.parts) continue
-    
-    for (const part of msg.parts) {
-      if (part.type === "tool" && part.callID === callID && part.state?.input) {
-        return part.state.input
-      }
-    }
-  }
-  
-  return null
-}

src/hooks/anthropic-context-window-limit-recovery/types.ts

@@ -18,17 +18,11 @@ export interface TruncateState {
   lastTruncatedPartId?: string
 }
 
-export interface DcpState {
-  attempted: boolean
-  itemsPruned: number
-}
-
 export interface AutoCompactState {
   pendingCompact: Set<string>
   errorDataBySession: Map<string, ParsedTokenLimitError>
   retryStateBySession: Map<string, RetryState>
   truncateStateBySession: Map<string, TruncateState>
-  dcpStateBySession: Map<string, DcpState>
   emptyContentAttemptBySession: Map<string, number>
   compactionInProgress: Set<string>
 }

src/hooks/auto-slash-command/constants.ts

@@ -8,4 +8,5 @@ export const SLASH_COMMAND_PATTERN = /^\/([a-zA-Z][\w-]*)\s*(.*)/
 export const EXCLUDED_COMMANDS = new Set([
   "ralph-loop",
   "cancel-ralph",
+  "ulw-loop",
 ])

src/hooks/auto-slash-command/index.test.ts

@@ -41,52 +41,49 @@ describe("createAutoSlashCommandHook", () => {
   })
 
   describe("slash command replacement", () => {
-    it("should replace message with error when command not found", async () => {
+    it("should not modify message when command not found", async () => {
       // #given a slash command that doesn't exist
       const hook = createAutoSlashCommandHook()
       const sessionID = `test-session-notfound-${Date.now()}`
       const input = createMockInput(sessionID)
       const output = createMockOutput("/nonexistent-command args")
+      const originalText = output.parts[0].text
 
       // #when hook is called
       await hook["chat.message"](input, output)
 
-      // #then should replace with error message
-      const textPart = output.parts.find((p) => p.type === "text")
-      expect(textPart?.text).toContain("<auto-slash-command>")
-      expect(textPart?.text).toContain("not found")
+      // #then should NOT modify the message (feature inactive when command not found)
+      expect(output.parts[0].text).toBe(originalText)
     })
 
-    it("should wrap replacement in auto-slash-command tags", async () => {
-      // #given any slash command
+    it("should not modify message for unknown command (feature inactive)", async () => {
+      // #given unknown slash command
       const hook = createAutoSlashCommandHook()
       const sessionID = `test-session-tags-${Date.now()}`
       const input = createMockInput(sessionID)
       const output = createMockOutput("/some-command")
+      const originalText = output.parts[0].text
 
       // #when hook is called
       await hook["chat.message"](input, output)
 
-      // #then should wrap in tags
-      const textPart = output.parts.find((p) => p.type === "text")
-      expect(textPart?.text).toContain("<auto-slash-command>")
-      expect(textPart?.text).toContain("</auto-slash-command>")
+      // #then should NOT modify (command not found = feature inactive)
+      expect(output.parts[0].text).toBe(originalText)
     })
 
-    it("should completely replace original message text", async () => {
-      // #given slash command
+    it("should not modify for unknown command (no prepending)", async () => {
+      // #given unknown slash command
       const hook = createAutoSlashCommandHook()
       const sessionID = `test-session-replace-${Date.now()}`
       const input = createMockInput(sessionID)
       const output = createMockOutput("/test-cmd some args")
+      const originalText = output.parts[0].text
 
       // #when hook is called
       await hook["chat.message"](input, output)
 
-      // #then original text should be replaced, not prepended
-      const textPart = output.parts.find((p) => p.type === "text")
-      expect(textPart?.text).not.toContain("/test-cmd some args\n<auto-slash-command>")
-      expect(textPart?.text?.startsWith("<auto-slash-command>")).toBe(true)
+      // #then should not modify (feature inactive for unknown commands)
+      expect(output.parts[0].text).toBe(originalText)
     })
   })
 
@@ -218,41 +215,40 @@ describe("createAutoSlashCommandHook", () => {
       expect(output.parts[0].text).toBe(originalText)
     })
 
-    it("should handle command with special characters in args", async () => {
-      // #given command with special characters
+    it("should handle command with special characters in args (not found = no modification)", async () => {
+      // #given command with special characters that doesn't exist
       const hook = createAutoSlashCommandHook()
       const sessionID = `test-session-special-${Date.now()}`
       const input = createMockInput(sessionID)
       const output = createMockOutput('/execute "test & stuff <tag>"')
+      const originalText = output.parts[0].text
 
       // #when hook is called
       await hook["chat.message"](input, output)
 
-      // #then should handle gracefully (not found, but processed)
-      const textPart = output.parts.find((p) => p.type === "text")
-      expect(textPart?.text).toContain("<auto-slash-command>")
-      expect(textPart?.text).toContain("/execute")
+      // #then should not modify (command not found = feature inactive)
+      expect(output.parts[0].text).toBe(originalText)
     })
 
-    it("should handle multiple text parts", async () => {
-      // #given multiple text parts
+    it("should handle multiple text parts (unknown command = no modification)", async () => {
+      // #given multiple text parts with unknown command
       const hook = createAutoSlashCommandHook()
       const sessionID = `test-session-multi-${Date.now()}`
       const input = createMockInput(sessionID)
       const output: AutoSlashCommandHookOutput = {
         message: {},
         parts: [
-          { type: "text", text: "/commit " },
-          { type: "text", text: "fix bug" },
+          { type: "text", text: "/truly-nonexistent-xyz-cmd " },
+          { type: "text", text: "some args" },
         ],
       }
+      const originalText = output.parts[0].text
 
       // #when hook is called
       await hook["chat.message"](input, output)
 
-      // #then should detect from combined text and modify first text part
-      const firstTextPart = output.parts.find((p) => p.type === "text")
-      expect(firstTextPart?.text).toContain("<auto-slash-command>")
+      // #then should not modify (command not found = feature inactive)
+      expect(output.parts[0].text).toBe(originalText)
     })
   })
 })

src/hooks/auto-slash-command/index.ts

@@ -68,24 +68,22 @@ export function createAutoSlashCommandHook(options?: AutoSlashCommandHookOptions
         return
       }
 
-      if (result.success && result.replacementText) {
-        const taggedContent = `${AUTO_SLASH_COMMAND_TAG_OPEN}\n${result.replacementText}\n${AUTO_SLASH_COMMAND_TAG_CLOSE}`
-        output.parts[idx].text = taggedContent
-
-        log(`[auto-slash-command] Replaced message with command template`, {
-          sessionID: input.sessionID,
-          command: parsed.command,
-        })
-      } else {
-        const errorMessage = `${AUTO_SLASH_COMMAND_TAG_OPEN}\n[AUTO-SLASH-COMMAND ERROR]\n${result.error}\n\nOriginal input: ${parsed.raw}\n${AUTO_SLASH_COMMAND_TAG_CLOSE}`
-        output.parts[idx].text = errorMessage
-
-        log(`[auto-slash-command] Command not found, showing error`, {
+      if (!result.success || !result.replacementText) {
+        log(`[auto-slash-command] Command not found, skipping`, {
           sessionID: input.sessionID,
           command: parsed.command,
           error: result.error,
         })
+        return
       }
+
+      const taggedContent = `${AUTO_SLASH_COMMAND_TAG_OPEN}\n${result.replacementText}\n${AUTO_SLASH_COMMAND_TAG_CLOSE}`
+      output.parts[idx].text = taggedContent
+
+      log(`[auto-slash-command] Replaced message with command template`, {
+        sessionID: input.sessionID,
+        command: parsed.command,
+      })
     },
   }
 }

src/hooks/claude-code-hooks/index.ts

@@ -145,13 +145,7 @@ export function createClaudeCodeHooksHook(
           const hookContent = result.messages.join("\n\n")
           log(`[claude-code-hooks] Injecting ${result.messages.length} hook messages`, { sessionID: input.sessionID, contentLength: hookContent.length, isFirstMessage })
 
-          if (isFirstMessage) {
-            const idx = output.parts.findIndex((p) => p.type === "text" && p.text)
-            if (idx >= 0) {
-              output.parts[idx].text = `${hookContent}\n\n${output.parts[idx].text ?? ""}`
-              log("UserPromptSubmit hooks prepended to first message parts directly", { sessionID: input.sessionID })
-            }
-          } else if (contextCollector) {
+          if (contextCollector) {
             log("[DEBUG] Registering hook content to contextCollector", {
               sessionID: input.sessionID,
               contentLength: hookContent.length,
@@ -168,14 +162,6 @@ export function createClaudeCodeHooksHook(
               sessionID: input.sessionID,
               contentLength: hookContent.length,
             })
-          } else {
-            const idx = output.parts.findIndex((p) => p.type === "text" && p.text)
-            if (idx >= 0) {
-              output.parts[idx].text = `${hookContent}\n\n${output.parts[idx].text ?? ""}`
-              log("Hook content prepended to message (fallback)", {
-                sessionID: input.sessionID,
-              })
-            }
           }
         }
       }
@@ -257,7 +243,7 @@ export function createClaudeCodeHooksHook(
       const cachedInput = getToolInput(input.sessionID, input.tool, input.callID) || {}
 
       // Use metadata if available and non-empty, otherwise wrap output.output in a structured object
-      // This ensures plugin tools (call_omo_agent, sisyphus_task, task) that return strings
+      // This ensures plugin tools (call_omo_agent, delegate_task, task) that return strings
       // get their results properly recorded in transcripts instead of empty {}
       const metadata = output.metadata as Record<string, unknown> | undefined
       const hasMetadata = metadata && typeof metadata === "object" && Object.keys(metadata).length > 0

src/hooks/comment-checker/constants.ts

@@ -1,83 +0,0 @@
-export const BDD_KEYWORDS = new Set([
-  "given",
-  "when",
-  "then",
-  "arrange",
-  "act",
-  "assert",
-  "when & then",
-  "when&then",
-])
-
-export const TYPE_CHECKER_PREFIXES = [
-  "type:",
-  "noqa",
-  "pyright:",
-  "ruff:",
-  "mypy:",
-  "pylint:",
-  "flake8:",
-  "pyre:",
-  "pytype:",
-  "eslint-disable",
-  "eslint-enable",
-  "eslint-ignore",
-  "prettier-ignore",
-  "ts-ignore",
-  "ts-expect-error",
-  "ts-nocheck",
-  "clippy::",
-  "allow(",
-  "deny(",
-  "warn(",
-  "forbid(",
-  "nolint",
-  "go:generate",
-  "go:build",
-  "go:embed",
-  "coverage:",
-  "c8 ignore",
-  "biome-ignore",
-  "region",
-  "endregion",
-]
-
-export const HOOK_MESSAGE_HEADER = `COMMENT/DOCSTRING DETECTED - IMMEDIATE ACTION REQUIRED
-
-Your recent changes contain comments or docstrings, which triggered this hook.
-You need to take immediate action. You must follow the conditions below.
-(Listed in priority order - you must always act according to this priority order)
-
-CRITICAL WARNING: This hook message MUST NEVER be ignored, even if you receive it multiple times.
-You MUST provide corresponding explanation or action for EACH occurrence of this message.
-Ignoring this message or failing to respond appropriately is strictly prohibited.
-
-PRIORITY-BASED ACTION GUIDELINES:
-
-1. This is a comment/docstring that already existed before
-\t-> Explain to the user that this is an existing comment/docstring and proceed (justify it)
-
-2. This is a newly written comment: but it's in given, when, then format
-\t-> Tell the user it's a BDD comment and proceed (justify it)
-\t-> Note: This applies to comments only, not docstrings
-
-3. This is a newly written comment/docstring: but it's a necessary comment/docstring
-\t-> Tell the user why this comment/docstring is absolutely necessary and proceed (justify it)
-\t-> Examples of necessary comments: complex algorithms, security-related, performance optimization, regex, mathematical formulas
-\t-> Examples of necessary docstrings: public API documentation, complex module/class interfaces
-\t-> IMPORTANT: Most docstrings are unnecessary if the code is self-explanatory. Only keep truly essential ones.
-
-4. This is a newly written comment/docstring: but it's an unnecessary comment/docstring
-\t-> Apologize to the user and remove the comment/docstring.
-\t-> Make the code itself clearer so it can be understood without comments/docstrings.
-\t-> For verbose docstrings: refactor code to be self-documenting instead of adding lengthy explanations.
-
-CODE SMELL WARNING: Using comments as visual separators (e.g., "// =========", "# ---", "// *** Section ***")
-is a code smell. If you need separators, your file is too long or poorly organized.
-Refactor into smaller modules or use proper code organization instead of comment-based section dividers.
-
-MANDATORY REQUIREMENT: You must acknowledge this hook message and take one of the above actions.
-Review in the above priority order and take the corresponding action EVERY TIME this appears.
-
-Detected comments/docstrings:
-`

src/hooks/comment-checker/filters/bdd.ts

@@ -1,21 +0,0 @@
-import type { CommentInfo, FilterResult } from "../types"
-import { BDD_KEYWORDS } from "../constants"
-
-function stripCommentPrefix(text: string): string {
-  let stripped = text.trim().toLowerCase()
-  const prefixes = ["#", "//", "--", "/*", "*/"]
-  for (const prefix of prefixes) {
-    if (stripped.startsWith(prefix)) {
-      stripped = stripped.slice(prefix.length).trim()
-    }
-  }
-  return stripped
-}
-
-export function filterBddComments(comment: CommentInfo): FilterResult {
-  const normalized = stripCommentPrefix(comment.text)
-  if (BDD_KEYWORDS.has(normalized)) {
-    return { shouldSkip: true, reason: `BDD keyword: ${normalized}` }
-  }
-  return { shouldSkip: false }
-}

src/hooks/comment-checker/filters/directive.ts

@@ -1,24 +0,0 @@
-import type { CommentInfo, FilterResult } from "../types"
-import { TYPE_CHECKER_PREFIXES } from "../constants"
-
-function stripCommentPrefix(text: string): string {
-  let stripped = text.trim().toLowerCase()
-  const prefixes = ["#", "//", "/*", "--"]
-  for (const prefix of prefixes) {
-    if (stripped.startsWith(prefix)) {
-      stripped = stripped.slice(prefix.length).trim()
-    }
-  }
-  stripped = stripped.replace(/^@/, "")
-  return stripped
-}
-
-export function filterDirectiveComments(comment: CommentInfo): FilterResult {
-  const normalized = stripCommentPrefix(comment.text)
-  for (const prefix of TYPE_CHECKER_PREFIXES) {
-    if (normalized.startsWith(prefix.toLowerCase())) {
-      return { shouldSkip: true, reason: `Directive: ${prefix}` }
-    }
-  }
-  return { shouldSkip: false }
-}

src/hooks/comment-checker/filters/docstring.ts

@@ -1,12 +0,0 @@
-import type { CommentInfo, FilterResult } from "../types"
-
-export function filterDocstringComments(comment: CommentInfo): FilterResult {
-  if (comment.isDocstring) {
-    return { shouldSkip: true, reason: "Docstring" }
-  }
-  const trimmed = comment.text.trimStart()
-  if (trimmed.startsWith("/**")) {
-    return { shouldSkip: true, reason: "JSDoc/PHPDoc" }
-  }
-  return { shouldSkip: false }
-}

src/hooks/comment-checker/filters/index.ts

@@ -1,26 +0,0 @@
-import type { CommentInfo, CommentFilter } from "../types"
-import { filterBddComments } from "./bdd"
-import { filterDirectiveComments } from "./directive"
-import { filterDocstringComments } from "./docstring"
-import { filterShebangComments } from "./shebang"
-
-export { filterBddComments, filterDirectiveComments, filterDocstringComments, filterShebangComments }
-
-const ALL_FILTERS: CommentFilter[] = [
-  filterShebangComments,
-  filterBddComments,
-  filterDirectiveComments,
-  filterDocstringComments,
-]
-
-export function applyFilters(comments: CommentInfo[]): CommentInfo[] {
-  return comments.filter((comment) => {
-    for (const filter of ALL_FILTERS) {
-      const result = filter(comment)
-      if (result.shouldSkip) {
-        return false
-      }
-    }
-    return true
-  })
-}

src/hooks/comment-checker/filters/shebang.ts

@@ -1,9 +0,0 @@
-import type { CommentInfo, FilterResult } from "../types"
-
-export function filterShebangComments(comment: CommentInfo): FilterResult {
-  const trimmed = comment.text.trimStart()
-  if (trimmed.startsWith("#!")) {
-    return { shouldSkip: true, reason: "Shebang" }
-  }
-  return { shouldSkip: false }
-}

src/hooks/comment-checker/output/formatter.ts

@@ -1,11 +0,0 @@
-import type { FileComments } from "../types"
-import { HOOK_MESSAGE_HEADER } from "../constants"
-import { buildCommentsXml } from "./xml-builder"
-
-export function formatHookMessage(fileCommentsList: FileComments[]): string {
-  if (fileCommentsList.length === 0) {
-    return ""
-  }
-  const xml = buildCommentsXml(fileCommentsList)
-  return `${HOOK_MESSAGE_HEADER}${xml}\n`
-}

src/hooks/comment-checker/output/index.ts

@@ -1,2 +0,0 @@
-export { buildCommentsXml } from "./xml-builder"
-export { formatHookMessage } from "./formatter"

src/hooks/comment-checker/output/xml-builder.ts

@@ -1,24 +0,0 @@
-import type { FileComments } from "../types"
-
-function escapeXml(text: string): string {
-  return text
-    .replace(/&/g, "&")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;")
-    .replace(/'/g, "&apos;")
-}
-
-export function buildCommentsXml(fileCommentsList: FileComments[]): string {
-  const lines: string[] = []
-
-  for (const fc of fileCommentsList) {
-    lines.push(`<comments file="${escapeXml(fc.filePath)}">`)
-    for (const comment of fc.comments) {
-      lines.push(`\t<comment line-number="${comment.lineNumber}">${escapeXml(comment.text)}</comment>`)
-    }
-    lines.push(`</comments>`)
-  }
-
-  return lines.join("\n")
-}

src/hooks/compaction-context-injector/index.ts

@@ -1,8 +1,16 @@
-import type { SummarizeContext } from "../preemptive-compaction"
 import { injectHookMessage } from "../../features/hook-message-injector"
 import { log } from "../../shared/logger"
+import { createSystemDirective, SystemDirectiveTypes } from "../../shared/system-directive"
 
-const SUMMARIZE_CONTEXT_PROMPT = `[COMPACTION CONTEXT INJECTION]
+export interface SummarizeContext {
+  sessionID: string
+  providerID: string
+  modelID: string
+  usageRatio: number
+  directory: string
+}
+
+const SUMMARIZE_CONTEXT_PROMPT = `${createSystemDirective(SystemDirectiveTypes.COMPACTION_CONTEXT)}
 
 When summarizing this session, you MUST include the following sections in your summary:
 

src/hooks/context-window-monitor.ts

@@ -1,4 +1,5 @@
 import type { PluginInput } from "@opencode-ai/plugin"
+import { createSystemDirective, SystemDirectiveTypes } from "../shared/system-directive"
 
 const ANTHROPIC_DISPLAY_LIMIT = 1_000_000
 const ANTHROPIC_ACTUAL_LIMIT =
@@ -8,7 +9,7 @@ const ANTHROPIC_ACTUAL_LIMIT =
     : 200_000
 const CONTEXT_WARNING_THRESHOLD = 0.70
 
-const CONTEXT_REMINDER = `[SYSTEM REMINDER - 1M Context Window]
+const CONTEXT_REMINDER = `${createSystemDirective(SystemDirectiveTypes.CONTEXT_WINDOW_MONITOR)}
 
 You are using Anthropic Claude with 1M context window.
 You have plenty of context remaining - do NOT rush or skip tasks.

src/hooks/delegate-task-retry/index.test.ts

@@ -1,18 +1,18 @@
 import { describe, expect, it } from "bun:test"
 import {
-  SISYPHUS_TASK_ERROR_PATTERNS,
-  detectSisyphusTaskError,
+  DELEGATE_TASK_ERROR_PATTERNS,
+  detectDelegateTaskError,
   buildRetryGuidance,
 } from "./index"
 
 describe("sisyphus-task-retry", () => {
-  describe("SISYPHUS_TASK_ERROR_PATTERNS", () => {
+  describe("DELEGATE_TASK_ERROR_PATTERNS", () => {
     // #given error patterns are defined
-    // #then should include all known sisyphus_task error types
+    // #then should include all known delegate_task error types
     it("should contain all known error patterns", () => {
-      expect(SISYPHUS_TASK_ERROR_PATTERNS.length).toBeGreaterThan(5)
+      expect(DELEGATE_TASK_ERROR_PATTERNS.length).toBeGreaterThan(5)
       
-      const patternTexts = SISYPHUS_TASK_ERROR_PATTERNS.map(p => p.pattern)
+      const patternTexts = DELEGATE_TASK_ERROR_PATTERNS.map(p => p.pattern)
       expect(patternTexts).toContain("run_in_background")
       expect(patternTexts).toContain("skills")
       expect(patternTexts).toContain("category OR subagent_type")
@@ -21,14 +21,14 @@ describe("sisyphus-task-retry", () => {
     })
   })
 
-  describe("detectSisyphusTaskError", () => {
+  describe("detectDelegateTaskError", () => {
     // #given tool output with run_in_background error
     // #when detecting error
     // #then should return matching error info
     it("should detect run_in_background missing error", () => {
       const output = "❌ Invalid arguments: 'run_in_background' parameter is REQUIRED. Use run_in_background=false for task delegation."
       
-      const result = detectSisyphusTaskError(output)
+      const result = detectDelegateTaskError(output)
       
       expect(result).not.toBeNull()
       expect(result?.errorType).toBe("missing_run_in_background")
@@ -37,7 +37,7 @@ describe("sisyphus-task-retry", () => {
     it("should detect skills missing error", () => {
       const output = "❌ Invalid arguments: 'skills' parameter is REQUIRED. Use skills=[] if no skills needed."
       
-      const result = detectSisyphusTaskError(output)
+      const result = detectDelegateTaskError(output)
       
       expect(result).not.toBeNull()
       expect(result?.errorType).toBe("missing_skills")
@@ -46,7 +46,7 @@ describe("sisyphus-task-retry", () => {
     it("should detect category/subagent mutual exclusion error", () => {
       const output = "❌ Invalid arguments: Provide EITHER category OR subagent_type, not both."
       
-      const result = detectSisyphusTaskError(output)
+      const result = detectDelegateTaskError(output)
       
       expect(result).not.toBeNull()
       expect(result?.errorType).toBe("mutual_exclusion")
@@ -55,7 +55,7 @@ describe("sisyphus-task-retry", () => {
     it("should detect unknown category error", () => {
       const output = '❌ Unknown category: "invalid-cat". Available: visual-engineering, ultrabrain, quick'
       
-      const result = detectSisyphusTaskError(output)
+      const result = detectDelegateTaskError(output)
       
       expect(result).not.toBeNull()
       expect(result?.errorType).toBe("unknown_category")
@@ -64,7 +64,7 @@ describe("sisyphus-task-retry", () => {
     it("should detect unknown agent error", () => {
       const output = '❌ Unknown agent: "fake-agent". Available agents: explore, librarian, oracle'
       
-      const result = detectSisyphusTaskError(output)
+      const result = detectDelegateTaskError(output)
       
       expect(result).not.toBeNull()
       expect(result?.errorType).toBe("unknown_agent")
@@ -73,7 +73,7 @@ describe("sisyphus-task-retry", () => {
     it("should return null for successful output", () => {
       const output = "Background task launched.\n\nTask ID: bg_12345\nSession ID: ses_abc"
       
-      const result = detectSisyphusTaskError(output)
+      const result = detectDelegateTaskError(output)
       
       expect(result).toBeNull()
     })

src/hooks/delegate-task-retry/index.ts

@@ -1,12 +1,12 @@
 import type { PluginInput } from "@opencode-ai/plugin"
 
-export interface SisyphusTaskErrorPattern {
+export interface DelegateTaskErrorPattern {
   pattern: string
   errorType: string
   fixHint: string
 }
 
-export const SISYPHUS_TASK_ERROR_PATTERNS: SisyphusTaskErrorPattern[] = [
+export const DELEGATE_TASK_ERROR_PATTERNS: DelegateTaskErrorPattern[] = [
   {
     pattern: "run_in_background",
     errorType: "missing_run_in_background",
@@ -45,7 +45,7 @@ export const SISYPHUS_TASK_ERROR_PATTERNS: SisyphusTaskErrorPattern[] = [
   {
     pattern: "Cannot call primary agent",
     errorType: "primary_agent",
-    fixHint: "Primary agents cannot be called via sisyphus_task. Use a subagent like 'explore', 'oracle', or 'librarian'",
+    fixHint: "Primary agents cannot be called via delegate_task. Use a subagent like 'explore', 'oracle', or 'librarian'",
   },
   {
     pattern: "Skills not found",
@@ -59,10 +59,10 @@ export interface DetectedError {
   originalOutput: string
 }
 
-export function detectSisyphusTaskError(output: string): DetectedError | null {
+export function detectDelegateTaskError(output: string): DetectedError | null {
   if (!output.includes("❌")) return null
 
-  for (const errorPattern of SISYPHUS_TASK_ERROR_PATTERNS) {
+  for (const errorPattern of DELEGATE_TASK_ERROR_PATTERNS) {
     if (output.includes(errorPattern.pattern)) {
       return {
         errorType: errorPattern.errorType,
@@ -80,16 +80,16 @@ function extractAvailableList(output: string): string | null {
 }
 
 export function buildRetryGuidance(errorInfo: DetectedError): string {
-  const pattern = SISYPHUS_TASK_ERROR_PATTERNS.find(
+  const pattern = DELEGATE_TASK_ERROR_PATTERNS.find(
     (p) => p.errorType === errorInfo.errorType
   )
 
   if (!pattern) {
-    return `[sisyphus_task ERROR] Fix the error and retry with correct parameters.`
+    return `[delegate_task ERROR] Fix the error and retry with correct parameters.`
   }
 
   let guidance = `
-[sisyphus_task CALL FAILED - IMMEDIATE RETRY REQUIRED]
+[delegate_task CALL FAILED - IMMEDIATE RETRY REQUIRED]
 
 **Error Type**: ${errorInfo.errorType}
 **Fix**: ${pattern.fixHint}
@@ -101,11 +101,11 @@ export function buildRetryGuidance(errorInfo: DetectedError): string {
   }
 
   guidance += `
-**Action**: Retry sisyphus_task NOW with corrected parameters.
+**Action**: Retry delegate_task NOW with corrected parameters.
 
 Example of CORRECT call:
 \`\`\`
-sisyphus_task(
+delegate_task(
   description="Task description",
   prompt="Detailed prompt...",
   category="general",  // OR subagent_type="explore"
@@ -118,15 +118,15 @@ sisyphus_task(
   return guidance
 }
 
-export function createSisyphusTaskRetryHook(_ctx: PluginInput) {
+export function createDelegateTaskRetryHook(_ctx: PluginInput) {
   return {
     "tool.execute.after": async (
       input: { tool: string; sessionID: string; callID: string },
       output: { title: string; output: string; metadata: unknown }
     ) => {
-      if (input.tool.toLowerCase() !== "sisyphus_task") return
+      if (input.tool.toLowerCase() !== "delegate_task") return
 
-      const errorInfo = detectSisyphusTaskError(output.output)
+      const errorInfo = detectDelegateTaskError(output.output)
       if (errorInfo) {
         const guidance = buildRetryGuidance(errorInfo)
         output.output += `\n${guidance}`

src/hooks/empty-message-sanitizer/index.ts

@@ -1,105 +0,0 @@
-import type { Message, Part } from "@opencode-ai/sdk"
-
-const PLACEHOLDER_TEXT = "[user interrupted]"
-
-interface MessageWithParts {
-  info: Message
-  parts: Part[]
-}
-
-type MessagesTransformHook = {
-// NOTE: This sanitizer runs on experimental.chat.messages.transform hook,
-// which executes AFTER chat.message hooks. Filesystem-injected messages
-// from hooks like claude-code-hooks and keyword-detector may bypass this
-// sanitizer if they inject empty content. Validation should be done at
-// injection time in injectHookMessage().
-
-  "experimental.chat.messages.transform"?: (
-    input: Record<string, never>,
-    output: { messages: MessageWithParts[] }
-  ) => Promise<void>
-}
-
-function hasTextContent(part: Part): boolean {
-  if (part.type === "text") {
-    const text = (part as unknown as { text?: string }).text
-    return Boolean(text && text.trim().length > 0)
-  }
-  return false
-}
-
-function isToolPart(part: Part): boolean {
-  const type = part.type as string
-  return type === "tool" || type === "tool_use" || type === "tool_result"
-}
-
-function hasValidContent(parts: Part[]): boolean {
-  return parts.some((part) => hasTextContent(part) || isToolPart(part))
-}
-
-export function createEmptyMessageSanitizerHook(): MessagesTransformHook {
-  return {
-    "experimental.chat.messages.transform": async (_input, output) => {
-      const { messages } = output
-
-      for (let i = 0; i < messages.length; i++) {
-        const message = messages[i]
-        const isLastMessage = i === messages.length - 1
-        const isAssistant = message.info.role === "assistant"
-        
-        // Skip final assistant message (allowed to be empty per API spec)
-        if (isLastMessage && isAssistant) continue
-
-        const parts = message.parts
-
-        // FIX: Removed `&& parts.length > 0` - empty arrays also need sanitization
-        // When parts is [], the message has no content and would cause API error:
-        // "all messages must have non-empty content except for the optional final assistant message"
-        if (!hasValidContent(parts)) {
-          let injected = false
-
-          for (const part of parts) {
-            if (part.type === "text") {
-              const textPart = part as unknown as { text?: string; synthetic?: boolean }
-              if (!textPart.text || !textPart.text.trim()) {
-                textPart.text = PLACEHOLDER_TEXT
-                textPart.synthetic = true
-                injected = true
-                break
-              }
-            }
-          }
-
-          if (!injected) {
-            const insertIndex = parts.findIndex((p) => isToolPart(p))
-
-            const newPart = {
-              id: `synthetic_${Date.now()}`,
-              messageID: message.info.id,
-              sessionID: (message.info as unknown as { sessionID?: string }).sessionID ?? "",
-              type: "text" as const,
-              text: PLACEHOLDER_TEXT,
-              synthetic: true,
-            }
-
-            if (insertIndex === -1) {
-              parts.push(newPart as Part)
-            } else {
-              parts.splice(insertIndex, 0, newPart as Part)
-            }
-          }
-        }
-
-        for (const part of parts) {
-          if (part.type === "text") {
-            const textPart = part as unknown as { text?: string; synthetic?: boolean }
-            if (textPart.text !== undefined && textPart.text.trim() === "") {
-              textPart.text = PLACEHOLDER_TEXT
-              textPart.synthetic = true
-            }
-          }
-        }
-      }
-    },
-  }
-}

src/hooks/index.ts

@@ -8,20 +8,19 @@ export { createDirectoryAgentsInjectorHook } from "./directory-agents-injector";
 export { createDirectoryReadmeInjectorHook } from "./directory-readme-injector";
 export { createEmptyTaskResponseDetectorHook } from "./empty-task-response-detector";
 export { createAnthropicContextWindowLimitRecoveryHook, type AnthropicContextWindowLimitRecoveryOptions } from "./anthropic-context-window-limit-recovery";
-export { createPreemptiveCompactionHook, type PreemptiveCompactionOptions, type SummarizeContext, type BeforeSummarizeCallback } from "./preemptive-compaction";
+
 export { createCompactionContextInjector } from "./compaction-context-injector";
 export { createThinkModeHook } from "./think-mode";
 export { createClaudeCodeHooksHook } from "./claude-code-hooks";
 export { createRulesInjectorHook } from "./rules-injector";
 export { createBackgroundNotificationHook } from "./background-notification"
-export { createBackgroundCompactionHook } from "./background-compaction"
 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";
-export { createEmptyMessageSanitizerHook } from "./empty-message-sanitizer";
+
 export { createThinkingBlockValidatorHook } from "./thinking-block-validator";
 export { createRalphLoopHook, type RalphLoopHook } from "./ralph-loop";
 export { createAutoSlashCommandHook } from "./auto-slash-command";
@@ -30,4 +29,4 @@ export { createPrometheusMdOnlyHook } from "./prometheus-md-only";
 export { createTaskResumeInfoHook } from "./task-resume-info";
 export { createStartWorkHook } from "./start-work";
 export { createSisyphusOrchestratorHook } from "./sisyphus-orchestrator";
-export { createSisyphusTaskRetryHook } from "./sisyphus-task-retry";
+export { createDelegateTaskRetryHook } from "./delegate-task-retry";

src/hooks/keyword-detector/constants.ts

@@ -12,7 +12,7 @@ You ARE the planner. You ARE NOT an implementer. You DO NOT write code. You DO N
 | Write/Edit | \`.sisyphus/**/*.md\` ONLY | Everything else |
 | Read | All files | - |
 | Bash | Research commands only | Implementation commands |
-| sisyphus_task | explore, librarian | - |
+| delegate_task | explore, librarian | - |
 
 **IF YOU TRY TO WRITE/EDIT OUTSIDE \`.sisyphus/\`:**
 - System will BLOCK your action
@@ -36,9 +36,9 @@ You ARE the planner. Your job: create bulletproof work plans.
 ### Research Protocol
 1. **Fire parallel background agents** for comprehensive context:
    \`\`\`
-   sisyphus_task(agent="explore", prompt="Find existing patterns for [topic] in codebase", background=true)
-   sisyphus_task(agent="explore", prompt="Find test infrastructure and conventions", background=true)
-   sisyphus_task(agent="librarian", prompt="Find official docs and best practices for [technology]", background=true)
+   delegate_task(agent="explore", prompt="Find existing patterns for [topic] in codebase", background=true)
+   delegate_task(agent="explore", prompt="Find test infrastructure and conventions", background=true)
+   delegate_task(agent="librarian", prompt="Find official docs and best practices for [technology]", background=true)
    \`\`\`
 2. **Wait for results** before planning - rushed plans fail
 3. **Synthesize findings** into informed requirements
@@ -101,14 +101,14 @@ TELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.
 
 ## EXECUTION RULES
 - **TODO**: Track EVERY step. Mark complete IMMEDIATELY after each.
-- **PARALLEL**: Fire independent agent calls simultaneously via sisyphus_task(background=true) - NEVER wait sequentially.
-- **BACKGROUND FIRST**: Use sisyphus_task for exploration/research agents (10+ concurrent if needed).
+- **PARALLEL**: Fire independent agent calls simultaneously via delegate_task(background=true) - NEVER wait sequentially.
+- **BACKGROUND FIRST**: Use delegate_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 sisyphus_task(background=true) in PARALLEL (10+ if needed)
+2. Spawn exploration/librarian agents via delegate_task(background=true) in PARALLEL (10+ if needed)
 3. Always Use Plan agent with gathered context to create detailed work breakdown
 4. Execute with continuous verification against original requirements
 

src/hooks/keyword-detector/index.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test, beforeEach, afterEach, spyOn } from "bun:test"
 import { createKeywordDetectorHook } from "./index"
-import { setMainSession } from "../../features/claude-code-session-state"
+import { setMainSession, updateSessionAgent, clearSessionAgent, _resetForTesting } from "../../features/claude-code-session-state"
 import { ContextCollector } from "../../features/context-injector"
 import * as sharedModule from "../../shared"
 import * as sessionState from "../../features/claude-code-session-state"
@@ -11,6 +11,7 @@ describe("keyword-detector registers to ContextCollector", () => {
   let getMainSessionSpy: ReturnType<typeof spyOn>
 
   beforeEach(() => {
+    _resetForTesting()
     logCalls = []
     logSpy = spyOn(sharedModule, "log").mockImplementation((msg: string, data?: unknown) => {
       logCalls.push({ msg, data })
@@ -332,3 +333,197 @@ describe("keyword-detector word boundary", () => {
     expect(toastCalls).not.toContain("Ultrawork Mode Activated")
   })
 })
+
+describe("keyword-detector agent-specific ultrawork messages", () => {
+  let logCalls: Array<{ msg: string; data?: unknown }>
+  let logSpy: ReturnType<typeof spyOn>
+
+  beforeEach(() => {
+    setMainSession(undefined)
+    logCalls = []
+    logSpy = spyOn(sharedModule, "log").mockImplementation((msg: string, data?: unknown) => {
+      logCalls.push({ msg, data })
+    })
+  })
+
+  afterEach(() => {
+    logSpy?.mockRestore()
+    setMainSession(undefined)
+  })
+
+  function createMockPluginInput() {
+    return {
+      client: {
+        tui: {
+          showToast: async () => {},
+        },
+      },
+    } as any
+  }
+
+  test("should use planner-specific ultrawork message when agent is prometheus", async () => {
+    // #given - collector and prometheus agent
+    const collector = new ContextCollector()
+    const hook = createKeywordDetectorHook(createMockPluginInput(), collector)
+    const sessionID = "prometheus-session"
+    const output = {
+      message: {} as Record<string, unknown>,
+      parts: [{ type: "text", text: "ultrawork plan this feature" }],
+    }
+
+    // #when - ultrawork keyword detected with prometheus agent
+    await hook["chat.message"]({ sessionID, agent: "prometheus" }, output)
+
+    // #then - should use planner-specific message with "YOU ARE A PLANNER" content
+    const pending = collector.getPending(sessionID)
+    const ultraworkEntry = pending.entries.find((e) => e.id === "keyword-ultrawork")
+    expect(ultraworkEntry).toBeDefined()
+    expect(ultraworkEntry!.content).toContain("YOU ARE A PLANNER, NOT AN IMPLEMENTER")
+    expect(ultraworkEntry!.content).not.toContain("YOU MUST LEVERAGE ALL AVAILABLE AGENTS")
+  })
+
+  test("should use planner-specific ultrawork message when agent name contains 'planner'", async () => {
+    // #given - collector and agent with 'planner' in name
+    const collector = new ContextCollector()
+    const hook = createKeywordDetectorHook(createMockPluginInput(), collector)
+    const sessionID = "planner-session"
+    const output = {
+      message: {} as Record<string, unknown>,
+      parts: [{ type: "text", text: "ulw create a work plan" }],
+    }
+
+    // #when - ultrawork keyword detected with planner agent
+    await hook["chat.message"]({ sessionID, agent: "Prometheus (Planner)" }, output)
+
+    // #then - should use planner-specific message
+    const pending = collector.getPending(sessionID)
+    const ultraworkEntry = pending.entries.find((e) => e.id === "keyword-ultrawork")
+    expect(ultraworkEntry).toBeDefined()
+    expect(ultraworkEntry!.content).toContain("YOU ARE A PLANNER, NOT AN IMPLEMENTER")
+  })
+
+  test("should use normal ultrawork message when agent is Sisyphus", async () => {
+    // #given - collector and Sisyphus agent
+    const collector = new ContextCollector()
+    const hook = createKeywordDetectorHook(createMockPluginInput(), collector)
+    const sessionID = "sisyphus-session"
+    const output = {
+      message: {} as Record<string, unknown>,
+      parts: [{ type: "text", text: "ultrawork implement this feature" }],
+    }
+
+    // #when - ultrawork keyword detected with Sisyphus agent
+    await hook["chat.message"]({ sessionID, agent: "Sisyphus" }, output)
+
+    // #then - should use normal ultrawork message with agent utilization instructions
+    const pending = collector.getPending(sessionID)
+    const ultraworkEntry = pending.entries.find((e) => e.id === "keyword-ultrawork")
+    expect(ultraworkEntry).toBeDefined()
+    expect(ultraworkEntry!.content).toContain("YOU MUST LEVERAGE ALL AVAILABLE AGENTS")
+    expect(ultraworkEntry!.content).not.toContain("YOU ARE A PLANNER, NOT AN IMPLEMENTER")
+  })
+
+  test("should use normal ultrawork message when agent is undefined", async () => {
+    // #given - collector with no agent specified
+    const collector = new ContextCollector()
+    const hook = createKeywordDetectorHook(createMockPluginInput(), collector)
+    const sessionID = "no-agent-session"
+    const output = {
+      message: {} as Record<string, unknown>,
+      parts: [{ type: "text", text: "ultrawork do something" }],
+    }
+
+    // #when - ultrawork keyword detected without agent
+    await hook["chat.message"]({ sessionID }, output)
+
+    // #then - should use normal ultrawork message (default behavior)
+    const pending = collector.getPending(sessionID)
+    const ultraworkEntry = pending.entries.find((e) => e.id === "keyword-ultrawork")
+    expect(ultraworkEntry).toBeDefined()
+    expect(ultraworkEntry!.content).toContain("YOU MUST LEVERAGE ALL AVAILABLE AGENTS")
+    expect(ultraworkEntry!.content).not.toContain("YOU ARE A PLANNER, NOT AN IMPLEMENTER")
+  })
+
+  test("should switch from planner to normal message when agent changes", async () => {
+    // #given - two sessions, one with prometheus, one with sisyphus
+    const collector = new ContextCollector()
+    const hook = createKeywordDetectorHook(createMockPluginInput(), collector)
+
+    // First session with prometheus
+    const prometheusSessionID = "prometheus-first"
+    const prometheusOutput = {
+      message: {} as Record<string, unknown>,
+      parts: [{ type: "text", text: "ultrawork plan" }],
+    }
+    await hook["chat.message"]({ sessionID: prometheusSessionID, agent: "prometheus" }, prometheusOutput)
+
+    // Second session with sisyphus
+    const sisyphusSessionID = "sisyphus-second"
+    const sisyphusOutput = {
+      message: {} as Record<string, unknown>,
+      parts: [{ type: "text", text: "ultrawork implement" }],
+    }
+    await hook["chat.message"]({ sessionID: sisyphusSessionID, agent: "Sisyphus" }, sisyphusOutput)
+
+    // #then - each session should have the correct message type
+    const prometheusPending = collector.getPending(prometheusSessionID)
+    const prometheusEntry = prometheusPending.entries.find((e) => e.id === "keyword-ultrawork")
+    expect(prometheusEntry!.content).toContain("YOU ARE A PLANNER, NOT AN IMPLEMENTER")
+
+    const sisyphusPending = collector.getPending(sisyphusSessionID)
+    const sisyphusEntry = sisyphusPending.entries.find((e) => e.id === "keyword-ultrawork")
+    expect(sisyphusEntry!.content).toContain("YOU MUST LEVERAGE ALL AVAILABLE AGENTS")
+  })
+
+  test("should use session state agent over stale input.agent (bug fix)", async () => {
+    // #given - same session, agent switched from prometheus to sisyphus in session state
+    const collector = new ContextCollector()
+    const hook = createKeywordDetectorHook(createMockPluginInput(), collector)
+    const sessionID = "same-session-agent-switch"
+
+    // Simulate: session state was updated to sisyphus (by index.ts updateSessionAgent)
+    updateSessionAgent(sessionID, "Sisyphus")
+
+    const output = {
+      message: {} as Record<string, unknown>,
+      parts: [{ type: "text", text: "ultrawork implement this" }],
+    }
+
+    // #when - hook receives stale input.agent="prometheus" but session state says "Sisyphus"
+    await hook["chat.message"]({ sessionID, agent: "prometheus" }, output)
+
+    // #then - should use Sisyphus from session state, NOT prometheus from stale input
+    const pending = collector.getPending(sessionID)
+    const ultraworkEntry = pending.entries.find((e) => e.id === "keyword-ultrawork")
+    expect(ultraworkEntry).toBeDefined()
+    expect(ultraworkEntry!.content).toContain("YOU MUST LEVERAGE ALL AVAILABLE AGENTS")
+    expect(ultraworkEntry!.content).not.toContain("YOU ARE A PLANNER, NOT AN IMPLEMENTER")
+
+    // cleanup
+    clearSessionAgent(sessionID)
+  })
+
+  test("should fall back to input.agent when session state is empty", async () => {
+    // #given - no session state, only input.agent available
+    const collector = new ContextCollector()
+    const hook = createKeywordDetectorHook(createMockPluginInput(), collector)
+    const sessionID = "no-session-state"
+
+    // Ensure no session state
+    clearSessionAgent(sessionID)
+
+    const output = {
+      message: {} as Record<string, unknown>,
+      parts: [{ type: "text", text: "ultrawork plan this" }],
+    }
+
+    // #when - hook receives input.agent="prometheus" with no session state
+    await hook["chat.message"]({ sessionID, agent: "prometheus" }, output)
+
+    // #then - should use prometheus from input.agent as fallback
+    const pending = collector.getPending(sessionID)
+    const ultraworkEntry = pending.entries.find((e) => e.id === "keyword-ultrawork")
+    expect(ultraworkEntry).toBeDefined()
+    expect(ultraworkEntry!.content).toContain("YOU ARE A PLANNER, NOT AN IMPLEMENTER")
+  })
+})

src/hooks/keyword-detector/index.ts

@@ -1,7 +1,8 @@
 import type { PluginInput } from "@opencode-ai/plugin"
 import { detectKeywordsWithType, extractPromptText, removeCodeBlocks } from "./detector"
 import { log } from "../../shared"
-import { getMainSessionID } from "../../features/claude-code-session-state"
+import { isSystemDirective } from "../../shared/system-directive"
+import { getMainSessionID, getSessionAgent, subagentSessions } from "../../features/claude-code-session-state"
 import type { ContextCollector } from "../../features/context-injector"
 
 export * from "./detector"
@@ -23,12 +24,26 @@ export function createKeywordDetectorHook(ctx: PluginInput, collector?: ContextC
       }
     ): Promise<void> => {
       const promptText = extractPromptText(output.parts)
-      let detectedKeywords = detectKeywordsWithType(removeCodeBlocks(promptText), input.agent)
+
+      if (isSystemDirective(promptText)) {
+        log(`[keyword-detector] Skipping system directive message`, { sessionID: input.sessionID })
+        return
+      }
+
+      const currentAgent = getSessionAgent(input.sessionID) ?? input.agent
+      let detectedKeywords = detectKeywordsWithType(removeCodeBlocks(promptText), currentAgent)
 
       if (detectedKeywords.length === 0) {
         return
       }
 
+      // Skip keyword detection for background task sessions to prevent mode injection
+      // (e.g., [analyze-mode]) which incorrectly triggers Prometheus restrictions
+      const isBackgroundTaskSession = subagentSessions.has(input.sessionID)
+      if (isBackgroundTaskSession) {
+        return
+      }
+
       const mainSessionID = getMainSessionID()
       const isNonMainSession = mainSessionID && input.sessionID !== mainSessionID
 

src/hooks/preemptive-compaction/constants.ts

@@ -1,3 +0,0 @@
-export const DEFAULT_THRESHOLD = 0.85
-export const MIN_TOKENS_FOR_COMPACTION = 50_000
-export const COMPACTION_COOLDOWN_MS = 60_000

src/hooks/preemptive-compaction/index.ts

@@ -1,265 +0,0 @@
-import { existsSync, readdirSync } from "node:fs"
-import { join } from "node:path"
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { ExperimentalConfig } from "../../config"
-import type { PreemptiveCompactionState, TokenInfo } from "./types"
-import {
-  DEFAULT_THRESHOLD,
-  MIN_TOKENS_FOR_COMPACTION,
-  COMPACTION_COOLDOWN_MS,
-} from "./constants"
-import {
-  findNearestMessageWithFields,
-  MESSAGE_STORAGE,
-} from "../../features/hook-message-injector"
-import { log } from "../../shared/logger"
-
-export interface SummarizeContext {
-  sessionID: string
-  providerID: string
-  modelID: string
-  usageRatio: number
-  directory: string
-}
-
-export type BeforeSummarizeCallback = (ctx: SummarizeContext) => Promise<void> | void
-
-export type GetModelLimitCallback = (providerID: string, modelID: string) => number | undefined
-
-export interface PreemptiveCompactionOptions {
-  experimental?: ExperimentalConfig
-  onBeforeSummarize?: BeforeSummarizeCallback
-  getModelLimit?: GetModelLimitCallback
-}
-
-interface MessageInfo {
-  id: string
-  role: string
-  sessionID: string
-  providerID?: string
-  modelID?: string
-  tokens?: TokenInfo
-  summary?: boolean
-  finish?: boolean
-}
-
-interface MessageWrapper {
-  info: MessageInfo
-}
-
-const CLAUDE_MODEL_PATTERN = /claude-(opus|sonnet|haiku)/i
-const CLAUDE_DEFAULT_CONTEXT_LIMIT =
-  process.env.ANTHROPIC_1M_CONTEXT === "true" ||
-  process.env.VERTEX_ANTHROPIC_1M_CONTEXT === "true"
-    ? 1_000_000
-    : 200_000
-
-function isSupportedModel(modelID: string): boolean {
-  return CLAUDE_MODEL_PATTERN.test(modelID)
-}
-
-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 createState(): PreemptiveCompactionState {
-  return {
-    lastCompactionTime: new Map(),
-    compactionInProgress: new Set(),
-  }
-}
-
-export function createPreemptiveCompactionHook(
-  ctx: PluginInput,
-  options?: PreemptiveCompactionOptions
-) {
-  const experimental = options?.experimental
-  const onBeforeSummarize = options?.onBeforeSummarize
-  const getModelLimit = options?.getModelLimit
-  // Preemptive compaction is now enabled by default.
-  // Backward compatibility: explicit false in experimental config disables the hook.
-  const explicitlyDisabled = experimental?.preemptive_compaction === false
-  const threshold = experimental?.preemptive_compaction_threshold ?? DEFAULT_THRESHOLD
-
-  if (explicitlyDisabled) {
-    return { event: async () => {} }
-  }
-
-  const state = createState()
-
-  const checkAndTriggerCompaction = async (
-    sessionID: string,
-    lastAssistant: MessageInfo
-  ): Promise<void> => {
-    if (state.compactionInProgress.has(sessionID)) return
-
-    const lastCompaction = state.lastCompactionTime.get(sessionID) ?? 0
-    if (Date.now() - lastCompaction < COMPACTION_COOLDOWN_MS) return
-
-    if (lastAssistant.summary === true) return
-
-    const tokens = lastAssistant.tokens
-    if (!tokens) return
-
-    const modelID = lastAssistant.modelID ?? ""
-    const providerID = lastAssistant.providerID ?? ""
-
-    if (!isSupportedModel(modelID)) {
-      log("[preemptive-compaction] skipping unsupported model", { modelID })
-      return
-    }
-
-    const configLimit = getModelLimit?.(providerID, modelID)
-    const contextLimit = configLimit ?? CLAUDE_DEFAULT_CONTEXT_LIMIT
-    const totalUsed = tokens.input + tokens.cache.read + tokens.output
-
-    if (totalUsed < MIN_TOKENS_FOR_COMPACTION) return
-
-    const usageRatio = totalUsed / contextLimit
-
-    log("[preemptive-compaction] checking", {
-      sessionID,
-      totalUsed,
-      contextLimit,
-      usageRatio: usageRatio.toFixed(2),
-      threshold,
-    })
-
-    if (usageRatio < threshold) return
-
-    state.compactionInProgress.add(sessionID)
-    state.lastCompactionTime.set(sessionID, Date.now())
-
-    if (!providerID || !modelID) {
-      state.compactionInProgress.delete(sessionID)
-      return
-    }
-
-    await ctx.client.tui
-      .showToast({
-        body: {
-          title: "Preemptive Compaction",
-          message: `Context at ${(usageRatio * 100).toFixed(0)}% - compacting to prevent overflow...`,
-          variant: "warning",
-          duration: 3000,
-        },
-      })
-      .catch(() => {})
-
-    log("[preemptive-compaction] triggering compaction", { sessionID, usageRatio })
-
-    try {
-      if (onBeforeSummarize) {
-        await onBeforeSummarize({
-          sessionID,
-          providerID,
-          modelID,
-          usageRatio,
-          directory: ctx.directory,
-        })
-      }
-
-      const summarizeBody = { providerID, modelID, auto: true }
-      await ctx.client.session.summarize({
-        path: { id: sessionID },
-        body: summarizeBody as never,
-        query: { directory: ctx.directory },
-      })
-
-      await ctx.client.tui
-        .showToast({
-          body: {
-            title: "Compaction Complete",
-            message: "Session compacted successfully. Resuming...",
-            variant: "success",
-            duration: 2000,
-          },
-        })
-        .catch(() => {})
-
-      state.compactionInProgress.delete(sessionID)
-      return
-    } catch (err) {
-      log("[preemptive-compaction] compaction failed", { sessionID, error: err })
-    } finally {
-      state.compactionInProgress.delete(sessionID)
-    }
-  }
-
-  const eventHandler = async ({ event }: { event: { type: string; properties?: unknown } }) => {
-    const props = event.properties as Record<string, unknown> | undefined
-
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info as { id?: string } | undefined
-      if (sessionInfo?.id) {
-        state.lastCompactionTime.delete(sessionInfo.id)
-        state.compactionInProgress.delete(sessionInfo.id)
-      }
-      return
-    }
-
-    if (event.type === "message.updated") {
-      const info = props?.info as MessageInfo | undefined
-      if (!info) return
-
-      if (info.role !== "assistant" || !info.finish) return
-
-      const sessionID = info.sessionID
-      if (!sessionID) return
-
-      await checkAndTriggerCompaction(sessionID, info)
-      return
-    }
-
-    if (event.type === "session.idle") {
-      const sessionID = props?.sessionID as string | undefined
-      if (!sessionID) return
-
-      try {
-        const resp = await ctx.client.session.messages({
-          path: { id: sessionID },
-          query: { directory: ctx.directory },
-        })
-
-        const messages = (resp.data ?? resp) as MessageWrapper[]
-        const assistants = messages
-          .filter((m) => m.info.role === "assistant")
-          .map((m) => m.info)
-
-        if (assistants.length === 0) return
-
-        const lastAssistant = assistants[assistants.length - 1]
-
-        if (!lastAssistant.providerID || !lastAssistant.modelID) {
-          const messageDir = getMessageDir(sessionID)
-          const storedMessage = messageDir ? findNearestMessageWithFields(messageDir) : null
-          if (storedMessage?.model?.providerID && storedMessage?.model?.modelID) {
-            lastAssistant.providerID = storedMessage.model.providerID
-            lastAssistant.modelID = storedMessage.model.modelID
-            log("[preemptive-compaction] using stored message model info", {
-              sessionID,
-              providerID: lastAssistant.providerID,
-              modelID: lastAssistant.modelID,
-            })
-          }
-        }
-
-        await checkAndTriggerCompaction(sessionID, lastAssistant)
-      } catch {}
-    }
-  }
-
-  return {
-    event: eventHandler,
-  }
-}

src/hooks/preemptive-compaction/types.ts

@@ -1,16 +0,0 @@
-export interface PreemptiveCompactionState {
-  lastCompactionTime: Map<string, number>
-  compactionInProgress: Set<string>
-}
-
-export interface TokenInfo {
-  input: number
-  output: number
-  reasoning: number
-  cache: { read: number; write: number }
-}
-
-export interface ModelLimits {
-  context: number
-  output: number
-}