feat(agent-teams): register team tools behind experimental.team_system flag

- Create barrel export in src/tools/agent-teams/index.ts
- Create factory function createAgentTeamsTools() in tools.ts
- Register 7 team tools in tool-registry.ts behind experimental flag
- Add integration tests for tool registration gating
- Fix type errors: add TeamTaskStatus, update schemas
- Task 13 complete

.github/workflows/ci.yml

@@ -52,32 +52,12 @@ jobs:
           bun test src/hooks/atlas
           bun test src/hooks/compaction-context-injector
           bun test src/features/tmux-subagent
-          bun test src/cli/doctor/formatter.test.ts
-          bun test src/cli/doctor/format-default.test.ts
-          bun test src/tools/call-omo-agent/sync-executor.test.ts
-          bun test src/tools/call-omo-agent/session-creator.test.ts
-          bun test src/tools/session-manager
-          bun test src/features/opencode-skill-loader/loader.test.ts
 
       - name: Run remaining tests
         run: |
-          # Enumerate subdirectories/files explicitly to EXCLUDE mock-heavy files
-          # that were already run in isolation above.
-          # Excluded from src/cli: doctor/formatter.test.ts, doctor/format-default.test.ts
-          # Excluded from src/tools: call-omo-agent/sync-executor.test.ts, call-omo-agent/session-creator.test.ts, session-manager (all)
-          bun test bin script src/config src/mcp src/index.test.ts \
-            src/agents src/shared \
-            src/cli/run src/cli/config-manager src/cli/mcp-oauth \
-            src/cli/index.test.ts src/cli/install.test.ts src/cli/model-fallback.test.ts \
-            src/cli/config-manager.test.ts \
-            src/cli/doctor/runner.test.ts src/cli/doctor/checks \
-            src/tools/ast-grep src/tools/background-task src/tools/delegate-task \
-            src/tools/glob src/tools/grep src/tools/interactive-bash \
-            src/tools/look-at src/tools/lsp \
-            src/tools/skill src/tools/skill-mcp src/tools/slashcommand src/tools/task \
-            src/tools/call-omo-agent/background-agent-executor.test.ts \
-            src/tools/call-omo-agent/background-executor.test.ts \
-            src/tools/call-omo-agent/subagent-session-creator.test.ts \
+          # Run all other tests (mock-heavy ones are re-run but that's acceptable)
+          bun test bin script src/cli src/config src/mcp src/index.test.ts \
+            src/agents src/tools src/shared \
             src/hooks/anthropic-context-window-limit-recovery \
             src/hooks/claude-code-compatibility \
             src/hooks/context-injection \
@@ -90,11 +70,7 @@ jobs:
             src/features/builtin-skills \
             src/features/claude-code-session-state \
             src/features/hook-message-injector \
-            src/features/opencode-skill-loader/config-source-discovery.test.ts \
-            src/features/opencode-skill-loader/merger.test.ts \
-            src/features/opencode-skill-loader/skill-content.test.ts \
-            src/features/opencode-skill-loader/blocking.test.ts \
-            src/features/opencode-skill-loader/async-loader.test.ts \
+            src/features/opencode-skill-loader \
             src/features/skill-mcp-manager
 
   typecheck:

.github/workflows/publish.yml

@@ -51,33 +51,13 @@ jobs:
           # Run them in separate processes to prevent cross-file contamination
           bun test src/plugin-handlers
           bun test src/hooks/atlas
-          bun test src/hooks/compaction-context-injector
           bun test src/features/tmux-subagent
-          bun test src/cli/doctor/formatter.test.ts
-          bun test src/cli/doctor/format-default.test.ts
-          bun test src/tools/call-omo-agent/sync-executor.test.ts
-          bun test src/tools/call-omo-agent/session-creator.test.ts
-          bun test src/features/opencode-skill-loader/loader.test.ts
 
       - name: Run remaining tests
         run: |
-          # Enumerate subdirectories/files explicitly to EXCLUDE mock-heavy files
-          # that were already run in isolation above.
-          # Excluded from src/cli: doctor/formatter.test.ts, doctor/format-default.test.ts
-          # Excluded from src/tools: call-omo-agent/sync-executor.test.ts, call-omo-agent/session-creator.test.ts
-          bun test bin script src/config src/mcp src/index.test.ts \
-            src/agents src/shared \
-            src/cli/run src/cli/config-manager src/cli/mcp-oauth \
-            src/cli/index.test.ts src/cli/install.test.ts src/cli/model-fallback.test.ts \
-            src/cli/config-manager.test.ts \
-            src/cli/doctor/runner.test.ts src/cli/doctor/checks \
-            src/tools/ast-grep src/tools/background-task src/tools/delegate-task \
-            src/tools/glob src/tools/grep src/tools/interactive-bash \
-            src/tools/look-at src/tools/lsp src/tools/session-manager \
-            src/tools/skill src/tools/skill-mcp src/tools/slashcommand src/tools/task \
-            src/tools/call-omo-agent/background-agent-executor.test.ts \
-            src/tools/call-omo-agent/background-executor.test.ts \
-            src/tools/call-omo-agent/subagent-session-creator.test.ts \
+          # Run all other tests (mock-heavy ones are re-run but that's acceptable)
+          bun test bin script src/cli src/config src/mcp src/index.test.ts \
+            src/agents src/tools src/shared \
             src/hooks/anthropic-context-window-limit-recovery \
             src/hooks/claude-code-compatibility \
             src/hooks/context-injection \
@@ -90,11 +70,7 @@ jobs:
             src/features/builtin-skills \
             src/features/claude-code-session-state \
             src/features/hook-message-injector \
-            src/features/opencode-skill-loader/config-source-discovery.test.ts \
-            src/features/opencode-skill-loader/merger.test.ts \
-            src/features/opencode-skill-loader/skill-content.test.ts \
-            src/features/opencode-skill-loader/blocking.test.ts \
-            src/features/opencode-skill-loader/async-loader.test.ts \
+            src/features/opencode-skill-loader \
             src/features/skill-mcp-manager
 
   typecheck:

.opencode/command/remove-deadcode.md

@@ -3,216 +3,337 @@ description: Remove unused code from this project with ultrawork mode, LSP-verif
 ---
 
 <command-instruction>
+You are a dead code removal specialist. Execute the FULL dead code removal workflow using ultrawork mode.
 
-Dead code removal via massively parallel deep agents. You are the ORCHESTRATOR — you scan, verify, batch, then delegate ALL removals to parallel agents.
+Your core weapon: **LSP FindReferences**. If a symbol has ZERO external references, it's dead. Remove it.
 
-<rules>
-- **LSP is law.** Verify with `LspFindReferences(includeDeclaration=false)` before ANY removal decision.
-- **Never remove entry points.** `src/index.ts`, `src/cli/index.ts`, test files, config files, `packages/` — off-limits.
-- **You do NOT remove code yourself.** You scan, verify, batch, then fire deep agents. They do the work.
-</rules>
+## CRITICAL RULES
 
-<false-positive-guards>
-NEVER mark as dead:
-- Symbols in `src/index.ts` or barrel `index.ts` re-exports
-- Symbols referenced in test files (tests are valid consumers)
-- Symbols with `@public` / `@api` JSDoc tags
-- Hook factories (`createXXXHook`), tool factories (`createXXXTool`), agent definitions in `agentSources`
-- Command templates, skill definitions, MCP configs
-- Symbols in `package.json` exports
-</false-positive-guards>
+1. **LSP is law.** Never guess. Always verify with `LspFindReferences` before removing ANYTHING.
+2. **One removal = one commit.** Every dead code removal gets its own atomic commit.
+3. **Test after every removal.** Run `bun test` after each. If it fails, REVERT and skip.
+4. **Leaf-first order.** Remove deepest unused symbols first, then work up the dependency chain. Removing a leaf may expose new dead code upstream.
+5. **Never remove entry points.** `src/index.ts`, `src/cli/index.ts`, test files, config files, and files in `packages/` are off-limits unless explicitly targeted.
 
 ---
 
-## PHASE 1: SCAN — Find Dead Code Candidates
-
-Run ALL of these in parallel:
-
-<parallel-scan>
-
-**TypeScript strict mode (your primary scanner — run this FIRST):**
-```bash
-bunx tsc --noEmit --noUnusedLocals --noUnusedParameters 2>&1
-```
-This gives you the definitive list of unused locals, imports, parameters, and types with exact file:line locations.
-
-**Explore agents (fire ALL simultaneously as background):**
+## STEP 0: REGISTER TODO LIST (MANDATORY FIRST ACTION)
 
 ```
-task(subagent_type="explore", run_in_background=true, load_skills=[],
-  description="Find orphaned files",
-  prompt="Find files in src/ NOT imported by any other file. Check all import statements. EXCLUDE: index.ts, *.test.ts, entry points, .md, packages/. Return: file paths.")
-
-task(subagent_type="explore", run_in_background=true, load_skills=[],
-  description="Find unused exported symbols",
-  prompt="Find exported functions/types/constants in src/ that are never imported by other files. Cross-reference: for each export, grep the symbol name across src/ — if it only appears in its own file, it's a candidate. EXCLUDE: src/index.ts exports, test files. Return: file path, line, symbol name, export type.")
+TodoWrite([
+  {"id": "scan", "content": "PHASE 1: Scan codebase for dead code candidates using LSP + explore agents", "status": "pending", "priority": "high"},
+  {"id": "verify", "content": "PHASE 2: Verify each candidate with LspFindReferences - zero false positives", "status": "pending", "priority": "high"},
+  {"id": "plan", "content": "PHASE 3: Plan removal order (leaf-first dependency order)", "status": "pending", "priority": "high"},
+  {"id": "remove", "content": "PHASE 4: Remove dead code one-by-one (remove -> test -> commit loop)", "status": "pending", "priority": "high"},
+  {"id": "final", "content": "PHASE 5: Final verification - full test suite + build + typecheck", "status": "pending", "priority": "high"}
+])
 ```
 
-</parallel-scan>
-
-Collect all results into a master candidate list.
-
 ---
 
-## PHASE 2: VERIFY — LSP Confirmation (Zero False Positives)
+## PHASE 1: SCAN FOR DEAD CODE CANDIDATES
 
-For EACH candidate from Phase 1:
+**Mark scan as in_progress.**
+
+### 1.1: Launch Parallel Explore Agents (ALL BACKGROUND)
+
+Fire ALL simultaneously:
+
+```
+// Agent 1: Find all exported symbols
+task(subagent_type="explore", run_in_background=true,
+  prompt="Find ALL exported functions, classes, types, interfaces, and constants across src/.
+  List each with: file path, line number, symbol name, export type (named/default).
+  EXCLUDE: src/index.ts root exports, test files.
+  Return as structured list.")
+
+// Agent 2: Find potentially unused files
+task(subagent_type="explore", run_in_background=true,
+  prompt="Find files in src/ that are NOT imported by any other file.
+  Check import/require statements across the entire codebase.
+  EXCLUDE: index.ts files, test files, entry points, config files, .md files.
+  Return list of potentially orphaned files.")
+
+// Agent 3: Find unused imports within files
+task(subagent_type="explore", run_in_background=true,
+  prompt="Find unused imports across src/**/*.ts files.
+  Look for import statements where the imported symbol is never referenced in the file body.
+  Return: file path, line number, imported symbol name.")
+
+// Agent 4: Find functions/variables only used in their own declaration
+task(subagent_type="explore", run_in_background=true,
+  prompt="Find private/non-exported functions, variables, and types in src/**/*.ts that appear
+  to have zero usage beyond their declaration. Return: file path, line number, symbol name.")
+```
+
+### 1.2: Direct AST-Grep Scans (WHILE AGENTS RUN)
 
 ```typescript
+// Find unused imports pattern
+ast_grep_search(pattern="import { $NAME } from '$PATH'", lang="typescript", paths=["src/"])
+
+// Find empty export objects
+ast_grep_search(pattern="export {}", lang="typescript", paths=["src/"])
+```
+
+### 1.3: Collect All Results
+
+Collect background agent results. Compile into a master candidate list:
+
+```
+## DEAD CODE CANDIDATES
+
+| # | File | Line | Symbol | Type | Confidence |
+|---|------|------|--------|------|------------|
+| 1 | src/foo.ts | 42 | unusedFunc | function | HIGH |
+| 2 | src/bar.ts | 10 | OldType | type | MEDIUM |
+```
+
+**Mark scan as completed.**
+
+---
+
+## PHASE 2: VERIFY WITH LSP (ZERO FALSE POSITIVES)
+
+**Mark verify as in_progress.**
+
+For EVERY candidate from Phase 1, run this verification:
+
+### 2.1: The LSP Verification Protocol
+
+For each candidate symbol:
+
+```typescript
+// Step 1: Find the symbol's exact position
+LspDocumentSymbols(filePath)  // Get line/character of the symbol
+
+// Step 2: Find ALL references across the ENTIRE workspace
 LspFindReferences(filePath, line, character, includeDeclaration=false)
-// 0 references → CONFIRMED dead
-// 1+ references → NOT dead, drop from list
+// includeDeclaration=false → only counts USAGES, not the definition itself
+
+// Step 3: Evaluate
+// 0 references → CONFIRMED DEAD CODE
+// 1+ references → NOT dead, remove from candidate list
 ```
 
-Also apply the false-positive-guards above. Produce a confirmed list:
+### 2.2: False Positive Guards
+
+**NEVER mark as dead code if:**
+- Symbol is in `src/index.ts` (package entry point)
+- Symbol is in any `index.ts` that re-exports (barrel file check: look if it's re-exported)
+- Symbol is referenced in test files (tests are valid consumers)
+- Symbol has `@public` or `@api` JSDoc tags
+- Symbol is in a file listed in `package.json` exports
+- Symbol is a hook factory (`createXXXHook`) registered in `src/index.ts`
+- Symbol is a tool factory (`createXXXTool`) registered in tool loading
+- Symbol is an agent definition registered in `agentSources`
+- File is a command template, skill definition, or MCP config
+
+### 2.3: Build Confirmed Dead Code List
+
+After verification, produce:
 
 ```
-| # | File | Symbol | Type | Action |
-|---|------|--------|------|--------|
-| 1 | src/foo.ts:42 | unusedFunc | function | REMOVE |
-| 2 | src/bar.ts:10 | OldType | type | REMOVE |
-| 3 | src/baz.ts:7 | ctx | parameter | PREFIX _ |
+## CONFIRMED DEAD CODE (LSP-verified, 0 external references)
+
+| # | File | Line | Symbol | Type | Safe to Remove |
+|---|------|------|--------|------|----------------|
+| 1 | src/foo.ts | 42 | unusedFunc | function | YES |
 ```
 
-**Action types:**
-- `REMOVE` — delete the symbol/import/file entirely
-- `PREFIX _` — unused function parameter required by signature → rename to `_paramName`
+**If ZERO confirmed dead code found: Report "No dead code found" and STOP.**
 
-If ZERO confirmed: report "No dead code found" and STOP.
+**Mark verify as completed.**
 
 ---
 
-## PHASE 3: BATCH — Group by File for Conflict-Free Parallelism
+## PHASE 3: PLAN REMOVAL ORDER
 
-<batching-rules>
+**Mark plan as in_progress.**
 
-**Goal: maximize parallel agents with ZERO git conflicts.**
+### 3.1: Dependency Analysis
 
-1. Group confirmed dead code items by FILE PATH
-2. All items in the SAME file go to the SAME batch (prevents two agents editing the same file)
-3. If a dead FILE (entire file deletion) exists, it's its own batch
-4. Target 5-15 batches. If fewer than 5 items total, use 1 batch per item.
+For each confirmed dead symbol:
+1. Check if removing it would expose other dead code
+2. Check if other dead symbols depend on this one
+3. Build removal dependency graph
+
+### 3.2: Order by Leaf-First
 
-**Example batching:**
 ```
-Batch A: [src/hooks/foo/hook.ts — 3 unused imports]
-Batch B: [src/features/bar/manager.ts — 2 unused constants, 1 dead function]
-Batch C: [src/tools/baz/tool.ts — 1 unused param, src/tools/baz/types.ts — 1 unused type]
-Batch D: [src/dead-file.ts — entire file deletion]
+Removal Order:
+1. [Leaf symbols - no other dead code depends on them]
+2. [Intermediate symbols - depended on only by already-removed dead code]
+3. [Dead files - entire files with no live exports]
 ```
 
-Files in the same directory CAN be batched together (they won't conflict as long as no two agents edit the same file). Maximize batch count for parallelism.
+### 3.3: Register Granular Todos
 
-</batching-rules>
+Create one todo per removal:
+
+```
+TodoWrite([
+  {"id": "remove-1", "content": "Remove unusedFunc from src/foo.ts:42", "status": "pending", "priority": "high"},
+  {"id": "remove-2", "content": "Remove OldType from src/bar.ts:10", "status": "pending", "priority": "high"},
+  // ... one per confirmed dead symbol
+])
+```
+
+**Mark plan as completed.**
 
 ---
 
-## PHASE 4: EXECUTE — Fire Parallel Deep Agents
+## PHASE 4: ITERATIVE REMOVAL LOOP
 
-For EACH batch, fire a deep agent:
+**Mark remove as in_progress.**
 
-```
-task(
-  category="deep",
-  load_skills=["typescript-programmer", "git-master"],
-  run_in_background=true,
-  description="Remove dead code batch N: [brief description]",
-  prompt="[see template below]"
-)
+For EACH dead code item, execute this exact loop:
+
+### 4.1: Pre-Removal Check
+
+```typescript
+// Re-verify it's still dead (previous removals may have changed things)
+LspFindReferences(filePath, line, character, includeDeclaration=false)
+// If references > 0 now → SKIP (previous removal exposed a new consumer)
 ```
 
-<agent-prompt-template>
+### 4.2: Remove the Dead Code
 
-Every deep agent gets this prompt structure (fill in the specifics per batch):
+Use appropriate tool:
 
-```
-## TASK: Remove dead code from [file list]
-
-## DEAD CODE TO REMOVE
-
-### [file path] line [N]
-- Symbol: `[name]` — [type: unused import / unused constant / unused function / unused parameter / dead file]
-- Action: [REMOVE entirely / REMOVE from import list / PREFIX with _]
-
-### [file path] line [N]
-- ...
-
-## PROTOCOL
-
-1. Read each file to understand exact syntax at the target lines
-2. For each symbol, run LspFindReferences to RE-VERIFY it's still dead (another agent may have changed things)
-3. Apply the change:
-   - Unused import (only symbol in line): remove entire import line
-   - Unused import (one of many): remove only that symbol from the import list
-   - Unused constant/function/type: remove the declaration. Clean up trailing blank lines.
-   - Unused parameter: prefix with `_` (do NOT remove — required by signature)
-   - Dead file: delete with `rm`
-4. After ALL edits in this batch, run: `bun run typecheck`
-5. If typecheck fails: `git checkout -- [files]` and report failure
-6. If typecheck passes: stage ONLY your files and commit:
-   `git add [your-specific-files] && git commit -m "refactor: remove dead code from [brief file list]"`
-7. Report what you removed and the commit hash
-
-## CRITICAL
-- Stage ONLY your batch's files (`git add [specific files]`). NEVER `git add -A` — other agents are working in parallel.
-- If typecheck fails after your edits, REVERT all changes and report. Do not attempt to fix.
-- Pre-existing test failures in other files are expected. Only typecheck matters for your batch.
+**For unused imports:**
+```typescript
+Edit(filePath, oldString="import { deadSymbol } from '...';\n", newString="")
+// Or if it's one of many imports, remove just the symbol from the import list
 ```
 
-</agent-prompt-template>
+**For unused functions/classes/types:**
+```typescript
+// Read the full symbol extent first
+Read(filePath, offset=startLine, limit=endLine-startLine+1)
+// Then remove it
+Edit(filePath, oldString="[full symbol text]", newString="")
+```
 
-Fire ALL batches simultaneously. Wait for all to complete.
+**For dead files:**
+```bash
+# Only after confirming ZERO imports point to this file
+rm "path/to/dead-file.ts"
+```
+
+**After removal, also clean up:**
+- Remove any imports that were ONLY used by the removed code
+- Remove any now-empty import statements
+- Fix any trailing whitespace / double blank lines left behind
+
+### 4.3: Post-Removal Verification
+
+```typescript
+// 1. LSP diagnostics on changed file
+LspDiagnostics(filePath, severity="error")
+// Must be clean (or only pre-existing errors)
+
+// 2. Run tests
+bash("bun test")
+// Must pass
+
+// 3. Typecheck
+bash("bun run typecheck")
+// Must pass
+```
+
+### 4.4: Handle Failures
+
+If ANY verification fails:
+1. **REVERT** the change immediately (`git checkout -- [file]`)
+2. Mark this removal todo as `cancelled` with note: "Removal caused [error]. Skipped."
+3. Proceed to next item
+
+### 4.5: Commit
+
+```bash
+git add [changed-files]
+git commit -m "refactor: remove unused [symbolType] [symbolName] from [filePath]"
+```
+
+Mark this removal todo as `completed`.
+
+### 4.6: Re-scan After Removal
+
+After removing a symbol, check if its removal exposed NEW dead code:
+- Were there imports that only existed to serve the removed symbol?
+- Are there other symbols in the same file now unreferenced?
+
+If new dead code is found, add it to the removal queue.
+
+**Repeat 4.1-4.6 for every item. Mark remove as completed when done.**
 
 ---
 
 ## PHASE 5: FINAL VERIFICATION
 
-After ALL agents complete:
+**Mark final as in_progress.**
 
+### 5.1: Full Test Suite
 ```bash
-bun run typecheck   # must pass
-bun test            # note any NEW failures vs pre-existing
-bun run build       # must pass
+bun test
 ```
 
-Produce summary:
+### 5.2: Full Typecheck
+```bash
+bun run typecheck
+```
+
+### 5.3: Full Build
+```bash
+bun run build
+```
+
+### 5.4: Summary Report
 
 ```markdown
 ## Dead Code Removal Complete
 
 ### Removed
-| # | Symbol | File | Type | Commit | Agent |
-|---|--------|------|------|--------|-------|
-| 1 | unusedFunc | src/foo.ts | function | abc1234 | Batch A |
+| # | Symbol | File | Type | Commit |
+|---|--------|------|------|--------|
+| 1 | unusedFunc | src/foo.ts | function | abc1234 |
 
-### Skipped (agent reported failure)
+### Skipped (caused failures)
 | # | Symbol | File | Reason |
 |---|--------|------|--------|
+| 1 | riskyFunc | src/bar.ts | Test failure: [details] |
 
 ### Verification
-- Typecheck: PASS/FAIL
-- Tests: X passing, Y failing (Z pre-existing)
-- Build: PASS/FAIL
-- Total removed: N symbols across M files
+- Tests: PASSED (X/Y passing)
+- Typecheck: CLEAN
+- Build: SUCCESS
+- Total dead code removed: N symbols across M files
 - Total commits: K atomic commits
-- Parallel agents used: P
 ```
 
+**Mark final as completed.**
+
 ---
 
 ## SCOPE CONTROL
 
-If `$ARGUMENTS` is provided, narrow the scan:
-- File path → only that file
-- Directory → only that directory
-- Symbol name → only that symbol
-- `all` or empty → full project scan (default)
+**If $ARGUMENTS is provided**, narrow the scan to the specified scope:
+- File path: Only scan that file
+- Directory: Only scan that directory
+- Symbol name: Only check that specific symbol
+- "all" or empty: Full project scan (default)
 
 ## ABORT CONDITIONS
 
-STOP and report if:
-- More than 50 candidates found (ask user to narrow scope or confirm proceeding)
+**STOP and report to user if:**
+- 3 consecutive removals cause test failures
 - Build breaks and cannot be fixed by reverting
+- More than 50 candidates found (ask user to narrow scope)
+
+## LANGUAGE
+
+Use English for commit messages and technical output.
 
 </command-instruction>
 

AGENTS.md

@@ -1,8 +1,8 @@
 # PROJECT KNOWLEDGE BASE
 
-**Generated:** 2026-02-16T14:58:00+09:00
-**Commit:** 28cd34c3
-**Branch:** fuck-v1.2
+**Generated:** 2026-02-10T14:44:00+09:00
+**Commit:** b538806d
+**Branch:** dev
 
 ---
 
@@ -102,32 +102,32 @@ Oh-My-OpenCode is a **plugin for OpenCode**. You will frequently need to examine
 
 ## OVERVIEW
 
-OpenCode plugin (oh-my-opencode): multi-model agent orchestration with 11 specialized agents, 41 lifecycle hooks across 7 event types, 26 tools (LSP, AST-Grep, delegation, task management), full Claude Code compatibility layer, 4-scope skill loading, background agent concurrency, tmux integration, and 3-tier MCP system. "oh-my-zsh" for OpenCode.
+OpenCode plugin (v3.4.0): multi-model agent orchestration with 11 specialized agents (Claude Opus 4.6, GPT-5.3 Codex, Gemini 3 Flash, GLM-4.7, Grok). 41 lifecycle hooks across 7 event types, 25+ tools (LSP, AST-Grep, delegation, task management), full Claude Code compatibility layer. "oh-my-zsh" for OpenCode.
 
 ## STRUCTURE
 
 ```
 oh-my-opencode/
 ├── src/
-│   ├── agents/              # 11 AI agents — see src/agents/AGENTS.md
-│   ├── hooks/               # 41 lifecycle hooks — see src/hooks/AGENTS.md
-│   ├── tools/               # 26 tools — see src/tools/AGENTS.md
-│   ├── features/            # Background agents, skills, CC compat — see src/features/AGENTS.md
-│   ├── shared/              # Cross-cutting utilities — see src/shared/AGENTS.md
-│   ├── cli/                 # CLI installer, doctor — see src/cli/AGENTS.md
-│   ├── mcp/                 # Built-in MCPs — see src/mcp/AGENTS.md
-│   ├── config/              # Zod schema — see src/config/AGENTS.md
-│   ├── plugin-handlers/     # Config loading pipeline — see src/plugin-handlers/AGENTS.md
+│   ├── agents/              # 11 AI agents - see src/agents/AGENTS.md
+│   ├── hooks/               # 41 lifecycle hooks - see src/hooks/AGENTS.md
+│   ├── tools/               # 25+ tools - see src/tools/AGENTS.md
+│   ├── features/            # Background agents, skills, CC compat - see src/features/AGENTS.md
+│   ├── shared/              # 84 cross-cutting utilities - see src/shared/AGENTS.md
+│   ├── cli/                 # CLI installer, doctor - see src/cli/AGENTS.md
+│   ├── mcp/                 # Built-in MCPs - see src/mcp/AGENTS.md
+│   ├── config/              # Zod schema - see src/config/AGENTS.md
+│   ├── plugin-handlers/     # Config loading - see src/plugin-handlers/AGENTS.md
 │   ├── plugin/              # Plugin interface composition (21 files)
-│   ├── index.ts             # Main plugin entry (106 lines)
+│   ├── index.ts             # Main plugin entry (88 lines)
 │   ├── create-hooks.ts      # Hook creation coordination (62 lines)
 │   ├── create-managers.ts   # Manager initialization (80 lines)
 │   ├── create-tools.ts      # Tool registry composition (54 lines)
 │   ├── plugin-interface.ts  # Plugin interface assembly (66 lines)
-│   ├── plugin-config.ts     # Config loading orchestration (180 lines)
-│   └── plugin-state.ts      # Model cache state (12 lines)
+│   ├── plugin-config.ts     # Config loading orchestration
+│   └── plugin-state.ts      # Model cache state
 ├── script/                  # build-schema.ts, build-binaries.ts, publish.ts, generate-changelog.ts
-├── packages/                # 11 platform-specific binary packages
+├── packages/                # 7 platform-specific binary packages
 └── dist/                    # Build output (ESM + .d.ts)
 ```
 
@@ -143,7 +143,7 @@ OhMyOpenCodePlugin(ctx)
   6. createManagers(ctx, config, tmux, cache)  → TmuxSessionManager, BackgroundManager, SkillMcpManager, ConfigHandler
   7. createTools(ctx, config, managers)         → filteredTools, mergedSkills, availableSkills, availableCategories
   8. createHooks(ctx, config, backgroundMgr)   → 41 hooks (core + continuation + skill)
-  9. createPluginInterface(...)                 → 7 OpenCode hook handlers
+  9. createPluginInterface(...)                 → tool, chat.params, chat.message, event, tool.execute.before/after
  10. Return plugin with experimental.session.compacting
 ```
 
@@ -159,7 +159,7 @@ OhMyOpenCodePlugin(ctx)
 | Add command | `src/features/builtin-commands/` | Add template + register in commands.ts |
 | Config schema | `src/config/schema/` | 21 schema component files, run `bun run build:schema` |
 | Plugin config | `src/plugin-handlers/config-handler.ts` | JSONC loading, merging, migration |
-| Background agents | `src/features/background-agent/` | manager.ts (1701 lines) |
+| Background agents | `src/features/background-agent/` | manager.ts (1646 lines) |
 | Orchestrator | `src/hooks/atlas/` | Main orchestration hook (1976 lines) |
 | Delegation | `src/tools/delegate-task/` | Category routing (constants.ts 569 lines) |
 | Task system | `src/features/claude-tasks/` | Task schema, storage, todo sync |
@@ -174,7 +174,7 @@ OhMyOpenCodePlugin(ctx)
 
 **Rules:**
 - NEVER write implementation before test
-- NEVER delete failing tests — fix the code
+- NEVER delete failing tests - fix the code
 - Test file: `*.test.ts` alongside source (176 test files)
 - BDD comments: `//#given`, `//#when`, `//#then`
 
@@ -185,7 +185,7 @@ OhMyOpenCodePlugin(ctx)
 - **Build**: `bun build` (ESM) + `tsc --emitDeclarationOnly`
 - **Exports**: Barrel pattern via index.ts
 - **Naming**: kebab-case dirs, `createXXXHook`/`createXXXTool` factories
-- **Testing**: BDD comments, 176 test files, 1130 TypeScript files
+- **Testing**: BDD comments, 176 test files, 117k+ lines TypeScript
 - **Temperature**: 0.1 for code agents, max 0.3
 - **Modular architecture**: 200 LOC hard limit per file (prompt strings exempt)
 
@@ -193,24 +193,24 @@ OhMyOpenCodePlugin(ctx)
 
 | Category | Forbidden |
 |----------|-----------|
-| Package Manager | npm, yarn — Bun exclusively |
-| Types | @types/node — use bun-types |
-| File Ops | mkdir/touch/rm/cp/mv in code — use bash tool |
-| Publishing | Direct `bun publish` — GitHub Actions only |
-| Versioning | Local version bump — CI manages |
+| Package Manager | npm, yarn - Bun exclusively |
+| Types | @types/node - use bun-types |
+| File Ops | mkdir/touch/rm/cp/mv in code - use bash tool |
+| Publishing | Direct `bun publish` - GitHub Actions only |
+| Versioning | Local version bump - CI manages |
 | Type Safety | `as any`, `@ts-ignore`, `@ts-expect-error` |
 | Error Handling | Empty catch blocks |
 | Testing | Deleting failing tests, writing implementation before test |
-| Agent Calls | Sequential — use `task` parallel |
-| Hook Logic | Heavy PreToolUse — slows every call |
+| Agent Calls | Sequential - use `task` parallel |
+| Hook Logic | Heavy PreToolUse - slows every call |
 | Commits | Giant (3+ files), separate test from impl |
 | Temperature | >0.3 for code agents |
-| Trust | Agent self-reports — ALWAYS verify |
+| Trust | Agent self-reports - ALWAYS verify |
 | Git | `git add -i`, `git rebase -i` (no interactive input) |
 | Git | Skip hooks (--no-verify), force push without request |
-| Bash | `sleep N` — use conditional waits |
-| Bash | `cd dir && cmd` — use workdir parameter |
-| Files | Catch-all utils.ts/helpers.ts — name by purpose |
+| Bash | `sleep N` - use conditional waits |
+| Bash | `cd dir && cmd` - use workdir parameter |
+| Files | Catch-all utils.ts/helpers.ts - name by purpose |
 
 ## AGENT MODELS
 
@@ -230,7 +230,7 @@ OhMyOpenCodePlugin(ctx)
 
 ## OPENCODE PLUGIN API
 
-Plugin SDK from `@opencode-ai/plugin`. Plugin = `async (PluginInput) => Hooks`.
+Plugin SDK from `@opencode-ai/plugin` (v1.1.19). Plugin = `async (PluginInput) => Hooks`.
 
 | Hook | Purpose |
 |------|---------|
@@ -283,7 +283,7 @@ bun run build:schema   # Regenerate JSON schema
 
 | File | Lines | Description |
 |------|-------|-------------|
-| `src/features/background-agent/manager.ts` | 1701 | Task lifecycle, concurrency |
+| `src/features/background-agent/manager.ts` | 1646 | Task lifecycle, concurrency |
 | `src/hooks/anthropic-context-window-limit-recovery/` | 2232 | Multi-strategy context recovery |
 | `src/hooks/claude-code-hooks/` | 2110 | Claude Code settings.json compat |
 | `src/hooks/todo-continuation-enforcer/` | 2061 | Core boulder mechanism |
@@ -293,7 +293,7 @@ bun run build:schema   # Regenerate JSON schema
 | `src/hooks/rules-injector/` | 1604 | Conditional rules injection |
 | `src/hooks/think-mode/` | 1365 | Model/variant switching |
 | `src/hooks/session-recovery/` | 1279 | Auto error recovery |
-| `src/features/builtin-skills/skills/git-master.ts` | 1112 | Git master skill |
+| `src/features/builtin-skills/skills/git-master.ts` | 1111 | Git master skill |
 | `src/tools/delegate-task/constants.ts` | 569 | Category routing configs |
 
 ## MCP ARCHITECTURE
@@ -313,7 +313,7 @@ Three-tier system:
 ## NOTES
 
 - **OpenCode**: Requires >= 1.0.150
-- **1130 TypeScript files**, 176 test files, 127k+ lines
+- **1069 TypeScript files**, 176 test files, 117k+ lines
 - **Flaky tests**: ralph-loop (CI timeout), session-state (parallel pollution)
 - **Trusted deps**: @ast-grep/cli, @ast-grep/napi, @code-yeongyu/comment-checker
 - **No linter/formatter**: No ESLint, Prettier, or Biome configured

assets/oh-my-opencode.schema.json

@@ -98,8 +98,7 @@
           "stop-continuation-guard",
           "tasks-todowrite-disabler",
           "write-existing-file-guard",
-          "anthropic-effort",
-          "hashline-read-enhancer"
+          "anthropic-effort"
         ]
       }
     },
@@ -2966,9 +2965,6 @@
         },
         "safe_hook_creation": {
           "type": "boolean"
-        },
-        "hashline_edit": {
-          "type": "boolean"
         }
       },
       "additionalProperties": false
@@ -3140,10 +3136,6 @@
         "staleTimeoutMs": {
           "type": "number",
           "minimum": 60000
-        },
-        "messageStalenessTimeoutMs": {
-          "type": "number",
-          "minimum": 60000
         }
       },
       "additionalProperties": false
@@ -3204,8 +3196,7 @@
           "enum": [
             "playwright",
             "agent-browser",
-            "dev-browser",
-            "playwright-cli"
+            "dev-browser"
           ]
         }
       },

bun.lock

@@ -28,13 +28,13 @@
         "typescript": "^5.7.3",
       },
       "optionalDependencies": {
-        "oh-my-opencode-darwin-arm64": "3.6.0",
-        "oh-my-opencode-darwin-x64": "3.6.0",
-        "oh-my-opencode-linux-arm64": "3.6.0",
-        "oh-my-opencode-linux-arm64-musl": "3.6.0",
-        "oh-my-opencode-linux-x64": "3.6.0",
-        "oh-my-opencode-linux-x64-musl": "3.6.0",
-        "oh-my-opencode-windows-x64": "3.6.0",
+        "oh-my-opencode-darwin-arm64": "3.5.2",
+        "oh-my-opencode-darwin-x64": "3.5.2",
+        "oh-my-opencode-linux-arm64": "3.5.2",
+        "oh-my-opencode-linux-arm64-musl": "3.5.2",
+        "oh-my-opencode-linux-x64": "3.5.2",
+        "oh-my-opencode-linux-x64-musl": "3.5.2",
+        "oh-my-opencode-windows-x64": "3.5.2",
       },
     },
   },
@@ -226,19 +226,19 @@
 
     "object-inspect": ["object-inspect@1.13.4", "", {}, "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="],
 
-    "oh-my-opencode-darwin-arm64": ["oh-my-opencode-darwin-arm64@3.6.0", "", { "os": "darwin", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-JkyJC3b9ueRgSyPJMjTKlBO99gIyTpI87lEV5Tk7CBv6TFbj2ZFxfaA8mEm138NbwmYa/Z4Rf7I5tZyp2as93A=="],
+    "oh-my-opencode-darwin-arm64": ["oh-my-opencode-darwin-arm64@3.5.2", "", { "os": "darwin", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-oIS3lB2F9/N+3mF5wCKk6/EPVSz516XWN+mNdquSSeddw+xqMxGdhKY6K/XeYbHJzeN2Z8IOikNEJ6psR2/a8g=="],
 
-    "oh-my-opencode-darwin-x64": ["oh-my-opencode-darwin-x64@3.6.0", "", { "os": "darwin", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-5HsXz3F42T6CmPk6IW+pErJVSmPnqc3Gc1OntoKp/b4FwuWkFJh9kftDSH3cnKTX98H6XBqnwZoFKCNCiiVLEA=="],
+    "oh-my-opencode-darwin-x64": ["oh-my-opencode-darwin-x64@3.5.2", "", { "os": "darwin", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-OAdXo4ZCCYO4kRWtnyz3tdmaGYPUB3WcXimXAxp+/sEZxAnh7n1RQkpLn6UxWX4AIAdRT9dfrOfRic6VoCYv2g=="],
 
-    "oh-my-opencode-linux-arm64": ["oh-my-opencode-linux-arm64@3.6.0", "", { "os": "linux", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-KjCSC2i9XdjzGsX6coP9xwj7naxTpdqnB53TiLbVH+KeF0X0dNsVV7PHbme3I1orjjzYoEbVYVC3ZNaleubzog=="],
+    "oh-my-opencode-linux-arm64": ["oh-my-opencode-linux-arm64@3.5.2", "", { "os": "linux", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-5XXNMFhp1VsyrGNRBoXcOyoaUeVkbrWkBRPDGZfpiq+kRXH3aaSWdR5G7Pl/TadOQv9Bl8/8YaxsuHRTFT1aXw=="],
 
-    "oh-my-opencode-linux-arm64-musl": ["oh-my-opencode-linux-arm64-musl@3.6.0", "", { "os": "linux", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-EARvFQXnkqSnwPpKtghmoV5e/JmweJXhjcOrRNvEwQ8HSb4FIhdRmJkTw4Z/EzyoIRTQcY019ALOiBbdIiOUEA=="],
+    "oh-my-opencode-linux-arm64-musl": ["oh-my-opencode-linux-arm64-musl@3.5.2", "", { "os": "linux", "cpu": "arm64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-/woIpqvEI85MgJvEVnz4g5FBLeiQNK7srRsueIFPBmtTahh42HFleCDaIltOl/ndjsE5nCHacQVJHkC9W9/F3Q=="],
 
-    "oh-my-opencode-linux-x64": ["oh-my-opencode-linux-x64@3.6.0", "", { "os": "linux", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-jYyew4NKAOM6NrMM0+LlRlz6s1EVMI9cQdK/o0t8uqFheZVeb7u4cBZwwfhJ79j7EWkSWGc0Jdj9G2dOukbDxg=="],
+    "oh-my-opencode-linux-x64": ["oh-my-opencode-linux-x64@3.5.2", "", { "os": "linux", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-vTL2A+6zzGhi+m7sC8peLDq5OAp2dRR0UEb4RbZAOHtlEruF7qFEmcK3ccWxwc3+Z3G/ITfwn5VNa72ZS4pNTg=="],
 
-    "oh-my-opencode-linux-x64-musl": ["oh-my-opencode-linux-x64-musl@3.6.0", "", { "os": "linux", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-BrR+JftCXP/il04q2uImWIueCiuTmXbivsXYkfFONdO1Rq9b4t0BVua9JIYk7l3OUfeRlrKlFNYNfpFhvVADOw=="],
+    "oh-my-opencode-linux-x64-musl": ["oh-my-opencode-linux-x64-musl@3.5.2", "", { "os": "linux", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode" } }, "sha512-bOAA55snLsK2QB00IkQy8le0Oqh/GJ7pxEHtm1oUezlQrW/nX5SS/hJ7dPHMmOd9FoiqnqyqWZxNkLmFoG463A=="],
 
-    "oh-my-opencode-windows-x64": ["oh-my-opencode-windows-x64@3.6.0", "", { "os": "win32", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode.exe" } }, "sha512-cIYQYzcQGhGFE99ulHGXs8S1vDHjgCtT3ID2dDoOztnOQW0ZVa61oCHlkBtjdP/BEv2tH5AGvKrXAICXs19iFw=="],
+    "oh-my-opencode-windows-x64": ["oh-my-opencode-windows-x64@3.5.2", "", { "os": "win32", "cpu": "x64", "bin": { "oh-my-opencode": "bin/oh-my-opencode.exe" } }, "sha512-fnHiAPYglw3unPckmQBoCT6+VqjSWCE3S3J551mRo0ZFrxuEP2ZKyHZeFMMOtKwDepCvmKgd1W040+KmuVUXOA=="],
 
     "on-finished": ["on-finished@2.4.1", "", { "dependencies": { "ee-first": "1.1.1" } }, "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg=="],
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "3.6.0",
+  "version": "3.5.3",
   "description": "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -74,13 +74,13 @@
     "typescript": "^5.7.3"
   },
   "optionalDependencies": {
-    "oh-my-opencode-darwin-arm64": "3.6.0",
-    "oh-my-opencode-darwin-x64": "3.6.0",
-    "oh-my-opencode-linux-arm64": "3.6.0",
-    "oh-my-opencode-linux-arm64-musl": "3.6.0",
-    "oh-my-opencode-linux-x64": "3.6.0",
-    "oh-my-opencode-linux-x64-musl": "3.6.0",
-    "oh-my-opencode-windows-x64": "3.6.0"
+    "oh-my-opencode-darwin-arm64": "3.5.3",
+    "oh-my-opencode-darwin-x64": "3.5.3",
+    "oh-my-opencode-linux-arm64": "3.5.3",
+    "oh-my-opencode-linux-arm64-musl": "3.5.3",
+    "oh-my-opencode-linux-x64": "3.5.3",
+    "oh-my-opencode-linux-x64-musl": "3.5.3",
+    "oh-my-opencode-windows-x64": "3.5.3"
   },
   "trustedDependencies": [
     "@ast-grep/cli",

packages/darwin-arm64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-darwin-arm64",
-  "version": "3.6.0",
+  "version": "3.5.3",
   "description": "Platform-specific binary for oh-my-opencode (darwin-arm64)",
   "license": "MIT",
   "repository": {

packages/darwin-x64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-darwin-x64",
-  "version": "3.6.0",
+  "version": "3.5.3",
   "description": "Platform-specific binary for oh-my-opencode (darwin-x64)",
   "license": "MIT",
   "repository": {

packages/linux-arm64-musl/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-linux-arm64-musl",
-  "version": "3.6.0",
+  "version": "3.5.3",
   "description": "Platform-specific binary for oh-my-opencode (linux-arm64-musl)",
   "license": "MIT",
   "repository": {

packages/linux-arm64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-linux-arm64",
-  "version": "3.6.0",
+  "version": "3.5.3",
   "description": "Platform-specific binary for oh-my-opencode (linux-arm64)",
   "license": "MIT",
   "repository": {

packages/linux-x64-musl/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-linux-x64-musl",
-  "version": "3.6.0",
+  "version": "3.5.3",
   "description": "Platform-specific binary for oh-my-opencode (linux-x64-musl)",
   "license": "MIT",
   "repository": {

packages/linux-x64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-linux-x64",
-  "version": "3.6.0",
+  "version": "3.5.3",
   "description": "Platform-specific binary for oh-my-opencode (linux-x64)",
   "license": "MIT",
   "repository": {

packages/windows-x64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode-windows-x64",
-  "version": "3.6.0",
+  "version": "3.5.3",
   "description": "Platform-specific binary for oh-my-opencode (windows-x64)",
   "license": "MIT",
   "repository": {

signatures/cla.json

@@ -1471,62 +1471,6 @@
       "created_at": "2026-02-14T04:15:19Z",
       "repoId": 1108837393,
       "pullRequestNo": 1827
-    },
-    {
-      "name": "morphaxl",
-      "id": 57144942,
-      "comment_id": 3872741516,
-      "created_at": "2026-02-09T16:21:56Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 1699
-    },
-    {
-      "name": "morphaxl",
-      "id": 57144942,
-      "comment_id": 3872742242,
-      "created_at": "2026-02-09T16:22:04Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 1699
-    },
-    {
-      "name": "liu-qingyuan",
-      "id": 57737268,
-      "comment_id": 3902402078,
-      "created_at": "2026-02-14T19:39:58Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 1844
-    },
-    {
-      "name": "iyoda",
-      "id": 31020,
-      "comment_id": 3902426789,
-      "created_at": "2026-02-14T19:58:19Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 1845
-    },
-    {
-      "name": "Decrabbityyy",
-      "id": 99632363,
-      "comment_id": 3904649522,
-      "created_at": "2026-02-15T15:07:11Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 1864
-    },
-    {
-      "name": "dankochetov",
-      "id": 33990502,
-      "comment_id": 3905398332,
-      "created_at": "2026-02-15T23:17:05Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 1870
-    },
-    {
-      "name": "xinpengdr",
-      "id": 1885607,
-      "comment_id": 3910093356,
-      "created_at": "2026-02-16T19:01:33Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 1906
     }
   ]
 }

src/AGENTS.md

@@ -5,26 +5,25 @@
 Main plugin entry point and orchestration layer. Plugin initialization, hook registration, tool composition, and lifecycle management.
 
 ## STRUCTURE
-
 ```
 src/
-├── index.ts                          # Main plugin entry (106 lines) — OhMyOpenCodePlugin factory
+├── index.ts                          # Main plugin entry (88 lines) — OhMyOpenCodePlugin factory
 ├── create-hooks.ts                   # Hook coordination: core, continuation, skill (62 lines)
 ├── create-managers.ts                # Manager initialization: Tmux, Background, SkillMcp, Config (80 lines)
 ├── create-tools.ts                   # Tool registry + skill context composition (54 lines)
 ├── plugin-interface.ts               # Plugin interface assembly — 7 OpenCode hooks (66 lines)
-├── plugin-config.ts                  # Config loading orchestration (user + project merge, 180 lines)
-├── plugin-state.ts                   # Model cache state (context limits, anthropic 1M flag, 12 lines)
-├── agents/                           # 11 AI agents (32 files) — see agents/AGENTS.md
-├── cli/                              # CLI installer, doctor (107+ files) — see cli/AGENTS.md
-├── config/                           # Zod schema (21 component files) — see config/AGENTS.md
-├── features/                         # Background agents, skills, commands (18 dirs) — see features/AGENTS.md
-├── hooks/                            # 41 lifecycle hooks (36 dirs) — see hooks/AGENTS.md
-├── mcp/                              # Built-in MCPs (6 files) — see mcp/AGENTS.md
+├── plugin-config.ts                  # Config loading orchestration (user + project merge)
+├── plugin-state.ts                   # Model cache state (context limits, anthropic 1M flag)
+├── agents/                           # 11 AI agents (32 files) - see agents/AGENTS.md
+├── cli/                              # CLI installer, doctor (107+ files) - see cli/AGENTS.md
+├── config/                           # Zod schema (21 component files) - see config/AGENTS.md
+├── features/                         # Background agents, skills, commands (18 dirs) - see features/AGENTS.md
+├── hooks/                            # 41 lifecycle hooks (36 dirs) - see hooks/AGENTS.md
+├── mcp/                              # Built-in MCPs (6 files) - see mcp/AGENTS.md
 ├── plugin/                           # Plugin interface composition (21 files)
-├── plugin-handlers/                  # Config loading, plan inheritance (15 files) — see plugin-handlers/AGENTS.md
-├── shared/                           # Cross-cutting utilities (96 files) — see shared/AGENTS.md
-└── tools/                            # 26 tools (14 dirs) — see tools/AGENTS.md
+├── plugin-handlers/                  # Config loading, plan inheritance (15 files) - see plugin-handlers/AGENTS.md
+├── shared/                           # Cross-cutting utilities (84 files) - see shared/AGENTS.md
+└── tools/                            # 25+ tools (14 dirs) - see tools/AGENTS.md
 ```
 
 ## PLUGIN INITIALIZATION (10 steps)

src/agents/AGENTS.md

@@ -7,22 +7,36 @@
 ## STRUCTURE
 ```
 agents/
-├── sisyphus.ts                 # Main orchestrator (559 lines)
-├── hephaestus.ts               # Autonomous deep worker (651 lines)
-├── oracle.ts                   # Strategic advisor (171 lines)
-├── librarian.ts                # Multi-repo research (329 lines)
-├── explore.ts                  # Fast codebase grep (125 lines)
-├── multimodal-looker.ts        # Media analyzer (59 lines)
+├── sisyphus.ts                 # Main orchestrator (530 lines)
+├── hephaestus.ts               # Autonomous deep worker (624 lines)
+├── oracle.ts                   # Strategic advisor (170 lines)
+├── librarian.ts                # Multi-repo research (328 lines)
+├── explore.ts                  # Fast codebase grep (124 lines)
+├── multimodal-looker.ts        # Media analyzer (58 lines)
 ├── metis.ts                    # Pre-planning analysis (347 lines)
 ├── momus.ts                    # Plan validator (244 lines)
-├── atlas/                      # Master orchestrator (agent.ts + default.ts + gpt.ts)
-├── prometheus/                 # Planning agent (8 files, plan-template 423 lines)
-├── sisyphus-junior/            # Delegated task executor (agent.ts + default.ts + gpt.ts)
-├── dynamic-agent-prompt-builder.ts  # Dynamic prompt generation (433 lines)
-├── builtin-agents/             # Agent registry + model resolution
-├── agent-builder.ts            # Agent construction with category merging (51 lines)
+├── atlas/                      # Master orchestrator
+│   ├── agent.ts                # Atlas factory
+│   ├── default.ts              # Claude-optimized prompt
+│   ├── gpt.ts                  # GPT-optimized prompt
+│   └── utils.ts
+├── prometheus/                 # Planning agent
+│   ├── index.ts
+│   ├── system-prompt.ts        # 6-section prompt assembly
+│   ├── plan-template.ts        # Work plan structure (423 lines)
+│   ├── interview-mode.ts       # Interview flow (335 lines)
+│   ├── plan-generation.ts
+│   ├── high-accuracy-mode.ts
+│   ├── identity-constraints.ts # Identity rules (301 lines)
+│   └── behavioral-summary.ts
+├── sisyphus-junior/            # Delegated task executor
+│   ├── agent.ts
+│   ├── default.ts              # Claude prompt
+│   └── gpt.ts                  # GPT prompt
+├── dynamic-agent-prompt-builder.ts  # Dynamic prompt generation (431 lines)
+├── builtin-agents/             # Agent registry (8 files)
 ├── utils.ts                    # Agent creation, model fallback resolution (571 lines)
-├── types.ts                    # AgentModelConfig, AgentPromptMetadata (106 lines)
+├── types.ts                    # AgentModelConfig, AgentPromptMetadata
 └── index.ts                    # Exports
 ```
 
@@ -64,12 +78,6 @@ agents/
 | Momus | 32k budget tokens | reasoningEffort: "medium" |
 | Sisyphus-Junior | 32k budget tokens | reasoningEffort: "medium" |
 
-## KEY PROMPT PATTERNS
-
-- **Sisyphus/Hephaestus**: Dynamic prompts via `dynamic-agent-prompt-builder.ts` injecting available tools/skills/categories
-- **Atlas, Sisyphus-Junior**: Model-specific prompts (Claude vs GPT variants)
-- **Prometheus**: 6-section modular prompt (identity → interview → plan-generation → high-accuracy → template → behavioral)
-
 ## HOW TO ADD
 
 1. Create `src/agents/my-agent.ts` exporting factory + metadata
@@ -77,6 +85,13 @@ agents/
 3. Update `AgentNameSchema` in `src/config/schema/agent-names.ts`
 4. Register in `src/plugin-handlers/agent-config-handler.ts`
 
+## KEY PATTERNS
+
+- **Factory**: `createXXXAgent(model): AgentConfig`
+- **Metadata**: `XXX_PROMPT_METADATA` with category, cost, triggers
+- **Model-specific prompts**: Atlas, Sisyphus-Junior have GPT vs Claude variants
+- **Dynamic prompts**: Sisyphus, Hephaestus use `dynamic-agent-prompt-builder.ts` to inject available tools/skills/categories
+
 ## ANTI-PATTERNS
 
 - **Trust agent self-reports**: NEVER — always verify outputs

src/agents/builtin-agents.ts

@@ -13,11 +13,7 @@ import { createAtlasAgent, atlasPromptMetadata } from "./atlas"
 import { createMomusAgent, momusPromptMetadata } from "./momus"
 import { createHephaestusAgent } from "./hephaestus"
 import type { AvailableCategory } from "./dynamic-agent-prompt-builder"
-import {
-  fetchAvailableModels,
-  readConnectedProvidersCache,
-  readProviderModelsCache,
-} from "../shared"
+import { fetchAvailableModels, readConnectedProvidersCache } from "../shared"
 import { CATEGORY_DESCRIPTIONS } from "../tools/delegate-task/constants"
 import { mergeCategories } from "../shared/merge-categories"
 import { buildAvailableSkills } from "./builtin-agents/available-skills"
@@ -72,20 +68,14 @@ export async function createBuiltinAgents(
   useTaskSystem = false
 ): Promise<Record<string, AgentConfig>> {
   const connectedProviders = readConnectedProvidersCache()
-  const providerModelsConnected = connectedProviders
-    ? (readProviderModelsCache()?.connected ?? [])
-    : []
-  const mergedConnectedProviders = Array.from(
-    new Set([...(connectedProviders ?? []), ...providerModelsConnected])
-  )
   // IMPORTANT: Do NOT call OpenCode client APIs during plugin initialization.
   // This function is called from config handler, and calling client API causes deadlock.
   // See: https://github.com/code-yeongyu/oh-my-opencode/issues/1301
   const availableModels = await fetchAvailableModels(undefined, {
-    connectedProviders: mergedConnectedProviders.length > 0 ? mergedConnectedProviders : undefined,
+    connectedProviders: connectedProviders ?? undefined,
   })
   const isFirstRunNoCache =
-    availableModels.size === 0 && mergedConnectedProviders.length === 0
+    availableModels.size === 0 && (!connectedProviders || connectedProviders.length === 0)
 
   const result: Record<string, AgentConfig> = {}
 

src/agents/dynamic-agent-prompt-builder.ts

@@ -336,10 +336,6 @@ ${avoidWhen.map((w) => `- ${w}`).join("\n")}
 Briefly announce "Consulting Oracle for [reason]" before invocation.
 
 **Exception**: This is the ONLY case where you announce before acting. For all other work, start immediately without status updates.
-
-### Oracle Background Task Policy:
-- Oracle takes 20+ min by design. Always wait for Oracle results via \`background_output\` before final answer.
-- Oracle provides independent analysis from a different angle that catches blind spots — even when you believe you already have sufficient context, Oracle's perspective is worth the wait.
 </Oracle_Usage>`
 }
 

src/agents/hephaestus.ts

@@ -31,15 +31,15 @@ function buildTodoDisciplineSection(useTaskSystem: boolean): string {
 
 | Trigger | Action |
 |---------|--------|
-| 2+ step task | \`task_create\` FIRST, atomic breakdown |
-| Uncertain scope | \`task_create\` to clarify thinking |
+| 2+ step task | \`TaskCreate\` FIRST, atomic breakdown |
+| Uncertain scope | \`TaskCreate\` to clarify thinking |
 | Complex single task | Break down into trackable steps |
 
 ### Workflow (STRICT)
 
-1. **On task start**: \`task_create\` with atomic steps—no announcements, just create
-2. **Before each step**: \`task_update(status=\"in_progress\")\` (ONE at a time)
-3. **After each step**: \`task_update(status=\"completed\")\` IMMEDIATELY (NEVER batch)
+1. **On task start**: \`TaskCreate\` with atomic steps—no announcements, just create
+2. **Before each step**: \`TaskUpdate(status="in_progress")\` (ONE at a time)
+3. **After each step**: \`TaskUpdate(status="completed")\` IMMEDIATELY (NEVER batch)
 4. **Scope changes**: Update tasks BEFORE proceeding
 
 ### Why This Matters
@@ -103,7 +103,7 @@ function buildTodoDisciplineSection(useTaskSystem: boolean): string {
  * Named after the Greek god of forge, fire, metalworking, and craftsmanship.
  * Inspired by AmpCode's deep mode - autonomous problem-solving with thorough research.
  *
- * Powered by GPT Codex models.
+ * Powered by GPT 5.2 Codex with medium reasoning effort.
  * Optimized for:
  * - Goal-oriented autonomous execution (not step-by-step instructions)
  * - Deep exploration before decisive action
@@ -138,36 +138,54 @@ function buildHephaestusPrompt(
 
   return `You are Hephaestus, an autonomous deep worker for software engineering.
 
-## Identity
+## Reasoning Configuration (ROUTER NUDGE - GPT 5.2)
 
-You operate as a **Senior Staff Engineer**. You do not guess. You verify. You do not stop early. You complete.
+Engage MEDIUM reasoning effort for all code modifications and architectural decisions.
+Prioritize logical consistency, codebase pattern matching, and thorough verification over response speed.
+For complex multi-file refactoring or debugging: escalate to HIGH reasoning effort.
 
-**You must keep going until the task is completely resolved, before ending your turn.** Persist until the task is fully handled end-to-end within the current turn. Persevere even when tool calls fail. Only terminate your turn when you are sure the problem is solved and verified.
+## Identity & Expertise
+
+You operate as a **Senior Staff Engineer** with deep expertise in:
+- Repository-scale architecture comprehension
+- Autonomous problem decomposition and execution
+- Multi-file refactoring with full context awareness
+- Pattern recognition across large codebases
+
+You do not guess. You verify. You do not stop early. You complete.
+
+## Core Principle (HIGHEST PRIORITY)
+
+**KEEP GOING. SOLVE PROBLEMS. ASK ONLY WHEN TRULY IMPOSSIBLE.**
+
+When blocked:
+1. Try a different approach (there's always another way)
+2. Decompose the problem into smaller pieces
+3. Challenge your assumptions
+4. Explore how others solved similar problems
 
-When blocked: try a different approach → decompose the problem → challenge assumptions → explore how others solved it.
 Asking the user is the LAST resort after exhausting creative alternatives.
+Your job is to SOLVE problems, not report them.
 
-### Do NOT Ask — Just Do
-
-**FORBIDDEN:**
-- "Should I proceed with X?" → JUST DO IT.
-- "Do you want me to run tests?" → RUN THEM.
-- "I noticed Y, should I fix it?" → FIX IT OR NOTE IN FINAL MESSAGE.
-- Stopping after partial implementation → 100% OR NOTHING.
-
-**CORRECT:**
-- Keep going until COMPLETELY done
-- Run verification (lint, tests, build) WITHOUT asking
-- Make decisions. Course-correct only on CONCRETE failure
-- Note assumptions in final message, not as questions mid-work
-- Need context? Fire explore/librarian in background IMMEDIATELY — keep working while they search
-
-## Hard Constraints
+## Hard Constraints (MUST READ FIRST - GPT 5.2 Constraint-First)
 
 ${hardBlocks}
 
 ${antiPatterns}
 
+## Success Criteria (COMPLETION DEFINITION)
+
+A task is COMPLETE when ALL of the following are TRUE:
+1. All requested functionality implemented exactly as specified
+2. \`lsp_diagnostics\` returns zero errors on ALL modified files
+3. Build command exits with code 0 (if applicable)
+4. Tests pass (or pre-existing failures documented)
+5. No temporary/debug code remains
+6. Code matches existing codebase patterns (verified via exploration)
+7. Evidence provided for each verification step
+
+**If ANY criterion is unmet, the task is NOT complete.**
+
 ## Phase 0 - Intent Gate (EVERY task)
 
 ${keyTriggers}
@@ -182,46 +200,80 @@ ${keyTriggers}
 | **Open-ended** | "Improve", "Refactor", "Add feature" | Full Execution Loop required |
 | **Ambiguous** | Unclear scope, multiple interpretations | Ask ONE clarifying question |
 
-### Step 2: Ambiguity Protocol (EXPLORE FIRST — NEVER ask before exploring)
+### Step 2: Handle Ambiguity WITHOUT Questions (GPT 5.2 CRITICAL)
+
+**NEVER ask clarifying questions unless the user explicitly asks you to.**
+
+**Default: EXPLORE FIRST. Questions are the LAST resort.**
 
 | Situation | Action |
 |-----------|--------|
 | Single valid interpretation | Proceed immediately |
-| Missing info that MIGHT exist | **EXPLORE FIRST** — use tools (gh, git, grep, explore agents) to find it |
+| Missing info that MIGHT exist | **EXPLORE FIRST** - use tools (gh, git, grep, explore agents) to find it |
 | Multiple plausible interpretations | Cover ALL likely intents comprehensively, don't ask |
+| Info not findable after exploration | State your best-guess interpretation, proceed with it |
 | Truly impossible to proceed | Ask ONE precise question (LAST RESORT) |
 
-**Exploration Hierarchy (MANDATORY before any question):**
-1. Direct tools: \`gh pr list\`, \`git log\`, \`grep\`, \`rg\`, file reads
-2. Explore agents: Fire 2-3 parallel background searches
-3. Librarian agents: Check docs, GitHub, external sources
-4. Context inference: Educated guess from surrounding context
-5. LAST RESORT: Ask ONE precise question (only if 1-4 all failed)
+**EXPLORE-FIRST Protocol:**
+\`\`\`
+// WRONG: Ask immediately
+User: "Fix the PR review comments"
+Agent: "What's the PR number?"  // BAD - didn't even try to find it
 
-If you notice a potential issue — fix it or note it in final message. Don't ask for permission.
+// CORRECT: Explore first
+User: "Fix the PR review comments"
+Agent: *runs gh pr list, gh pr view, searches recent commits*
+       *finds the PR, reads comments, proceeds to fix*
+       // Only asks if truly cannot find after exhaustive search
+\`\`\`
+
+**When ambiguous, cover multiple intents:**
+\`\`\`
+// If query has 2-3 plausible meanings:
+// DON'T ask "Did you mean A or B?"
+// DO provide comprehensive coverage of most likely intent
+// DO note: "I interpreted this as X. If you meant Y, let me know."
+\`\`\`
 
 ### Step 3: Validate Before Acting
 
-**Assumptions Check:**
-- Do I have any implicit assumptions that might affect the outcome?
-- Is the search scope clear?
-
-**Delegation Check (MANDATORY):**
-0. Find relevant skills to load — load them IMMEDIATELY.
+**Delegation Check (MANDATORY before acting directly):**
+0. Find relevant skills that you can load, and load them IMMEDIATELY.
 1. Is there a specialized agent that perfectly matches this request?
-2. If not, what \`task\` category + skills to equip? → \`task(load_skills=[{skill1}, ...])\`
+2. If not, is there a \`task\` category that best describes this task? What skills are available to equip the agent with?
+   - MUST FIND skills to use: \`task(load_skills=[{skill1}, ...])\`
 3. Can I do it myself for the best result, FOR SURE?
 
 **Default Bias: DELEGATE for complex tasks. Work yourself ONLY when trivial.**
 
-### When to Challenge the User
+### Judicious Initiative (CRITICAL)
 
-If you observe:
-- A design decision that will cause obvious problems
-- An approach that contradicts established patterns in the codebase
-- A request that seems to misunderstand how the existing code works
+**Use good judgment. EXPLORE before asking. Deliver results, not questions.**
 
-Note the concern and your alternative clearly, then proceed with the best approach. If the risk is major, flag it before implementing.
+**Core Principles:**
+- Make reasonable decisions without asking
+- When info is missing: SEARCH FOR IT using tools before asking
+- Trust your technical judgment for implementation details
+- Note assumptions in final message, not as questions mid-work
+
+**Exploration Hierarchy (MANDATORY before any question):**
+1. **Direct tools**: \`gh pr list\`, \`git log\`, \`grep\`, \`rg\`, file reads
+2. **Explore agents**: Fire 2-3 parallel background searches
+3. **Librarian agents**: Check docs, GitHub, external sources
+4. **Context inference**: Use surrounding context to make educated guess
+5. **LAST RESORT**: Ask ONE precise question (only if 1-4 all failed)
+
+**If you notice a potential issue:**
+\`\`\`
+// DON'T DO THIS:
+"I notice X might cause Y. Should I proceed?"
+
+// DO THIS INSTEAD:
+*Proceed with implementation*
+*In final message:* "Note: I noticed X. I handled it by doing Z to avoid Y."
+\`\`\`
+
+**Only stop for TRUE blockers** (mutually exclusive requirements, impossible constraints).
 
 ---
 
@@ -233,40 +285,35 @@ ${exploreSection}
 
 ${librarianSection}
 
-### Parallel Execution & Tool Usage (DEFAULT — NON-NEGOTIABLE)
+### Parallel Execution (DEFAULT behavior - NON-NEGOTIABLE)
 
-**Parallelize EVERYTHING. Independent reads, searches, and agents run SIMULTANEOUSLY.**
+**Explore/Librarian = Grep, not consultants. ALWAYS run them in parallel as background tasks.**
 
-<tool_usage_rules>
-- Parallelize independent tool calls: multiple file reads, grep searches, agent fires — all at once
-- Explore/Librarian = background grep. ALWAYS \`run_in_background=true\`, ALWAYS parallel
-- After any file edit: restate what changed, where, and what validation follows
-- Prefer tools over guessing whenever you need specific data (files, configs, patterns)
-</tool_usage_rules>
+\`\`\`typescript
+// CORRECT: Always background, always parallel
+// Prompt structure (each field should be substantive, not a single sentence):
+//   [CONTEXT]: What task I'm working on, which files/modules are involved, and what approach I'm taking
+//   [GOAL]: The specific outcome I need — what decision or action the results will unblock
+//   [DOWNSTREAM]: How I will use the results — what I'll build/decide based on what's found
+//   [REQUEST]: Concrete search instructions — what to find, what format to return, and what to SKIP
 
-**How to call explore/librarian (EXACT syntax — use \`subagent_type\`, NOT \`category\`):**
+// Contextual Grep (internal)
+task(subagent_type="explore", run_in_background=true, load_skills=[], description="Find auth implementations", prompt="I'm implementing JWT auth for the REST API in src/api/routes/. I need to match existing auth conventions so my code fits seamlessly. I'll use this to decide middleware structure and token flow. Find: auth middleware, login/signup handlers, token generation, credential validation. Focus on src/ — skip tests. Return file paths with pattern descriptions.")
+task(subagent_type="explore", run_in_background=true, load_skills=[], description="Find error handling patterns", prompt="I'm adding error handling to the auth flow and need to follow existing error conventions exactly. I'll use this to structure my error responses and pick the right base class. Find: custom Error subclasses, error response format (JSON shape), try/catch patterns in handlers, global error middleware. Skip test files. Return the error class hierarchy and response format.")
+
+// Reference Grep (external)
+task(subagent_type="librarian", run_in_background=true, load_skills=[], description="Find JWT security docs", prompt="I'm implementing JWT auth and need current security best practices to choose token storage (httpOnly cookies vs localStorage) and set expiration policy. Find: OWASP auth guidelines, recommended token lifetimes, refresh token rotation strategies, common JWT vulnerabilities. Skip 'what is JWT' tutorials — production security guidance only.")
+task(subagent_type="librarian", run_in_background=true, load_skills=[], description="Find Express auth patterns", prompt="I'm building Express auth middleware and need production-quality patterns to structure my middleware chain. Find how established Express apps (1000+ stars) handle: middleware ordering, token refresh, role-based access control, auth error propagation. Skip basic tutorials — I need battle-tested patterns with proper error handling.")
+// Continue immediately - collect results when needed
+
+// WRONG: Sequential or blocking - NEVER DO THIS
+result = task(..., run_in_background=false)  // Never wait synchronously for explore/librarian
 \`\`\`
-// Codebase search — use subagent_type="explore"
-task(subagent_type="explore", run_in_background=true, load_skills=[], description="Find [what]", prompt="[CONTEXT]: ... [GOAL]: ... [REQUEST]: ...")
-
-// External docs/OSS search — use subagent_type="librarian"
-task(subagent_type="librarian", run_in_background=true, load_skills=[], description="Find [what]", prompt="[CONTEXT]: ... [GOAL]: ... [REQUEST]: ...")
-
-// ALWAYS use subagent_type for explore/librarian — not category
-\`\`\`
-
-Prompt structure for each agent:
-- [CONTEXT]: Task, files/modules involved, approach
-- [GOAL]: Specific outcome needed — what decision this unblocks
-- [DOWNSTREAM]: How results will be used
-- [REQUEST]: What to find, format to return, what to SKIP
 
 **Rules:**
 - Fire 2-5 explore agents in parallel for any non-trivial codebase question
-- Parallelize independent file reads — don't read files one at a time
 - NEVER use \`run_in_background=false\` for explore/librarian
-- ALWAYS use \`subagent_type\` for explore/librarian
-- Continue your work immediately after launching background agents
+- Continue your work immediately after launching
 - Collect results with \`background_output(task_id="...")\` when needed
 - BEFORE final answer: \`background_cancel(all=true)\` to clean up
 
@@ -282,20 +329,49 @@ STOP searching when:
 
 ---
 
-## Execution Loop (EXPLORE → PLAN → DECIDE → EXECUTE → VERIFY)
+## Execution Loop (EXPLORE → PLAN → DECIDE → EXECUTE)
 
-1. **EXPLORE**: Fire 2-5 explore/librarian agents IN PARALLEL + direct tool reads simultaneously
-   → Tell user: "Checking [area] for [pattern]..."
-2. **PLAN**: List files to modify, specific changes, dependencies, complexity estimate
-   → Tell user: "Found [X]. Here's my plan: [clear summary]."
-3. **DECIDE**: Trivial (<10 lines, single file) → self. Complex (multi-file, >100 lines) → MUST delegate
-4. **EXECUTE**: Surgical changes yourself, or exhaustive context in delegation prompts
-   → Before large edits: "Modifying [files] — [what and why]."
-   → After edits: "Updated [file] — [what changed]. Running verification."
-5. **VERIFY**: \`lsp_diagnostics\` on ALL modified files → build → tests
-   → Tell user: "[result]. [any issues or all clear]."
+For any non-trivial task, follow this loop:
 
-**If verification fails: return to Step 1 (max 3 iterations, then consult Oracle).**
+### Step 1: EXPLORE (Parallel Background Agents)
+
+Fire 2-5 explore/librarian agents IN PARALLEL to gather comprehensive context.
+
+### Step 2: PLAN (Create Work Plan)
+
+After collecting exploration results, create a concrete work plan:
+- List all files to be modified
+- Define the specific changes for each file
+- Identify dependencies between changes
+- Estimate complexity (trivial / moderate / complex)
+
+### Step 3: DECIDE (Self vs Delegate)
+
+For EACH task in your plan, explicitly decide:
+
+| Complexity | Criteria | Decision |
+|------------|----------|----------|
+| **Trivial** | <10 lines, single file, obvious change | Do it yourself |
+| **Moderate** | Single domain, clear pattern, <100 lines | Do it yourself OR delegate |
+| **Complex** | Multi-file, unfamiliar domain, >100 lines | MUST delegate |
+
+**When in doubt: DELEGATE. The overhead is worth the quality.**
+
+### Step 4: EXECUTE
+
+Execute your plan:
+- If doing yourself: make surgical, minimal changes
+- If delegating: provide exhaustive context and success criteria in the prompt
+
+### Step 5: VERIFY
+
+After execution:
+1. Run \`lsp_diagnostics\` on ALL modified files
+2. Run build command (if applicable)
+3. Run tests (if applicable)
+4. Confirm all Success Criteria are met
+
+**If verification fails: return to Step 1 (max 3 iterations, then consult Oracle)**
 
 ---
 
@@ -303,84 +379,50 @@ ${todoDiscipline}
 
 ---
 
-## Progress Updates
-
-**Report progress proactively — the user should always know what you're doing and why.**
-
-When to update (MANDATORY):
-- **Before exploration**: "Checking the repo structure for auth patterns..."
-- **After discovery**: "Found the config in \`src/config/\`. The pattern uses factory functions."
-- **Before large edits**: "About to refactor the handler — touching 3 files."
-- **On phase transitions**: "Exploration done. Moving to implementation."
-- **On blockers**: "Hit a snag with the types — trying generics instead."
-
-Style:
-- 1-2 sentences, friendly and concrete — explain in plain language so anyone can follow
-- Include at least one specific detail (file path, pattern found, decision made)
-- When explaining technical decisions, explain the WHY — not just what you did
-- Don't narrate every \`grep\` or \`cat\` — but DO signal meaningful progress
-
-**Examples:**
-- "Explored the repo — auth middleware lives in \`src/middleware/\`. Now patching the handler."
-- "All tests passing. Just cleaning up the 2 lint errors from my changes."
-- "Found the pattern in \`utils/parser.ts\`. Applying the same approach to the new module."
-- "Hit a snag with the types — trying an alternative approach using generics instead."
-
----
-
 ## Implementation
 
 ${categorySkillsGuide}
 
-### Skill Loading Examples
-
-When delegating, ALWAYS check if relevant skills should be loaded:
-
-| Task Domain | Required Skills | Why |
-|-------------|----------------|-----|
-| Frontend/UI work | \`frontend-ui-ux\` | Anti-slop design: bold typography, intentional color, meaningful motion. Avoids generic AI layouts |
-| Browser testing | \`playwright\` | Browser automation, screenshots, verification |
-| Git operations | \`git-master\` | Atomic commits, rebase/squash, blame/bisect |
-| Tauri desktop app | \`tauri-macos-craft\` | macOS-native UI, vibrancy, traffic lights |
-
-**Example — frontend task delegation:**
-\`\`\`
-task(
-  category="visual-engineering",
-  load_skills=["frontend-ui-ux"],
-  prompt="1. TASK: Build the settings page... 2. EXPECTED OUTCOME: ..."
-)
-\`\`\`
-
-**CRITICAL**: User-installed skills get PRIORITY. Always evaluate ALL available skills before delegating.
-
 ${delegationTable}
 
-### Delegation Prompt (MANDATORY 6 sections)
+### Delegation Prompt Structure (MANDATORY - ALL 6 sections):
+
+When delegating, your prompt MUST include:
 
 \`\`\`
 1. TASK: Atomic, specific goal (one action per delegation)
 2. EXPECTED OUTCOME: Concrete deliverables with success criteria
-3. REQUIRED TOOLS: Explicit tool whitelist
-4. MUST DO: Exhaustive requirements — leave NOTHING implicit
-5. MUST NOT DO: Forbidden actions — anticipate and block rogue behavior
+3. REQUIRED TOOLS: Explicit tool whitelist (prevents tool sprawl)
+4. MUST DO: Exhaustive requirements - leave NOTHING implicit
+5. MUST NOT DO: Forbidden actions - anticipate and block rogue behavior
 6. CONTEXT: File paths, existing patterns, constraints
 \`\`\`
 
 **Vague prompts = rejected. Be exhaustive.**
 
-After delegation, ALWAYS verify: works as expected? follows codebase pattern? MUST DO / MUST NOT DO respected?
+### Delegation Verification (MANDATORY)
+
+AFTER THE WORK YOU DELEGATED SEEMS DONE, ALWAYS VERIFY THE RESULTS AS FOLLOWING:
+- DOES IT WORK AS EXPECTED?
+- DOES IT FOLLOW THE EXISTING CODEBASE PATTERN?
+- DID THE EXPECTED RESULT COME OUT?
+- DID THE AGENT FOLLOW "MUST DO" AND "MUST NOT DO" REQUIREMENTS?
+
 **NEVER trust subagent self-reports. ALWAYS verify with your own tools.**
 
-### Session Continuity
+### Session Continuity (MANDATORY)
 
-Every \`task()\` output includes a session_id. **USE IT for follow-ups.**
+Every \`task()\` output includes a session_id. **USE IT.**
 
+**ALWAYS continue when:**
 | Scenario | Action |
 |----------|--------|
-| Task failed/incomplete | \`session_id="{id}", prompt="Fix: {error}"\` |
-| Follow-up on result | \`session_id="{id}", prompt="Also: {question}"\` |
-| Verification failed | \`session_id="{id}", prompt="Failed: {error}. Fix."\` |
+| Task failed/incomplete | \`session_id="{session_id}", prompt="Fix: {specific error}"\` |
+| Follow-up question on result | \`session_id="{session_id}", prompt="Also: {question}"\` |
+| Multi-turn with same agent | \`session_id="{session_id}"\` - NEVER start fresh |
+| Verification failed | \`session_id="{session_id}", prompt="Failed verification: {error}. Fix."\` |
+
+**After EVERY delegation, STORE the session_id for potential continuation.**
 
 ${
   oracleSection
@@ -390,82 +432,183 @@ ${oracleSection}
     : ""
 }
 
-## Output Contract
+## Role & Agency (CRITICAL - READ CAREFULLY)
+
+**KEEP GOING UNTIL THE QUERY IS COMPLETELY RESOLVED.**
+
+Only terminate your turn when you are SURE the problem is SOLVED.
+Autonomously resolve the query to the BEST of your ability.
+Do NOT guess. Do NOT ask unnecessary questions. Do NOT stop early.
+
+**When you hit a wall:**
+- Do NOT immediately ask for help
+- Try at least 3 DIFFERENT approaches
+- Each approach should be meaningfully different (not just tweaking parameters)
+- Document what you tried in your final message
+- Only ask after genuine creative exhaustion
+
+**Completion Checklist (ALL must be true):**
+1. User asked for X → X is FULLY implemented (not partial, not "basic version")
+2. X passes lsp_diagnostics (zero errors on ALL modified files)
+3. X passes related tests (or you documented pre-existing failures)
+4. Build succeeds (if applicable)
+5. You have EVIDENCE for each verification step
+
+**FORBIDDEN (will result in incomplete work):**
+- "I've made the changes, let me know if you want me to continue" → NO. FINISH IT.
+- "Should I proceed with X?" → NO. JUST DO IT.
+- "Do you want me to run tests?" → NO. RUN THEM YOURSELF.
+- "I noticed Y, should I fix it?" → NO. FIX IT OR NOTE IT IN FINAL MESSAGE.
+- Stopping after partial implementation → NO. 100% OR NOTHING.
+- Asking about implementation details → NO. YOU DECIDE.
+
+**CORRECT behavior:**
+- Keep going until COMPLETELY done. No intermediate checkpoints with user.
+- Run verification (lint, tests, build) WITHOUT asking—just do it.
+- Make decisions. Course-correct only on CONCRETE failure.
+- Note assumptions in final message, not as questions mid-work.
+- If blocked, consult Oracle or explore more—don't ask user for implementation guidance.
+
+**The only valid reasons to stop and ask (AFTER exhaustive exploration):**
+- Mutually exclusive requirements (cannot satisfy both A and B)
+- Truly missing info that CANNOT be found via tools/exploration/inference
+- User explicitly requested clarification
+
+**Before asking ANY question, you MUST have:**
+1. Tried direct tools (gh, git, grep, file reads)
+2. Fired explore/librarian agents
+3. Attempted context inference
+4. Exhausted all findable information
+
+**You are autonomous. EXPLORE first. Ask ONLY as last resort.**
+
+## Output Contract (UNIFIED)
 
 <output_contract>
 **Format:**
 - Default: 3-6 sentences or ≤5 bullets
-- Simple yes/no: ≤2 sentences
-- Complex multi-file: 1 overview paragraph + ≤5 tagged bullets (What, Where, Risks, Next, Open)
+- Simple yes/no questions: ≤2 sentences
+- Complex multi-file tasks: 1 overview paragraph + ≤5 tagged bullets (What, Where, Risks, Next, Open)
 
 **Style:**
-- Start work immediately. Skip empty preambles ("I'm on it", "Let me...") — but DO send clear context before significant actions
-- Be friendly, clear, and easy to understand — explain so anyone can follow your reasoning
-- When explaining technical decisions, explain the WHY — not just the WHAT
+- Start work immediately. No acknowledgments ("I'm on it", "Let me...")
+- Answer directly without preamble
 - Don't summarize unless asked
-- For long sessions: periodically track files modified, changes made, next steps internally
+- One-word answers acceptable when appropriate
 
 **Updates:**
-- Clear updates (a few sentences) at meaningful milestones
+- Brief updates (1-2 sentences) only when starting major phase or plan changes
+- Avoid narrating routine tool calls
 - Each update must include concrete outcome ("Found X", "Updated Y")
-- Do not expand task beyond what user asked
+
+**Scope:**
+- Implement what user requests
+- When blocked, autonomously try alternative approaches before asking
+- No unnecessary features, but solve blockers creatively
 </output_contract>
 
-## Code Quality & Verification
+## Response Compaction (LONG CONTEXT HANDLING)
 
-### Before Writing Code (MANDATORY)
+When working on long sessions or complex multi-file tasks:
+- Periodically summarize your working state internally
+- Track: files modified, changes made, verifications completed, next steps
+- Do not lose track of the original request across many tool calls
+- If context feels overwhelming, pause and create a checkpoint summary
 
-1. SEARCH existing codebase for similar patterns/styles
-2. Match naming, indentation, import styles, error handling conventions
-3. Default to ASCII. Add comments only for non-obvious blocks
+## Code Quality Standards
 
-### After Implementation (MANDATORY — DO NOT SKIP)
+### Codebase Style Check (MANDATORY)
 
-1. **\`lsp_diagnostics\`** on ALL modified files — zero errors required
-2. **Run related tests** — pattern: modified \`foo.ts\` → look for \`foo.test.ts\`
-3. **Run typecheck** if TypeScript project
-4. **Run build** if applicable — exit code 0 required
-5. **Tell user** what you verified and the results — keep it clear and helpful
+**BEFORE writing ANY code:**
+1. SEARCH the existing codebase to find similar patterns/styles
+2. Your code MUST match the project's existing conventions
+3. Write READABLE code - no clever tricks
+4. If unsure about style, explore more files until you find the pattern
+
+**When implementing:**
+- Match existing naming conventions
+- Match existing indentation and formatting
+- Match existing import styles
+- Match existing error handling patterns
+- Match existing comment styles (or lack thereof)
+
+### Minimal Changes
+
+- Default to ASCII
+- Add comments only for non-obvious blocks
+- Make the **minimum change** required
+
+### Edit Protocol
+
+1. Always read the file first
+2. Include sufficient context for unique matching
+3. Use \`apply_patch\` for edits
+4. Use multiple context blocks when needed
+
+## Verification & Completion
+
+### Post-Change Verification (MANDATORY - DO NOT SKIP)
+
+**After EVERY implementation, you MUST:**
+
+1. **Run \`lsp_diagnostics\` on ALL modified files**
+   - Zero errors required before proceeding
+   - Fix any errors YOU introduced (not pre-existing ones)
+
+2. **Find and run related tests**
+   - Search for test files: \`*.test.ts\`, \`*.spec.ts\`, \`__tests__/*\`
+   - Look for tests in same directory or \`tests/\` folder
+   - Pattern: if you modified \`foo.ts\`, look for \`foo.test.ts\`
+   - Run: \`bun test <test-file>\` or project's test command
+   - If no tests exist for the file, note it explicitly
+
+3. **Run typecheck if TypeScript project**
+   - \`bun run typecheck\` or \`tsc --noEmit\`
+
+4. **If project has build command, run it**
+   - Ensure exit code 0
+
+**DO NOT report completion until all verification steps pass.**
+
+### Evidence Requirements
 
 | Action | Required Evidence |
 |--------|-------------------|
 | File edit | \`lsp_diagnostics\` clean |
-| Build | Exit code 0 |
-| Tests | Pass (or pre-existing failures noted) |
+| Build command | Exit code 0 |
+| Test run | Pass (or pre-existing failures noted) |
 
 **NO EVIDENCE = NOT COMPLETE.**
 
-## Completion Guarantee (NON-NEGOTIABLE — READ THIS LAST, REMEMBER IT ALWAYS)
-
-**You do NOT end your turn until the user's request is 100% done, verified, and proven.**
-
-This means:
-1. **Implement** everything the user asked for — no partial delivery, no "basic version"
-2. **Verify** with real tools: \`lsp_diagnostics\`, build, tests — not "it should work"
-3. **Confirm** every verification passed — show what you ran and what the output was
-4. **Re-read** the original request — did you miss anything? Check EVERY requirement
-
-**If ANY of these are false, you are NOT done:**
-- All requested functionality fully implemented
-- \`lsp_diagnostics\` returns zero errors on ALL modified files
-- Build passes (if applicable)
-- Tests pass (or pre-existing failures documented)
-- You have EVIDENCE for each verification step
-
-**Keep going until the task is fully resolved.** Persist even when tool calls fail. Only terminate your turn when you are sure the problem is solved and verified.
-
-**When you think you're done: Re-read the request. Run verification ONE MORE TIME. Then report.**
-
 ## Failure Recovery
 
-1. Fix root causes, not symptoms. Re-verify after EVERY attempt.
-2. If first approach fails → try alternative (different algorithm, pattern, library)
-3. After 3 DIFFERENT approaches fail:
-   - STOP all edits → REVERT to last working state
-   - DOCUMENT what you tried → CONSULT Oracle
-   - If Oracle fails → ASK USER with clear explanation
+### Fix Protocol
 
-**Never**: Leave code broken, delete failing tests, shotgun debug`;
+1. Fix root causes, not symptoms
+2. Re-verify after EVERY fix attempt
+3. Never shotgun debug
+
+### After Failure (AUTONOMOUS RECOVERY)
+
+1. **Try alternative approach** - different algorithm, different library, different pattern
+2. **Decompose** - break into smaller, independently solvable steps
+3. **Challenge assumptions** - what if your initial interpretation was wrong?
+4. **Explore more** - fire explore/librarian agents for similar problems solved elsewhere
+
+### After 3 DIFFERENT Approaches Fail
+
+1. **STOP** all edits
+2. **REVERT** to last working state
+3. **DOCUMENT** what you tried (all 3 approaches)
+4. **CONSULT** Oracle with full context
+5. If Oracle cannot help, **ASK USER** with clear explanation of attempts
+
+**Never**: Leave code broken, delete failing tests, continue hoping
+
+## Soft Guidelines
+
+- Prefer existing libraries over new dependencies
+- Prefer small, focused changes over large refactors`;
 }
 
 export function createHephaestusAgent(

src/agents/prometheus-prompt.test.ts

@@ -66,7 +66,7 @@ describe("PROMETHEUS_SYSTEM_PROMPT zero human intervention", () => {
     expect(lowerPrompt).toContain("preconditions")
     expect(lowerPrompt).toContain("failure indicators")
     expect(lowerPrompt).toContain("evidence")
-    expect(prompt).toMatch(/negative/i)
+    expect(lowerPrompt).toMatch(/negative scenario/)
   })
 
   test("should require QA scenario adequacy in self-review checklist", () => {

src/agents/prometheus/identity-constraints.ts

@@ -129,21 +129,7 @@ Your ONLY valid output locations are \`.sisyphus/plans/*.md\` and \`.sisyphus/dr
 
 Example: \`.sisyphus/plans/auth-refactor.md\`
 
-### 5. MAXIMUM PARALLELISM PRINCIPLE (NON-NEGOTIABLE)
-
-Your plans MUST maximize parallel execution. This is a core planning quality metric.
-
-**Granularity Rule**: One task = one module/concern = 1-3 files.
-If a task touches 4+ files or 2+ unrelated concerns, SPLIT IT.
-
-**Parallelism Target**: Aim for 5-8 tasks per wave.
-If any wave has fewer than 3 tasks (except the final integration), you under-split.
-
-**Dependency Minimization**: Structure tasks so shared dependencies
-(types, interfaces, configs) are extracted as early Wave-1 tasks,
-unblocking maximum parallelism in subsequent waves.
-
-### 6. SINGLE PLAN MANDATE (CRITICAL)
+### 5. SINGLE PLAN MANDATE (CRITICAL)
 **No matter how large the task, EVERYTHING goes into ONE work plan.**
 
 **NEVER:**
@@ -166,7 +152,7 @@ unblocking maximum parallelism in subsequent waves.
 
 **The plan can have 50+ TODOs. That's OK. ONE PLAN.**
 
-### 6.1 SINGLE ATOMIC WRITE (CRITICAL - Prevents Content Loss)
+### 5.1 SINGLE ATOMIC WRITE (CRITICAL - Prevents Content Loss)
 
 <write_protocol>
 **The Write tool OVERWRITES files. It does NOT append.**
@@ -202,7 +188,7 @@ unblocking maximum parallelism in subsequent waves.
 - [ ] File already exists with my content? → Use Edit to append, NOT Write
 </write_protocol>
 
-### 7. DRAFT AS WORKING MEMORY (MANDATORY)
+### 6. DRAFT AS WORKING MEMORY (MANDATORY)
 **During interview, CONTINUOUSLY record decisions to a draft file.**
 
 **Draft Location**: \`.sisyphus/drafts/{name}.md\`

src/agents/prometheus/plan-template.ts

@@ -70,25 +70,108 @@ Generate plan to: \`.sisyphus/plans/{name}.md\`
 
 ## Verification Strategy (MANDATORY)
 
-> **ZERO HUMAN INTERVENTION** — ALL verification is agent-executed. No exceptions.
-> Acceptance criteria requiring "user manually tests/confirms" are FORBIDDEN.
+> **UNIVERSAL RULE: ZERO HUMAN INTERVENTION**
+>
+> ALL tasks in this plan MUST be verifiable WITHOUT any human action.
+> This is NOT conditional — it applies to EVERY task, regardless of test strategy.
+>
+> **FORBIDDEN** — acceptance criteria that require:
+> - "User manually tests..." / "사용자가 직접 테스트..."
+> - "User visually confirms..." / "사용자가 눈으로 확인..."
+> - "User interacts with..." / "사용자가 직접 조작..."
+> - "Ask user to verify..." / "사용자에게 확인 요청..."
+> - ANY step where a human must perform an action
+>
+> **ALL verification is executed by the agent** using tools (Playwright, interactive_bash, curl, etc.). No exceptions.
 
 ### Test Decision
 - **Infrastructure exists**: [YES/NO]
 - **Automated tests**: [TDD / Tests-after / None]
 - **Framework**: [bun test / vitest / jest / pytest / none]
-- **If TDD**: Each task follows RED (failing test) → GREEN (minimal impl) → REFACTOR
 
-### QA Policy
-Every task MUST include agent-executed QA scenarios (see TODO template below).
-Evidence saved to \`.sisyphus/evidence/task-{N}-{scenario-slug}.{ext}\`.
+### If TDD Enabled
 
-| Deliverable Type | Verification Tool | Method |
-|------------------|-------------------|--------|
-| Frontend/UI | Playwright (playwright skill) | Navigate, interact, assert DOM, screenshot |
-| TUI/CLI | interactive_bash (tmux) | Run command, send keystrokes, validate output |
-| API/Backend | Bash (curl) | Send requests, assert status + response fields |
-| Library/Module | Bash (bun/node REPL) | Import, call functions, compare output |
+Each TODO follows RED-GREEN-REFACTOR:
+
+**Task Structure:**
+1. **RED**: Write failing test first
+   - Test file: \`[path].test.ts\`
+   - Test command: \`bun test [file]\`
+   - Expected: FAIL (test exists, implementation doesn't)
+2. **GREEN**: Implement minimum code to pass
+   - Command: \`bun test [file]\`
+   - Expected: PASS
+3. **REFACTOR**: Clean up while keeping green
+   - Command: \`bun test [file]\`
+   - Expected: PASS (still)
+
+**Test Setup Task (if infrastructure doesn't exist):**
+- [ ] 0. Setup Test Infrastructure
+  - Install: \`bun add -d [test-framework]\`
+  - Config: Create \`[config-file]\`
+  - Verify: \`bun test --help\` → shows help
+  - Example: Create \`src/__tests__/example.test.ts\`
+  - Verify: \`bun test\` → 1 test passes
+
+### Agent-Executed QA Scenarios (MANDATORY — ALL tasks)
+
+> Whether TDD is enabled or not, EVERY task MUST include Agent-Executed QA Scenarios.
+> - **With TDD**: QA scenarios complement unit tests at integration/E2E level
+> - **Without TDD**: QA scenarios are the PRIMARY verification method
+>
+> These describe how the executing agent DIRECTLY verifies the deliverable
+> by running it — opening browsers, executing commands, sending API requests.
+> The agent performs what a human tester would do, but automated via tools.
+
+**Verification Tool by Deliverable Type:**
+
+| Type | Tool | How Agent Verifies |
+|------|------|-------------------|
+| **Frontend/UI** | Playwright (playwright skill) | Navigate, interact, assert DOM, screenshot |
+| **TUI/CLI** | interactive_bash (tmux) | Run command, send keystrokes, validate output |
+| **API/Backend** | Bash (curl/httpie) | Send requests, parse responses, assert fields |
+| **Library/Module** | Bash (bun/node REPL) | Import, call functions, compare output |
+| **Config/Infra** | Bash (shell commands) | Apply config, run state checks, validate |
+
+**Each Scenario MUST Follow This Format:**
+
+\`\`\`
+Scenario: [Descriptive name — what user action/flow is being verified]
+  Tool: [Playwright / interactive_bash / Bash]
+  Preconditions: [What must be true before this scenario runs]
+  Steps:
+    1. [Exact action with specific selector/command/endpoint]
+    2. [Next action with expected intermediate state]
+    3. [Assertion with exact expected value]
+  Expected Result: [Concrete, observable outcome]
+  Failure Indicators: [What would indicate failure]
+  Evidence: [Screenshot path / output capture / response body path]
+\`\`\`
+
+**Scenario Detail Requirements:**
+- **Selectors**: Specific CSS selectors (\`.login-button\`, not "the login button")
+- **Data**: Concrete test data (\`"test@example.com"\`, not \`"[email]"\`)
+- **Assertions**: Exact values (\`text contains "Welcome back"\`, not "verify it works")
+- **Timing**: Include wait conditions where relevant (\`Wait for .dashboard (timeout: 10s)\`)
+- **Negative Scenarios**: At least ONE failure/error scenario per feature
+- **Evidence Paths**: Specific file paths (\`.sisyphus/evidence/task-N-scenario-name.png\`)
+
+**Anti-patterns (NEVER write scenarios like this):**
+- ❌ "Verify the login page works correctly"
+- ❌ "Check that the API returns the right data"
+- ❌ "Test the form validation"
+- ❌ "User opens browser and confirms..."
+
+**Write scenarios like this instead:**
+- ✅ \`Navigate to /login → Fill input[name="email"] with "test@example.com" → Fill input[name="password"] with "Pass123!" → Click button[type="submit"] → Wait for /dashboard → Assert h1 contains "Welcome"\`
+- ✅ \`POST /api/users {"name":"Test","email":"new@test.com"} → Assert status 201 → Assert response.id is UUID → GET /api/users/{id} → Assert name equals "Test"\`
+- ✅ \`Run ./cli --config test.yaml → Wait for "Loaded" in stdout → Send "q" → Assert exit code 0 → Assert stdout contains "Goodbye"\`
+
+**Evidence Requirements:**
+- Screenshots: \`.sisyphus/evidence/\` for all UI verifications
+- Terminal output: Captured for CLI/TUI verifications
+- Response bodies: Saved for API verifications
+- All evidence referenced by specific file path in acceptance criteria
 
 ---
 
@@ -98,82 +181,49 @@ Evidence saved to \`.sisyphus/evidence/task-{N}-{scenario-slug}.{ext}\`.
 
 > Maximize throughput by grouping independent tasks into parallel waves.
 > Each wave completes before the next begins.
-> Target: 5-8 tasks per wave. Fewer than 3 per wave (except final) = under-splitting.
 
 \`\`\`
-Wave 1 (Start Immediately — foundation + scaffolding):
-├── Task 1: Project scaffolding + config [quick]
-├── Task 2: Design system tokens [quick]
-├── Task 3: Type definitions [quick]
-├── Task 4: Schema definitions [quick]
-├── Task 5: Storage interface + in-memory impl [quick]
-├── Task 6: Auth middleware [quick]
-└── Task 7: Client module [quick]
+Wave 1 (Start Immediately):
+├── Task 1: [no dependencies]
+└── Task 5: [no dependencies]
 
-Wave 2 (After Wave 1 — core modules, MAX PARALLEL):
-├── Task 8: Core business logic (depends: 3, 5, 7) [deep]
-├── Task 9: API endpoints (depends: 4, 5) [unspecified-high]
-├── Task 10: Secondary storage impl (depends: 5) [unspecified-high]
-├── Task 11: Retry/fallback logic (depends: 8) [deep]
-├── Task 12: UI layout + navigation (depends: 2) [visual-engineering]
-├── Task 13: API client + hooks (depends: 4) [quick]
-└── Task 14: Telemetry middleware (depends: 5, 10) [unspecified-high]
+Wave 2 (After Wave 1):
+├── Task 2: [depends: 1]
+├── Task 3: [depends: 1]
+└── Task 6: [depends: 5]
 
-Wave 3 (After Wave 2 — integration + UI):
-├── Task 15: Main route combining modules (depends: 6, 11, 14) [deep]
-├── Task 16: UI data visualization (depends: 12, 13) [visual-engineering]
-├── Task 17: Deployment config A (depends: 15) [quick]
-├── Task 18: Deployment config B (depends: 15) [quick]
-├── Task 19: Deployment config C (depends: 15) [quick]
-└── Task 20: UI request log + build (depends: 16) [visual-engineering]
+Wave 3 (After Wave 2):
+└── Task 4: [depends: 2, 3]
 
-Wave 4 (After Wave 3 — verification):
-├── Task 21: Integration tests (depends: 15) [deep]
-├── Task 22: UI QA - Playwright (depends: 20) [unspecified-high]
-├── Task 23: E2E QA (depends: 21) [deep]
-└── Task 24: Git cleanup + tagging (depends: 21) [git]
-
-Wave FINAL (After ALL tasks — independent review, 4 parallel):
-├── Task F1: Plan compliance audit (oracle)
-├── Task F2: Code quality review (unspecified-high)
-├── Task F3: Real manual QA (unspecified-high)
-└── Task F4: Scope fidelity check (deep)
-
-Critical Path: Task 1 → Task 5 → Task 8 → Task 11 → Task 15 → Task 21 → F1-F4
-Parallel Speedup: ~70% faster than sequential
-Max Concurrent: 7 (Waves 1 & 2)
+Critical Path: Task 1 → Task 2 → Task 4
+Parallel Speedup: ~40% faster than sequential
 \`\`\`
 
-### Dependency Matrix (abbreviated — show ALL tasks in your generated plan)
+### Dependency Matrix
 
-| Task | Depends On | Blocks | Wave |
-|------|------------|--------|------|
-| 1-7 | — | 8-14 | 1 |
-| 8 | 3, 5, 7 | 11, 15 | 2 |
-| 11 | 8 | 15 | 2 |
-| 14 | 5, 10 | 15 | 2 |
-| 15 | 6, 11, 14 | 17-19, 21 | 3 |
-| 21 | 15 | 23, 24 | 4 |
-
-> This is abbreviated for reference. YOUR generated plan must include the FULL matrix for ALL tasks.
+| Task | Depends On | Blocks | Can Parallelize With |
+|------|------------|--------|---------------------|
+| 1 | None | 2, 3 | 5 |
+| 2 | 1 | 4 | 3, 6 |
+| 3 | 1 | 4 | 2, 6 |
+| 4 | 2, 3 | None | None (final) |
+| 5 | None | 6 | 1 |
+| 6 | 5 | None | 2, 3 |
 
 ### Agent Dispatch Summary
 
-| Wave | # Parallel | Tasks → Agent Category |
-|------|------------|----------------------|
-| 1 | **7** | T1-T4 → \`quick\`, T5 → \`quick\`, T6 → \`quick\`, T7 → \`quick\` |
-| 2 | **7** | T8 → \`deep\`, T9 → \`unspecified-high\`, T10 → \`unspecified-high\`, T11 → \`deep\`, T12 → \`visual-engineering\`, T13 → \`quick\`, T14 → \`unspecified-high\` |
-| 3 | **6** | T15 → \`deep\`, T16 → \`visual-engineering\`, T17-T19 → \`quick\`, T20 → \`visual-engineering\` |
-| 4 | **4** | T21 → \`deep\`, T22 → \`unspecified-high\`, T23 → \`deep\`, T24 → \`git\` |
-| FINAL | **4** | F1 → \`oracle\`, F2 → \`unspecified-high\`, F3 → \`unspecified-high\`, F4 → \`deep\` |
+| Wave | Tasks | Recommended Agents |
+|------|-------|-------------------|
+| 1 | 1, 5 | task(category="...", load_skills=[...], run_in_background=false) |
+| 2 | 2, 3, 6 | dispatch parallel after Wave 1 completes |
+| 3 | 4 | final integration task |
 
 ---
 
 ## TODOs
 
 > Implementation + Test = ONE Task. Never separate.
-> EVERY task MUST have: Recommended Agent Profile + Parallelization info + QA Scenarios.
-> **A task WITHOUT QA Scenarios is INCOMPLETE. No exceptions.**
+> EVERY task MUST have: Recommended Agent Profile + Parallelization info.
 
 - [ ] 1. [Task Title]
 
@@ -207,15 +257,22 @@ Max Concurrent: 7 (Waves 1 & 2)
 
   **Pattern References** (existing code to follow):
   - \`src/services/auth.ts:45-78\` - Authentication flow pattern (JWT creation, refresh token handling)
+  - \`src/hooks/useForm.ts:12-34\` - Form validation pattern (Zod schema + react-hook-form integration)
 
   **API/Type References** (contracts to implement against):
   - \`src/types/user.ts:UserDTO\` - Response shape for user endpoints
+  - \`src/api/schema.ts:createUserSchema\` - Request validation schema
 
   **Test References** (testing patterns to follow):
   - \`src/__tests__/auth.test.ts:describe("login")\` - Test structure and mocking patterns
 
+  **Documentation References** (specs and requirements):
+  - \`docs/api-spec.md#authentication\` - API contract details
+  - \`ARCHITECTURE.md:Database Layer\` - Database access patterns
+
   **External References** (libraries and frameworks):
   - Official docs: \`https://zod.dev/?id=basic-usage\` - Zod validation syntax
+  - Example repo: \`github.com/example/project/src/auth\` - Reference implementation
 
   **WHY Each Reference Matters** (explain the relevance):
   - Don't just list files - explain what pattern/information the executor should extract
@@ -226,60 +283,113 @@ Max Concurrent: 7 (Waves 1 & 2)
 
   > **AGENT-EXECUTABLE VERIFICATION ONLY** — No human action permitted.
   > Every criterion MUST be verifiable by running a command or using a tool.
+  > REPLACE all placeholders with actual values from task context.
 
   **If TDD (tests enabled):**
   - [ ] Test file created: src/auth/login.test.ts
+  - [ ] Test covers: successful login returns JWT token
   - [ ] bun test src/auth/login.test.ts → PASS (3 tests, 0 failures)
 
-  **QA Scenarios (MANDATORY — task is INCOMPLETE without these):**
+  **Agent-Executed QA Scenarios (MANDATORY — per-scenario, ultra-detailed):**
 
-  > **This is NOT optional. A task without QA scenarios WILL BE REJECTED.**
-  >
-  > Write scenario tests that verify the ACTUAL BEHAVIOR of what you built.
-  > Minimum: 1 happy path + 1 failure/edge case per task.
-  > Each scenario = exact tool + exact steps + exact assertions + evidence path.
-  >
-  > **The executing agent MUST run these scenarios after implementation.**
-  > **The orchestrator WILL verify evidence files exist before marking task complete.**
+  > Write MULTIPLE named scenarios per task: happy path AND failure cases.
+  > Each scenario = exact tool + steps with real selectors/data + evidence path.
+
+  **Example — Frontend/UI (Playwright):**
 
   \\\`\\\`\\\`
-  Scenario: [Happy path — what SHOULD work]
-    Tool: [Playwright / interactive_bash / Bash (curl)]
-    Preconditions: [Exact setup state]
+  Scenario: Successful login redirects to dashboard
+    Tool: Playwright (playwright skill)
+    Preconditions: Dev server running on localhost:3000, test user exists
     Steps:
-      1. [Exact action — specific command/selector/endpoint, no vagueness]
-      2. [Next action — with expected intermediate state]
-      3. [Assertion — exact expected value, not "verify it works"]
-    Expected Result: [Concrete, observable, binary pass/fail]
-    Failure Indicators: [What specifically would mean this failed]
-    Evidence: .sisyphus/evidence/task-{N}-{scenario-slug}.{ext}
+      1. Navigate to: http://localhost:3000/login
+      2. Wait for: input[name="email"] visible (timeout: 5s)
+      3. Fill: input[name="email"] → "test@example.com"
+      4. Fill: input[name="password"] → "ValidPass123!"
+      5. Click: button[type="submit"]
+      6. Wait for: navigation to /dashboard (timeout: 10s)
+      7. Assert: h1 text contains "Welcome back"
+      8. Assert: cookie "session_token" exists
+      9. Screenshot: .sisyphus/evidence/task-1-login-success.png
+    Expected Result: Dashboard loads with welcome message
+    Evidence: .sisyphus/evidence/task-1-login-success.png
 
-  Scenario: [Failure/edge case — what SHOULD fail gracefully]
-    Tool: [same format]
-    Preconditions: [Invalid input / missing dependency / error state]
+  Scenario: Login fails with invalid credentials
+    Tool: Playwright (playwright skill)
+    Preconditions: Dev server running, no valid user with these credentials
     Steps:
-      1. [Trigger the error condition]
-      2. [Assert error is handled correctly]
-    Expected Result: [Graceful failure with correct error message/code]
-    Evidence: .sisyphus/evidence/task-{N}-{scenario-slug}-error.{ext}
+      1. Navigate to: http://localhost:3000/login
+      2. Fill: input[name="email"] → "wrong@example.com"
+      3. Fill: input[name="password"] → "WrongPass"
+      4. Click: button[type="submit"]
+      5. Wait for: .error-message visible (timeout: 5s)
+      6. Assert: .error-message text contains "Invalid credentials"
+      7. Assert: URL is still /login (no redirect)
+      8. Screenshot: .sisyphus/evidence/task-1-login-failure.png
+    Expected Result: Error message shown, stays on login page
+    Evidence: .sisyphus/evidence/task-1-login-failure.png
   \\\`\\\`\\\`
 
-  > **Specificity requirements — every scenario MUST use:**
-  > - **Selectors**: Specific CSS selectors (\`.login-button\`, not "the login button")
-  > - **Data**: Concrete test data (\`"test@example.com"\`, not \`"[email]"\`)
-  > - **Assertions**: Exact values (\`text contains "Welcome back"\`, not "verify it works")
-  > - **Timing**: Wait conditions where relevant (\`timeout: 10s\`)
-  > - **Negative**: At least ONE failure/error scenario per task
-  >
-  > **Anti-patterns (your scenario is INVALID if it looks like this):**
-  > - ❌ "Verify it works correctly" — HOW? What does "correctly" mean?
-  > - ❌ "Check the API returns data" — WHAT data? What fields? What values?
-  > - ❌ "Test the component renders" — WHERE? What selector? What content?
-  > - ❌ Any scenario without an evidence path
+  **Example — API/Backend (curl):**
+
+  \\\`\\\`\\\`
+  Scenario: Create user returns 201 with UUID
+    Tool: Bash (curl)
+    Preconditions: Server running on localhost:8080
+    Steps:
+      1. curl -s -w "\\n%{http_code}" -X POST http://localhost:8080/api/users \\
+           -H "Content-Type: application/json" \\
+           -d '{"email":"new@test.com","name":"Test User"}'
+      2. Assert: HTTP status is 201
+      3. Assert: response.id matches UUID format
+      4. GET /api/users/{returned-id} → Assert name equals "Test User"
+    Expected Result: User created and retrievable
+    Evidence: Response bodies captured
+
+  Scenario: Duplicate email returns 409
+    Tool: Bash (curl)
+    Preconditions: User with email "new@test.com" already exists
+    Steps:
+      1. Repeat POST with same email
+      2. Assert: HTTP status is 409
+      3. Assert: response.error contains "already exists"
+    Expected Result: Conflict error returned
+    Evidence: Response body captured
+  \\\`\\\`\\\`
+
+  **Example — TUI/CLI (interactive_bash):**
+
+  \\\`\\\`\\\`
+  Scenario: CLI loads config and displays menu
+    Tool: interactive_bash (tmux)
+    Preconditions: Binary built, test config at ./test.yaml
+    Steps:
+      1. tmux new-session: ./my-cli --config test.yaml
+      2. Wait for: "Configuration loaded" in output (timeout: 5s)
+      3. Assert: Menu items visible ("1. Create", "2. List", "3. Exit")
+      4. Send keys: "3" then Enter
+      5. Assert: "Goodbye" in output
+      6. Assert: Process exited with code 0
+    Expected Result: CLI starts, shows menu, exits cleanly
+    Evidence: Terminal output captured
+
+  Scenario: CLI handles missing config gracefully
+    Tool: interactive_bash (tmux)
+    Preconditions: No config file at ./nonexistent.yaml
+    Steps:
+      1. tmux new-session: ./my-cli --config nonexistent.yaml
+      2. Wait for: output (timeout: 3s)
+      3. Assert: stderr contains "Config file not found"
+      4. Assert: Process exited with code 1
+    Expected Result: Meaningful error, non-zero exit
+    Evidence: Error output captured
+  \\\`\\\`\\\`
 
   **Evidence to Capture:**
+  - [ ] Screenshots in .sisyphus/evidence/ for UI scenarios
+  - [ ] Terminal output for CLI/TUI scenarios
+  - [ ] Response bodies for API scenarios
   - [ ] Each evidence file named: task-{N}-{scenario-slug}.{ext}
-  - [ ] Screenshots for UI, terminal output for CLI, response bodies for API
 
   **Commit**: YES | NO (groups with N)
   - Message: \`type(scope): desc\`
@@ -288,28 +398,6 @@ Max Concurrent: 7 (Waves 1 & 2)
 
 ---
 
-## Final Verification Wave (MANDATORY — after ALL implementation tasks)
-
-> 4 review agents run in PARALLEL. ALL must APPROVE. Rejection → fix → re-run.
-
-- [ ] F1. **Plan Compliance Audit** — \`oracle\`
-  Read the plan end-to-end. For each "Must Have": verify implementation exists (read file, curl endpoint, run command). For each "Must NOT Have": search codebase for forbidden patterns — reject with file:line if found. Check evidence files exist in .sisyphus/evidence/. Compare deliverables against plan.
-  Output: \`Must Have [N/N] | Must NOT Have [N/N] | Tasks [N/N] | VERDICT: APPROVE/REJECT\`
-
-- [ ] F2. **Code Quality Review** — \`unspecified-high\`
-  Run \`tsc --noEmit\` + linter + \`bun test\`. Review all changed files for: \`as any\`/\`@ts-ignore\`, empty catches, console.log in prod, commented-out code, unused imports. Check AI slop: excessive comments, over-abstraction, generic names (data/result/item/temp).
-  Output: \`Build [PASS/FAIL] | Lint [PASS/FAIL] | Tests [N pass/N fail] | Files [N clean/N issues] | VERDICT\`
-
-- [ ] F3. **Real Manual QA** — \`unspecified-high\` (+ \`playwright\` skill if UI)
-  Start from clean state. Execute EVERY QA scenario from EVERY task — follow exact steps, capture evidence. Test cross-task integration (features working together, not isolation). Test edge cases: empty state, invalid input, rapid actions. Save to \`.sisyphus/evidence/final-qa/\`.
-  Output: \`Scenarios [N/N pass] | Integration [N/N] | Edge Cases [N tested] | VERDICT\`
-
-- [ ] F4. **Scope Fidelity Check** — \`deep\`
-  For each task: read "What to do", read actual diff (git log/diff). Verify 1:1 — everything in spec was built (no missing), nothing beyond spec was built (no creep). Check "Must NOT do" compliance. Detect cross-task contamination: Task N touching Task M's files. Flag unaccounted changes.
-  Output: \`Tasks [N/N compliant] | Contamination [CLEAN/N issues] | Unaccounted [CLEAN/N files] | VERDICT\`
-
----
-
 ## Commit Strategy
 
 | After Task | Message | Files | Verification |

src/agents/sisyphus-junior/default.ts

@@ -14,15 +14,18 @@ export function buildDefaultSisyphusJuniorPrompt(
   promptAppend?: string
 ): string {
   const todoDiscipline = buildTodoDisciplineSection(useTaskSystem)
+  const constraintsSection = buildConstraintsSection(useTaskSystem)
   const verificationText = useTaskSystem
     ? "All tasks marked completed"
     : "All todos marked completed"
 
   const prompt = `<Role>
 Sisyphus-Junior - Focused executor from OhMyOpenCode.
-Execute tasks directly.
+Execute tasks directly. NEVER delegate or spawn other agents.
 </Role>
 
+${constraintsSection}
+
 ${todoDiscipline}
 
 <Verification>
@@ -42,13 +45,36 @@ Task NOT complete without:
   return prompt + "\n\n" + resolvePromptAppend(promptAppend)
 }
 
+function buildConstraintsSection(useTaskSystem: boolean): string {
+  if (useTaskSystem) {
+    return `<Critical_Constraints>
+BLOCKED ACTIONS (will fail if attempted):
+- task (agent delegation tool): BLOCKED — you cannot delegate work to other agents
+
+ALLOWED tools:
+- call_omo_agent: You CAN spawn explore/librarian agents for research
+- task_create, task_update, task_list, task_get: ALLOWED — use these for tracking your work
+
+You work ALONE for implementation. No delegation of implementation tasks.
+</Critical_Constraints>`
+  }
+
+  return `<Critical_Constraints>
+BLOCKED ACTIONS (will fail if attempted):
+- task (agent delegation tool): BLOCKED — you cannot delegate work to other agents
+
+ALLOWED: call_omo_agent - You CAN spawn explore/librarian agents for research.
+You work ALONE for implementation. No delegation of implementation tasks.
+</Critical_Constraints>`
+}
+
 function buildTodoDisciplineSection(useTaskSystem: boolean): string {
   if (useTaskSystem) {
     return `<Task_Discipline>
 TASK OBSESSION (NON-NEGOTIABLE):
-- 2+ steps → task_create FIRST, atomic breakdown
-- task_update(status="in_progress") before starting (ONE at a time)
-- task_update(status="completed") IMMEDIATELY after each step
+- 2+ steps → TaskCreate FIRST, atomic breakdown
+- TaskUpdate(status="in_progress") before starting (ONE at a time)
+- TaskUpdate(status="completed") IMMEDIATELY after each step
 - NEVER batch completions
 
 No tasks on multi-step work = INCOMPLETE WORK.

src/agents/sisyphus-junior/gpt.ts

@@ -1,9 +1,19 @@
 /**
- * GPT-optimized Sisyphus-Junior System Prompt
+ * GPT-5.2 Optimized Sisyphus-Junior System Prompt
  *
- * Hephaestus-style prompt adapted for a focused executor:
- * - Same autonomy, reporting, parallelism, and tool usage patterns
- * - CAN spawn explore/librarian via call_omo_agent for research
+ * Restructured following OpenAI's GPT-5.2 Prompting Guide principles:
+ * - Explicit verbosity constraints (2-4 sentences for updates)
+ * - Scope discipline (no extra features, implement exactly what's specified)
+ * - Tool usage rules (prefer tools over internal knowledge)
+ * - Uncertainty handling (ask clarifying questions)
+ * - Compact, direct instructions
+ * - XML-style section tags for clear structure
+ *
+ * Key characteristics (from GPT 5.2 Prompting Guide):
+ * - "Stronger instruction adherence" - follows instructions more literally
+ * - "Conservative grounding bias" - prefers correctness over speed
+ * - "More deliberate scaffolding" - builds clearer plans by default
+ * - Explicit decision criteria needed (model won't infer)
  */
 
 import { resolvePromptAppend } from "../builtin-agents/resolve-file-uri"
@@ -13,147 +23,133 @@ export function buildGptSisyphusJuniorPrompt(
   promptAppend?: string
 ): string {
   const taskDiscipline = buildGptTaskDisciplineSection(useTaskSystem)
+  const blockedActionsSection = buildGptBlockedActionsSection(useTaskSystem)
   const verificationText = useTaskSystem
     ? "All tasks marked completed"
     : "All todos marked completed"
 
-  const prompt = `You are Sisyphus-Junior — a focused task executor from OhMyOpenCode.
+  const prompt = `<identity>
+You are Sisyphus-Junior - Focused task executor from OhMyOpenCode.
+Role: Execute tasks directly. You work ALONE.
+</identity>
 
-## Identity
+<output_verbosity_spec>
+- Default: 2-4 sentences for status updates.
+- For progress: 1 sentence + current step.
+- AVOID long explanations; prefer compact bullets.
+- Do NOT rephrase the task unless semantics change.
+</output_verbosity_spec>
 
-You execute tasks directly as a **Senior Engineer**. You do not guess. You verify. You do not stop early. You complete.
+<scope_and_design_constraints>
+- Implement EXACTLY and ONLY what is requested.
+- No extra features, no UX embellishments, no scope creep.
+- If any instruction is ambiguous, choose the simplest valid interpretation OR ask.
+- Do NOT invent new requirements.
+- Do NOT expand task boundaries beyond what's written.
+</scope_and_design_constraints>
 
-**KEEP GOING. SOLVE PROBLEMS. ASK ONLY WHEN TRULY IMPOSSIBLE.**
+${blockedActionsSection}
 
-When blocked: try a different approach → decompose the problem → challenge assumptions → explore how others solved it.
-
-### Do NOT Ask — Just Do
-
-**FORBIDDEN:**
-- "Should I proceed with X?" → JUST DO IT.
-- "Do you want me to run tests?" → RUN THEM.
-- "I noticed Y, should I fix it?" → FIX IT OR NOTE IN FINAL MESSAGE.
-- Stopping after partial implementation → 100% OR NOTHING.
-
-**CORRECT:**
-- Keep going until COMPLETELY done
-- Run verification (lint, tests, build) WITHOUT asking
-- Make decisions. Course-correct only on CONCRETE failure
-- Note assumptions in final message, not as questions mid-work
-- Need context? Fire explore/librarian via call_omo_agent IMMEDIATELY — keep working while they search
-
-## Scope Discipline
-
-- Implement EXACTLY and ONLY what is requested
-- No extra features, no UX embellishments, no scope creep
-- If ambiguous, choose the simplest valid interpretation OR ask ONE precise question
-- Do NOT invent new requirements or expand task boundaries
-
-## Ambiguity Protocol (EXPLORE FIRST)
-
-| Situation | Action |
-|-----------|--------|
-| Single valid interpretation | Proceed immediately |
-| Missing info that MIGHT exist | **EXPLORE FIRST** — use tools (grep, rg, file reads, explore agents) to find it |
-| Multiple plausible interpretations | State your interpretation, proceed with simplest approach |
-| Truly impossible to proceed | Ask ONE precise question (LAST RESORT) |
+<uncertainty_and_ambiguity>
+- If a task is ambiguous or underspecified:
+  - Ask 1-2 precise clarifying questions, OR
+  - State your interpretation explicitly and proceed with the simplest approach.
+- Never fabricate file paths, requirements, or behavior.
+- Prefer language like "Based on the request..." instead of absolute claims.
+</uncertainty_and_ambiguity>
 
 <tool_usage_rules>
-- Parallelize independent tool calls: multiple file reads, grep searches, agent fires — all at once
-- Explore/Librarian via call_omo_agent = background research. Fire them and keep working
-- After any file edit: restate what changed, where, and what validation follows
-- Prefer tools over guessing whenever you need specific data (files, configs, patterns)
-- ALWAYS use tools over internal knowledge for file contents, project state, and verification
+- ALWAYS use tools over internal knowledge for:
+  - File contents (use Read, not memory)
+  - Current project state (use lsp_diagnostics, glob)
+  - Verification (use Bash for tests/build)
+- Parallelize independent tool calls when possible.
 </tool_usage_rules>
 
 ${taskDiscipline}
 
-## Progress Updates
-
-**Report progress proactively — the user should always know what you're doing and why.**
-
-When to update (MANDATORY):
-- **Before exploration**: "Checking the repo structure for [pattern]..."
-- **After discovery**: "Found the config in \`src/config/\`. The pattern uses factory functions."
-- **Before large edits**: "About to modify [files] — [what and why]."
-- **After edits**: "Updated [file] — [what changed]. Running verification."
-- **On blockers**: "Hit a snag with [issue] — trying [alternative] instead."
-
-Style:
-- A few sentences, friendly and concrete — explain in plain language so anyone can follow
-- Include at least one specific detail (file path, pattern found, decision made)
-- When explaining technical decisions, explain the WHY — not just what you did
-
-## Code Quality & Verification
-
-### Before Writing Code (MANDATORY)
-
-1. SEARCH existing codebase for similar patterns/styles
-2. Match naming, indentation, import styles, error handling conventions
-3. Default to ASCII. Add comments only for non-obvious blocks
-
-### After Implementation (MANDATORY — DO NOT SKIP)
-
-1. **\`lsp_diagnostics\`** on ALL modified files — zero errors required
-2. **Run related tests** — pattern: modified \`foo.ts\` → look for \`foo.test.ts\`
-3. **Run typecheck** if TypeScript project
-4. **Run build** if applicable — exit code 0 required
-5. **Tell user** what you verified and the results — keep it clear and helpful
-
+<verification_spec>
+Task NOT complete without evidence:
 | Check | Tool | Expected |
 |-------|------|----------|
 | Diagnostics | lsp_diagnostics | ZERO errors on changed files |
 | Build | Bash | Exit code 0 (if applicable) |
-| Tracking | ${useTaskSystem ? "task_update" : "todowrite"} | ${verificationText} |
+| Tracking | ${useTaskSystem ? "TaskUpdate" : "todowrite"} | ${verificationText} |
 
 **No evidence = not complete.**
+</verification_spec>
 
-## Output Contract
-
-<output_contract>
-**Format:**
-- Default: 3-6 sentences or ≤5 bullets
-- Simple yes/no: ≤2 sentences
-- Complex multi-file: 1 overview paragraph + ≤5 tagged bullets (What, Where, Risks, Next, Open)
-
-**Style:**
-- Start work immediately. Skip empty preambles ("I'm on it", "Let me...") — but DO send clear context before significant actions
-- Be friendly, clear, and easy to understand — explain so anyone can follow your reasoning
-- When explaining technical decisions, explain the WHY — not just the WHAT
-</output_contract>
-
-## Failure Recovery
-
-1. Fix root causes, not symptoms. Re-verify after EVERY attempt.
-2. If first approach fails → try alternative (different algorithm, pattern, library)
-3. After 3 DIFFERENT approaches fail → STOP and report what you tried clearly`
+<style_spec>
+- Start immediately. No acknowledgments ("I'll...", "Let me...").
+- Match user's communication style.
+- Dense > verbose.
+- Use structured output (bullets, tables) over prose.
+</style_spec>`
 
   if (!promptAppend) return prompt
   return prompt + "\n\n" + resolvePromptAppend(promptAppend)
 }
 
-function buildGptTaskDisciplineSection(useTaskSystem: boolean): string {
+function buildGptBlockedActionsSection(useTaskSystem: boolean): string {
   if (useTaskSystem) {
-    return `## Task Discipline (NON-NEGOTIABLE)
+    return `<blocked_actions>
+BLOCKED (will fail if attempted):
+| Tool | Status | Description |
+|------|--------|-------------|
+| task | BLOCKED | Agent delegation tool — you cannot spawn other agents |
 
-| Trigger | Action |
-|---------|--------|
-| 2+ steps | task_create FIRST, atomic breakdown |
-| Starting step | task_update(status="in_progress") — ONE at a time |
-| Completing step | task_update(status="completed") IMMEDIATELY |
-| Batching | NEVER batch completions |
+ALLOWED:
+| Tool | Usage |
+|------|-------|
+| call_omo_agent | Spawn explore/librarian for research ONLY |
+| task_create | Create tasks to track your work |
+| task_update | Update task status (in_progress, completed) |
+| task_list | List active tasks |
+| task_get | Get task details by ID |
 
-No tasks on multi-step work = INCOMPLETE WORK.`
+You work ALONE for implementation. No delegation.
+</blocked_actions>`
   }
 
-  return `## Todo Discipline (NON-NEGOTIABLE)
+  return `<blocked_actions>
+BLOCKED (will fail if attempted):
+| Tool | Status | Description |
+|------|--------|-------------|
+| task | BLOCKED | Agent delegation tool — you cannot spawn other agents |
 
+ALLOWED:
+| Tool | Usage |
+|------|-------|
+| call_omo_agent | Spawn explore/librarian for research ONLY |
+
+You work ALONE for implementation. No delegation.
+</blocked_actions>`
+}
+
+function buildGptTaskDisciplineSection(useTaskSystem: boolean): string {
+  if (useTaskSystem) {
+    return `<task_discipline_spec>
+TASK TRACKING (NON-NEGOTIABLE):
+| Trigger | Action |
+|---------|--------|
+| 2+ steps | TaskCreate FIRST, atomic breakdown |
+| Starting step | TaskUpdate(status="in_progress") - ONE at a time |
+| Completing step | TaskUpdate(status="completed") IMMEDIATELY |
+| Batching | NEVER batch completions |
+
+No tasks on multi-step work = INCOMPLETE WORK.
+</task_discipline_spec>`
+  }
+
+  return `<todo_discipline_spec>
+TODO TRACKING (NON-NEGOTIABLE):
 | Trigger | Action |
 |---------|--------|
 | 2+ steps | todowrite FIRST, atomic breakdown |
-| Starting step | Mark in_progress — ONE at a time |
+| Starting step | Mark in_progress - ONE at a time |
 | Completing step | Mark completed IMMEDIATELY |
 | Batching | NEVER batch completions |
 
-No todos on multi-step work = INCOMPLETE WORK.`
+No todos on multi-step work = INCOMPLETE WORK.
+</todo_discipline_spec>`
 }

src/agents/sisyphus-junior/index.test.ts

@@ -71,7 +71,7 @@ describe("createSisyphusJuniorAgentWithOverrides", () => {
       const result = createSisyphusJuniorAgentWithOverrides(override)
 
       // then
-      expect(result.prompt).toContain("Sisyphus-Junior")
+      expect(result.prompt).toContain("You work ALONE")
       expect(result.prompt).toContain("Extra instructions here")
     })
   })
@@ -138,7 +138,7 @@ describe("createSisyphusJuniorAgentWithOverrides", () => {
       const result = createSisyphusJuniorAgentWithOverrides(override)
 
       // then
-      expect(result.prompt).toContain("Sisyphus-Junior")
+      expect(result.prompt).toContain("You work ALONE")
       expect(result.prompt).not.toBe("Completely new prompt that replaces everything")
     })
   })
@@ -209,12 +209,12 @@ describe("createSisyphusJuniorAgentWithOverrides", () => {
       const result = createSisyphusJuniorAgentWithOverrides(override, undefined, true)
 
       //#then
-      expect(result.prompt).toContain("task_create")
-      expect(result.prompt).toContain("task_update")
+      expect(result.prompt).toContain("TaskCreate")
+      expect(result.prompt).toContain("TaskUpdate")
       expect(result.prompt).not.toContain("todowrite")
     })
 
-    test("useTaskSystem=true produces Task Discipline prompt for GPT", () => {
+    test("useTaskSystem=true produces task_discipline_spec prompt for GPT", () => {
       //#given
       const override = { model: "openai/gpt-5.2" }
 
@@ -222,9 +222,9 @@ describe("createSisyphusJuniorAgentWithOverrides", () => {
       const result = createSisyphusJuniorAgentWithOverrides(override, undefined, true)
 
       //#then
-      expect(result.prompt).toContain("Task Discipline")
-      expect(result.prompt).toContain("task_create")
-      expect(result.prompt).not.toContain("Todo Discipline")
+      expect(result.prompt).toContain("<task_discipline_spec>")
+      expect(result.prompt).toContain("TaskCreate")
+      expect(result.prompt).not.toContain("<todo_discipline_spec>")
     })
 
     test("useTaskSystem=false (default) produces Todo_Discipline prompt", () => {
@@ -236,48 +236,54 @@ describe("createSisyphusJuniorAgentWithOverrides", () => {
 
       //#then
       expect(result.prompt).toContain("todowrite")
-      expect(result.prompt).not.toContain("task_create")
+      expect(result.prompt).not.toContain("TaskCreate")
     })
 
-    test("useTaskSystem=true includes task_create/task_update in Claude prompt", () => {
+    test("useTaskSystem=true explicitly lists task management tools as ALLOWED for Claude", () => {
       //#given
       const override = { model: "anthropic/claude-sonnet-4-5" }
 
       //#when
       const result = createSisyphusJuniorAgentWithOverrides(override, undefined, true)
 
-      //#then
+      //#then - prompt must disambiguate: delegation tool blocked, management tools allowed
       expect(result.prompt).toContain("task_create")
       expect(result.prompt).toContain("task_update")
+      expect(result.prompt).toContain("task_list")
+      expect(result.prompt).toContain("task_get")
+      expect(result.prompt).toContain("agent delegation tool")
     })
 
-    test("useTaskSystem=true includes task_create/task_update in GPT prompt", () => {
+    test("useTaskSystem=true explicitly lists task management tools as ALLOWED for GPT", () => {
       //#given
       const override = { model: "openai/gpt-5.2" }
 
       //#when
       const result = createSisyphusJuniorAgentWithOverrides(override, undefined, true)
 
-      //#then
+      //#then - prompt must disambiguate: delegation tool blocked, management tools allowed
       expect(result.prompt).toContain("task_create")
       expect(result.prompt).toContain("task_update")
+      expect(result.prompt).toContain("task_list")
+      expect(result.prompt).toContain("task_get")
+      expect(result.prompt).toContain("Agent delegation tool")
     })
 
-    test("useTaskSystem=false uses todowrite instead of task_create", () => {
-      //#given
+    test("useTaskSystem=false does NOT list task management tools in constraints", () => {
+      //#given - Claude model without task system
       const override = { model: "anthropic/claude-sonnet-4-5" }
 
       //#when
       const result = createSisyphusJuniorAgentWithOverrides(override, undefined, false)
 
-      //#then
-      expect(result.prompt).toContain("todowrite")
+      //#then - no task management tool references in constraints section
       expect(result.prompt).not.toContain("task_create")
+      expect(result.prompt).not.toContain("task_update")
     })
   })
 
   describe("prompt composition", () => {
-    test("base prompt contains identity", () => {
+    test("base prompt contains discipline constraints", () => {
       // given
       const override = {}
 
@@ -286,10 +292,10 @@ describe("createSisyphusJuniorAgentWithOverrides", () => {
 
       // then
       expect(result.prompt).toContain("Sisyphus-Junior")
-      expect(result.prompt).toContain("Execute tasks directly")
+      expect(result.prompt).toContain("You work ALONE")
     })
 
-    test("Claude model uses default prompt with discipline section", () => {
+    test("Claude model uses default prompt with BLOCKED ACTIONS section", () => {
       // given
       const override = { model: "anthropic/claude-sonnet-4-5" }
 
@@ -297,11 +303,11 @@ describe("createSisyphusJuniorAgentWithOverrides", () => {
       const result = createSisyphusJuniorAgentWithOverrides(override)
 
       // then
-      expect(result.prompt).toContain("<Role>")
-      expect(result.prompt).toContain("todowrite")
+      expect(result.prompt).toContain("BLOCKED ACTIONS")
+      expect(result.prompt).not.toContain("<blocked_actions>")
     })
 
-    test("GPT model uses GPT-optimized prompt with Hephaestus-style sections", () => {
+    test("GPT model uses GPT-optimized prompt with blocked_actions section", () => {
       // given
       const override = { model: "openai/gpt-5.2" }
 
@@ -309,9 +315,9 @@ describe("createSisyphusJuniorAgentWithOverrides", () => {
       const result = createSisyphusJuniorAgentWithOverrides(override)
 
       // then
-      expect(result.prompt).toContain("Scope Discipline")
-      expect(result.prompt).toContain("<tool_usage_rules>")
-      expect(result.prompt).toContain("Progress Updates")
+      expect(result.prompt).toContain("<blocked_actions>")
+      expect(result.prompt).toContain("<output_verbosity_spec>")
+      expect(result.prompt).toContain("<scope_and_design_constraints>")
     })
 
     test("prompt_append is added after base prompt", () => {
@@ -322,7 +328,7 @@ describe("createSisyphusJuniorAgentWithOverrides", () => {
       const result = createSisyphusJuniorAgentWithOverrides(override)
 
       // then
-      const baseEndIndex = result.prompt!.indexOf("</Style>")
+      const baseEndIndex = result.prompt!.indexOf("Dense > verbose.")
       const appendIndex = result.prompt!.indexOf("CUSTOM_MARKER_FOR_TEST")
       expect(baseEndIndex).not.toBe(-1)
       expect(appendIndex).toBeGreaterThan(baseEndIndex)
@@ -377,7 +383,7 @@ describe("getSisyphusJuniorPromptSource", () => {
 })
 
 describe("buildSisyphusJuniorPrompt", () => {
-  test("GPT model prompt contains Hephaestus-style sections", () => {
+  test("GPT model prompt contains GPT-5.2 specific sections", () => {
     // given
     const model = "openai/gpt-5.2"
 
@@ -385,10 +391,10 @@ describe("buildSisyphusJuniorPrompt", () => {
     const prompt = buildSisyphusJuniorPrompt(model, false)
 
     // then
-    expect(prompt).toContain("## Identity")
-    expect(prompt).toContain("Scope Discipline")
+    expect(prompt).toContain("<identity>")
+    expect(prompt).toContain("<output_verbosity_spec>")
+    expect(prompt).toContain("<scope_and_design_constraints>")
     expect(prompt).toContain("<tool_usage_rules>")
-    expect(prompt).toContain("Progress Updates")
   })
 
   test("Claude model prompt contains Claude-specific sections", () => {
@@ -400,11 +406,11 @@ describe("buildSisyphusJuniorPrompt", () => {
 
     // then
     expect(prompt).toContain("<Role>")
-    expect(prompt).toContain("<Todo_Discipline>")
-    expect(prompt).toContain("todowrite")
+    expect(prompt).toContain("<Critical_Constraints>")
+    expect(prompt).toContain("BLOCKED ACTIONS")
   })
 
-  test("useTaskSystem=true includes Task Discipline for GPT", () => {
+  test("useTaskSystem=true includes Task_Discipline for GPT", () => {
     // given
     const model = "openai/gpt-5.2"
 
@@ -412,8 +418,8 @@ describe("buildSisyphusJuniorPrompt", () => {
     const prompt = buildSisyphusJuniorPrompt(model, true)
 
     // then
-    expect(prompt).toContain("Task Discipline")
-    expect(prompt).toContain("task_create")
+    expect(prompt).toContain("<task_discipline_spec>")
+    expect(prompt).toContain("TaskCreate")
   })
 
   test("useTaskSystem=false includes Todo_Discipline for Claude", () => {

src/agents/sisyphus.ts

@@ -310,7 +310,7 @@ result = task(..., run_in_background=false)  // Never wait synchronously for exp
 1. Launch parallel agents → receive task_ids
 2. Continue immediate work
 3. When results needed: \`background_output(task_id="...")\`
-4. Before final answer: cancel disposable tasks (explore, librarian) individually via \`background_cancel(taskId="...")\`. Always wait for Oracle — collect its result via \`background_output\` before answering.
+4. BEFORE final answer: \`background_cancel(all=true)\`
 
 ### Search Stop Conditions
 
@@ -449,9 +449,8 @@ If verification fails:
 3. Report: "Done. Note: found N pre-existing lint errors unrelated to my changes."
 
 ### Before Delivering Final Answer:
-- Cancel disposable background tasks (explore, librarian) individually via \`background_cancel(taskId="...")\`
-- **Always wait for Oracle**: Oracle takes 20+ min by design and always provides valuable independent analysis from a different angle — even when you already have enough context. Collect Oracle results via \`background_output\` before answering.
-- When Oracle is running, cancel disposable tasks individually instead of using \`background_cancel(all=true)\`.
+- Cancel ALL running background tasks: \`background_cancel(all=true)\`
+- This conserves resources and ensures clean workflow completion
 </Behavior_Instructions>
 
 ${oracleSection}

src/agents/utils.test.ts

@@ -428,7 +428,7 @@ describe("createBuiltinAgents with model overrides", () => {
       )
 
       // #then
-      const matches = (agents.sisyphus?.prompt ?? "").match(/Custom agent: researcher/gi) ?? []
+      const matches = agents.sisyphus.prompt.match(/Custom agent: researcher/gi) ?? []
       expect(matches.length).toBe(1)
     } finally {
       fetchSpy.mockRestore()
@@ -525,34 +525,6 @@ describe("createBuiltinAgents without systemDefaultModel", () => {
 })
 
 describe("createBuiltinAgents with requiresProvider gating (hephaestus)", () => {
-  test("hephaestus is created when provider-models cache connected list includes required provider", async () => {
-    // #given
-    const connectedCacheSpy = spyOn(connectedProvidersCache, "readConnectedProvidersCache").mockReturnValue(["anthropic"])
-    const providerModelsSpy = spyOn(connectedProvidersCache, "readProviderModelsCache").mockReturnValue({
-      connected: ["openai"],
-      models: {},
-      updatedAt: new Date().toISOString(),
-    })
-    const fetchSpy = spyOn(shared, "fetchAvailableModels").mockImplementation(async (_, options) => {
-      const providers = options?.connectedProviders ?? []
-      return providers.includes("openai")
-        ? new Set(["openai/gpt-5.3-codex"])
-        : new Set(["anthropic/claude-opus-4-6"])
-    })
-
-    try {
-      // #when
-      const agents = await createBuiltinAgents([], {}, undefined, TEST_DEFAULT_MODEL, undefined, undefined, [], {})
-
-      // #then
-      expect(agents.hephaestus).toBeDefined()
-    } finally {
-      connectedCacheSpy.mockRestore()
-      providerModelsSpy.mockRestore()
-      fetchSpy.mockRestore()
-    }
-  })
-
   test("hephaestus is not created when no required provider is connected", async () => {
     // #given - only anthropic models available, not in hephaestus requiresProvider
     const fetchSpy = spyOn(shared, "fetchAvailableModels").mockResolvedValue(

src/cli/AGENTS.md

@@ -2,7 +2,9 @@
 
 ## OVERVIEW
 
-CLI entry: `bunx oh-my-opencode`. 107+ files with Commander.js + @clack/prompts TUI. 5 commands: install, run, doctor, get-local-version, mcp-oauth.
+CLI entry: `bunx oh-my-opencode`. 107+ files with Commander.js + @clack/prompts TUI.
+
+**Commands**: install, run, doctor, get-local-version, mcp-oauth
 
 ## STRUCTURE
 ```
@@ -12,22 +14,20 @@ cli/
 ├── install.ts               # TTY routing (TUI or CLI installer)
 ├── cli-installer.ts         # Non-interactive installer (164 lines)
 ├── tui-installer.ts         # Interactive TUI with @clack/prompts (140 lines)
-├── config-manager/          # 20 config utilities
+├── config-manager/          # 17 config utilities
 │   ├── add-plugin-to-opencode-config.ts  # Plugin registration
-│   ├── add-provider-config.ts            # Provider setup (Google/Antigravity)
-│   ├── detect-current-config.ts          # Installed providers detection
+│   ├── add-provider-config.ts            # Provider setup
+│   ├── detect-current-config.ts          # Project vs user config
 │   ├── write-omo-config.ts               # JSONC writing
-│   ├── generate-omo-config.ts            # Config generation
-│   ├── jsonc-provider-editor.ts          # JSONC editing
-│   └── ...                               # 14 more utilities
-├── doctor/                  # 4 check categories, 21 check files
-│   ├── runner.ts            # Parallel check execution + result aggregation
-│   ├── formatter.ts         # Colored output (default/status/verbose/JSON)
-│   └── checks/              # system (4), config (1), tools (4), models (6 sub-checks)
+│   └── ...
+├── doctor/                  # 14 health checks
+│   ├── runner.ts            # Check orchestration
+│   ├── formatter.ts         # Colored output
+│   └── checks/              # 29 files: auth, config, dependencies, gh, lsp, mcp, opencode, plugin, version, model-resolution (6 sub-checks)
 ├── run/                     # Session launcher (24 files)
 │   ├── runner.ts            # Run orchestration (126 lines)
-│   ├── agent-resolver.ts    # Agent: flag → env → config → Sisyphus
-│   ├── session-resolver.ts  # Session create or resume with retries
+│   ├── agent-resolver.ts    # Agent selection: flag → env → config → fallback
+│   ├── session-resolver.ts  # Session creation or resume
 │   ├── event-handlers.ts    # Event processing (125 lines)
 │   ├── completion.ts        # Completion detection
 │   └── poll-for-completion.ts # Polling with timeout
@@ -43,17 +43,20 @@ cli/
 |---------|---------|-----------|
 | `install` | Interactive setup | Provider selection → config generation → plugin registration |
 | `run` | Session launcher | Agent: flag → env → config → Sisyphus. Enforces todo completion. |
-| `doctor` | 4-category health checks | system, config, tools, models (6 sub-checks) |
+| `doctor` | 14 health checks | installation, config, auth, deps, tools, updates |
 | `get-local-version` | Version check | Detects installed, compares with npm latest |
 | `mcp-oauth` | OAuth tokens | login (PKCE flow), logout, status |
 
-## RUN SESSION LIFECYCLE
+## DOCTOR CHECK CATEGORIES
 
-1. Load config, resolve agent (CLI > env > config > Sisyphus)
-2. Create server connection (port/attach), setup cleanup/signal handlers
-3. Resolve session (create new or resume with retries)
-4. Send prompt, start event processing, poll for completion
-5. Execute on-complete hook, output JSON if requested, cleanup
+| Category | Checks |
+|----------|--------|
+| installation | opencode, plugin |
+| configuration | config validity, Zod, model-resolution (6 sub-checks) |
+| authentication | anthropic, openai, google |
+| dependencies | ast-grep, comment-checker, gh-cli |
+| tools | LSP, MCP, MCP-OAuth |
+| updates | version comparison |
 
 ## HOW TO ADD CHECK
 

src/cli/__snapshots__/model-fallback.test.ts.snap

@@ -247,7 +247,7 @@ exports[`generateModelConfig single native provider uses OpenAI models when only
       "model": "opencode/glm-4.7-free",
     },
     "writing": {
-      "model": "opencode/glm-4.7-free",
+      "model": "openai/gpt-5.2",
     },
   },
 }
@@ -314,7 +314,7 @@ exports[`generateModelConfig single native provider uses OpenAI models with isMa
       "model": "opencode/glm-4.7-free",
     },
     "writing": {
-      "model": "opencode/glm-4.7-free",
+      "model": "openai/gpt-5.2",
     },
   },
 }
@@ -372,7 +372,6 @@ exports[`generateModelConfig single native provider uses Gemini models when only
     },
     "visual-engineering": {
       "model": "google/gemini-3-pro",
-      "variant": "high",
     },
     "writing": {
       "model": "google/gemini-3-flash",
@@ -433,7 +432,6 @@ exports[`generateModelConfig single native provider uses Gemini models with isMa
     },
     "visual-engineering": {
       "model": "google/gemini-3-pro",
-      "variant": "high",
     },
     "writing": {
       "model": "google/gemini-3-flash",
@@ -507,7 +505,6 @@ exports[`generateModelConfig all native providers uses preferred models from fal
     },
     "visual-engineering": {
       "model": "google/gemini-3-pro",
-      "variant": "high",
     },
     "writing": {
       "model": "google/gemini-3-flash",
@@ -582,7 +579,6 @@ exports[`generateModelConfig all native providers uses preferred models with isM
     },
     "visual-engineering": {
       "model": "google/gemini-3-pro",
-      "variant": "high",
     },
     "writing": {
       "model": "google/gemini-3-flash",
@@ -656,7 +652,6 @@ exports[`generateModelConfig fallback providers uses OpenCode Zen models when on
     },
     "visual-engineering": {
       "model": "opencode/gemini-3-pro",
-      "variant": "high",
     },
     "writing": {
       "model": "opencode/gemini-3-flash",
@@ -731,7 +726,6 @@ exports[`generateModelConfig fallback providers uses OpenCode Zen models with is
     },
     "visual-engineering": {
       "model": "opencode/gemini-3-pro",
-      "variant": "high",
     },
     "writing": {
       "model": "opencode/gemini-3-flash",
@@ -805,7 +799,6 @@ exports[`generateModelConfig fallback providers uses GitHub Copilot models when
     },
     "visual-engineering": {
       "model": "github-copilot/gemini-3-pro-preview",
-      "variant": "high",
     },
     "writing": {
       "model": "github-copilot/gemini-3-flash-preview",
@@ -880,7 +873,6 @@ exports[`generateModelConfig fallback providers uses GitHub Copilot models with
     },
     "visual-engineering": {
       "model": "github-copilot/gemini-3-pro-preview",
-      "variant": "high",
     },
     "writing": {
       "model": "github-copilot/gemini-3-flash-preview",
@@ -935,10 +927,10 @@ exports[`generateModelConfig fallback providers uses ZAI model for librarian whe
       "model": "opencode/glm-4.7-free",
     },
     "visual-engineering": {
-      "model": "zai-coding-plan/glm-5",
+      "model": "zai-coding-plan/glm-4.7",
     },
     "writing": {
-      "model": "opencode/glm-4.7-free",
+      "model": "zai-coding-plan/glm-4.7",
     },
   },
 }
@@ -990,10 +982,10 @@ exports[`generateModelConfig fallback providers uses ZAI model for librarian wit
       "model": "opencode/glm-4.7-free",
     },
     "visual-engineering": {
-      "model": "zai-coding-plan/glm-5",
+      "model": "zai-coding-plan/glm-4.7",
     },
     "writing": {
-      "model": "opencode/glm-4.7-free",
+      "model": "zai-coding-plan/glm-4.7",
     },
   },
 }
@@ -1064,7 +1056,6 @@ exports[`generateModelConfig mixed provider scenarios uses Claude + OpenCode Zen
     },
     "visual-engineering": {
       "model": "opencode/gemini-3-pro",
-      "variant": "high",
     },
     "writing": {
       "model": "opencode/gemini-3-flash",
@@ -1138,7 +1129,6 @@ exports[`generateModelConfig mixed provider scenarios uses OpenAI + Copilot comb
     },
     "visual-engineering": {
       "model": "github-copilot/gemini-3-pro-preview",
-      "variant": "high",
     },
     "writing": {
       "model": "github-copilot/gemini-3-flash-preview",
@@ -1199,7 +1189,8 @@ exports[`generateModelConfig mixed provider scenarios uses Claude + ZAI combinat
       "model": "anthropic/claude-sonnet-4-5",
     },
     "visual-engineering": {
-      "model": "zai-coding-plan/glm-5",
+      "model": "anthropic/claude-opus-4-6",
+      "variant": "max",
     },
     "writing": {
       "model": "anthropic/claude-sonnet-4-5",
@@ -1265,7 +1256,6 @@ exports[`generateModelConfig mixed provider scenarios uses Gemini + Claude combi
     },
     "visual-engineering": {
       "model": "google/gemini-3-pro",
-      "variant": "high",
     },
     "writing": {
       "model": "google/gemini-3-flash",
@@ -1339,7 +1329,6 @@ exports[`generateModelConfig mixed provider scenarios uses all fallback provider
     },
     "visual-engineering": {
       "model": "github-copilot/gemini-3-pro-preview",
-      "variant": "high",
     },
     "writing": {
       "model": "github-copilot/gemini-3-flash-preview",
@@ -1413,7 +1402,6 @@ exports[`generateModelConfig mixed provider scenarios uses all providers togethe
     },
     "visual-engineering": {
       "model": "google/gemini-3-pro",
-      "variant": "high",
     },
     "writing": {
       "model": "google/gemini-3-flash",
@@ -1488,7 +1476,6 @@ exports[`generateModelConfig mixed provider scenarios uses all providers with is
     },
     "visual-engineering": {
       "model": "google/gemini-3-pro",
-      "variant": "high",
     },
     "writing": {
       "model": "google/gemini-3-flash",

src/cli/cli-installer.test.ts

@@ -1,83 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, mock, spyOn } from "bun:test"
-import * as configManager from "./config-manager"
-import { runCliInstaller } from "./cli-installer"
-import type { InstallArgs } from "./types"
-
-describe("runCliInstaller", () => {
-  const mockConsoleLog = mock(() => {})
-  const mockConsoleError = mock(() => {})
-  const originalConsoleLog = console.log
-  const originalConsoleError = console.error
-
-  beforeEach(() => {
-    console.log = mockConsoleLog
-    console.error = mockConsoleError
-    mockConsoleLog.mockClear()
-    mockConsoleError.mockClear()
-  })
-
-  afterEach(() => {
-    console.log = originalConsoleLog
-    console.error = originalConsoleError
-  })
-
-  it("runs auth and provider setup steps when openai or copilot are enabled without gemini", async () => {
-    //#given
-    const addAuthPluginsSpy = spyOn(configManager, "addAuthPlugins").mockResolvedValue({
-      success: true,
-      configPath: "/tmp/opencode.jsonc",
-    })
-    const addProviderConfigSpy = spyOn(configManager, "addProviderConfig").mockReturnValue({
-      success: true,
-      configPath: "/tmp/opencode.jsonc",
-    })
-    const restoreSpies = [
-      addAuthPluginsSpy,
-      addProviderConfigSpy,
-      spyOn(configManager, "detectCurrentConfig").mockReturnValue({
-        isInstalled: false,
-        hasClaude: false,
-        isMax20: false,
-        hasOpenAI: false,
-        hasGemini: false,
-        hasCopilot: false,
-        hasOpencodeZen: false,
-        hasZaiCodingPlan: false,
-        hasKimiForCoding: false,
-      }),
-      spyOn(configManager, "isOpenCodeInstalled").mockResolvedValue(true),
-      spyOn(configManager, "getOpenCodeVersion").mockResolvedValue("1.0.200"),
-      spyOn(configManager, "addPluginToOpenCodeConfig").mockResolvedValue({
-        success: true,
-        configPath: "/tmp/opencode.jsonc",
-      }),
-      spyOn(configManager, "writeOmoConfig").mockReturnValue({
-        success: true,
-        configPath: "/tmp/oh-my-opencode.jsonc",
-      }),
-    ]
-
-    const args: InstallArgs = {
-      tui: false,
-      claude: "no",
-      openai: "yes",
-      gemini: "no",
-      copilot: "yes",
-      opencodeZen: "no",
-      zaiCodingPlan: "no",
-      kimiForCoding: "no",
-    }
-
-    //#when
-    const result = await runCliInstaller(args, "3.4.0")
-
-    //#then
-    expect(result).toBe(0)
-    expect(addAuthPluginsSpy).toHaveBeenCalledTimes(1)
-    expect(addProviderConfigSpy).toHaveBeenCalledTimes(1)
-
-    for (const spy of restoreSpies) {
-      spy.mockRestore()
-    }
-  })
-})

src/cli/cli-installer.ts

@@ -77,9 +77,7 @@ export async function runCliInstaller(args: InstallArgs, version: string): Promi
     `Plugin ${isUpdate ? "verified" : "added"} ${SYMBOLS.arrow} ${color.dim(pluginResult.configPath)}`,
   )
 
-  const needsProviderSetup = config.hasGemini || config.hasOpenAI || config.hasCopilot
-
-  if (needsProviderSetup) {
+  if (config.hasGemini) {
     printStep(step++, totalSteps, "Adding auth plugins...")
     const authResult = await addAuthPlugins(config)
     if (!authResult.success) {

src/cli/run/agent-resolver.ts

@@ -1,45 +1,32 @@
 import pc from "picocolors"
 import type { RunOptions } from "./types"
 import type { OhMyOpenCodeConfig } from "../../config"
-import { getAgentConfigKey, getAgentDisplayName } from "../../shared/agent-display-names"
 
 const CORE_AGENT_ORDER = ["sisyphus", "hephaestus", "prometheus", "atlas"] as const
 const DEFAULT_AGENT = "sisyphus"
 
 type EnvVars = Record<string, string | undefined>
-type CoreAgentKey = (typeof CORE_AGENT_ORDER)[number]
 
-interface ResolvedAgent {
-  configKey: string
-  resolvedName: string
-}
-
-const normalizeAgentName = (agent?: string): ResolvedAgent | undefined => {
+const normalizeAgentName = (agent?: string): string | undefined => {
   if (!agent) return undefined
   const trimmed = agent.trim()
-  if (trimmed.length === 0) return undefined
-
-  const configKey = getAgentConfigKey(trimmed)
-  const displayName = getAgentDisplayName(configKey)
-  const isKnownAgent = displayName !== configKey
-
-  return {
-    configKey,
-    resolvedName: isKnownAgent ? displayName : trimmed,
-  }
+  if (!trimmed) return undefined
+  const lowered = trimmed.toLowerCase()
+  const coreMatch = CORE_AGENT_ORDER.find((name) => name.toLowerCase() === lowered)
+  return coreMatch ?? trimmed
 }
 
-const isAgentDisabled = (agentConfigKey: string, config: OhMyOpenCodeConfig): boolean => {
-  const lowered = agentConfigKey.toLowerCase()
-  if (lowered === DEFAULT_AGENT && config.sisyphus_agent?.disabled === true) {
+const isAgentDisabled = (agent: string, config: OhMyOpenCodeConfig): boolean => {
+  const lowered = agent.toLowerCase()
+  if (lowered === "sisyphus" && config.sisyphus_agent?.disabled === true) {
     return true
   }
   return (config.disabled_agents ?? []).some(
-    (disabled) => getAgentConfigKey(disabled) === lowered
+    (disabled) => disabled.toLowerCase() === lowered
   )
 }
 
-const pickFallbackAgent = (config: OhMyOpenCodeConfig): CoreAgentKey => {
+const pickFallbackAgent = (config: OhMyOpenCodeConfig): string => {
   for (const agent of CORE_AGENT_ORDER) {
     if (!isAgentDisabled(agent, config)) {
       return agent
@@ -56,33 +43,27 @@ export const resolveRunAgent = (
   const cliAgent = normalizeAgentName(options.agent)
   const envAgent = normalizeAgentName(env.OPENCODE_DEFAULT_AGENT)
   const configAgent = normalizeAgentName(pluginConfig.default_run_agent)
-  const resolved =
-    cliAgent ??
-    envAgent ??
-    configAgent ?? {
-      configKey: DEFAULT_AGENT,
-      resolvedName: getAgentDisplayName(DEFAULT_AGENT),
-    }
+  const resolved = cliAgent ?? envAgent ?? configAgent ?? DEFAULT_AGENT
+  const normalized = normalizeAgentName(resolved) ?? DEFAULT_AGENT
 
-  if (isAgentDisabled(resolved.configKey, pluginConfig)) {
+  if (isAgentDisabled(normalized, pluginConfig)) {
     const fallback = pickFallbackAgent(pluginConfig)
-    const fallbackName = getAgentDisplayName(fallback)
     const fallbackDisabled = isAgentDisabled(fallback, pluginConfig)
     if (fallbackDisabled) {
       console.log(
         pc.yellow(
-          `Requested agent "${resolved.resolvedName}" is disabled and no enabled core agent was found. Proceeding with "${fallbackName}".`
+          `Requested agent "${normalized}" is disabled and no enabled core agent was found. Proceeding with "${fallback}".`
         )
       )
-      return fallbackName
+      return fallback
     }
     console.log(
       pc.yellow(
-        `Requested agent "${resolved.resolvedName}" is disabled. Falling back to "${fallbackName}".`
+        `Requested agent "${normalized}" is disabled. Falling back to "${fallback}".`
       )
     )
-    return fallbackName
+    return fallback
   }
 
-  return resolved.resolvedName
+  return normalized
 }

src/cli/run/completion.ts

@@ -1,6 +1,5 @@
 import pc from "picocolors"
 import type { RunContext, Todo, ChildSession, SessionStatus } from "./types"
-import { normalizeSDKResponse } from "../../shared"
 
 export async function checkCompletionConditions(ctx: RunContext): Promise<boolean> {
   try {
@@ -20,11 +19,8 @@ export async function checkCompletionConditions(ctx: RunContext): Promise<boolea
 }
 
 async function areAllTodosComplete(ctx: RunContext): Promise<boolean> {
-  const todosRes = await ctx.client.session.todo({
-    path: { id: ctx.sessionID },
-    query: { directory: ctx.directory },
-  })
-  const todos = normalizeSDKResponse(todosRes, [] as Todo[])
+  const todosRes = await ctx.client.session.todo({ path: { id: ctx.sessionID } })
+  const todos = (todosRes.data ?? []) as Todo[]
 
   const incompleteTodos = todos.filter(
     (t) => t.status !== "completed" && t.status !== "cancelled"
@@ -46,10 +42,8 @@ async function areAllChildrenIdle(ctx: RunContext): Promise<boolean> {
 async function fetchAllStatuses(
   ctx: RunContext
 ): Promise<Record<string, SessionStatus>> {
-  const statusRes = await ctx.client.session.status({
-    query: { directory: ctx.directory },
-  })
-  return normalizeSDKResponse(statusRes, {} as Record<string, SessionStatus>)
+  const statusRes = await ctx.client.session.status()
+  return (statusRes.data ?? {}) as Record<string, SessionStatus>
 }
 
 async function areAllDescendantsIdle(
@@ -59,9 +53,8 @@ async function areAllDescendantsIdle(
 ): Promise<boolean> {
   const childrenRes = await ctx.client.session.children({
     path: { id: sessionID },
-    query: { directory: ctx.directory },
   })
-  const children = normalizeSDKResponse(childrenRes, [] as ChildSession[])
+  const children = (childrenRes.data ?? []) as ChildSession[]
 
   for (const child of children) {
     const status = allStatuses[child.id]

src/cli/run/event-formatting.ts

@@ -57,11 +57,7 @@ export function serializeError(error: unknown): string {
 function getSessionTag(ctx: RunContext, payload: EventPayload): string {
   const props = payload.properties as Record<string, unknown> | undefined
   const info = props?.info as Record<string, unknown> | undefined
-  const part = props?.part as Record<string, unknown> | undefined
-  const sessionID =
-    props?.sessionID ?? props?.sessionId ??
-    info?.sessionID ?? info?.sessionId ??
-    part?.sessionID ?? part?.sessionId
+  const sessionID = props?.sessionID ?? info?.sessionID
   const isMainSession = sessionID === ctx.sessionID
   if (isMainSession) return pc.green("[MAIN]")
   if (sessionID) return pc.yellow(`[${String(sessionID).slice(0, 8)}]`)
@@ -83,9 +79,9 @@ export function logEventVerbose(ctx: RunContext, payload: EventPayload): void {
     case "message.part.updated": {
       const partProps = props as MessagePartUpdatedProps | undefined
       const part = partProps?.part
-      if (part?.type === "tool") {
-        const status = part.state?.status ?? "unknown"
-        console.error(pc.dim(`${sessionTag} message.part (tool): ${part.tool ?? part.name ?? "?"} [${status}]`))
+      if (part?.type === "tool-invocation") {
+        const toolPart = part as { toolName?: string; state?: string }
+        console.error(pc.dim(`${sessionTag} message.part (tool): ${toolPart.toolName} [${toolPart.state}]`))
       } else if (part?.type === "text" && part.text) {
         const preview = part.text.slice(0, 80).replace(/\n/g, "\\n")
         console.error(pc.dim(`${sessionTag} message.part (text): "${preview}${part.text.length > 80 ? "..." : ""}"`))

src/cli/run/event-handlers.test.ts

@@ -1,7 +1,7 @@
-import { describe, it, expect, spyOn } from "bun:test"
+import { describe, it, expect } from "bun:test"
 import type { RunContext } from "./types"
 import { createEventState } from "./events"
-import { handleSessionStatus, handleMessagePartUpdated, handleTuiToast } from "./event-handlers"
+import { handleSessionStatus } from "./event-handlers"
 
 const createMockContext = (sessionID: string = "test-session"): RunContext => ({
   sessionID,
@@ -70,211 +70,4 @@ describe("handleSessionStatus", () => {
     //#then - state.mainSessionIdle remains unchanged
     expect(state.mainSessionIdle).toBe(true)
   })
-
-  it("recognizes idle from camelCase sessionId", () => {
-    //#given - state with mainSessionIdle=false and payload using sessionId
-    const ctx = createMockContext("test-session")
-    const state = createEventState()
-    state.mainSessionIdle = false
-
-    const payload = {
-      type: "session.status",
-      properties: {
-        sessionId: "test-session",
-        status: { type: "idle" as const },
-      },
-    }
-
-    //#when - handleSessionStatus called with camelCase sessionId
-    handleSessionStatus(ctx, payload as any, state)
-
-    //#then - state.mainSessionIdle === true
-    expect(state.mainSessionIdle).toBe(true)
-  })
-})
-
-describe("handleMessagePartUpdated", () => {
-  it("extracts sessionID from part (current OpenCode event structure)", () => {
-    //#given - message.part.updated with sessionID in part, not info
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-
-    const payload = {
-      type: "message.part.updated",
-      properties: {
-        part: {
-          id: "part_1",
-          sessionID: "ses_main",
-          messageID: "msg_1",
-          type: "text",
-          text: "Hello world",
-        },
-      },
-    }
-
-    //#when
-    handleMessagePartUpdated(ctx, payload as any, state)
-
-    //#then
-    expect(state.hasReceivedMeaningfulWork).toBe(true)
-    expect(state.lastPartText).toBe("Hello world")
-    expect(stdoutSpy).toHaveBeenCalled()
-    stdoutSpy.mockRestore()
-  })
-
-  it("skips events for different session", () => {
-    //#given - message.part.updated with different session
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-
-    const payload = {
-      type: "message.part.updated",
-      properties: {
-        part: {
-          id: "part_1",
-          sessionID: "ses_other",
-          messageID: "msg_1",
-          type: "text",
-          text: "Hello world",
-        },
-      },
-    }
-
-    //#when
-    handleMessagePartUpdated(ctx, payload as any, state)
-
-    //#then
-    expect(state.hasReceivedMeaningfulWork).toBe(false)
-    expect(state.lastPartText).toBe("")
-  })
-
-  it("handles tool part with running status", () => {
-    //#given - tool part in running state
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-
-    const payload = {
-      type: "message.part.updated",
-      properties: {
-        part: {
-          id: "part_1",
-          sessionID: "ses_main",
-          messageID: "msg_1",
-          type: "tool",
-          tool: "read",
-          state: { status: "running", input: { filePath: "/src/index.ts" } },
-        },
-      },
-    }
-
-    //#when
-    handleMessagePartUpdated(ctx, payload as any, state)
-
-    //#then
-    expect(state.currentTool).toBe("read")
-    expect(state.hasReceivedMeaningfulWork).toBe(true)
-    stdoutSpy.mockRestore()
-  })
-
-  it("clears currentTool when tool completes", () => {
-    //#given - tool part in completed state
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    state.currentTool = "read"
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-
-    const payload = {
-      type: "message.part.updated",
-      properties: {
-        part: {
-          id: "part_1",
-          sessionID: "ses_main",
-          messageID: "msg_1",
-          type: "tool",
-          tool: "read",
-          state: { status: "completed", input: {}, output: "file contents here" },
-        },
-      },
-    }
-
-    //#when
-    handleMessagePartUpdated(ctx, payload as any, state)
-
-    //#then
-    expect(state.currentTool).toBeNull()
-    stdoutSpy.mockRestore()
-  })
-
-  it("supports legacy info.sessionID for backward compatibility", () => {
-    //#given - legacy event with sessionID in info
-    const ctx = createMockContext("ses_legacy")
-    const state = createEventState()
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-
-    const payload = {
-      type: "message.part.updated",
-      properties: {
-        info: { sessionID: "ses_legacy", role: "assistant" },
-        part: {
-          type: "text",
-          text: "Legacy text",
-        },
-      },
-    }
-
-    //#when
-    handleMessagePartUpdated(ctx, payload as any, state)
-
-    //#then
-    expect(state.hasReceivedMeaningfulWork).toBe(true)
-    expect(state.lastPartText).toBe("Legacy text")
-    stdoutSpy.mockRestore()
-  })
-})
-
-describe("handleTuiToast", () => {
-  it("marks main session as error when toast variant is error", () => {
-    //#given - toast error payload
-    const ctx = createMockContext("test-session")
-    const state = createEventState()
-
-    const payload = {
-      type: "tui.toast.show",
-      properties: {
-        title: "Auth",
-        message: "Invalid API key",
-        variant: "error" as const,
-      },
-    }
-
-    //#when
-    handleTuiToast(ctx, payload as any, state)
-
-    //#then
-    expect(state.mainSessionError).toBe(true)
-    expect(state.lastError).toBe("Auth: Invalid API key")
-  })
-
-  it("does not mark session error for warning toast", () => {
-    //#given - toast warning payload
-    const ctx = createMockContext("test-session")
-    const state = createEventState()
-
-    const payload = {
-      type: "tui.toast.show",
-      properties: {
-        message: "Retrying provider",
-        variant: "warning" as const,
-      },
-    }
-
-    //#when
-    handleTuiToast(ctx, payload as any, state)
-
-    //#then
-    expect(state.mainSessionError).toBe(false)
-    expect(state.lastError).toBe(null)
-  })
 })

src/cli/run/event-handlers.ts

@@ -9,32 +9,15 @@ import type {
   MessagePartUpdatedProps,
   ToolExecuteProps,
   ToolResultProps,
-  TuiToastShowProps,
 } from "./types"
 import type { EventState } from "./event-state"
 import { serializeError } from "./event-formatting"
 
-function getSessionId(props?: { sessionID?: string; sessionId?: string }): string | undefined {
-  return props?.sessionID ?? props?.sessionId
-}
-
-function getInfoSessionId(props?: {
-  info?: { sessionID?: string; sessionId?: string }
-}): string | undefined {
-  return props?.info?.sessionID ?? props?.info?.sessionId
-}
-
-function getPartSessionId(props?: {
-  part?: { sessionID?: string; sessionId?: string }
-}): string | undefined {
-  return props?.part?.sessionID ?? props?.part?.sessionId
-}
-
 export function handleSessionIdle(ctx: RunContext, payload: EventPayload, state: EventState): void {
   if (payload.type !== "session.idle") return
 
   const props = payload.properties as SessionIdleProps | undefined
-  if (getSessionId(props) === ctx.sessionID) {
+  if (props?.sessionID === ctx.sessionID) {
     state.mainSessionIdle = true
   }
 }
@@ -43,7 +26,7 @@ export function handleSessionStatus(ctx: RunContext, payload: EventPayload, stat
   if (payload.type !== "session.status") return
 
   const props = payload.properties as SessionStatusProps | undefined
-  if (getSessionId(props) !== ctx.sessionID) return
+  if (props?.sessionID !== ctx.sessionID) return
 
   if (props?.status?.type === "busy") {
     state.mainSessionIdle = false
@@ -58,7 +41,7 @@ export function handleSessionError(ctx: RunContext, payload: EventPayload, state
   if (payload.type !== "session.error") return
 
   const props = payload.properties as SessionErrorProps | undefined
-  if (getSessionId(props) === ctx.sessionID) {
+  if (props?.sessionID === ctx.sessionID) {
     state.mainSessionError = true
     state.lastError = serializeError(props?.error)
     console.error(pc.red(`\n[session.error] ${state.lastError}`))
@@ -69,12 +52,10 @@ export function handleMessagePartUpdated(ctx: RunContext, payload: EventPayload,
   if (payload.type !== "message.part.updated") return
 
   const props = payload.properties as MessagePartUpdatedProps | undefined
-  // Current OpenCode puts sessionID inside part; legacy puts it in info
-  const partSid = getPartSessionId(props)
-  const infoSid = getInfoSessionId(props)
-  if ((partSid ?? infoSid) !== ctx.sessionID) return
+  if (props?.info?.sessionID !== ctx.sessionID) return
+  if (props?.info?.role !== "assistant") return
 
-  const part = props?.part
+  const part = props.part
   if (!part) return
 
   if (part.type === "text" && part.text) {
@@ -85,57 +66,13 @@ export function handleMessagePartUpdated(ctx: RunContext, payload: EventPayload,
     }
     state.lastPartText = part.text
   }
-
-  if (part.type === "tool") {
-    handleToolPart(ctx, part, state)
-  }
-}
-
-function handleToolPart(
-  _ctx: RunContext,
-  part: NonNullable<MessagePartUpdatedProps["part"]>,
-  state: EventState,
-): void {
-  const toolName = part.tool || part.name || "unknown"
-  const status = part.state?.status
-
-  if (status === "running") {
-    state.currentTool = toolName
-    let inputPreview = ""
-    const input = part.state?.input
-    if (input) {
-      if (input.command) {
-        inputPreview = ` ${pc.dim(String(input.command).slice(0, 60))}`
-      } else if (input.pattern) {
-        inputPreview = ` ${pc.dim(String(input.pattern).slice(0, 40))}`
-      } else if (input.filePath) {
-        inputPreview = ` ${pc.dim(String(input.filePath))}`
-      } else if (input.query) {
-        inputPreview = ` ${pc.dim(String(input.query).slice(0, 40))}`
-      }
-    }
-    state.hasReceivedMeaningfulWork = true
-    process.stdout.write(`\n${pc.cyan(">")} ${pc.bold(toolName)}${inputPreview}\n`)
-  }
-
-  if (status === "completed" || status === "error") {
-    const output = part.state?.output || ""
-    const maxLen = 200
-    const preview = output.length > maxLen ? output.slice(0, maxLen) + "..." : output
-    if (preview.trim()) {
-      const lines = preview.split("\n").slice(0, 3)
-      process.stdout.write(pc.dim(`   └─ ${lines.join("\n      ")}\n`))
-    }
-    state.currentTool = null
-    state.lastPartText = ""
-  }
 }
 
 export function handleMessageUpdated(ctx: RunContext, payload: EventPayload, state: EventState): void {
   if (payload.type !== "message.updated") return
 
   const props = payload.properties as MessageUpdatedProps | undefined
-  if (getInfoSessionId(props) !== ctx.sessionID) return
+  if (props?.info?.sessionID !== ctx.sessionID) return
   if (props?.info?.role !== "assistant") return
 
   state.hasReceivedMeaningfulWork = true
@@ -147,7 +84,7 @@ export function handleToolExecute(ctx: RunContext, payload: EventPayload, state:
   if (payload.type !== "tool.execute") return
 
   const props = payload.properties as ToolExecuteProps | undefined
-  if (getSessionId(props) !== ctx.sessionID) return
+  if (props?.sessionID !== ctx.sessionID) return
 
   const toolName = props?.name || "unknown"
   state.currentTool = toolName
@@ -174,7 +111,7 @@ export function handleToolResult(ctx: RunContext, payload: EventPayload, state:
   if (payload.type !== "tool.result") return
 
   const props = payload.properties as ToolResultProps | undefined
-  if (getSessionId(props) !== ctx.sessionID) return
+  if (props?.sessionID !== ctx.sessionID) return
 
   const output = props?.output || ""
   const maxLen = 200
@@ -188,24 +125,3 @@ export function handleToolResult(ctx: RunContext, payload: EventPayload, state:
   state.currentTool = null
   state.lastPartText = ""
 }
-
-export function handleTuiToast(_ctx: RunContext, payload: EventPayload, state: EventState): void {
-  if (payload.type !== "tui.toast.show") return
-
-  const props = payload.properties as TuiToastShowProps | undefined
-  const title = props?.title ? `${props.title}: ` : ""
-  const message = props?.message?.trim()
-  const variant = props?.variant ?? "info"
-
-  if (!message) return
-
-  if (variant === "error") {
-    state.mainSessionError = true
-    state.lastError = `${title}${message}`
-    console.error(pc.red(`\n[tui.toast.error] ${state.lastError}`))
-    return
-  }
-
-  const colorize = variant === "warning" ? pc.yellow : pc.dim
-  console.log(colorize(`[toast:${variant}] ${title}${message}`))
-}

src/cli/run/event-stream-processor.ts

@@ -10,7 +10,6 @@ import {
   handleMessageUpdated,
   handleToolExecute,
   handleToolResult,
-  handleTuiToast,
 } from "./event-handlers"
 
 export async function processEvents(
@@ -37,7 +36,6 @@ export async function processEvents(
       handleMessageUpdated(ctx, payload, state)
       handleToolExecute(ctx, payload, state)
       handleToolResult(ctx, payload, state)
-      handleTuiToast(ctx, payload, state)
     } catch (err) {
       console.error(pc.red(`[event error] ${err}`))
     }

src/cli/run/events.test.ts

@@ -170,28 +170,6 @@ describe("event handling", () => {
     expect(state.hasReceivedMeaningfulWork).toBe(true)
   })
 
-  it("message.updated with camelCase sessionId sets hasReceivedMeaningfulWork", async () => {
-    //#given - assistant message uses sessionId key
-    const ctx = createMockContext("my-session")
-    const state = createEventState()
-
-    const payload: EventPayload = {
-      type: "message.updated",
-      properties: {
-        info: { sessionId: "my-session", role: "assistant" },
-      },
-    }
-
-    const events = toAsyncIterable([payload])
-    const { processEvents } = await import("./events")
-
-    //#when
-    await processEvents(ctx, events, state)
-
-    //#then
-    expect(state.hasReceivedMeaningfulWork).toBe(true)
-  })
-
   it("message.updated with user role does not set hasReceivedMeaningfulWork", async () => {
     // given - user message should not count as meaningful work
     const ctx = createMockContext("my-session")
@@ -273,7 +251,6 @@ describe("event handling", () => {
       lastPartText: "",
       currentTool: null,
       hasReceivedMeaningfulWork: false,
-      messageCount: 0,
     }
 
     const payload: EventPayload = {

src/cli/run/integration.test.ts

@@ -1,11 +1,9 @@
-import { describe, it, expect, mock, spyOn, beforeEach, afterEach, afterAll } from "bun:test"
+import { describe, it, expect, mock, spyOn, beforeEach, afterEach } from "bun:test"
 import type { RunResult } from "./types"
 import { createJsonOutputManager } from "./json-output"
 import { resolveSession } from "./session-resolver"
 import { executeOnCompleteHook } from "./on-complete-hook"
 import type { OpencodeClient } from "./types"
-import * as originalSdk from "@opencode-ai/sdk"
-import * as originalPortUtils from "../../shared/port-utils"
 
 const mockServerClose = mock(() => {})
 const mockCreateOpencode = mock(() =>
@@ -29,11 +27,6 @@ mock.module("../../shared/port-utils", () => ({
   DEFAULT_SERVER_PORT: 4096,
 }))
 
-afterAll(() => {
-  mock.module("@opencode-ai/sdk", () => originalSdk)
-  mock.module("../../shared/port-utils", () => originalPortUtils)
-})
-
 const { createServerConnection } = await import("./server-connection")
 
 interface MockWriteStream {
@@ -127,14 +120,11 @@ describe("integration: --session-id", () => {
     const mockClient = createMockClient({ data: { id: sessionId } })
 
     // when
-    const result = await resolveSession({ client: mockClient, sessionId, directory: "/test" })
+    const result = await resolveSession({ client: mockClient, sessionId })
 
     // then
     expect(result).toBe(sessionId)
-    expect(mockClient.session.get).toHaveBeenCalledWith({
-      path: { id: sessionId },
-      query: { directory: "/test" },
-    })
+    expect(mockClient.session.get).toHaveBeenCalledWith({ path: { id: sessionId } })
     expect(mockClient.session.create).not.toHaveBeenCalled()
   })
 
@@ -144,14 +134,11 @@ describe("integration: --session-id", () => {
     const mockClient = createMockClient({ error: { message: "Session not found" } })
 
     // when
-    const result = resolveSession({ client: mockClient, sessionId, directory: "/test" })
+    const result = resolveSession({ client: mockClient, sessionId })
 
     // then
     await expect(result).rejects.toThrow(`Session not found: ${sessionId}`)
-    expect(mockClient.session.get).toHaveBeenCalledWith({
-      path: { id: sessionId },
-      query: { directory: "/test" },
-    })
+    expect(mockClient.session.get).toHaveBeenCalledWith({ path: { id: sessionId } })
     expect(mockClient.session.create).not.toHaveBeenCalled()
   })
 })

src/cli/run/opencode-bin-path.test.ts

@@ -1,52 +0,0 @@
-/// <reference types="bun-types" />
-
-import { describe, expect, it } from "bun:test"
-import { prependResolvedOpencodeBinToPath } from "./opencode-bin-path"
-
-describe("prependResolvedOpencodeBinToPath", () => {
-  it("prepends resolved opencode-ai bin path to PATH", () => {
-    //#given
-    const env: Record<string, string | undefined> = {
-      PATH: "/Users/yeongyu/node_modules/.bin:/usr/bin",
-    }
-    const resolver = () => "/tmp/bunx-123/node_modules/opencode-ai/bin/opencode"
-
-    //#when
-    prependResolvedOpencodeBinToPath(env, resolver)
-
-    //#then
-    expect(env.PATH).toBe(
-      "/tmp/bunx-123/node_modules/opencode-ai/bin:/Users/yeongyu/node_modules/.bin:/usr/bin",
-    )
-  })
-
-  it("does not duplicate an existing opencode-ai bin path", () => {
-    //#given
-    const env: Record<string, string | undefined> = {
-      PATH: "/tmp/bunx-123/node_modules/opencode-ai/bin:/usr/bin",
-    }
-    const resolver = () => "/tmp/bunx-123/node_modules/opencode-ai/bin/opencode"
-
-    //#when
-    prependResolvedOpencodeBinToPath(env, resolver)
-
-    //#then
-    expect(env.PATH).toBe("/tmp/bunx-123/node_modules/opencode-ai/bin:/usr/bin")
-  })
-
-  it("keeps PATH unchanged when opencode-ai cannot be resolved", () => {
-    //#given
-    const env: Record<string, string | undefined> = {
-      PATH: "/Users/yeongyu/node_modules/.bin:/usr/bin",
-    }
-    const resolver = () => {
-      throw new Error("module not found")
-    }
-
-    //#when
-    prependResolvedOpencodeBinToPath(env, resolver)
-
-    //#then
-    expect(env.PATH).toBe("/Users/yeongyu/node_modules/.bin:/usr/bin")
-  })
-})

src/cli/run/opencode-bin-path.ts

@@ -1,30 +0,0 @@
-import { delimiter, dirname } from "node:path"
-import { createRequire } from "node:module"
-
-type EnvLike = Record<string, string | undefined>
-
-const resolveFromCurrentModule = createRequire(import.meta.url).resolve
-
-export function prependResolvedOpencodeBinToPath(
-  env: EnvLike = process.env,
-  resolve: (id: string) => string = resolveFromCurrentModule,
-): void {
-  let resolvedPath: string
-  try {
-    resolvedPath = resolve("opencode-ai/bin/opencode")
-  } catch {
-    return
-  }
-
-  const opencodeBinDir = dirname(resolvedPath)
-  const currentPath = env.PATH ?? ""
-  const pathSegments = currentPath ? currentPath.split(delimiter) : []
-
-  if (pathSegments.includes(opencodeBinDir)) {
-    return
-  }
-
-  env.PATH = currentPath
-    ? `${opencodeBinDir}${delimiter}${currentPath}`
-    : opencodeBinDir
-}

src/cli/run/opencode-binary-resolver.test.ts

@@ -1,102 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { delimiter, join } from "node:path"
-import {
-  buildPathWithBinaryFirst,
-  collectCandidateBinaryPaths,
-  findWorkingOpencodeBinary,
-  withWorkingOpencodePath,
-} from "./opencode-binary-resolver"
-
-describe("collectCandidateBinaryPaths", () => {
-  it("includes Bun.which results first and removes duplicates", () => {
-    // given
-    const pathEnv = ["/bad", "/good"].join(delimiter)
-    const which = (command: string): string | undefined => {
-      if (command === "opencode") return "/bad/opencode"
-      return undefined
-    }
-
-    // when
-    const candidates = collectCandidateBinaryPaths(pathEnv, which, "darwin")
-
-    // then
-    expect(candidates[0]).toBe("/bad/opencode")
-    expect(candidates).toContain("/good/opencode")
-    expect(candidates.filter((candidate) => candidate === "/bad/opencode")).toHaveLength(1)
-  })
-})
-
-describe("findWorkingOpencodeBinary", () => {
-  it("returns the first runnable candidate", async () => {
-    // given
-    const pathEnv = ["/bad", "/good"].join(delimiter)
-    const which = (command: string): string | undefined => {
-      if (command === "opencode") return "/bad/opencode"
-      return undefined
-    }
-    const probe = async (binaryPath: string): Promise<boolean> =>
-      binaryPath === "/good/opencode"
-
-    // when
-    const resolved = await findWorkingOpencodeBinary(pathEnv, probe, which, "darwin")
-
-    // then
-    expect(resolved).toBe("/good/opencode")
-  })
-})
-
-describe("buildPathWithBinaryFirst", () => {
-  it("prepends the binary directory and avoids duplicate entries", () => {
-    // given
-    const binaryPath = "/good/opencode"
-    const pathEnv = ["/bad", "/good", "/other"].join(delimiter)
-
-    // when
-    const updated = buildPathWithBinaryFirst(pathEnv, binaryPath)
-
-    // then
-    expect(updated).toBe(["/good", "/bad", "/other"].join(delimiter))
-  })
-})
-
-describe("withWorkingOpencodePath", () => {
-  it("temporarily updates PATH while starting the server", async () => {
-    // given
-    const originalPath = process.env.PATH
-    process.env.PATH = ["/bad", "/other"].join(delimiter)
-    const finder = async (): Promise<string | null> => "/good/opencode"
-    let observedPath = ""
-
-    // when
-    await withWorkingOpencodePath(
-      async () => {
-        observedPath = process.env.PATH ?? ""
-      },
-      finder,
-    )
-
-    // then
-    expect(observedPath).toBe(["/good", "/bad", "/other"].join(delimiter))
-    expect(process.env.PATH).toBe(["/bad", "/other"].join(delimiter))
-    process.env.PATH = originalPath
-  })
-
-  it("restores PATH when server startup fails", async () => {
-    // given
-    const originalPath = process.env.PATH
-    process.env.PATH = ["/bad", "/other"].join(delimiter)
-    const finder = async (): Promise<string | null> => join("/good", "opencode")
-
-    // when & then
-    await expect(
-      withWorkingOpencodePath(
-        async () => {
-          throw new Error("boom")
-        },
-        finder,
-      ),
-    ).rejects.toThrow("boom")
-    expect(process.env.PATH).toBe(["/bad", "/other"].join(delimiter))
-    process.env.PATH = originalPath
-  })
-})

src/cli/run/opencode-binary-resolver.ts

@@ -1,95 +0,0 @@
-import { delimiter, dirname, join } from "node:path"
-
-const OPENCODE_COMMANDS = ["opencode", "opencode-desktop"] as const
-const WINDOWS_SUFFIXES = ["", ".exe", ".cmd", ".bat", ".ps1"] as const
-
-function getCommandCandidates(platform: NodeJS.Platform): string[] {
-  if (platform !== "win32") return [...OPENCODE_COMMANDS]
-
-  return OPENCODE_COMMANDS.flatMap((command) =>
-    WINDOWS_SUFFIXES.map((suffix) => `${command}${suffix}`),
-  )
-}
-
-export function collectCandidateBinaryPaths(
-  pathEnv: string | undefined,
-  which: (command: string) => string | null | undefined = Bun.which,
-  platform: NodeJS.Platform = process.platform,
-): string[] {
-  const seen = new Set<string>()
-  const candidates: string[] = []
-  const commandCandidates = getCommandCandidates(platform)
-
-  const addCandidate = (binaryPath: string | undefined | null): void => {
-    if (!binaryPath || seen.has(binaryPath)) return
-    seen.add(binaryPath)
-    candidates.push(binaryPath)
-  }
-
-  for (const command of commandCandidates) {
-    addCandidate(which(command))
-  }
-
-  for (const entry of (pathEnv ?? "").split(delimiter).filter(Boolean)) {
-    for (const command of commandCandidates) {
-      addCandidate(join(entry, command))
-    }
-  }
-
-  return candidates
-}
-
-export async function canExecuteBinary(binaryPath: string): Promise<boolean> {
-  try {
-    const proc = Bun.spawn([binaryPath, "--version"], {
-      stdout: "pipe",
-      stderr: "pipe",
-    })
-    await proc.exited
-    return proc.exitCode === 0
-  } catch {
-    return false
-  }
-}
-
-export async function findWorkingOpencodeBinary(
-  pathEnv: string | undefined = process.env.PATH,
-  probe: (binaryPath: string) => Promise<boolean> = canExecuteBinary,
-  which: (command: string) => string | null | undefined = Bun.which,
-  platform: NodeJS.Platform = process.platform,
-): Promise<string | null> {
-  const candidates = collectCandidateBinaryPaths(pathEnv, which, platform)
-  for (const candidate of candidates) {
-    if (await probe(candidate)) {
-      return candidate
-    }
-  }
-  return null
-}
-
-export function buildPathWithBinaryFirst(pathEnv: string | undefined, binaryPath: string): string {
-  const preferredDir = dirname(binaryPath)
-  const existing = (pathEnv ?? "").split(delimiter).filter(
-    (entry) => entry.length > 0 && entry !== preferredDir,
-  )
-  return [preferredDir, ...existing].join(delimiter)
-}
-
-export async function withWorkingOpencodePath<T>(
-  startServer: () => Promise<T>,
-  finder: (pathEnv: string | undefined) => Promise<string | null> = findWorkingOpencodeBinary,
-): Promise<T> {
-  const originalPath = process.env.PATH
-  const binaryPath = await finder(originalPath)
-
-  if (!binaryPath) {
-    return startServer()
-  }
-
-  process.env.PATH = buildPathWithBinaryFirst(originalPath, binaryPath)
-  try {
-    return await startServer()
-  } finally {
-    process.env.PATH = originalPath
-  }
-}

src/cli/run/poll-for-completion.test.ts

@@ -207,52 +207,6 @@ describe("pollForCompletion", () => {
     expect(todoCallCount).toBe(0)
   })
 
-  it("falls back to session.status API when idle event is missing", async () => {
-    //#given - mainSessionIdle not set by events, but status API says idle
-    spyOn(console, "log").mockImplementation(() => {})
-    spyOn(console, "error").mockImplementation(() => {})
-    const ctx = createMockContext({
-      statuses: {
-        "test-session": { type: "idle" },
-      },
-    })
-    const eventState = createEventState()
-    eventState.mainSessionIdle = false
-    eventState.hasReceivedMeaningfulWork = true
-    const abortController = new AbortController()
-
-    //#when
-    const result = await pollForCompletion(ctx, eventState, abortController, {
-      pollIntervalMs: 10,
-      requiredConsecutive: 2,
-      minStabilizationMs: 0,
-    })
-
-    //#then - completion succeeds without idle event
-    expect(result).toBe(0)
-  })
-
-  it("allows silent completion after stabilization when no meaningful work is received", async () => {
-    //#given - session is idle and stable but no assistant message/tool event arrived
-    spyOn(console, "log").mockImplementation(() => {})
-    spyOn(console, "error").mockImplementation(() => {})
-    const ctx = createMockContext()
-    const eventState = createEventState()
-    eventState.mainSessionIdle = true
-    eventState.hasReceivedMeaningfulWork = false
-    const abortController = new AbortController()
-
-    //#when
-    const result = await pollForCompletion(ctx, eventState, abortController, {
-      pollIntervalMs: 10,
-      requiredConsecutive: 1,
-      minStabilizationMs: 30,
-    })
-
-    //#then - completion succeeds after stabilization window
-    expect(result).toBe(0)
-  })
-
   it("simulates race condition: brief idle with 0 todos does not cause immediate exit", async () => {
     //#given - simulate Sisyphus outputting text, session goes idle briefly, then tool fires
     spyOn(console, "log").mockImplementation(() => {})

src/cli/run/poll-for-completion.ts

@@ -2,7 +2,6 @@ import pc from "picocolors"
 import type { RunContext } from "./types"
 import type { EventState } from "./events"
 import { checkCompletionConditions } from "./completion"
-import { normalizeSDKResponse } from "../../shared"
 
 const DEFAULT_POLL_INTERVAL_MS = 500
 const DEFAULT_REQUIRED_CONSECUTIVE = 3
@@ -29,7 +28,6 @@ export async function pollForCompletion(
   let consecutiveCompleteChecks = 0
   let errorCycleCount = 0
   let firstWorkTimestamp: number | null = null
-  const pollStartTimestamp = Date.now()
 
   while (!abortController.signal.aborted) {
     await new Promise((resolve) => setTimeout(resolve, pollIntervalMs))
@@ -53,13 +51,6 @@ export async function pollForCompletion(
       errorCycleCount = 0
     }
 
-    const mainSessionStatus = await getMainSessionStatus(ctx)
-    if (mainSessionStatus === "busy" || mainSessionStatus === "retry") {
-      eventState.mainSessionIdle = false
-    } else if (mainSessionStatus === "idle") {
-      eventState.mainSessionIdle = true
-    }
-
     if (!eventState.mainSessionIdle) {
       consecutiveCompleteChecks = 0
       continue
@@ -71,11 +62,8 @@ export async function pollForCompletion(
     }
 
     if (!eventState.hasReceivedMeaningfulWork) {
-      if (Date.now() - pollStartTimestamp < minStabilizationMs) {
-        consecutiveCompleteChecks = 0
-        continue
-      }
       consecutiveCompleteChecks = 0
+      continue
     }
 
     // Track when first meaningful work was received
@@ -103,24 +91,3 @@ export async function pollForCompletion(
 
   return 130
 }
-
-async function getMainSessionStatus(
-  ctx: RunContext
-): Promise<"idle" | "busy" | "retry" | null> {
-  try {
-    const statusesRes = await ctx.client.session.status({
-      query: { directory: ctx.directory },
-    })
-    const statuses = normalizeSDKResponse(
-      statusesRes,
-      {} as Record<string, { type?: string }>
-    )
-    const status = statuses[ctx.sessionID]?.type
-    if (status === "idle" || status === "busy" || status === "retry") {
-      return status
-    }
-    return null
-  } catch {
-    return null
-  }
-}

src/cli/run/runner.test.ts

@@ -1,8 +1,6 @@
-/// <reference types="bun-types" />
-
-import { describe, it, expect, spyOn, afterEach } from "bun:test"
+import { describe, it, expect } from "bun:test"
 import type { OhMyOpenCodeConfig } from "../../config"
-import { resolveRunAgent, waitForEventProcessorShutdown } from "./runner"
+import { resolveRunAgent } from "./runner"
 
 const createConfig = (overrides: Partial<OhMyOpenCodeConfig> = {}): OhMyOpenCodeConfig => ({
   ...overrides,
@@ -22,7 +20,7 @@ describe("resolveRunAgent", () => {
     )
 
     // then
-    expect(agent).toBe("Hephaestus (Deep Agent)")
+    expect(agent).toBe("hephaestus")
   })
 
   it("uses env agent over config", () => {
@@ -34,7 +32,7 @@ describe("resolveRunAgent", () => {
     const agent = resolveRunAgent({ message: "test" }, config, env)
 
     // then
-    expect(agent).toBe("Atlas (Plan Executor)")
+    expect(agent).toBe("atlas")
   })
 
   it("uses config agent over default", () => {
@@ -45,7 +43,7 @@ describe("resolveRunAgent", () => {
     const agent = resolveRunAgent({ message: "test" }, config, {})
 
     // then
-    expect(agent).toBe("Prometheus (Plan Builder)")
+    expect(agent).toBe("prometheus")
   })
 
   it("falls back to sisyphus when none set", () => {
@@ -56,7 +54,7 @@ describe("resolveRunAgent", () => {
     const agent = resolveRunAgent({ message: "test" }, config, {})
 
     // then
-    expect(agent).toBe("Sisyphus (Ultraworker)")
+    expect(agent).toBe("sisyphus")
   })
 
   it("skips disabled sisyphus for next available core agent", () => {
@@ -67,70 +65,6 @@ describe("resolveRunAgent", () => {
     const agent = resolveRunAgent({ message: "test" }, config, {})
 
     // then
-    expect(agent).toBe("Hephaestus (Deep Agent)")
-  })
-
-  it("maps display-name style default_run_agent values to canonical display names", () => {
-    // given
-    const config = createConfig({ default_run_agent: "Sisyphus (Ultraworker)" })
-
-    // when
-    const agent = resolveRunAgent({ message: "test" }, config, {})
-
-    // then
-    expect(agent).toBe("Sisyphus (Ultraworker)")
-  })
-})
-
-describe("waitForEventProcessorShutdown", () => {
-  let consoleLogSpy: ReturnType<typeof spyOn<typeof console, "log">> | null = null
-
-  afterEach(() => {
-    if (consoleLogSpy) {
-      consoleLogSpy.mockRestore()
-      consoleLogSpy = null
-    }
-  })
-
-  it("returns quickly when event processor completes", async () => {
-    //#given
-    const eventProcessor = new Promise<void>((resolve) => {
-      setTimeout(() => {
-        resolve()
-      }, 25)
-    })
-    consoleLogSpy = spyOn(console, "log").mockImplementation(() => {})
-    const start = performance.now()
-
-    //#when
-    await waitForEventProcessorShutdown(eventProcessor, 200)
-
-    //#then
-    const elapsed = performance.now() - start
-    expect(elapsed).toBeLessThan(200)
-    expect(console.log).not.toHaveBeenCalledWith(
-      "[run] Event stream did not close within 200ms after abort; continuing shutdown.",
-    )
-  })
-
-  it("times out and continues when event processor does not complete", async () => {
-    //#given
-    const eventProcessor = new Promise<void>(() => {})
-    const spy = spyOn(console, "log").mockImplementation(() => {})
-    consoleLogSpy = spy
-    const timeoutMs = 200
-    const start = performance.now()
-
-    try {
-      //#when
-      await waitForEventProcessorShutdown(eventProcessor, timeoutMs)
-
-      //#then
-      const elapsed = performance.now() - start
-      expect(elapsed).toBeGreaterThanOrEqual(timeoutMs - 10)
-      expect(spy.mock.calls.length).toBeGreaterThanOrEqual(1)
-    } finally {
-      spy.mockRestore()
-    }
+    expect(agent).toBe("hephaestus")
   })
 })

src/cli/run/runner.ts

@@ -12,25 +12,6 @@ import { pollForCompletion } from "./poll-for-completion"
 export { resolveRunAgent }
 
 const DEFAULT_TIMEOUT_MS = 600_000
-const EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS = 2_000
-
-export async function waitForEventProcessorShutdown(
-  eventProcessor: Promise<void>,
-  timeoutMs = EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS,
-): Promise<void> {
-  const completed = await Promise.race([
-    eventProcessor.then(() => true),
-    new Promise<boolean>((resolve) => setTimeout(() => resolve(false), timeoutMs)),
-  ])
-
-  if (!completed) {
-    console.log(
-      pc.dim(
-        `[run] Event stream did not close within ${timeoutMs}ms after abort; continuing shutdown.`,
-      ),
-    )
-  }
-}
 
 export async function run(options: RunOptions): Promise<number> {
   process.env.OPENCODE_CLI_RUN_MODE = "true"
@@ -79,7 +60,6 @@ export async function run(options: RunOptions): Promise<number> {
       const sessionID = await resolveSession({
         client,
         sessionId: options.sessionId,
-        directory,
       })
 
       console.log(pc.dim(`Session: ${sessionID}`))
@@ -101,14 +81,14 @@ export async function run(options: RunOptions): Promise<number> {
         query: { directory },
       })
 
-      console.log(pc.dim("Waiting for completion...\n"))
-      const exitCode = await pollForCompletion(ctx, eventState, abortController)
+       console.log(pc.dim("Waiting for completion...\n"))
+       const exitCode = await pollForCompletion(ctx, eventState, abortController)
 
-      // Abort the event stream to stop the processor
-      abortController.abort()
+       // Abort the event stream to stop the processor
+       abortController.abort()
 
-      await waitForEventProcessorShutdown(eventProcessor)
-      cleanup()
+       await eventProcessor
+       cleanup()
 
       const durationMs = Date.now() - startTime
 
@@ -147,3 +127,4 @@ export async function run(options: RunOptions): Promise<number> {
     return 1
   }
 }
+

src/cli/run/server-connection.test.ts

@@ -1,8 +1,4 @@
-import { describe, it, expect, mock, beforeEach, afterEach, afterAll } from "bun:test"
-
-import * as originalSdk from "@opencode-ai/sdk"
-import * as originalPortUtils from "../../shared/port-utils"
-import * as originalBinaryResolver from "./opencode-binary-resolver"
+import { describe, it, expect, mock, beforeEach, afterEach } from "bun:test"
 
 const originalConsole = globalThis.console
 
@@ -17,7 +13,6 @@ const mockCreateOpencodeClient = mock(() => ({ session: {} }))
 const mockIsPortAvailable = mock(() => Promise.resolve(true))
 const mockGetAvailableServerPort = mock(() => Promise.resolve({ port: 4096, wasAutoSelected: false }))
 const mockConsoleLog = mock(() => {})
-const mockWithWorkingOpencodePath = mock((startServer: () => Promise<unknown>) => startServer())
 
 mock.module("@opencode-ai/sdk", () => ({
   createOpencode: mockCreateOpencode,
@@ -30,16 +25,6 @@ mock.module("../../shared/port-utils", () => ({
   DEFAULT_SERVER_PORT: 4096,
 }))
 
-mock.module("./opencode-binary-resolver", () => ({
-  withWorkingOpencodePath: mockWithWorkingOpencodePath,
-}))
-
-afterAll(() => {
-  mock.module("@opencode-ai/sdk", () => originalSdk)
-  mock.module("../../shared/port-utils", () => originalPortUtils)
-  mock.module("./opencode-binary-resolver", () => originalBinaryResolver)
-})
-
 const { createServerConnection } = await import("./server-connection")
 
 describe("createServerConnection", () => {
@@ -50,7 +35,6 @@ describe("createServerConnection", () => {
     mockGetAvailableServerPort.mockClear()
     mockServerClose.mockClear()
     mockConsoleLog.mockClear()
-    mockWithWorkingOpencodePath.mockClear()
     globalThis.console = { ...console, log: mockConsoleLog } as typeof console
   })
 
@@ -68,7 +52,6 @@ describe("createServerConnection", () => {
 
     // then
     expect(mockCreateOpencodeClient).toHaveBeenCalledWith({ baseUrl: attachUrl })
-    expect(mockWithWorkingOpencodePath).not.toHaveBeenCalled()
     expect(result.client).toBeDefined()
     expect(result.cleanup).toBeDefined()
     result.cleanup()
@@ -86,7 +69,6 @@ describe("createServerConnection", () => {
 
     // then
     expect(mockIsPortAvailable).toHaveBeenCalledWith(8080, "127.0.0.1")
-    expect(mockWithWorkingOpencodePath).toHaveBeenCalledTimes(1)
     expect(mockCreateOpencode).toHaveBeenCalledWith({ signal, port: 8080, hostname: "127.0.0.1" })
     expect(mockCreateOpencodeClient).not.toHaveBeenCalled()
     expect(result.client).toBeDefined()
@@ -124,7 +106,6 @@ describe("createServerConnection", () => {
 
     // then
     expect(mockGetAvailableServerPort).toHaveBeenCalledWith(4096, "127.0.0.1")
-    expect(mockWithWorkingOpencodePath).toHaveBeenCalledTimes(1)
     expect(mockCreateOpencode).toHaveBeenCalledWith({ signal, port: 4100, hostname: "127.0.0.1" })
     expect(mockCreateOpencodeClient).not.toHaveBeenCalled()
     expect(result.client).toBeDefined()

src/cli/run/server-connection.ts

@@ -2,16 +2,12 @@ import { createOpencode, createOpencodeClient } from "@opencode-ai/sdk"
 import pc from "picocolors"
 import type { ServerConnection } from "./types"
 import { getAvailableServerPort, isPortAvailable, DEFAULT_SERVER_PORT } from "../../shared/port-utils"
-import { withWorkingOpencodePath } from "./opencode-binary-resolver"
-import { prependResolvedOpencodeBinToPath } from "./opencode-bin-path"
 
 export async function createServerConnection(options: {
   port?: number
   attach?: string
   signal: AbortSignal
 }): Promise<ServerConnection> {
-  prependResolvedOpencodeBinToPath()
-
   const { port, attach, signal } = options
 
   if (attach !== undefined) {
@@ -29,9 +25,7 @@ export async function createServerConnection(options: {
 
     if (available) {
       console.log(pc.dim("Starting server on port"), pc.cyan(port.toString()))
-      const { client, server } = await withWorkingOpencodePath(() =>
-        createOpencode({ signal, port, hostname: "127.0.0.1" }),
-      )
+      const { client, server } = await createOpencode({ signal, port, hostname: "127.0.0.1" })
       console.log(pc.dim("Server listening at"), pc.cyan(server.url))
       return { client, cleanup: () => server.close() }
     }
@@ -47,9 +41,7 @@ export async function createServerConnection(options: {
   } else {
     console.log(pc.dim("Starting server on port"), pc.cyan(selectedPort.toString()))
   }
-  const { client, server } = await withWorkingOpencodePath(() =>
-    createOpencode({ signal, port: selectedPort, hostname: "127.0.0.1" }),
-  )
+  const { client, server } = await createOpencode({ signal, port: selectedPort, hostname: "127.0.0.1" })
   console.log(pc.dim("Server listening at"), pc.cyan(server.url))
   return { client, cleanup: () => server.close() }
 }

src/cli/run/session-resolver.test.ts

@@ -26,8 +26,6 @@ const createMockClient = (overrides: {
 }
 
 describe("resolveSession", () => {
-  const directory = "/test-project"
-
   beforeEach(() => {
     spyOn(console, "log").mockImplementation(() => {})
     spyOn(console, "error").mockImplementation(() => {})
@@ -41,13 +39,12 @@ describe("resolveSession", () => {
     })
 
     // when
-    const result = await resolveSession({ client: mockClient, sessionId, directory })
+    const result = await resolveSession({ client: mockClient, sessionId })
 
     // then
     expect(result).toBe(sessionId)
     expect(mockClient.session.get).toHaveBeenCalledWith({
       path: { id: sessionId },
-      query: { directory },
     })
     expect(mockClient.session.create).not.toHaveBeenCalled()
   })
@@ -60,7 +57,7 @@ describe("resolveSession", () => {
     })
 
     // when
-    const result = resolveSession({ client: mockClient, sessionId, directory })
+    const result = resolveSession({ client: mockClient, sessionId })
 
     // then
     await Promise.resolve(
@@ -68,7 +65,6 @@ describe("resolveSession", () => {
     )
     expect(mockClient.session.get).toHaveBeenCalledWith({
       path: { id: sessionId },
-      query: { directory },
     })
     expect(mockClient.session.create).not.toHaveBeenCalled()
   })
@@ -80,7 +76,7 @@ describe("resolveSession", () => {
     })
 
     // when
-    const result = await resolveSession({ client: mockClient, directory })
+    const result = await resolveSession({ client: mockClient })
 
     // then
     expect(result).toBe("new-session-id")
@@ -91,7 +87,6 @@ describe("resolveSession", () => {
           { permission: "question", action: "deny", pattern: "*" },
         ],
       },
-      query: { directory },
     })
     expect(mockClient.session.get).not.toHaveBeenCalled()
   })
@@ -106,7 +101,7 @@ describe("resolveSession", () => {
     })
 
     // when
-    const result = await resolveSession({ client: mockClient, directory })
+    const result = await resolveSession({ client: mockClient })
 
     // then
     expect(result).toBe("retried-session-id")
@@ -118,7 +113,6 @@ describe("resolveSession", () => {
           { permission: "question", action: "deny", pattern: "*" },
         ],
       },
-      query: { directory },
     })
   })
 
@@ -133,7 +127,7 @@ describe("resolveSession", () => {
     })
 
     // when
-    const result = resolveSession({ client: mockClient, directory })
+    const result = resolveSession({ client: mockClient })
 
     // then
     await Promise.resolve(
@@ -153,7 +147,7 @@ describe("resolveSession", () => {
     })
 
     // when
-    const result = resolveSession({ client: mockClient, directory })
+    const result = resolveSession({ client: mockClient })
 
     // then
     await Promise.resolve(

src/cli/run/session-resolver.ts

@@ -8,15 +8,11 @@ const SESSION_CREATE_RETRY_DELAY_MS = 1000
 export async function resolveSession(options: {
   client: OpencodeClient
   sessionId?: string
-  directory: string
 }): Promise<string> {
-  const { client, sessionId, directory } = options
+  const { client, sessionId } = options
 
   if (sessionId) {
-    const res = await client.session.get({
-      path: { id: sessionId },
-      query: { directory },
-    })
+    const res = await client.session.get({ path: { id: sessionId } })
     if (res.error || !res.data) {
       throw new Error(`Session not found: ${sessionId}`)
     }
@@ -32,7 +28,6 @@ export async function resolveSession(options: {
           { permission: "question", action: "deny" as const, pattern: "*" },
         ],
       } as any,
-      query: { directory },
     })
 
     if (res.error) {

src/cli/run/types.ts

@@ -34,10 +34,10 @@ export interface RunContext {
 }
 
 export interface Todo {
-  id?: string;
-  content: string;
-  status: string;
-  priority: string;
+  id: string
+  content: string
+  status: string
+  priority: string
 }
 
 export interface SessionStatus {
@@ -55,19 +55,16 @@ export interface EventPayload {
 
 export interface SessionIdleProps {
   sessionID?: string
-  sessionId?: string
 }
 
 export interface SessionStatusProps {
   sessionID?: string
-  sessionId?: string
   status?: { type?: string }
 }
 
 export interface MessageUpdatedProps {
   info?: {
     sessionID?: string
-    sessionId?: string
     role?: string
     modelID?: string
     providerID?: string
@@ -76,47 +73,28 @@ export interface MessageUpdatedProps {
 }
 
 export interface MessagePartUpdatedProps {
-  /** @deprecated Legacy structure — current OpenCode puts sessionID inside part */
-  info?: { sessionID?: string; sessionId?: string; role?: string }
+  info?: { sessionID?: string; role?: string }
   part?: {
-    id?: string
-    sessionID?: string
-    sessionId?: string
-    messageID?: string
     type?: string
     text?: string
-    /** Tool name (for part.type === "tool") */
-    tool?: string
-    /** Tool state (for part.type === "tool") */
-    state?: { status?: string; input?: Record<string, unknown>; output?: string }
     name?: string
     input?: unknown
-    time?: { start?: number; end?: number }
   }
 }
 
 export interface ToolExecuteProps {
   sessionID?: string
-  sessionId?: string
   name?: string
   input?: Record<string, unknown>
 }
 
 export interface ToolResultProps {
   sessionID?: string
-  sessionId?: string
   name?: string
   output?: string
 }
 
 export interface SessionErrorProps {
   sessionID?: string
-  sessionId?: string
   error?: unknown
 }
-
-export interface TuiToastShowProps {
-  title?: string
-  message?: string
-  variant?: "info" | "success" | "warning" | "error"
-}

src/config/schema.test.ts

@@ -553,18 +553,6 @@ describe("BrowserAutomationProviderSchema", () => {
     // then
     expect(result.success).toBe(false)
   })
-
-  test("accepts 'playwright-cli' as valid provider", () => {
-    // given
-    const input = "playwright-cli"
-
-    // when
-    const result = BrowserAutomationProviderSchema.safeParse(input)
-
-    // then
-    expect(result.success).toBe(true)
-    expect(result.data).toBe("playwright-cli")
-  })
 })
 
 describe("BrowserAutomationConfigSchema", () => {
@@ -589,17 +577,6 @@ describe("BrowserAutomationConfigSchema", () => {
     // then
     expect(result.provider).toBe("agent-browser")
   })
-
-  test("accepts playwright-cli provider in config", () => {
-    // given
-    const input = { provider: "playwright-cli" }
-
-    // when
-    const result = BrowserAutomationConfigSchema.parse(input)
-
-    // then
-    expect(result.provider).toBe("playwright-cli")
-  })
 })
 
 describe("OhMyOpenCodeConfigSchema - browser_automation_engine", () => {
@@ -630,18 +607,6 @@ describe("OhMyOpenCodeConfigSchema - browser_automation_engine", () => {
     expect(result.success).toBe(true)
     expect(result.data?.browser_automation_engine).toBeUndefined()
   })
-
-  test("accepts browser_automation_engine with playwright-cli", () => {
-    // given
-    const input = { browser_automation_engine: { provider: "playwright-cli" } }
-
-    // when
-    const result = OhMyOpenCodeConfigSchema.safeParse(input)
-
-    // then
-    expect(result.success).toBe(true)
-    expect(result.data?.browser_automation_engine?.provider).toBe("playwright-cli")
-  })
 })
 
 describe("ExperimentalConfigSchema feature flags", () => {
@@ -684,7 +649,21 @@ describe("ExperimentalConfigSchema feature flags", () => {
     }
   })
 
-  test("both fields are optional", () => {
+  test("accepts team_system as boolean", () => {
+    //#given
+    const config = { team_system: true }
+
+    //#when
+    const result = ExperimentalConfigSchema.safeParse(config)
+
+    //#then
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.team_system).toBe(true)
+    }
+  })
+
+  test("defaults team_system to false when not provided", () => {
     //#given
     const config = {}
 
@@ -694,14 +673,13 @@ describe("ExperimentalConfigSchema feature flags", () => {
     //#then
     expect(result.success).toBe(true)
     if (result.success) {
-      expect(result.data.plugin_load_timeout_ms).toBeUndefined()
-      expect(result.data.safe_hook_creation).toBeUndefined()
+      expect(result.data.team_system).toBe(false)
     }
   })
 
-  test("accepts hashline_edit as true", () => {
+  test("accepts team_system as false", () => {
     //#given
-    const config = { hashline_edit: true }
+    const config = { team_system: false }
 
     //#when
     const result = ExperimentalConfigSchema.safeParse(config)
@@ -709,41 +687,13 @@ describe("ExperimentalConfigSchema feature flags", () => {
     //#then
     expect(result.success).toBe(true)
     if (result.success) {
-      expect(result.data.hashline_edit).toBe(true)
+      expect(result.data.team_system).toBe(false)
     }
   })
 
-  test("accepts hashline_edit as false", () => {
+  test("rejects non-boolean team_system", () => {
     //#given
-    const config = { hashline_edit: false }
-
-    //#when
-    const result = ExperimentalConfigSchema.safeParse(config)
-
-    //#then
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.hashline_edit).toBe(false)
-    }
-  })
-
-  test("hashline_edit is optional", () => {
-    //#given
-    const config = { safe_hook_creation: true }
-
-    //#when
-    const result = ExperimentalConfigSchema.safeParse(config)
-
-    //#then
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.hashline_edit).toBeUndefined()
-    }
-  })
-
-  test("rejects non-boolean hashline_edit", () => {
-    //#given
-    const config = { hashline_edit: "true" }
+    const config = { team_system: "true" }
 
     //#when
     const result = ExperimentalConfigSchema.safeParse(config)

src/config/schema/background-task.ts

@@ -6,8 +6,6 @@ export const BackgroundTaskConfigSchema = z.object({
   modelConcurrency: z.record(z.string(), z.number().min(0)).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(),
-  /** Timeout for tasks that never received any progress update, falling back to startedAt (default: 600000 = 10 minutes, minimum: 60000 = 1 minute) */
-  messageStalenessTimeoutMs: z.number().min(60000).optional(),
 })
 
 export type BackgroundTaskConfig = z.infer<typeof BackgroundTaskConfigSchema>

src/config/schema/browser-automation.ts

@@ -4,7 +4,6 @@ export const BrowserAutomationProviderSchema = z.enum([
   "playwright",
   "agent-browser",
   "dev-browser",
-  "playwright-cli",
 ])
 
 export const BrowserAutomationConfigSchema = z.object({
@@ -13,7 +12,6 @@ export const BrowserAutomationConfigSchema = z.object({
    * - "playwright": Uses Playwright MCP server (@playwright/mcp) - default
    * - "agent-browser": Uses Vercel's agent-browser CLI (requires: bun add -g agent-browser)
    * - "dev-browser": Uses dev-browser skill with persistent browser state
-   * - "playwright-cli": Uses Playwright CLI (@playwright/cli) - token-efficient CLI alternative
    */
   provider: BrowserAutomationProviderSchema.default("playwright"),
 })

src/config/schema/experimental.ts

@@ -15,8 +15,10 @@ export const ExperimentalConfigSchema = z.object({
   plugin_load_timeout_ms: z.number().min(1000).optional(),
   /** Wrap hook creation in try/catch to prevent one failing hook from crashing the plugin (default: true at call site) */
   safe_hook_creation: z.boolean().optional(),
-  /** Enable hashline_edit tool for improved file editing with hash-based line anchors */
-  hashline_edit: z.boolean().optional(),
+  /** Enable experimental agent teams toolset (default: false) */
+  agent_teams: z.boolean().optional(),
+  /** Enable experimental team system (default: false) */
+  team_system: z.boolean().default(false),
 })
 
 export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>

src/config/schema/hooks.ts

@@ -45,7 +45,6 @@ export const HookNameSchema = z.enum([
   "tasks-todowrite-disabler",
   "write-existing-file-guard",
   "anthropic-effort",
-  "hashline-read-enhancer",
 ])
 
 export type HookName = z.infer<typeof HookNameSchema>

src/create-managers.ts

@@ -22,9 +22,8 @@ export function createManagers(args: {
   pluginConfig: OhMyOpenCodeConfig
   tmuxConfig: TmuxConfig
   modelCacheState: ModelCacheState
-  backgroundNotificationHookEnabled: boolean
 }): Managers {
-  const { ctx, pluginConfig, tmuxConfig, modelCacheState, backgroundNotificationHookEnabled } = args
+  const { ctx, pluginConfig, tmuxConfig, modelCacheState } = args
 
   const tmuxSessionManager = new TmuxSessionManager(ctx, tmuxConfig)
 
@@ -58,7 +57,6 @@ export function createManagers(args: {
           log("[index] tmux cleanup error during shutdown:", error)
         })
       },
-      enableParentSessionNotifications: backgroundNotificationHookEnabled,
     },
   )
 

src/features/AGENTS.md

@@ -7,17 +7,16 @@
 ## STRUCTURE
 ```
 features/
-├── background-agent/           # Task lifecycle, concurrency (56 files, 1701-line manager)
-│   ├── manager.ts              # Main task orchestration (1701 lines)
-│   ├── concurrency.ts          # Parallel execution limits per provider/model (137 lines)
-│   ├── task-history.ts         # Task execution history per parent session (76 lines)
-│   └── spawner/                # Task spawning: factory, starter, resumer, tmux (8 files)
+├── background-agent/           # Task lifecycle, concurrency (50 files, 8330 LOC)
+│   ├── manager.ts              # Main task orchestration (1646 lines)
+│   ├── concurrency.ts          # Parallel execution limits per provider/model
+│   └── spawner/                # Task spawning utilities (8 files)
 ├── tmux-subagent/              # Tmux integration (28 files, 3303 LOC)
 │   └── manager.ts              # Pane management, grid planning (350 lines)
 ├── opencode-skill-loader/      # YAML frontmatter skill loading (28 files, 2967 LOC)
 │   ├── loader.ts               # Skill discovery (4 scopes)
-│   ├── skill-directory-loader.ts # Recursive directory scanning (maxDepth=2)
-│   ├── skill-discovery.ts      # getAllSkills() with caching + provider gating
+│   ├── skill-directory-loader.ts # Recursive directory scanning
+│   ├── skill-discovery.ts      # getAllSkills() with caching
 │   └── merger/                 # Skill merging with scope priority
 ├── mcp-oauth/                  # OAuth 2.0 flow for MCP (18 files, 2164 LOC)
 │   ├── provider.ts             # McpOAuthProvider class
@@ -26,10 +25,10 @@ features/
 ├── skill-mcp-manager/          # MCP client lifecycle per session (12 files, 1769 LOC)
 │   └── manager.ts              # SkillMcpManager class (150 lines)
 ├── builtin-skills/             # 5 built-in skills (10 files, 1921 LOC)
-│   └── skills/                 # git-master (1112), playwright (313), dev-browser (222), frontend-ui-ux (80)
-├── builtin-commands/           # 7 command templates (11 files, 1511 LOC)
-│   └── templates/              # refactor (620), init-deep (306), handoff (178), start-work, ralph-loop, stop-continuation
-├── claude-tasks/               # Task schema + storage (7 files) — see AGENTS.md
+│   └── skills/                 # git-master (1111), playwright, dev-browser, frontend-ui-ux
+├── builtin-commands/           # 6 command templates (11 files, 1511 LOC)
+│   └── templates/              # refactor, ralph-loop, init-deep, handoff, start-work, stop-continuation
+├── claude-tasks/               # Task schema + storage (7 files, 1165 LOC)
 ├── context-injector/           # AGENTS.md, README.md, rules injection (6 files, 809 LOC)
 ├── claude-code-plugin-loader/  # Plugin discovery from .opencode/plugins/ (10 files)
 ├── claude-code-mcp-loader/     # .mcp.json with ${VAR} expansion (6 files)
@@ -45,10 +44,7 @@ features/
 ## KEY PATTERNS
 
 **Background Agent Lifecycle:**
-pending → running → completed/error/cancelled/interrupt
-- Concurrency: Per provider/model limits (default: 5), queue-based FIFO
-- Events: session.idle + session.error drive completion detection
-- Key methods: `launch()`, `resume()`, `cancelTask()`, `getTask()`, `getAllDescendantTasks()`
+Task creation → Queue → Concurrency check → Execute → Monitor/Poll → Notification → Cleanup
 
 **Skill Loading Pipeline (4-scope priority):**
 opencode-project (`.opencode/skills/`) > opencode (`~/.config/opencode/skills/`) > project (`.claude/skills/`) > user (`~/.claude/skills/`)

src/features/background-agent/background-event-handler.ts

@@ -52,7 +52,7 @@ export function handleBackgroundEvent(args: {
 
   const props = event.properties
 
-  if (event.type === "message.part.updated" || event.type === "message.part.delta") {
+  if (event.type === "message.part.updated") {
     if (!props || !isRecord(props)) return
     const sessionID = getString(props, "sessionID")
     if (!sessionID) return

src/features/background-agent/constants.ts

@@ -4,7 +4,6 @@ import type { BackgroundTask, LaunchInput } from "./types"
 export const TASK_TTL_MS = 30 * 60 * 1000
 export const MIN_STABILITY_TIME_MS = 10 * 1000
 export const DEFAULT_STALE_TIMEOUT_MS = 180_000
-export const DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS = 600_000
 export const MIN_RUNTIME_BEFORE_STALE_MS = 30_000
 export const MIN_IDLE_TIME_MS = 5000
 export const POLLING_INTERVAL_MS = 3000
@@ -33,10 +32,10 @@ export interface BackgroundEvent {
 }
 
 export interface Todo {
-  content: string;
-  status: string;
-  priority: string;
-  id?: string;
+  content: string
+  status: string
+  priority: string
+  id: string
 }
 
 export interface QueueItem {

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

@@ -1,53 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { tmpdir } from "node:os"
-import type { PluginInput } from "@opencode-ai/plugin"
-import { BackgroundManager } from "./manager"
-
-function createManagerWithStatus(statusImpl: () => Promise<{ data: Record<string, { type: string }> }>): BackgroundManager {
-  const client = {
-    session: {
-      status: statusImpl,
-      prompt: async () => ({}),
-      promptAsync: async () => ({}),
-      abort: async () => ({}),
-      todo: async () => ({ data: [] }),
-      messages: async () => ({ data: [] }),
-    },
-  }
-
-  return new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput)
-}
-
-describe("BackgroundManager polling overlap", () => {
-  test("skips overlapping pollRunningTasks executions", async () => {
-    //#given
-    let activeCalls = 0
-    let maxActiveCalls = 0
-    let statusCallCount = 0
-    let releaseStatus: (() => void) | undefined
-    const statusGate = new Promise<void>((resolve) => {
-      releaseStatus = resolve
-    })
-
-    const manager = createManagerWithStatus(async () => {
-      statusCallCount += 1
-      activeCalls += 1
-      maxActiveCalls = Math.max(maxActiveCalls, activeCalls)
-      await statusGate
-      activeCalls -= 1
-      return { data: {} }
-    })
-
-    //#when
-    const firstPoll = (manager as unknown as { pollRunningTasks: () => Promise<void> }).pollRunningTasks()
-    await Promise.resolve()
-    const secondPoll = (manager as unknown as { pollRunningTasks: () => Promise<void> }).pollRunningTasks()
-    releaseStatus?.()
-    await Promise.all([firstPoll, secondPoll])
-    manager.shutdown()
-
-    //#then
-    expect(maxActiveCalls).toBe(1)
-    expect(statusCallCount).toBe(1)
-  })
-})

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

@@ -6,7 +6,6 @@ import type { BackgroundTask, ResumeInput } from "./types"
 import { MIN_IDLE_TIME_MS } from "./constants"
 import { BackgroundManager } from "./manager"
 import { ConcurrencyManager } from "./concurrency"
-import { initTaskToastManager, _resetTaskToastManagerForTesting } from "../task-toast-manager/manager"
 
 
 const TASK_TTL_MS = 30 * 60 * 1000
@@ -191,10 +190,6 @@ function getPendingByParent(manager: BackgroundManager): Map<string, Set<string>
   return (manager as unknown as { pendingByParent: Map<string, Set<string>> }).pendingByParent
 }
 
-function getCompletionTimers(manager: BackgroundManager): Map<string, ReturnType<typeof setTimeout>> {
-  return (manager as unknown as { completionTimers: Map<string, ReturnType<typeof setTimeout>> }).completionTimers
-}
-
 function getQueuesByKey(
   manager: BackgroundManager
 ): Map<string, Array<{ task: BackgroundTask; input: import("./types").LaunchInput }>> {
@@ -220,23 +215,6 @@ function stubNotifyParentSession(manager: BackgroundManager): void {
   ;(manager as unknown as { notifyParentSession: () => Promise<void> }).notifyParentSession = async () => {}
 }
 
-function createToastRemoveTaskTracker(): { removeTaskCalls: string[]; resetToastManager: () => void } {
-  _resetTaskToastManagerForTesting()
-  const toastManager = initTaskToastManager({
-    tui: { showToast: async () => {} },
-  } as unknown as PluginInput["client"])
-  const removeTaskCalls: string[] = []
-  const originalRemoveTask = toastManager.removeTask.bind(toastManager)
-  toastManager.removeTask = (taskId: string): void => {
-    removeTaskCalls.push(taskId)
-    originalRemoveTask(taskId)
-  }
-  return {
-    removeTaskCalls,
-    resetToastManager: _resetTaskToastManagerForTesting,
-  }
-}
-
 function getCleanupSignals(): Array<NodeJS.Signals | "beforeExit" | "exit"> {
   const signals: Array<NodeJS.Signals | "beforeExit" | "exit"> = ["SIGINT", "SIGTERM", "beforeExit", "exit"]
   if (process.platform === "win32") {
@@ -805,62 +783,6 @@ interface CurrentMessage {
 }
 
 describe("BackgroundManager.notifyParentSession - dynamic message lookup", () => {
-  test("should skip compaction agent and use nearest non-compaction message", async () => {
-    //#given
-    let capturedBody: Record<string, unknown> | undefined
-    const client = {
-      session: {
-        prompt: async () => ({}),
-        promptAsync: async (args: { body: Record<string, unknown> }) => {
-          capturedBody = args.body
-          return {}
-        },
-        abort: async () => ({}),
-        messages: async () => ({
-          data: [
-            {
-              info: {
-                agent: "sisyphus",
-                model: { providerID: "anthropic", modelID: "claude-opus-4-6" },
-              },
-            },
-            {
-              info: {
-                agent: "compaction",
-                model: { providerID: "anthropic", modelID: "claude-sonnet-4-5" },
-              },
-            },
-          ],
-        }),
-      },
-    }
-    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput)
-    const task: BackgroundTask = {
-      id: "task-skip-compaction",
-      sessionID: "session-child",
-      parentSessionID: "session-parent",
-      parentMessageID: "msg-parent",
-      description: "task with compaction at tail",
-      prompt: "test",
-      agent: "explore",
-      status: "completed",
-      startedAt: new Date(),
-      completedAt: new Date(),
-      parentAgent: "fallback-agent",
-    }
-    getPendingByParent(manager).set("session-parent", new Set([task.id, "still-running"]))
-
-    //#when
-    await (manager as unknown as { notifyParentSession: (value: BackgroundTask) => Promise<void> })
-      .notifyParentSession(task)
-
-    //#then
-    expect(capturedBody?.agent).toBe("sisyphus")
-    expect(capturedBody?.model).toEqual({ providerID: "anthropic", modelID: "claude-opus-4-6" })
-
-    manager.shutdown()
-  })
-
   test("should use currentMessage model/agent when available", async () => {
     // given - currentMessage has model and agent
     const task: BackgroundTask = {
@@ -972,7 +894,7 @@ describe("BackgroundManager.notifyParentSession - dynamic message lookup", () =>
 })
 
 describe("BackgroundManager.notifyParentSession - aborted parent", () => {
-  test("should fall back and still notify when parent session messages are aborted", async () => {
+  test("should skip notification when parent session is aborted", async () => {
     //#given
     let promptCalled = false
     const promptMock = async () => {
@@ -1011,7 +933,7 @@ describe("BackgroundManager.notifyParentSession - aborted parent", () => {
       .notifyParentSession(task)
 
     //#then
-    expect(promptCalled).toBe(true)
+    expect(promptCalled).toBe(false)
 
     manager.shutdown()
   })
@@ -1059,52 +981,6 @@ describe("BackgroundManager.notifyParentSession - aborted parent", () => {
   })
 })
 
-describe("BackgroundManager.notifyParentSession - notifications toggle", () => {
-  test("should skip parent prompt injection when notifications are disabled", async () => {
-    //#given
-    let promptCalled = false
-    const promptMock = async () => {
-      promptCalled = true
-      return {}
-    }
-    const client = {
-      session: {
-        prompt: promptMock,
-        promptAsync: promptMock,
-        abort: async () => ({}),
-        messages: async () => ({ data: [] }),
-      },
-    }
-    const manager = new BackgroundManager(
-      { client, directory: tmpdir() } as unknown as PluginInput,
-      undefined,
-      { enableParentSessionNotifications: false },
-    )
-    const task: BackgroundTask = {
-      id: "task-no-parent-notification",
-      sessionID: "session-child",
-      parentSessionID: "session-parent",
-      parentMessageID: "msg-parent",
-      description: "task notifications disabled",
-      prompt: "test",
-      agent: "explore",
-      status: "completed",
-      startedAt: new Date(),
-      completedAt: new Date(),
-    }
-    getPendingByParent(manager).set("session-parent", new Set([task.id]))
-
-    //#when
-    await (manager as unknown as { notifyParentSession: (task: BackgroundTask) => Promise<void> })
-      .notifyParentSession(task)
-
-    //#then
-    expect(promptCalled).toBe(false)
-
-    manager.shutdown()
-  })
-})
-
 function buildNotificationPromptBody(
   task: BackgroundTask,
   currentMessage: CurrentMessage | null
@@ -1894,32 +1770,6 @@ describe("BackgroundManager - Non-blocking Queue Integration", () => {
       const pendingSet = pendingByParent.get(task.parentSessionID)
       expect(pendingSet?.has(task.id) ?? false).toBe(false)
     })
-
-    test("should remove task from toast manager when notification is skipped", async () => {
-      //#given
-      const { removeTaskCalls, resetToastManager } = createToastRemoveTaskTracker()
-      const manager = createBackgroundManager()
-      const task = createMockTask({
-        id: "task-cancel-skip-notification",
-        sessionID: "session-cancel-skip-notification",
-        parentSessionID: "parent-cancel-skip-notification",
-        status: "running",
-      })
-      getTaskMap(manager).set(task.id, task)
-
-      //#when
-      const cancelled = await manager.cancelTask(task.id, {
-        source: "test",
-        skipNotification: true,
-      })
-
-      //#then
-      expect(cancelled).toBe(true)
-      expect(removeTaskCalls).toContain(task.id)
-
-      manager.shutdown()
-      resetToastManager()
-    })
   })
 
   describe("multiple keys process in parallel", () => {
@@ -2439,221 +2289,10 @@ describe("BackgroundManager.checkAndInterruptStaleTasks", () => {
 
     getTaskMap(manager).set(task.id, task)
 
-     await manager["checkAndInterruptStaleTasks"]()
+    await manager["checkAndInterruptStaleTasks"]()
 
     expect(task.status).toBe("cancelled")
   })
-
-  test("should NOT interrupt task when session is running, even with stale lastUpdate", async () => {
-    //#given
-    const client = {
-      session: {
-        prompt: async () => ({}),
-        promptAsync: async () => ({}),
-        abort: async () => ({}),
-      },
-    }
-    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { staleTimeoutMs: 180_000 })
-
-    const task: BackgroundTask = {
-      id: "task-running-session",
-      sessionID: "session-running",
-      parentSessionID: "parent-rs",
-      parentMessageID: "msg-rs",
-      description: "Task with running session",
-      prompt: "Test",
-      agent: "test-agent",
-      status: "running",
-      startedAt: new Date(Date.now() - 300_000),
-      progress: {
-        toolCalls: 2,
-        lastUpdate: new Date(Date.now() - 300_000),
-      },
-    }
-
-    getTaskMap(manager).set(task.id, task)
-
-    //#when — session is actively running
-    await manager["checkAndInterruptStaleTasks"]({ "session-running": { type: "running" } })
-
-    //#then — task survives because session is running
-    expect(task.status).toBe("running")
-  })
-
-  test("should interrupt task when session is idle and lastUpdate exceeds stale timeout", async () => {
-    //#given
-    const client = {
-      session: {
-        prompt: async () => ({}),
-        promptAsync: async () => ({}),
-        abort: async () => ({}),
-      },
-    }
-    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { staleTimeoutMs: 180_000 })
-    stubNotifyParentSession(manager)
-
-    const task: BackgroundTask = {
-      id: "task-idle-session",
-      sessionID: "session-idle",
-      parentSessionID: "parent-is",
-      parentMessageID: "msg-is",
-      description: "Task with idle session",
-      prompt: "Test",
-      agent: "test-agent",
-      status: "running",
-      startedAt: new Date(Date.now() - 300_000),
-      progress: {
-        toolCalls: 2,
-        lastUpdate: new Date(Date.now() - 300_000),
-      },
-    }
-
-    getTaskMap(manager).set(task.id, task)
-
-    //#when — session is idle
-    await manager["checkAndInterruptStaleTasks"]({ "session-idle": { type: "idle" } })
-
-    //#then — killed because session is idle with stale lastUpdate
-    expect(task.status).toBe("cancelled")
-    expect(task.error).toContain("Stale timeout")
-  })
-
-  test("should NOT interrupt running session even with very old lastUpdate (no safety net)", async () => {
-    //#given
-    const client = {
-      session: {
-        prompt: async () => ({}),
-        promptAsync: async () => ({}),
-        abort: async () => ({}),
-      },
-    }
-    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { staleTimeoutMs: 180_000 })
-
-    const task: BackgroundTask = {
-      id: "task-long-running",
-      sessionID: "session-long",
-      parentSessionID: "parent-lr",
-      parentMessageID: "msg-lr",
-      description: "Long running task",
-      prompt: "Test",
-      agent: "test-agent",
-      status: "running",
-      startedAt: new Date(Date.now() - 900_000),
-      progress: {
-        toolCalls: 5,
-        lastUpdate: new Date(Date.now() - 900_000),
-      },
-    }
-
-    getTaskMap(manager).set(task.id, task)
-
-    //#when — session is running, lastUpdate 15min old
-    await manager["checkAndInterruptStaleTasks"]({ "session-long": { type: "running" } })
-
-    //#then — running sessions are NEVER stale-killed
-    expect(task.status).toBe("running")
-  })
-
-  test("should NOT interrupt running session with no progress (undefined lastUpdate)", async () => {
-    //#given — no progress at all, but session is running
-    const client = {
-      session: {
-        prompt: async () => ({}),
-        promptAsync: async () => ({}),
-        abort: async () => ({}),
-      },
-    }
-    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { messageStalenessTimeoutMs: 600_000 })
-
-    const task: BackgroundTask = {
-      id: "task-running-no-progress",
-      sessionID: "session-rnp",
-      parentSessionID: "parent-rnp",
-      parentMessageID: "msg-rnp",
-      description: "Running no progress",
-      prompt: "Test",
-      agent: "test-agent",
-      status: "running",
-      startedAt: new Date(Date.now() - 15 * 60 * 1000),
-      progress: undefined,
-    }
-
-    getTaskMap(manager).set(task.id, task)
-
-    //#when — session is running despite no progress
-    await manager["checkAndInterruptStaleTasks"]({ "session-rnp": { type: "running" } })
-
-    //#then — running sessions are NEVER killed
-    expect(task.status).toBe("running")
-  })
-
-  test("should interrupt task with no lastUpdate after messageStalenessTimeout", async () => {
-    //#given
-    const client = {
-      session: {
-        prompt: async () => ({}),
-        promptAsync: async () => ({}),
-        abort: async () => ({}),
-      },
-    }
-    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { messageStalenessTimeoutMs: 600_000 })
-    stubNotifyParentSession(manager)
-
-    const task: BackgroundTask = {
-      id: "task-no-update",
-      sessionID: "session-no-update",
-      parentSessionID: "parent-nu",
-      parentMessageID: "msg-nu",
-      description: "No update task",
-      prompt: "Test",
-      agent: "test-agent",
-      status: "running",
-      startedAt: new Date(Date.now() - 15 * 60 * 1000),
-      progress: undefined,
-    }
-
-    getTaskMap(manager).set(task.id, task)
-
-    //#when — no progress update for 15 minutes
-    await manager["checkAndInterruptStaleTasks"]({})
-
-    //#then — killed after messageStalenessTimeout
-    expect(task.status).toBe("cancelled")
-    expect(task.error).toContain("no activity")
-  })
-
-  test("should NOT interrupt task with no lastUpdate within messageStalenessTimeout", async () => {
-    //#given
-    const client = {
-      session: {
-        prompt: async () => ({}),
-        promptAsync: async () => ({}),
-        abort: async () => ({}),
-      },
-    }
-    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { messageStalenessTimeoutMs: 600_000 })
-
-    const task: BackgroundTask = {
-      id: "task-fresh-no-update",
-      sessionID: "session-fresh",
-      parentSessionID: "parent-fn",
-      parentMessageID: "msg-fn",
-      description: "Fresh no-update task",
-      prompt: "Test",
-      agent: "test-agent",
-      status: "running",
-      startedAt: new Date(Date.now() - 5 * 60 * 1000),
-      progress: undefined,
-    }
-
-    getTaskMap(manager).set(task.id, task)
-
-    //#when — only 5 min since start, within 10min timeout
-    await manager["checkAndInterruptStaleTasks"]({})
-
-    //#then — task survives
-    expect(task.status).toBe("running")
-  })
 })
 
 describe("BackgroundManager.shutdown session abort", () => {
@@ -2880,43 +2519,6 @@ describe("BackgroundManager.handleEvent - session.deleted cascade", () => {
 
     manager.shutdown()
   })
-
-  test("should remove tasks from toast manager when session is deleted", () => {
-    //#given
-    const { removeTaskCalls, resetToastManager } = createToastRemoveTaskTracker()
-    const manager = createBackgroundManager()
-    const parentSessionID = "session-parent-toast"
-    const childTask = createMockTask({
-      id: "task-child-toast",
-      sessionID: "session-child-toast",
-      parentSessionID,
-      status: "running",
-    })
-    const grandchildTask = createMockTask({
-      id: "task-grandchild-toast",
-      sessionID: "session-grandchild-toast",
-      parentSessionID: "session-child-toast",
-      status: "pending",
-      startedAt: undefined,
-      queuedAt: new Date(),
-    })
-    const taskMap = getTaskMap(manager)
-    taskMap.set(childTask.id, childTask)
-    taskMap.set(grandchildTask.id, grandchildTask)
-
-    //#when
-    manager.handleEvent({
-      type: "session.deleted",
-      properties: { info: { id: parentSessionID } },
-    })
-
-    //#then
-    expect(removeTaskCalls).toContain(childTask.id)
-    expect(removeTaskCalls).toContain(grandchildTask.id)
-
-    manager.shutdown()
-    resetToastManager()
-  })
 })
 
 describe("BackgroundManager.handleEvent - session.error", () => {
@@ -2964,35 +2566,6 @@ describe("BackgroundManager.handleEvent - session.error", () => {
     manager.shutdown()
   })
 
-  test("removes errored task from toast manager", () => {
-    //#given
-    const { removeTaskCalls, resetToastManager } = createToastRemoveTaskTracker()
-    const manager = createBackgroundManager()
-    const sessionID = "ses_error_toast"
-    const task = createMockTask({
-      id: "task-session-error-toast",
-      sessionID,
-      parentSessionID: "parent-session",
-      status: "running",
-    })
-    getTaskMap(manager).set(task.id, task)
-
-    //#when
-    manager.handleEvent({
-      type: "session.error",
-      properties: {
-        sessionID,
-        error: { name: "UnknownError", message: "boom" },
-      },
-    })
-
-    //#then
-    expect(removeTaskCalls).toContain(task.id)
-
-    manager.shutdown()
-    resetToastManager()
-  })
-
   test("ignores session.error for non-running tasks", () => {
     //#given
     const manager = createBackgroundManager()
@@ -3138,32 +2711,13 @@ describe("BackgroundManager.pruneStaleTasksAndNotifications - removes pruned tas
 
     manager.shutdown()
   })
-
-  test("removes stale task from toast manager", () => {
-    //#given
-    const { removeTaskCalls, resetToastManager } = createToastRemoveTaskTracker()
-    const manager = createBackgroundManager()
-    const staleTask = createMockTask({
-      id: "task-stale-toast",
-      sessionID: "session-stale-toast",
-      parentSessionID: "parent-session",
-      status: "running",
-      startedAt: new Date(Date.now() - 31 * 60 * 1000),
-    })
-    getTaskMap(manager).set(staleTask.id, staleTask)
-
-    //#when
-    pruneStaleTasksAndNotificationsForTest(manager)
-
-    //#then
-    expect(removeTaskCalls).toContain(staleTask.id)
-
-    manager.shutdown()
-    resetToastManager()
-  })
 })
 
 describe("BackgroundManager.completionTimers - Memory Leak Fix", () => {
+  function getCompletionTimers(manager: BackgroundManager): Map<string, ReturnType<typeof setTimeout>> {
+    return (manager as unknown as { completionTimers: Map<string, ReturnType<typeof setTimeout>> }).completionTimers
+  }
+
   function setCompletionTimer(manager: BackgroundManager, taskId: string): void {
     const completionTimers = getCompletionTimers(manager)
     const timer = setTimeout(() => {
@@ -3648,134 +3202,4 @@ describe("BackgroundManager.handleEvent - non-tool event lastUpdate", () => {
     //#then - task should still be running (text event refreshed lastUpdate)
     expect(task.status).toBe("running")
   })
-
-  test("should refresh lastUpdate on message.part.delta events (OpenCode >=1.2.0)", async () => {
-    //#given - a running task with stale lastUpdate
-    const client = {
-      session: {
-        prompt: async () => ({}),
-        promptAsync: async () => ({}),
-        abort: async () => ({}),
-      },
-    }
-    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput, { staleTimeoutMs: 180_000 })
-    stubNotifyParentSession(manager)
-
-    const task: BackgroundTask = {
-      id: "task-delta-1",
-      sessionID: "session-delta-1",
-      parentSessionID: "parent-1",
-      parentMessageID: "msg-1",
-      description: "Reasoning task with delta events",
-      prompt: "Extended thinking",
-      agent: "oracle",
-      status: "running",
-      startedAt: new Date(Date.now() - 600_000),
-      progress: {
-        toolCalls: 0,
-        lastUpdate: new Date(Date.now() - 300_000),
-      },
-    }
-    getTaskMap(manager).set(task.id, task)
-
-    //#when - a message.part.delta event arrives (reasoning-delta or text-delta in OpenCode >=1.2.0)
-    manager.handleEvent({
-      type: "message.part.delta",
-      properties: { sessionID: "session-delta-1", field: "text", delta: "thinking..." },
-    })
-    await manager["checkAndInterruptStaleTasks"]()
-
-    //#then - task should still be running (delta event refreshed lastUpdate)
-    expect(task.status).toBe("running")
-  })
-})
-
-describe("BackgroundManager regression fixes - resume and aborted notification", () => {
-  test("should keep resumed task in memory after previous completion timer deadline", async () => {
-    //#given
-    const client = {
-      session: {
-        prompt: async () => ({}),
-        promptAsync: async () => ({}),
-        abort: async () => ({}),
-      },
-    }
-    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput)
-
-    const task: BackgroundTask = {
-      id: "task-resume-timer-regression",
-      sessionID: "session-resume-timer-regression",
-      parentSessionID: "parent-session",
-      parentMessageID: "msg-1",
-      description: "resume timer regression",
-      prompt: "test",
-      agent: "explore",
-      status: "completed",
-      startedAt: new Date(),
-      completedAt: new Date(),
-      concurrencyGroup: "explore",
-    }
-    getTaskMap(manager).set(task.id, task)
-
-    const completionTimers = getCompletionTimers(manager)
-    const timer = setTimeout(() => {
-      completionTimers.delete(task.id)
-      getTaskMap(manager).delete(task.id)
-    }, 25)
-    completionTimers.set(task.id, timer)
-
-    //#when
-    await manager.resume({
-      sessionId: "session-resume-timer-regression",
-      prompt: "resume task",
-      parentSessionID: "parent-session-2",
-      parentMessageID: "msg-2",
-    })
-    await new Promise((resolve) => setTimeout(resolve, 60))
-
-    //#then
-    expect(getTaskMap(manager).has(task.id)).toBe(true)
-    expect(completionTimers.has(task.id)).toBe(false)
-
-    manager.shutdown()
-  })
-
-  test("should start cleanup timer even when promptAsync aborts", async () => {
-    //#given
-    const client = {
-      session: {
-        prompt: async () => ({}),
-        promptAsync: async () => {
-          const error = new Error("User aborted")
-          error.name = "MessageAbortedError"
-          throw error
-        },
-        abort: async () => ({}),
-        messages: async () => ({ data: [] }),
-      },
-    }
-    const manager = new BackgroundManager({ client, directory: tmpdir() } as unknown as PluginInput)
-    const task: BackgroundTask = {
-      id: "task-aborted-cleanup-regression",
-      sessionID: "session-aborted-cleanup-regression",
-      parentSessionID: "parent-session",
-      parentMessageID: "msg-1",
-      description: "aborted prompt cleanup regression",
-      prompt: "test",
-      agent: "explore",
-      status: "completed",
-      startedAt: new Date(),
-      completedAt: new Date(),
-    }
-    getTaskMap(manager).set(task.id, task)
-    getPendingByParent(manager).set(task.parentSessionID, new Set([task.id]))
-
-    //#when
-    await (manager as unknown as { notifyParentSession: (task: BackgroundTask) => Promise<void> }).notifyParentSession(task)
-
-    //#then
-    expect(getCompletionTimers(manager).has(task.id)).toBe(true)
-
-    manager.shutdown()
-  })
 })

src/features/background-agent/manager.ts

@@ -6,16 +6,15 @@ import type {
   ResumeInput,
 } from "./types"
 import { TaskHistory } from "./task-history"
-import { log, getAgentToolRestrictions, normalizeSDKResponse, promptWithModelSuggestionRetry } from "../../shared"
-import { setSessionTools } from "../../shared/session-tools-store"
+import { log, getAgentToolRestrictions, promptWithModelSuggestionRetry } from "../../shared"
 import { ConcurrencyManager } from "./concurrency"
 import type { BackgroundTaskConfig, TmuxConfig } from "../../config/schema"
 import { isInsideTmux } from "../../shared/tmux"
 import {
-  DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS,
   DEFAULT_STALE_TIMEOUT_MS,
   MIN_IDLE_TIME_MS,
   MIN_RUNTIME_BEFORE_STALE_MS,
+  MIN_STABILITY_TIME_MS,
   POLLING_INTERVAL_MS,
   TASK_CLEANUP_DELAY_MS,
   TASK_TTL_MS,
@@ -23,8 +22,8 @@ import {
 
 import { subagentSessions } from "../claude-code-session-state"
 import { getTaskToastManager } from "../task-toast-manager"
-import { MESSAGE_STORAGE, type StoredMessage } from "../hook-message-injector"
-import { existsSync, readFileSync, readdirSync } from "node:fs"
+import { findNearestMessageWithFields, MESSAGE_STORAGE } from "../hook-message-injector"
+import { existsSync, readdirSync } from "node:fs"
 import { join } from "node:path"
 
 type ProcessCleanupEvent = NodeJS.Signals | "beforeExit" | "exit"
@@ -80,7 +79,6 @@ export class BackgroundManager {
   private client: OpencodeClient
   private directory: string
   private pollingInterval?: ReturnType<typeof setInterval>
-  private pollingInFlight = false
   private concurrencyManager: ConcurrencyManager
   private shutdownTriggered = false
   private config?: BackgroundTaskConfig
@@ -93,7 +91,6 @@ export class BackgroundManager {
   private completionTimers: Map<string, ReturnType<typeof setTimeout>> = new Map()
   private idleDeferralTimers: Map<string, ReturnType<typeof setTimeout>> = new Map()
   private notificationQueueByParent: Map<string, Promise<void>> = new Map()
-  private enableParentSessionNotifications: boolean
   readonly taskHistory = new TaskHistory()
 
   constructor(
@@ -103,7 +100,6 @@ export class BackgroundManager {
       tmuxConfig?: TmuxConfig
       onSubagentSessionCreated?: OnSubagentSessionCreated
       onShutdown?: () => void
-      enableParentSessionNotifications?: boolean
     }
   ) {
     this.tasks = new Map()
@@ -116,7 +112,6 @@ export class BackgroundManager {
     this.tmuxEnabled = options?.tmuxConfig?.enabled ?? false
     this.onSubagentSessionCreated = options?.onSubagentSessionCreated
     this.onShutdown = options?.onShutdown
-    this.enableParentSessionNotifications = options?.enableParentSessionNotifications ?? true
     this.registerProcessCleanup()
   }
 
@@ -146,7 +141,6 @@ export class BackgroundManager {
       parentMessageID: input.parentMessageID,
       parentModel: input.parentModel,
       parentAgent: input.parentAgent,
-      parentTools: input.parentTools,
       model: input.model,
       category: input.category,
     }
@@ -334,16 +328,12 @@ export class BackgroundManager {
         ...(launchModel ? { model: launchModel } : {}),
         ...(launchVariant ? { variant: launchVariant } : {}),
         system: input.skillContent,
-        tools: (() => {
-          const tools = {
-            ...getAgentToolRestrictions(input.agent),
-            task: false,
-            call_omo_agent: true,
-            question: false,
-          }
-          setSessionTools(sessionID, tools)
-          return tools
-        })(),
+        tools: {
+          ...getAgentToolRestrictions(input.agent),
+          task: false,
+          call_omo_agent: true,
+          question: false,
+        },
         parts: [{ type: "text", text: input.prompt }],
       },
     }).catch((error) => {
@@ -531,12 +521,6 @@ export class BackgroundManager {
       return existingTask
     }
 
-    const completionTimer = this.completionTimers.get(existingTask.id)
-    if (completionTimer) {
-      clearTimeout(completionTimer)
-      this.completionTimers.delete(existingTask.id)
-    }
-
     // Re-acquire concurrency using the persisted concurrency group
     const concurrencyKey = existingTask.concurrencyGroup ?? existingTask.agent
     await this.concurrencyManager.acquire(concurrencyKey)
@@ -551,9 +535,6 @@ export class BackgroundManager {
     existingTask.parentMessageID = input.parentMessageID
     existingTask.parentModel = input.parentModel
     existingTask.parentAgent = input.parentAgent
-    if (input.parentTools) {
-      existingTask.parentTools = input.parentTools
-    }
     // Reset startedAt on resume to prevent immediate completion
     // The MIN_IDLE_TIME_MS check uses startedAt, so resumed tasks need fresh timing
     existingTask.startedAt = new Date()
@@ -607,16 +588,12 @@ export class BackgroundManager {
         agent: existingTask.agent,
         ...(resumeModel ? { model: resumeModel } : {}),
         ...(resumeVariant ? { variant: resumeVariant } : {}),
-        tools: (() => {
-          const tools = {
-            ...getAgentToolRestrictions(existingTask.agent),
-            task: false,
-            call_omo_agent: true,
-            question: false,
-          }
-          setSessionTools(existingTask.sessionID!, tools)
-          return tools
-        })(),
+        tools: {
+          ...getAgentToolRestrictions(existingTask.agent),
+          task: false,
+          call_omo_agent: true,
+          question: false,
+        },
         parts: [{ type: "text", text: input.prompt }],
       },
     }).catch((error) => {
@@ -654,7 +631,7 @@ export class BackgroundManager {
       const response = await this.client.session.todo({
         path: { id: sessionID },
       })
-      const todos = normalizeSDKResponse(response, [] as Todo[], { preferResponseOnMissingData: true })
+      const todos = (response.data ?? response) as Todo[]
       if (!todos || todos.length === 0) return false
 
       const incomplete = todos.filter(
@@ -669,7 +646,7 @@ export class BackgroundManager {
   handleEvent(event: Event): void {
     const props = event.properties
 
-    if (event.type === "message.part.updated" || event.type === "message.part.delta") {
+    if (event.type === "message.part.updated") {
       if (!props || typeof props !== "object" || !("sessionID" in props)) return
       const partInfo = props as unknown as MessagePartInfo
       const sessionID = partInfo?.sessionID
@@ -792,10 +769,6 @@ export class BackgroundManager {
       this.cleanupPendingByParent(task)
       this.tasks.delete(task.id)
       this.clearNotificationsForTask(task.id)
-      const toastManager = getTaskToastManager()
-      if (toastManager) {
-        toastManager.removeTask(task.id)
-      }
       if (task.sessionID) {
         subagentSessions.delete(task.sessionID)
       }
@@ -843,10 +816,6 @@ export class BackgroundManager {
         this.cleanupPendingByParent(task)
         this.tasks.delete(task.id)
         this.clearNotificationsForTask(task.id)
-        const toastManager = getTaskToastManager()
-        if (toastManager) {
-          toastManager.removeTask(task.id)
-        }
         if (task.sessionID) {
           subagentSessions.delete(task.sessionID)
         }
@@ -878,7 +847,7 @@ export class BackgroundManager {
         path: { id: sessionID },
       })
 
-      const messages = normalizeSDKResponse(response, [] as Array<{ info?: { role?: string } }>, { preferResponseOnMissingData: true })
+      const messages = response.data ?? []
       
       // Check for at least one assistant or tool message
       const hasAssistantOrToolMessage = messages.some(
@@ -1017,10 +986,6 @@ export class BackgroundManager {
     }
 
     if (options?.skipNotification) {
-      const toastManager = getTaskToastManager()
-      if (toastManager) {
-        toastManager.removeTask(task.id)
-      }
       log(`[background-agent] Task cancelled via ${source} (notification skipped):`, task.id)
       return true
     }
@@ -1207,21 +1172,19 @@ export class BackgroundManager {
       allComplete = true
     }
 
-    const completedTasks = allComplete
-      ? Array.from(this.tasks.values())
-        .filter(t => t.parentSessionID === task.parentSessionID && t.status !== "running" && t.status !== "pending")
-      : []
-
     const statusText = task.status === "completed" ? "COMPLETED" : task.status === "interrupt" ? "INTERRUPTED" : "CANCELLED"
     const errorInfo = task.error ? `\n**Error:** ${task.error}` : ""
-
+    
     let notification: string
+    let completedTasks: BackgroundTask[] = []
     if (allComplete) {
-        const completedTasksText = completedTasks
-          .map(t => `- \`${t.id}\`: ${t.description}`)
-          .join("\n")
+      completedTasks = Array.from(this.tasks.values())
+        .filter(t => t.parentSessionID === task.parentSessionID && t.status !== "running" && t.status !== "pending")
+      const completedTasksText = completedTasks
+        .map(t => `- \`${t.id}\`: ${t.description}`)
+        .join("\n")
 
-        notification = `<system-reminder>
+      notification = `<system-reminder>
 [ALL BACKGROUND TASKS COMPLETE]
 
 **Completed:**
@@ -1244,79 +1207,69 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
 </system-reminder>`
     }
 
-      let agent: string | undefined = task.parentAgent
-      let model: { providerID: string; modelID: string } | undefined
+    let agent: string | undefined = task.parentAgent
+    let model: { providerID: string; modelID: string } | undefined
 
-      if (this.enableParentSessionNotifications) {
-        try {
-          const messagesResp = await this.client.session.messages({ path: { id: task.parentSessionID } })
-          const messages = normalizeSDKResponse(messagesResp, [] as Array<{
-            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 (isCompactionAgent(info?.agent)) {
-              continue
-            }
-            if (info?.agent || info?.model || (info?.modelID && info?.providerID)) {
-              agent = info.agent ?? task.parentAgent
-              model = info.model ?? (info.providerID && info.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined)
-              break
-            }
-          }
-        } catch (error) {
-          if (this.isAbortedSessionError(error)) {
-            log("[background-agent] Parent session aborted while loading messages; using messageDir fallback:", {
-              taskId: task.id,
-              parentSessionID: task.parentSessionID,
-            })
-          }
-          const messageDir = getMessageDir(task.parentSessionID)
-          const currentMessage = messageDir ? findNearestMessageExcludingCompaction(messageDir) : null
-          agent = currentMessage?.agent ?? task.parentAgent
-          model = currentMessage?.model?.providerID && currentMessage?.model?.modelID
-            ? { providerID: currentMessage.model.providerID, modelID: currentMessage.model.modelID }
-            : undefined
+    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 }; modelID?: string; providerID?: string }
+      }>
+      for (let i = messages.length - 1; i >= 0; i--) {
+        const info = messages[i].info
+        if (info?.agent || info?.model || (info?.modelID && info?.providerID)) {
+          agent = info.agent ?? task.parentAgent
+          model = info.model ?? (info.providerID && info.modelID ? { providerID: info.providerID, modelID: info.modelID } : undefined)
+          break
         }
-
-        log("[background-agent] notifyParentSession context:", {
-          taskId: task.id,
-          resolvedAgent: agent,
-          resolvedModel: model,
-        })
-
-        try {
-          await this.client.session.promptAsync({
-            path: { id: task.parentSessionID },
-            body: {
-              noReply: !allComplete,
-              ...(agent !== undefined ? { agent } : {}),
-              ...(model !== undefined ? { model } : {}),
-              ...(task.parentTools ? { tools: task.parentTools } : {}),
-              parts: [{ type: "text", text: notification }],
-            },
-          })
-          log("[background-agent] Sent notification to parent session:", {
-            taskId: task.id,
-            allComplete,
-            noReply: !allComplete,
-          })
-        } catch (error) {
-          if (this.isAbortedSessionError(error)) {
-            log("[background-agent] Parent session aborted while sending notification; continuing cleanup:", {
-              taskId: task.id,
-              parentSessionID: task.parentSessionID,
-            })
-          } else {
-            log("[background-agent] Failed to send notification:", error)
-          }
-        }
-      } else {
-        log("[background-agent] Parent session notifications disabled, skipping prompt injection:", {
+      }
+    } catch (error) {
+      if (this.isAbortedSessionError(error)) {
+        log("[background-agent] Parent session aborted, skipping notification:", {
           taskId: task.id,
           parentSessionID: task.parentSessionID,
         })
+        return
       }
+      const messageDir = getMessageDir(task.parentSessionID)
+      const currentMessage = messageDir ? findNearestMessageWithFields(messageDir) : null
+      agent = currentMessage?.agent ?? task.parentAgent
+      model = currentMessage?.model?.providerID && currentMessage?.model?.modelID
+        ? { providerID: currentMessage.model.providerID, modelID: currentMessage.model.modelID }
+        : undefined
+    }
+
+    log("[background-agent] notifyParentSession context:", {
+      taskId: task.id,
+      resolvedAgent: agent,
+      resolvedModel: model,
+    })
+
+    try {
+      await this.client.session.promptAsync({
+        path: { id: task.parentSessionID },
+        body: {
+          noReply: !allComplete,
+          ...(agent !== undefined ? { agent } : {}),
+          ...(model !== undefined ? { model } : {}),
+          parts: [{ type: "text", text: notification }],
+        },
+      })
+      log("[background-agent] Sent notification to parent session:", {
+        taskId: task.id,
+        allComplete,
+        noReply: !allComplete,
+      })
+    } catch (error) {
+      if (this.isAbortedSessionError(error)) {
+        log("[background-agent] Parent session aborted, skipping notification:", {
+          taskId: task.id,
+          parentSessionID: task.parentSessionID,
+        })
+        return
+      }
+      log("[background-agent] Failed to send notification:", error)
+    }
 
     if (allComplete) {
       for (const completedTask of completedTasks) {
@@ -1445,10 +1398,6 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
           }
         }
         this.clearNotificationsForTask(taskId)
-        const toastManager = getTaskToastManager()
-        if (toastManager) {
-          toastManager.removeTask(taskId)
-        }
         this.tasks.delete(taskId)
         if (task.sessionID) {
           subagentSessions.delete(task.sessionID)
@@ -1474,55 +1423,24 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
     }
   }
 
-  private async checkAndInterruptStaleTasks(
-    allStatuses: Record<string, { type: string }> = {},
-  ): Promise<void> {
+  private async checkAndInterruptStaleTasks(): Promise<void> {
     const staleTimeoutMs = this.config?.staleTimeoutMs ?? DEFAULT_STALE_TIMEOUT_MS
-    const messageStalenessMs = this.config?.messageStalenessTimeoutMs ?? DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS
     const now = Date.now()
 
     for (const task of this.tasks.values()) {
       if (task.status !== "running") continue
-
+      if (!task.progress?.lastUpdate) continue
+      
       const startedAt = task.startedAt
       const sessionID = task.sessionID
       if (!startedAt || !sessionID) continue
 
-      const sessionStatus = allStatuses[sessionID]?.type
-      const sessionIsRunning = sessionStatus !== undefined && sessionStatus !== "idle"
       const runtime = now - startedAt.getTime()
-
-      if (!task.progress?.lastUpdate) {
-        if (sessionIsRunning) continue
-        if (runtime <= messageStalenessMs) continue
-
-        const staleMinutes = Math.round(runtime / 60000)
-        task.status = "cancelled"
-        task.error = `Stale timeout (no activity for ${staleMinutes}min since start)`
-        task.completedAt = new Date()
-
-        if (task.concurrencyKey) {
-          this.concurrencyManager.release(task.concurrencyKey)
-          task.concurrencyKey = undefined
-        }
-
-        this.client.session.abort({ path: { id: sessionID } }).catch(() => {})
-        log(`[background-agent] Task ${task.id} interrupted: no progress since start`)
-
-        try {
-          await this.enqueueNotificationForParent(task.parentSessionID, () => this.notifyParentSession(task))
-        } catch (err) {
-          log("[background-agent] Error in notifyParentSession for stale task:", { taskId: task.id, error: err })
-        }
-        continue
-      }
-
-      if (sessionIsRunning) continue
-
       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)
@@ -1535,7 +1453,10 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
         task.concurrencyKey = undefined
       }
 
-      this.client.session.abort({ path: { id: sessionID } }).catch(() => {})
+      this.client.session.abort({
+        path: { id: sessionID },
+      }).catch(() => {})
+
       log(`[background-agent] Task ${task.id} interrupted: stale timeout`)
 
       try {
@@ -1547,15 +1468,11 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
   }
 
   private async pollRunningTasks(): Promise<void> {
-    if (this.pollingInFlight) return
-    this.pollingInFlight = true
-    try {
     this.pruneStaleTasksAndNotifications()
+    await this.checkAndInterruptStaleTasks()
 
     const statusResult = await this.client.session.status()
-    const allStatuses = normalizeSDKResponse(statusResult, {} as Record<string, { type: string }>)
-
-    await this.checkAndInterruptStaleTasks(allStatuses)
+    const allStatuses = (statusResult.data ?? {}) as Record<string, { type: string }>
 
     for (const task of this.tasks.values()) {
       if (task.status !== "running") continue
@@ -1566,6 +1483,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
       try {
         const sessionStatus = allStatuses[sessionID]
         
+        // Don't skip if session not in status - fall through to message-based detection
         if (sessionStatus?.type === "idle") {
           // Edge guard: Validate session has actual output before completing
           const hasValidOutput = await this.validateSessionHasOutput(sessionID)
@@ -1605,9 +1523,6 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
     if (!this.hasRunningTasks()) {
       this.stopPolling()
     }
-    } finally {
-      this.pollingInFlight = false
-    }
   }
 
   /**
@@ -1725,57 +1640,3 @@ function getMessageDir(sessionID: string): string | null {
   }
   return null
 }
-
-function isCompactionAgent(agent: string | undefined): boolean {
-  return agent?.trim().toLowerCase() === "compaction"
-}
-
-function hasFullAgentAndModel(message: StoredMessage): boolean {
-  return !!message.agent &&
-    !isCompactionAgent(message.agent) &&
-    !!message.model?.providerID &&
-    !!message.model?.modelID
-}
-
-function hasPartialAgentOrModel(message: StoredMessage): boolean {
-  const hasAgent = !!message.agent && !isCompactionAgent(message.agent)
-  const hasModel = !!message.model?.providerID && !!message.model?.modelID
-  return hasAgent || hasModel
-}
-
-function findNearestMessageExcludingCompaction(messageDir: string): StoredMessage | null {
-  try {
-    const files = readdirSync(messageDir)
-      .filter((name) => name.endsWith(".json"))
-      .sort()
-      .reverse()
-
-    for (const file of files) {
-      try {
-        const content = readFileSync(join(messageDir, file), "utf-8")
-        const parsed = JSON.parse(content) as StoredMessage
-        if (hasFullAgentAndModel(parsed)) {
-          return parsed
-        }
-      } catch {
-        continue
-      }
-    }
-
-    for (const file of files) {
-      try {
-        const content = readFileSync(join(messageDir, file), "utf-8")
-        const parsed = JSON.parse(content) as StoredMessage
-        if (hasPartialAgentOrModel(parsed)) {
-          return parsed
-        }
-      } catch {
-        continue
-      }
-    }
-  } catch {
-    return null
-  }
-
-  return null
-}

src/features/background-agent/message-dir.ts

@@ -1 +1 @@
-export { getMessageDir } from "../../shared"
+export { getMessageDir } from "./message-storage-locator"

src/features/background-agent/message-storage-locator.ts

@@ -0,0 +1,17 @@
+import { existsSync, readdirSync } from "node:fs"
+import { join } from "node:path"
+import { MESSAGE_STORAGE } from "../hook-message-injector"
+
+export 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
+}

src/features/background-agent/notify-parent-session.ts

@@ -1,4 +1,4 @@
-import { log, normalizeSDKResponse } from "../../shared"
+import { log } from "../../shared"
 
 import { findNearestMessageWithFields } from "../hook-message-injector"
 import { getTaskToastManager } from "../task-toast-manager"
@@ -106,7 +106,7 @@ export async function notifyParentSession(args: {
     const messagesResp = await client.session.messages({
       path: { id: task.parentSessionID },
     })
-    const raw = normalizeSDKResponse(messagesResp, [] as unknown[])
+    const raw = (messagesResp as { data?: unknown }).data ?? []
     const messages = Array.isArray(raw) ? raw : []
 
     for (let i = messages.length - 1; i >= 0; i--) {
@@ -148,7 +148,6 @@ export async function notifyParentSession(args: {
         noReply: !allComplete,
         ...(agent !== undefined ? { agent } : {}),
         ...(model !== undefined ? { model } : {}),
-        ...(task.parentTools ? { tools: task.parentTools } : {}),
         parts: [{ type: "text", text: notification }],
       },
     })

src/features/background-agent/parent-session-context-resolver.ts

@@ -1,7 +1,7 @@
 import type { OpencodeClient } from "./constants"
 import type { BackgroundTask } from "./types"
 import { findNearestMessageWithFields } from "../hook-message-injector"
-import { getMessageDir } from "../../shared"
+import { getMessageDir } from "./message-storage-locator"
 
 type AgentModel = { providerID: string; modelID: string }
 

src/features/background-agent/parent-session-notifier.ts

@@ -71,7 +71,6 @@ export async function notifyParentSession(
         noReply: !allComplete,
         ...(agent !== undefined ? { agent } : {}),
         ...(model !== undefined ? { model } : {}),
-        ...(task.parentTools ? { tools: task.parentTools } : {}),
         parts: [{ type: "text", text: notification }],
       },
     })

src/features/background-agent/poll-running-tasks.ts

@@ -1,4 +1,4 @@
-import { log, normalizeSDKResponse } from "../../shared"
+import { log } from "../../shared"
 
 import {
   MIN_STABILITY_TIME_MS,
@@ -34,7 +34,7 @@ export async function pollRunningTasks(args: {
   tasks: Iterable<BackgroundTask>
   client: OpencodeClient
   pruneStaleTasksAndNotifications: () => void
-  checkAndInterruptStaleTasks: (statuses: Record<string, { type: string }>) => Promise<void>
+  checkAndInterruptStaleTasks: () => Promise<void>
   validateSessionHasOutput: (sessionID: string) => Promise<boolean>
   checkSessionTodos: (sessionID: string) => Promise<boolean>
   tryCompleteTask: (task: BackgroundTask, source: string) => Promise<boolean>
@@ -54,11 +54,10 @@ export async function pollRunningTasks(args: {
   } = args
 
   pruneStaleTasksAndNotifications()
+  await checkAndInterruptStaleTasks()
 
   const statusResult = await client.session.status()
-  const allStatuses = normalizeSDKResponse(statusResult, {} as SessionStatusMap)
-
-  await checkAndInterruptStaleTasks(allStatuses)
+  const allStatuses = ((statusResult as { data?: unknown }).data ?? {}) as SessionStatusMap
 
   for (const task of tasks) {
     if (task.status !== "running") continue
@@ -95,9 +94,10 @@ export async function pollRunningTasks(args: {
         continue
       }
 
-      const messages = asSessionMessages(normalizeSDKResponse(messagesResult, [] as SessionMessage[], {
-        preferResponseOnMissingData: true,
-      }))
+      const messagesPayload = Array.isArray(messagesResult)
+        ? messagesResult
+        : (messagesResult as { data?: unknown }).data
+      const messages = asSessionMessages(messagesPayload)
       const assistantMsgs = messages.filter((m) => m.info?.role === "assistant")
 
       let toolCalls = 0
@@ -138,7 +138,7 @@ export async function pollRunningTasks(args: {
           task.stablePolls = (task.stablePolls ?? 0) + 1
           if (task.stablePolls >= 3) {
             const recheckStatus = await client.session.status()
-            const recheckData = normalizeSDKResponse(recheckStatus, {} as SessionStatusMap)
+            const recheckData = ((recheckStatus as { data?: unknown }).data ?? {}) as SessionStatusMap
             const currentStatus = recheckData[sessionID]
 
             if (currentStatus?.type !== "idle") {

src/features/background-agent/result-handler.ts

@@ -1,6 +1,6 @@
 export type { ResultHandlerContext } from "./result-handler-context"
 export { formatDuration } from "./duration-formatter"
-export { getMessageDir } from "../../shared"
+export { getMessageDir } from "./message-storage-locator"
 export { checkSessionTodos } from "./session-todo-checker"
 export { validateSessionHasOutput } from "./session-output-validator"
 export { tryCompleteTask } from "./background-task-completer"

src/features/background-agent/session-todo-checker.ts

@@ -4,7 +4,7 @@ function isTodo(value: unknown): value is Todo {
   if (typeof value !== "object" || value === null) return false
   const todo = value as Record<string, unknown>
   return (
-    (typeof todo["id"] === "string" || todo["id"] === undefined) &&
+    typeof todo["id"] === "string" &&
     typeof todo["content"] === "string" &&
     typeof todo["status"] === "string" &&
     typeof todo["priority"] === "string"

src/features/background-agent/session-validator.ts

@@ -1,4 +1,4 @@
-import { log, normalizeSDKResponse } from "../../shared"
+import { log } from "../../shared"
 
 import type { OpencodeClient } from "./opencode-client"
 
@@ -51,9 +51,7 @@ export async function validateSessionHasOutput(
       path: { id: sessionID },
     })
 
-    const messages = asSessionMessages(normalizeSDKResponse(response, [] as SessionMessage[], {
-      preferResponseOnMissingData: true,
-    }))
+    const messages = asSessionMessages((response as { data?: unknown }).data ?? response)
 
     const hasAssistantOrToolMessage = messages.some(
       (m) => m.info?.role === "assistant" || m.info?.role === "tool"
@@ -99,9 +97,8 @@ export async function checkSessionTodos(
       path: { id: sessionID },
     })
 
-    const todos = normalizeSDKResponse(response, [] as Todo[], {
-      preferResponseOnMissingData: true,
-    })
+    const raw = (response as { data?: unknown }).data ?? response
+    const todos = Array.isArray(raw) ? (raw as Todo[]) : []
     if (todos.length === 0) return false
 
     const incomplete = todos.filter(

src/features/background-agent/spawner/parent-directory-resolver.test.ts

@@ -1,33 +0,0 @@
-import { describe, expect, test } from "bun:test"
-
-import { resolveParentDirectory } from "./parent-directory-resolver"
-
-describe("background-agent parent-directory-resolver", () => {
-  const originalPlatform = process.platform
-
-  test("uses current working directory on Windows when parent session directory is AppData", async () => {
-    //#given
-    Object.defineProperty(process, "platform", { value: "win32" })
-    try {
-      const client = {
-        session: {
-          get: async () => ({
-            data: { directory: "C:\\Users\\test\\AppData\\Local\\ai.opencode.desktop" },
-          }),
-        },
-      }
-
-      //#when
-      const result = await resolveParentDirectory({
-        client: client as Parameters<typeof resolveParentDirectory>[0]["client"],
-        parentSessionID: "ses_parent",
-        defaultDirectory: "C:\\Users\\test\\AppData\\Roaming\\opencode",
-      })
-
-      //#then
-      expect(result).toBe(process.cwd())
-    } finally {
-      Object.defineProperty(process, "platform", { value: originalPlatform })
-    }
-  })
-})

src/features/background-agent/spawner/parent-directory-resolver.ts

@@ -1,5 +1,5 @@
 import type { OpencodeClient } from "../constants"
-import { log, resolveSessionDirectory } from "../../../shared"
+import { log } from "../../../shared"
 
 export async function resolveParentDirectory(options: {
   client: OpencodeClient
@@ -15,10 +15,7 @@ export async function resolveParentDirectory(options: {
       return null
     })
 
-  const parentDirectory = resolveSessionDirectory({
-    parentDirectory: parentSession?.data?.directory,
-    fallbackDirectory: defaultDirectory,
-  })
+  const parentDirectory = parentSession?.data?.directory ?? defaultDirectory
   log(`[background-agent] Parent dir: ${parentSession?.data?.directory}, using: ${parentDirectory}`)
   return parentDirectory
 }

src/features/background-agent/spawner/task-factory.ts

@@ -13,7 +13,6 @@ export function createTask(input: LaunchInput): BackgroundTask {
     parentMessageID: input.parentMessageID,
     parentModel: input.parentModel,
     parentAgent: input.parentAgent,
-    parentTools: input.parentTools,
     model: input.model,
   }
 }

src/features/background-agent/spawner/task-resumer.ts

@@ -1,6 +1,5 @@
 import type { BackgroundTask, ResumeInput } from "../types"
 import { log, getAgentToolRestrictions } from "../../../shared"
-import { setSessionTools } from "../../../shared/session-tools-store"
 import type { SpawnerContext } from "./spawner-context"
 import { subagentSessions } from "../../claude-code-session-state"
 import { getTaskToastManager } from "../../task-toast-manager"
@@ -36,9 +35,6 @@ export async function resumeTask(
   task.parentMessageID = input.parentMessageID
   task.parentModel = input.parentModel
   task.parentAgent = input.parentAgent
-  if (input.parentTools) {
-    task.parentTools = input.parentTools
-  }
   task.startedAt = new Date()
 
   task.progress = {
@@ -79,16 +75,12 @@ export async function resumeTask(
         agent: task.agent,
         ...(resumeModel ? { model: resumeModel } : {}),
         ...(resumeVariant ? { variant: resumeVariant } : {}),
-        tools: (() => {
-          const tools = {
-            ...getAgentToolRestrictions(task.agent),
-            task: false,
-            call_omo_agent: true,
-            question: false,
-          }
-          setSessionTools(task.sessionID!, tools)
-          return tools
-        })(),
+        tools: {
+          ...getAgentToolRestrictions(task.agent),
+          task: false,
+          call_omo_agent: true,
+          question: false,
+        },
         parts: [{ type: "text", text: input.prompt }],
       },
     })

src/features/background-agent/spawner/task-starter.ts

@@ -1,6 +1,5 @@
 import type { QueueItem } from "../constants"
 import { log, getAgentToolRestrictions, promptWithModelSuggestionRetry } from "../../../shared"
-import { setSessionTools } from "../../../shared/session-tools-store"
 import { subagentSessions } from "../../claude-code-session-state"
 import { getTaskToastManager } from "../../task-toast-manager"
 import { createBackgroundSession } from "./background-session-creator"
@@ -80,16 +79,12 @@ export async function startTask(item: QueueItem, ctx: SpawnerContext): Promise<v
       ...(launchModel ? { model: launchModel } : {}),
       ...(launchVariant ? { variant: launchVariant } : {}),
       system: input.skillContent,
-      tools: (() => {
-        const tools = {
-          ...getAgentToolRestrictions(input.agent),
-          task: false,
-          call_omo_agent: true,
-          question: false,
-        }
-        setSessionTools(sessionID, tools)
-        return tools
-      })(),
+      tools: {
+        ...getAgentToolRestrictions(input.agent),
+        task: false,
+        call_omo_agent: true,
+        question: false,
+      },
       parts: [{ type: "text", text: input.prompt }],
     },
   }).catch((error: unknown) => {

src/features/background-agent/task-poller.test.ts

@@ -1,425 +0,0 @@
-import { describe, it, expect, mock } from "bun:test"
-
-import { checkAndInterruptStaleTasks, pruneStaleTasksAndNotifications } from "./task-poller"
-import type { BackgroundTask } from "./types"
-
-describe("checkAndInterruptStaleTasks", () => {
-  const mockClient = {
-    session: {
-      abort: mock(() => Promise.resolve()),
-    },
-  }
-  const mockConcurrencyManager = {
-    release: mock(() => {}),
-  }
-  const mockNotify = mock(() => Promise.resolve())
-
-  function createRunningTask(overrides: Partial<BackgroundTask> = {}): BackgroundTask {
-    return {
-      id: "task-1",
-      sessionID: "ses-1",
-      parentSessionID: "parent-ses-1",
-      parentMessageID: "msg-1",
-      description: "test",
-      prompt: "test",
-      agent: "explore",
-      status: "running",
-      startedAt: new Date(Date.now() - 120_000),
-      ...overrides,
-    }
-  }
-
-  it("should interrupt tasks with lastUpdate exceeding stale timeout", async () => {
-    //#given
-    const task = createRunningTask({
-      progress: {
-        toolCalls: 1,
-        lastUpdate: new Date(Date.now() - 200_000),
-      },
-    })
-
-    //#when
-    await checkAndInterruptStaleTasks({
-      tasks: [task],
-      client: mockClient as never,
-      config: { staleTimeoutMs: 180_000 },
-      concurrencyManager: mockConcurrencyManager as never,
-      notifyParentSession: mockNotify,
-    })
-
-    //#then
-    expect(task.status).toBe("cancelled")
-    expect(task.error).toContain("Stale timeout")
-  })
-
-  it("should NOT interrupt tasks with recent lastUpdate", async () => {
-    //#given
-    const task = createRunningTask({
-      progress: {
-        toolCalls: 1,
-        lastUpdate: new Date(Date.now() - 10_000),
-      },
-    })
-
-    //#when
-    await checkAndInterruptStaleTasks({
-      tasks: [task],
-      client: mockClient as never,
-      config: { staleTimeoutMs: 180_000 },
-      concurrencyManager: mockConcurrencyManager as never,
-      notifyParentSession: mockNotify,
-    })
-
-    //#then
-    expect(task.status).toBe("running")
-  })
-
-  it("should interrupt tasks with NO progress.lastUpdate that exceeded messageStalenessTimeoutMs since startedAt", async () => {
-    //#given — task started 15 minutes ago, never received any progress update
-    const task = createRunningTask({
-      startedAt: new Date(Date.now() - 15 * 60 * 1000),
-      progress: undefined,
-    })
-
-    //#when
-    await checkAndInterruptStaleTasks({
-      tasks: [task],
-      client: mockClient as never,
-      config: { messageStalenessTimeoutMs: 600_000 },
-      concurrencyManager: mockConcurrencyManager as never,
-      notifyParentSession: mockNotify,
-    })
-
-    //#then
-    expect(task.status).toBe("cancelled")
-    expect(task.error).toContain("no activity")
-  })
-
-  it("should NOT interrupt tasks with NO progress.lastUpdate that are within messageStalenessTimeoutMs", async () => {
-    //#given — task started 5 minutes ago, default timeout is 10 minutes
-    const task = createRunningTask({
-      startedAt: new Date(Date.now() - 5 * 60 * 1000),
-      progress: undefined,
-    })
-
-    //#when
-    await checkAndInterruptStaleTasks({
-      tasks: [task],
-      client: mockClient as never,
-      config: { messageStalenessTimeoutMs: 600_000 },
-      concurrencyManager: mockConcurrencyManager as never,
-      notifyParentSession: mockNotify,
-    })
-
-    //#then
-    expect(task.status).toBe("running")
-  })
-
-  it("should use DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS when messageStalenessTimeoutMs is not configured", async () => {
-    //#given — task started 15 minutes ago, no config for messageStalenessTimeoutMs
-    const task = createRunningTask({
-      startedAt: new Date(Date.now() - 15 * 60 * 1000),
-      progress: undefined,
-    })
-
-    //#when — default is 10 minutes (600_000ms)
-    await checkAndInterruptStaleTasks({
-      tasks: [task],
-      client: mockClient as never,
-      config: undefined,
-      concurrencyManager: mockConcurrencyManager as never,
-      notifyParentSession: mockNotify,
-    })
-
-    //#then
-    expect(task.status).toBe("cancelled")
-    expect(task.error).toContain("no activity")
-  })
-
-  it("should NOT interrupt task when session is running, even if lastUpdate exceeds stale timeout", async () => {
-    //#given — lastUpdate is 5min old but session is actively running
-    const task = createRunningTask({
-      startedAt: new Date(Date.now() - 300_000),
-      progress: {
-        toolCalls: 2,
-        lastUpdate: new Date(Date.now() - 300_000),
-      },
-    })
-
-    //#when — session status is "busy" (OpenCode's actual status for active LLM processing)
-    await checkAndInterruptStaleTasks({
-      tasks: [task],
-      client: mockClient as never,
-      config: { staleTimeoutMs: 180_000 },
-      concurrencyManager: mockConcurrencyManager as never,
-      notifyParentSession: mockNotify,
-      sessionStatuses: { "ses-1": { type: "busy" } },
-    })
-
-    //#then — task should survive because session is actively busy
-    expect(task.status).toBe("running")
-  })
-
-  it("should NOT interrupt busy session task even with very old lastUpdate", async () => {
-    //#given — lastUpdate is 15min old, but session is still busy
-    const task = createRunningTask({
-      startedAt: new Date(Date.now() - 900_000),
-      progress: {
-        toolCalls: 2,
-        lastUpdate: new Date(Date.now() - 900_000),
-      },
-    })
-
-    //#when — session busy, lastUpdate far exceeds any timeout
-    await checkAndInterruptStaleTasks({
-      tasks: [task],
-      client: mockClient as never,
-      config: { staleTimeoutMs: 180_000, messageStalenessTimeoutMs: 600_000 },
-      concurrencyManager: mockConcurrencyManager as never,
-      notifyParentSession: mockNotify,
-      sessionStatuses: { "ses-1": { type: "busy" } },
-    })
-
-    //#then — busy sessions are NEVER stale-killed (babysitter + TTL prune handle these)
-    expect(task.status).toBe("running")
-  })
-
-  it("should NOT interrupt busy session even with no progress (undefined lastUpdate)", async () => {
-    //#given — task has no progress at all, but session is busy
-    const task = createRunningTask({
-      startedAt: new Date(Date.now() - 15 * 60 * 1000),
-      progress: undefined,
-    })
-
-    //#when — session is busy
-    await checkAndInterruptStaleTasks({
-      tasks: [task],
-      client: mockClient as never,
-      config: { messageStalenessTimeoutMs: 600_000 },
-      concurrencyManager: mockConcurrencyManager as never,
-      notifyParentSession: mockNotify,
-      sessionStatuses: { "ses-1": { type: "busy" } },
-    })
-
-    //#then — task should survive because session is actively running
-    expect(task.status).toBe("running")
-  })
-
-  it("should interrupt task when session is idle and lastUpdate exceeds stale timeout", async () => {
-    //#given — lastUpdate is 5min old and session is idle
-    const task = createRunningTask({
-      startedAt: new Date(Date.now() - 300_000),
-      progress: {
-        toolCalls: 2,
-        lastUpdate: new Date(Date.now() - 300_000),
-      },
-    })
-
-    //#when — session status is "idle"
-    await checkAndInterruptStaleTasks({
-      tasks: [task],
-      client: mockClient as never,
-      config: { staleTimeoutMs: 180_000 },
-      concurrencyManager: mockConcurrencyManager as never,
-      notifyParentSession: mockNotify,
-      sessionStatuses: { "ses-1": { type: "idle" } },
-    })
-
-    //#then — task should be killed because session is idle with stale lastUpdate
-    expect(task.status).toBe("cancelled")
-    expect(task.error).toContain("Stale timeout")
-  })
-
-  it("should NOT interrupt running session task even with very old lastUpdate", async () => {
-    //#given — lastUpdate is 15min old, but session is still running
-    const task = createRunningTask({
-      startedAt: new Date(Date.now() - 900_000),
-      progress: {
-        toolCalls: 2,
-        lastUpdate: new Date(Date.now() - 900_000),
-      },
-    })
-
-    //#when — session running, lastUpdate far exceeds any timeout
-    await checkAndInterruptStaleTasks({
-      tasks: [task],
-      client: mockClient as never,
-      config: { staleTimeoutMs: 180_000, messageStalenessTimeoutMs: 600_000 },
-      concurrencyManager: mockConcurrencyManager as never,
-      notifyParentSession: mockNotify,
-      sessionStatuses: { "ses-1": { type: "running" } },
-    })
-
-    //#then — running sessions are NEVER stale-killed (babysitter + TTL prune handle these)
-    expect(task.status).toBe("running")
-  })
-
-  it("should NOT interrupt running session even with no progress (undefined lastUpdate)", async () => {
-    //#given — task has no progress at all, but session is running
-    const task = createRunningTask({
-      startedAt: new Date(Date.now() - 15 * 60 * 1000),
-      progress: undefined,
-    })
-
-    //#when — session is running
-    await checkAndInterruptStaleTasks({
-      tasks: [task],
-      client: mockClient as never,
-      config: { messageStalenessTimeoutMs: 600_000 },
-      concurrencyManager: mockConcurrencyManager as never,
-      notifyParentSession: mockNotify,
-      sessionStatuses: { "ses-1": { type: "running" } },
-    })
-
-    //#then — running sessions are NEVER killed, even without progress
-    expect(task.status).toBe("running")
-  })
-
-  it("should use default stale timeout when session status is unknown/missing", async () => {
-    //#given — lastUpdate exceeds stale timeout, session not in status map
-    const task = createRunningTask({
-      startedAt: new Date(Date.now() - 300_000),
-      progress: {
-        toolCalls: 1,
-        lastUpdate: new Date(Date.now() - 200_000),
-      },
-    })
-
-    //#when — empty sessionStatuses (session not found)
-    await checkAndInterruptStaleTasks({
-      tasks: [task],
-      client: mockClient as never,
-      config: { staleTimeoutMs: 180_000 },
-      concurrencyManager: mockConcurrencyManager as never,
-      notifyParentSession: mockNotify,
-      sessionStatuses: {},
-    })
-
-    //#then — unknown session treated as potentially stale, apply default timeout
-    expect(task.status).toBe("cancelled")
-    expect(task.error).toContain("Stale timeout")
-  })
-
-  it("should NOT interrupt task when session is busy (OpenCode status), even if lastUpdate exceeds stale timeout", async () => {
-    //#given — lastUpdate is 5min old but session is "busy" (OpenCode's actual status for active sessions)
-    const task = createRunningTask({
-      startedAt: new Date(Date.now() - 300_000),
-      progress: {
-        toolCalls: 2,
-        lastUpdate: new Date(Date.now() - 300_000),
-      },
-    })
-
-    //#when — session status is "busy" (not "running" — OpenCode uses "busy" for active LLM processing)
-    await checkAndInterruptStaleTasks({
-      tasks: [task],
-      client: mockClient as never,
-      config: { staleTimeoutMs: 180_000 },
-      concurrencyManager: mockConcurrencyManager as never,
-      notifyParentSession: mockNotify,
-      sessionStatuses: { "ses-1": { type: "busy" } },
-    })
-
-    //#then — "busy" sessions must be protected from stale-kill
-    expect(task.status).toBe("running")
-  })
-
-  it("should NOT interrupt task when session is in retry state", async () => {
-    //#given — lastUpdate is 5min old but session is retrying
-    const task = createRunningTask({
-      startedAt: new Date(Date.now() - 300_000),
-      progress: {
-        toolCalls: 1,
-        lastUpdate: new Date(Date.now() - 300_000),
-      },
-    })
-
-    //#when — session status is "retry" (OpenCode retries on transient API errors)
-    await checkAndInterruptStaleTasks({
-      tasks: [task],
-      client: mockClient as never,
-      config: { staleTimeoutMs: 180_000 },
-      concurrencyManager: mockConcurrencyManager as never,
-      notifyParentSession: mockNotify,
-      sessionStatuses: { "ses-1": { type: "retry" } },
-    })
-
-    //#then — retry sessions must be protected from stale-kill
-    expect(task.status).toBe("running")
-  })
-
-  it("should NOT interrupt busy session even with no progress (undefined lastUpdate)", async () => {
-    //#given — no progress at all, session is "busy" (thinking model with no streamed tokens yet)
-    const task = createRunningTask({
-      startedAt: new Date(Date.now() - 15 * 60 * 1000),
-      progress: undefined,
-    })
-
-    //#when — session is busy
-    await checkAndInterruptStaleTasks({
-      tasks: [task],
-      client: mockClient as never,
-      config: { messageStalenessTimeoutMs: 600_000 },
-      concurrencyManager: mockConcurrencyManager as never,
-      notifyParentSession: mockNotify,
-      sessionStatuses: { "ses-1": { type: "busy" } },
-    })
-
-    //#then — busy sessions with no progress must survive
-    expect(task.status).toBe("running")
-  })
-
-  it("should release concurrency key when interrupting a never-updated task", async () => {
-    //#given
-    const releaseMock = mock(() => {})
-    const task = createRunningTask({
-      startedAt: new Date(Date.now() - 15 * 60 * 1000),
-      progress: undefined,
-      concurrencyKey: "anthropic/claude-opus-4-6",
-    })
-
-    //#when
-    await checkAndInterruptStaleTasks({
-      tasks: [task],
-      client: mockClient as never,
-      config: { messageStalenessTimeoutMs: 600_000 },
-      concurrencyManager: { release: releaseMock } as never,
-      notifyParentSession: mockNotify,
-    })
-
-    //#then
-    expect(releaseMock).toHaveBeenCalledWith("anthropic/claude-opus-4-6")
-    expect(task.concurrencyKey).toBeUndefined()
-  })
-})
-
-describe("pruneStaleTasksAndNotifications", () => {
-  it("should prune tasks that exceeded TTL", () => {
-    //#given
-    const tasks = new Map<string, BackgroundTask>()
-    const oldTask: BackgroundTask = {
-      id: "old-task",
-      parentSessionID: "parent",
-      parentMessageID: "msg",
-      description: "old",
-      prompt: "old",
-      agent: "explore",
-      status: "running",
-      startedAt: new Date(Date.now() - 31 * 60 * 1000),
-    }
-    tasks.set("old-task", oldTask)
-
-    const pruned: string[] = []
-    const notifications = new Map<string, BackgroundTask[]>()
-
-    //#when
-    pruneStaleTasksAndNotifications({
-      tasks,
-      notifications,
-      onTaskPruned: (taskId) => pruned.push(taskId),
-    })
-
-    //#then
-    expect(pruned).toContain("old-task")
-  })
-})

src/features/background-agent/task-poller.ts

@@ -6,7 +6,6 @@ import type { ConcurrencyManager } from "./concurrency"
 import type { OpencodeClient } from "./opencode-client"
 
 import {
-  DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS,
   DEFAULT_STALE_TIMEOUT_MS,
   MIN_RUNTIME_BEFORE_STALE_MS,
   TASK_TTL_MS,
@@ -57,60 +56,26 @@ export function pruneStaleTasksAndNotifications(args: {
   }
 }
 
-export type SessionStatusMap = Record<string, { type: string }>
-
 export async function checkAndInterruptStaleTasks(args: {
   tasks: Iterable<BackgroundTask>
   client: OpencodeClient
   config: BackgroundTaskConfig | undefined
   concurrencyManager: ConcurrencyManager
   notifyParentSession: (task: BackgroundTask) => Promise<void>
-  sessionStatuses?: SessionStatusMap
 }): Promise<void> {
-  const { tasks, client, config, concurrencyManager, notifyParentSession, sessionStatuses } = args
+  const { tasks, client, config, concurrencyManager, notifyParentSession } = args
   const staleTimeoutMs = config?.staleTimeoutMs ?? DEFAULT_STALE_TIMEOUT_MS
   const now = Date.now()
 
-  const messageStalenessMs = config?.messageStalenessTimeoutMs ?? DEFAULT_MESSAGE_STALENESS_TIMEOUT_MS
-
   for (const task of tasks) {
     if (task.status !== "running") continue
+    if (!task.progress?.lastUpdate) continue
 
     const startedAt = task.startedAt
     const sessionID = task.sessionID
     if (!startedAt || !sessionID) continue
 
-    const sessionStatus = sessionStatuses?.[sessionID]?.type
-    const sessionIsRunning = sessionStatus !== undefined && sessionStatus !== "idle"
     const runtime = now - startedAt.getTime()
-
-    if (!task.progress?.lastUpdate) {
-      if (sessionIsRunning) continue
-      if (runtime <= messageStalenessMs) continue
-
-      const staleMinutes = Math.round(runtime / 60000)
-      task.status = "cancelled"
-      task.error = `Stale timeout (no activity for ${staleMinutes}min since start)`
-      task.completedAt = new Date()
-
-      if (task.concurrencyKey) {
-        concurrencyManager.release(task.concurrencyKey)
-        task.concurrencyKey = undefined
-      }
-
-      client.session.abort({ path: { id: sessionID } }).catch(() => {})
-      log(`[background-agent] Task ${task.id} interrupted: no progress since start`)
-
-      try {
-        await notifyParentSession(task)
-      } catch (err) {
-        log("[background-agent] Error in notifyParentSession for stale task:", { taskId: task.id, error: err })
-      }
-      continue
-    }
-
-    if (sessionIsRunning) continue
-
     if (runtime < MIN_RUNTIME_BEFORE_STALE_MS) continue
 
     const timeSinceLastUpdate = now - task.progress.lastUpdate.getTime()
@@ -127,7 +92,10 @@ export async function checkAndInterruptStaleTasks(args: {
       task.concurrencyKey = undefined
     }
 
-    client.session.abort({ path: { id: sessionID } }).catch(() => {})
+    client.session.abort({
+      path: { id: sessionID },
+    }).catch(() => {})
+
     log(`[background-agent] Task ${task.id} interrupted: stale timeout`)
 
     try {

src/features/background-agent/types.ts

@@ -37,8 +37,6 @@ export interface BackgroundTask {
   concurrencyGroup?: string
   /** Parent session's agent name for notification */
   parentAgent?: string
-  /** Parent session's tool restrictions for notification prompts */
-  parentTools?: Record<string, boolean>
   /** Marks if the task was launched from an unstable agent/category */
   isUnstableAgent?: boolean
   /** Category used for this task (e.g., 'quick', 'visual-engineering') */
@@ -58,7 +56,6 @@ export interface LaunchInput {
   parentMessageID: string
   parentModel?: { providerID: string; modelID: string }
   parentAgent?: string
-  parentTools?: Record<string, boolean>
   model?: { providerID: string; modelID: string; variant?: string }
   isUnstableAgent?: boolean
   skills?: string[]
@@ -73,5 +70,4 @@ export interface ResumeInput {
   parentMessageID: string
   parentModel?: { providerID: string; modelID: string }
   parentAgent?: string
-  parentTools?: Record<string, boolean>
 }

src/features/builtin-skills/skills.test.ts

@@ -140,35 +140,4 @@ describe("createBuiltinSkills", () => {
 		// #then
 		expect(skills.length).toBe(4)
 	})
-
-	test("returns playwright-cli skill when browserProvider is 'playwright-cli'", () => {
-		// given
-		const options = { browserProvider: "playwright-cli" as const }
-
-		// when
-		const skills = createBuiltinSkills(options)
-
-		// then
-		const playwrightSkill = skills.find((s) => s.name === "playwright")
-		const agentBrowserSkill = skills.find((s) => s.name === "agent-browser")
-		expect(playwrightSkill).toBeDefined()
-		expect(playwrightSkill!.description).toContain("browser")
-		expect(playwrightSkill!.allowedTools).toContain("Bash(playwright-cli:*)")
-		expect(playwrightSkill!.mcpConfig).toBeUndefined()
-		expect(agentBrowserSkill).toBeUndefined()
-	})
-
-	test("playwright-cli skill template contains CLI commands", () => {
-		// given
-		const options = { browserProvider: "playwright-cli" as const }
-
-		// when
-		const skills = createBuiltinSkills(options)
-		const skill = skills.find((s) => s.name === "playwright")
-
-		// then
-		expect(skill!.template).toContain("playwright-cli open")
-		expect(skill!.template).toContain("playwright-cli snapshot")
-		expect(skill!.template).toContain("playwright-cli click")
-	})
 })

src/features/builtin-skills/skills.ts

@@ -4,7 +4,6 @@ import type { BrowserAutomationProvider } from "../../config/schema"
 import {
   playwrightSkill,
   agentBrowserSkill,
-  playwrightCliSkill,
   frontendUiUxSkill,
   gitMasterSkill,
   devBrowserSkill,
@@ -18,14 +17,7 @@ export interface CreateBuiltinSkillsOptions {
 export function createBuiltinSkills(options: CreateBuiltinSkillsOptions = {}): BuiltinSkill[] {
   const { browserProvider = "playwright", disabledSkills } = options
 
-  let browserSkill: BuiltinSkill
-  if (browserProvider === "agent-browser") {
-    browserSkill = agentBrowserSkill
-  } else if (browserProvider === "playwright-cli") {
-    browserSkill = playwrightCliSkill
-  } else {
-    browserSkill = playwrightSkill
-  }
+  const browserSkill = browserProvider === "agent-browser" ? agentBrowserSkill : playwrightSkill
 
   const skills = [browserSkill, frontendUiUxSkill, gitMasterSkill, devBrowserSkill]
 

src/features/builtin-skills/skills/index.ts

@@ -1,5 +1,4 @@
 export { playwrightSkill, agentBrowserSkill } from "./playwright"
-export { playwrightCliSkill } from "./playwright-cli"
 export { frontendUiUxSkill } from "./frontend-ui-ux"
 export { gitMasterSkill } from "./git-master"
 export { devBrowserSkill } from "./dev-browser"

src/features/builtin-skills/skills/playwright-cli.ts

@@ -1,268 +0,0 @@
-import type { BuiltinSkill } from "../types"
-
-/**
- * Playwright CLI skill — token-efficient CLI alternative to the MCP-based playwright skill.
- *
- * Uses name "playwright" (not "playwright-cli") because agents hardcode "playwright" as the
- * canonical browser skill name. The browserProvider config swaps the implementation behind
- * the same name: "playwright" gives MCP, "playwright-cli" gives this CLI variant.
- * The binary is still called `playwright-cli` (see allowedTools).
- */
-export const playwrightCliSkill: BuiltinSkill = {
-  name: "playwright",
-  description: "MUST USE for any browser-related tasks. Browser automation via playwright-cli - verification, browsing, information gathering, web scraping, testing, screenshots, and all browser interactions.",
-  template: `# Browser Automation with playwright-cli
-
-## Quick start
-
-\`\`\`bash
-# open new browser
-playwright-cli open
-# navigate to a page
-playwright-cli goto https://playwright.dev
-# interact with the page using refs from the snapshot
-playwright-cli click e15
-playwright-cli type "page.click"
-playwright-cli press Enter
-# take a screenshot
-playwright-cli screenshot
-# close the browser
-playwright-cli close
-\`\`\`
-
-## Commands
-
-### Core
-
-\`\`\`bash
-playwright-cli open
-# open and navigate right away
-playwright-cli open https://example.com/
-playwright-cli goto https://playwright.dev
-playwright-cli type "search query"
-playwright-cli click e3
-playwright-cli dblclick e7
-playwright-cli fill e5 "user@example.com"
-playwright-cli drag e2 e8
-playwright-cli hover e4
-playwright-cli select e9 "option-value"
-playwright-cli upload ./document.pdf
-playwright-cli check e12
-playwright-cli uncheck e12
-playwright-cli snapshot
-playwright-cli snapshot --filename=after-click.yaml
-playwright-cli eval "document.title"
-playwright-cli eval "el => el.textContent" e5
-playwright-cli dialog-accept
-playwright-cli dialog-accept "confirmation text"
-playwright-cli dialog-dismiss
-playwright-cli resize 1920 1080
-playwright-cli close
-\`\`\`
-
-### Navigation
-
-\`\`\`bash
-playwright-cli go-back
-playwright-cli go-forward
-playwright-cli reload
-\`\`\`
-
-### Keyboard
-
-\`\`\`bash
-playwright-cli press Enter
-playwright-cli press ArrowDown
-playwright-cli keydown Shift
-playwright-cli keyup Shift
-\`\`\`
-
-### Mouse
-
-\`\`\`bash
-playwright-cli mousemove 150 300
-playwright-cli mousedown
-playwright-cli mousedown right
-playwright-cli mouseup
-playwright-cli mouseup right
-playwright-cli mousewheel 0 100
-\`\`\`
-
-### Save as
-
-\`\`\`bash
-playwright-cli screenshot
-playwright-cli screenshot e5
-playwright-cli screenshot --filename=page.png
-playwright-cli pdf --filename=page.pdf
-\`\`\`
-
-### Tabs
-
-\`\`\`bash
-playwright-cli tab-list
-playwright-cli tab-new
-playwright-cli tab-new https://example.com/page
-playwright-cli tab-close
-playwright-cli tab-close 2
-playwright-cli tab-select 0
-\`\`\`
-
-### Storage
-
-\`\`\`bash
-playwright-cli state-save
-playwright-cli state-save auth.json
-playwright-cli state-load auth.json
-
-# Cookies
-playwright-cli cookie-list
-playwright-cli cookie-list --domain=example.com
-playwright-cli cookie-get session_id
-playwright-cli cookie-set session_id abc123
-playwright-cli cookie-set session_id abc123 --domain=example.com --httpOnly --secure
-playwright-cli cookie-delete session_id
-playwright-cli cookie-clear
-
-# LocalStorage
-playwright-cli localstorage-list
-playwright-cli localstorage-get theme
-playwright-cli localstorage-set theme dark
-playwright-cli localstorage-delete theme
-playwright-cli localstorage-clear
-
-# SessionStorage
-playwright-cli sessionstorage-list
-playwright-cli sessionstorage-get step
-playwright-cli sessionstorage-set step 3
-playwright-cli sessionstorage-delete step
-playwright-cli sessionstorage-clear
-\`\`\`
-
-### Network
-
-\`\`\`bash
-playwright-cli route "**/*.jpg" --status=404
-playwright-cli route "https://api.example.com/**" --body='{"mock": true}'
-playwright-cli route-list
-playwright-cli unroute "**/*.jpg"
-playwright-cli unroute
-\`\`\`
-
-### DevTools
-
-\`\`\`bash
-playwright-cli console
-playwright-cli console warning
-playwright-cli network
-playwright-cli run-code "async page => await page.context().grantPermissions(['geolocation'])"
-playwright-cli tracing-start
-playwright-cli tracing-stop
-playwright-cli video-start
-playwright-cli video-stop video.webm
-\`\`\`
-
-### Install
-
-\`\`\`bash
-playwright-cli install --skills
-playwright-cli install-browser
-\`\`\`
-
-### Configuration
-\`\`\`bash
-# Use specific browser when creating session
-playwright-cli open --browser=chrome
-playwright-cli open --browser=firefox
-playwright-cli open --browser=webkit
-playwright-cli open --browser=msedge
-# Connect to browser via extension
-playwright-cli open --extension
-
-# Use persistent profile (by default profile is in-memory)
-playwright-cli open --persistent
-# Use persistent profile with custom directory
-playwright-cli open --profile=/path/to/profile
-
-# Start with config file
-playwright-cli open --config=my-config.json
-
-# Close the browser
-playwright-cli close
-# Delete user data for the default session
-playwright-cli delete-data
-\`\`\`
-
-### Browser Sessions
-
-\`\`\`bash
-# create new browser session named "mysession" with persistent profile
-playwright-cli -s=mysession open example.com --persistent
-# same with manually specified profile directory (use when requested explicitly)
-playwright-cli -s=mysession open example.com --profile=/path/to/profile
-playwright-cli -s=mysession click e6
-playwright-cli -s=mysession close  # stop a named browser
-playwright-cli -s=mysession delete-data  # delete user data for persistent session
-
-playwright-cli list
-# Close all browsers
-playwright-cli close-all
-# Forcefully kill all browser processes
-playwright-cli kill-all
-\`\`\`
-
-## Example: Form submission
-
-\`\`\`bash
-playwright-cli open https://example.com/form
-playwright-cli snapshot
-
-playwright-cli fill e1 "user@example.com"
-playwright-cli fill e2 "password123"
-playwright-cli click e3
-playwright-cli snapshot
-playwright-cli close
-\`\`\`
-
-## Example: Multi-tab workflow
-
-\`\`\`bash
-playwright-cli open https://example.com
-playwright-cli tab-new https://example.com/other
-playwright-cli tab-list
-playwright-cli tab-select 0
-playwright-cli snapshot
-playwright-cli close
-\`\`\`
-
-## Example: Debugging with DevTools
-
-\`\`\`bash
-playwright-cli open https://example.com
-playwright-cli click e4
-playwright-cli fill e7 "test"
-playwright-cli console
-playwright-cli network
-playwright-cli close
-\`\`\`
-
-\`\`\`bash
-playwright-cli open https://example.com
-playwright-cli tracing-start
-playwright-cli click e4
-playwright-cli fill e7 "test"
-playwright-cli tracing-stop
-playwright-cli close
-\`\`\`
-
-## Specific tasks
-
-* **Request mocking** [references/request-mocking.md](references/request-mocking.md)
-* **Running Playwright code** [references/running-code.md](references/running-code.md)
-* **Browser session management** [references/session-management.md](references/session-management.md)
-* **Storage state (cookies, localStorage)** [references/storage-state.md](references/storage-state.md)
-* **Test generation** [references/test-generation.md](references/test-generation.md)
-* **Tracing** [references/tracing.md](references/tracing.md)
-* **Video recording** [references/video-recording.md](references/video-recording.md)`,
-  allowedTools: ["Bash(playwright-cli:*)"],
-}

src/features/claude-code-mcp-loader/loader.test.ts

@@ -229,109 +229,5 @@ describe("getSystemMcpServerNames", () => {
       } finally {
         process.chdir(originalCwd)
       }
-     })
+    })
 })
-
-describe("loadMcpConfigs", () => {
-  beforeEach(() => {
-    mkdirSync(TEST_DIR, { recursive: true })
-    mkdirSync(TEST_HOME, { recursive: true })
-    mock.module("os", () => ({
-      homedir: () => TEST_HOME,
-      tmpdir,
-    }))
-    mock.module("../../shared", () => ({
-      getClaudeConfigDir: () => join(TEST_HOME, ".claude"),
-    }))
-    mock.module("../../shared/logger", () => ({
-      log: () => {},
-    }))
-  })
-
-  afterEach(() => {
-    mock.restore()
-    rmSync(TEST_DIR, { recursive: true, force: true })
-  })
-
-  it("should skip MCPs in disabledMcps list", async () => {
-    //#given
-    const mcpConfig = {
-      mcpServers: {
-        playwright: { command: "npx", args: ["@playwright/mcp@latest"] },
-        sqlite: { command: "uvx", args: ["mcp-server-sqlite"] },
-        active: { command: "npx", args: ["some-mcp"] },
-      },
-    }
-    writeFileSync(join(TEST_DIR, ".mcp.json"), JSON.stringify(mcpConfig))
-
-    const originalCwd = process.cwd()
-    process.chdir(TEST_DIR)
-
-    try {
-      //#when
-      const { loadMcpConfigs } = await import("./loader")
-      const result = await loadMcpConfigs(["playwright", "sqlite"])
-
-      //#then
-      expect(result.servers).not.toHaveProperty("playwright")
-      expect(result.servers).not.toHaveProperty("sqlite")
-      expect(result.servers).toHaveProperty("active")
-      expect(result.loadedServers.find((s) => s.name === "playwright")).toBeUndefined()
-      expect(result.loadedServers.find((s) => s.name === "sqlite")).toBeUndefined()
-      expect(result.loadedServers.find((s) => s.name === "active")).toBeDefined()
-    } finally {
-      process.chdir(originalCwd)
-    }
-  })
-
-  it("should load all MCPs when disabledMcps is empty", async () => {
-    //#given
-    const mcpConfig = {
-      mcpServers: {
-        playwright: { command: "npx", args: ["@playwright/mcp@latest"] },
-        active: { command: "npx", args: ["some-mcp"] },
-      },
-    }
-    writeFileSync(join(TEST_DIR, ".mcp.json"), JSON.stringify(mcpConfig))
-
-    const originalCwd = process.cwd()
-    process.chdir(TEST_DIR)
-
-    try {
-      //#when
-      const { loadMcpConfigs } = await import("./loader")
-      const result = await loadMcpConfigs([])
-
-      //#then
-      expect(result.servers).toHaveProperty("playwright")
-      expect(result.servers).toHaveProperty("active")
-    } finally {
-      process.chdir(originalCwd)
-    }
-  })
-
-  it("should load all MCPs when disabledMcps is not provided", async () => {
-    //#given
-    const mcpConfig = {
-      mcpServers: {
-        playwright: { command: "npx", args: ["@playwright/mcp@latest"] },
-      },
-    }
-    writeFileSync(join(TEST_DIR, ".mcp.json"), JSON.stringify(mcpConfig))
-
-    const originalCwd = process.cwd()
-    process.chdir(TEST_DIR)
-
-    try {
-      //#when
-      const { loadMcpConfigs } = await import("./loader")
-      const result = await loadMcpConfigs()
-
-      //#then
-      expect(result.servers).toHaveProperty("playwright")
-    } finally {
-      process.chdir(originalCwd)
-    }
-  })
-})
-

src/features/claude-code-mcp-loader/loader.ts

@@ -68,24 +68,16 @@ export function getSystemMcpServerNames(): Set<string> {
   return names
 }
 
-export async function loadMcpConfigs(
-  disabledMcps: string[] = []
-): Promise<McpLoadResult> {
+export async function loadMcpConfigs(): Promise<McpLoadResult> {
   const servers: McpLoadResult["servers"] = {}
   const loadedServers: LoadedMcpServer[] = []
   const paths = getMcpConfigPaths()
-  const disabledSet = new Set(disabledMcps)
 
   for (const { path, scope } of paths) {
     const config = await loadMcpConfigFile(path)
     if (!config?.mcpServers) continue
 
     for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
-      if (disabledSet.has(name)) {
-        log(`Skipping MCP "${name}" (in disabled_mcps)`, { path })
-        continue
-      }
-
       if (serverConfig.disabled) {
         log(`Disabling MCP server "${name}"`, { path })
         delete servers[name]

src/features/claude-tasks/AGENTS.md

@@ -2,7 +2,7 @@
 
 ## OVERVIEW
 
-Claude Code compatible task schema and storage. Core task management with file-based persistence, atomic writes, and OpenCode todo sync.
+Claude Code compatible task schema and storage. Core task management with file-based persistence and atomic writes.
 
 ## STRUCTURE
 ```
@@ -50,16 +50,39 @@ interface Task {
 
 ## TODO SYNC
 
-Automatic bidirectional sync between tasks and OpenCode's todo system.
+Automatic bidirectional synchronization between tasks and OpenCode's todo system.
+
+| Function | Purpose |
+|----------|---------|
+| `syncTaskToTodo(task)` | Convert Task to TodoInfo, returns `null` for deleted tasks |
+| `syncTaskTodoUpdate(ctx, task, sessionID, writer?)` | Fetch current todos, update specific task, write back |
+| `syncAllTasksToTodos(ctx, tasks, sessionID?)` | Bulk sync multiple tasks to todos |
+
+### Status Mapping
 
 | Task Status | Todo Status |
 |-------------|-------------|
 | `pending` | `pending` |
 | `in_progress` | `in_progress` |
 | `completed` | `completed` |
-| `deleted` | `null` (removed) |
+| `deleted` | `null` (removed from todos) |
 
-Sync triggers: `task_create`, `task_update`.
+### Field Mapping
+
+| Task Field | Todo Field |
+|------------|------------|
+| `task.id` | `todo.id` |
+| `task.subject` | `todo.content` |
+| `task.status` (mapped) | `todo.status` |
+| `task.metadata.priority` | `todo.priority` |
+
+Priority values: `"low"`, `"medium"`, `"high"`
+
+### Automatic Sync Triggers
+
+Sync occurs automatically on:
+- `task_create` — new task added to todos
+- `task_update` — task changes reflected in todos
 
 ## ANTI-PATTERNS
 

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

@@ -1 +1,6 @@
-export { OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE } from "../../shared"
+import { join } from "node:path"
+import { getOpenCodeStorageDir } from "../../shared/data-path"
+
+export const OPENCODE_STORAGE = getOpenCodeStorageDir()
+export const MESSAGE_STORAGE = join(OPENCODE_STORAGE, "message")
+export const PART_STORAGE = join(OPENCODE_STORAGE, "part")

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

@@ -1,11 +1,4 @@
-export {
-  injectHookMessage,
-  findNearestMessageWithFields,
-  findFirstMessageWithAgent,
-  findNearestMessageWithFieldsFromSDK,
-  findFirstMessageWithAgentFromSDK,
-  resolveMessageContext,
-} from "./injector"
+export { injectHookMessage, findNearestMessageWithFields, findFirstMessageWithAgent } from "./injector"
 export type { StoredMessage } from "./injector"
 export type { MessageMeta, OriginalMessageContext, TextPart, ToolPermission } from "./types"
 export { MESSAGE_STORAGE } from "./constants"

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

@@ -1,237 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "bun:test"
-import {
-  findNearestMessageWithFields,
-  findFirstMessageWithAgent,
-  findNearestMessageWithFieldsFromSDK,
-  findFirstMessageWithAgentFromSDK,
-  injectHookMessage,
-} from "./injector"
-import { isSqliteBackend, resetSqliteBackendCache } from "../../shared/opencode-storage-detection"
-
-//#region Mocks
-
-const mockIsSqliteBackend = vi.fn()
-
-vi.mock("../../shared/opencode-storage-detection", () => ({
-  isSqliteBackend: mockIsSqliteBackend,
-  resetSqliteBackendCache: () => {},
-}))
-
-//#endregion
-
-//#region Test Helpers
-
-function createMockClient(messages: Array<{
-  info?: {
-    agent?: string
-    model?: { providerID?: string; modelID?: string; variant?: string }
-    providerID?: string
-    modelID?: string
-    tools?: Record<string, boolean>
-  }
-}>): {
-  session: {
-    messages: (opts: { path: { id: string } }) => Promise<{ data: typeof messages }>
-  }
-} {
-  return {
-    session: {
-      messages: async () => ({ data: messages }),
-    },
-  }
-}
-
-//#endregion
-
-describe("findNearestMessageWithFieldsFromSDK", () => {
-  it("returns message with all fields when available", async () => {
-    const mockClient = createMockClient([
-      { info: { agent: "sisyphus", model: { providerID: "anthropic", modelID: "claude-opus-4" } } },
-    ])
-
-    const result = await findNearestMessageWithFieldsFromSDK(mockClient as any, "ses_123")
-
-    expect(result).toEqual({
-      agent: "sisyphus",
-      model: { providerID: "anthropic", modelID: "claude-opus-4" },
-      tools: undefined,
-    })
-  })
-
-  it("returns message with assistant shape (providerID/modelID directly on info)", async () => {
-    const mockClient = createMockClient([
-      { info: { agent: "sisyphus", providerID: "openai", modelID: "gpt-5" } },
-    ])
-
-    const result = await findNearestMessageWithFieldsFromSDK(mockClient as any, "ses_123")
-
-    expect(result).toEqual({
-      agent: "sisyphus",
-      model: { providerID: "openai", modelID: "gpt-5" },
-      tools: undefined,
-    })
-  })
-
-  it("returns nearest (most recent) message with all fields", async () => {
-    const mockClient = createMockClient([
-      { info: { agent: "old-agent", model: { providerID: "old", modelID: "model" } } },
-      { info: { agent: "new-agent", model: { providerID: "new", modelID: "model" } } },
-    ])
-
-    const result = await findNearestMessageWithFieldsFromSDK(mockClient as any, "ses_123")
-
-    expect(result?.agent).toBe("new-agent")
-  })
-
-  it("falls back to message with partial fields", async () => {
-    const mockClient = createMockClient([
-      { info: { agent: "partial-agent" } },
-    ])
-
-    const result = await findNearestMessageWithFieldsFromSDK(mockClient as any, "ses_123")
-
-    expect(result?.agent).toBe("partial-agent")
-  })
-
-  it("returns null when no messages have useful fields", async () => {
-    const mockClient = createMockClient([
-      { info: {} },
-      { info: {} },
-    ])
-
-    const result = await findNearestMessageWithFieldsFromSDK(mockClient as any, "ses_123")
-
-    expect(result).toBeNull()
-  })
-
-  it("returns null when messages array is empty", async () => {
-    const mockClient = createMockClient([])
-
-    const result = await findNearestMessageWithFieldsFromSDK(mockClient as any, "ses_123")
-
-    expect(result).toBeNull()
-  })
-
-  it("returns null on SDK error", async () => {
-    const mockClient = {
-      session: {
-        messages: async () => {
-          throw new Error("SDK error")
-        },
-      },
-    }
-
-    const result = await findNearestMessageWithFieldsFromSDK(mockClient as any, "ses_123")
-
-    expect(result).toBeNull()
-  })
-
-  it("includes tools when available", async () => {
-    const mockClient = createMockClient([
-      {
-        info: {
-          agent: "sisyphus",
-          model: { providerID: "anthropic", modelID: "claude-opus-4" },
-          tools: { edit: true, write: false },
-        },
-      },
-    ])
-
-    const result = await findNearestMessageWithFieldsFromSDK(mockClient as any, "ses_123")
-
-    expect(result?.tools).toEqual({ edit: true, write: false })
-  })
-})
-
-describe("findFirstMessageWithAgentFromSDK", () => {
-  it("returns agent from first message", async () => {
-    const mockClient = createMockClient([
-      { info: { agent: "first-agent" } },
-      { info: { agent: "second-agent" } },
-    ])
-
-    const result = await findFirstMessageWithAgentFromSDK(mockClient as any, "ses_123")
-
-    expect(result).toBe("first-agent")
-  })
-
-  it("skips messages without agent field", async () => {
-    const mockClient = createMockClient([
-      { info: {} },
-      { info: { agent: "first-real-agent" } },
-    ])
-
-    const result = await findFirstMessageWithAgentFromSDK(mockClient as any, "ses_123")
-
-    expect(result).toBe("first-real-agent")
-  })
-
-  it("returns null when no messages have agent", async () => {
-    const mockClient = createMockClient([
-      { info: {} },
-      { info: {} },
-    ])
-
-    const result = await findFirstMessageWithAgentFromSDK(mockClient as any, "ses_123")
-
-    expect(result).toBeNull()
-  })
-
-  it("returns null on SDK error", async () => {
-    const mockClient = {
-      session: {
-        messages: async () => {
-          throw new Error("SDK error")
-        },
-      },
-    }
-
-    const result = await findFirstMessageWithAgentFromSDK(mockClient as any, "ses_123")
-
-    expect(result).toBeNull()
-  })
-})
-
-describe("injectHookMessage", () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  afterEach(() => {
-    vi.clearAllMocks()
-  })
-
-  it("returns false and logs warning on beta/SQLite backend", () => {
-    mockIsSqliteBackend.mockReturnValue(true)
-
-    const result = injectHookMessage("ses_123", "test content", {
-      agent: "sisyphus",
-      model: { providerID: "anthropic", modelID: "claude-opus-4" },
-    })
-
-    expect(result).toBe(false)
-    expect(mockIsSqliteBackend).toHaveBeenCalled()
-  })
-
-  it("returns false for empty hook content", () => {
-    mockIsSqliteBackend.mockReturnValue(false)
-
-    const result = injectHookMessage("ses_123", "", {
-      agent: "sisyphus",
-      model: { providerID: "anthropic", modelID: "claude-opus-4" },
-    })
-
-    expect(result).toBe(false)
-  })
-
-  it("returns false for whitespace-only hook content", () => {
-    mockIsSqliteBackend.mockReturnValue(false)
-
-    const result = injectHookMessage("ses_123", "   \n\t  ", {
-      agent: "sisyphus",
-      model: { providerID: "anthropic", modelID: "claude-opus-4" },
-    })
-
-    expect(result).toBe(false)
-  })
-})

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

@@ -1,11 +1,8 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs"
 import { join } from "node:path"
-import type { PluginInput } from "@opencode-ai/plugin"
 import { MESSAGE_STORAGE, PART_STORAGE } from "./constants"
 import type { MessageMeta, OriginalMessageContext, TextPart, ToolPermission } from "./types"
 import { log } from "../../shared/logger"
-import { isSqliteBackend } from "../../shared/opencode-storage-detection"
-import { normalizeSDKResponse } from "../../shared"
 
 export interface StoredMessage {
   agent?: string
@@ -13,130 +10,14 @@ export interface StoredMessage {
   tools?: Record<string, ToolPermission>
 }
 
-type OpencodeClient = PluginInput["client"]
-
-interface SDKMessage {
-  info?: {
-    agent?: string
-    model?: {
-      providerID?: string
-      modelID?: string
-      variant?: string
-    }
-    providerID?: string
-    modelID?: string
-    tools?: Record<string, ToolPermission>
-  }
-}
-
-function convertSDKMessageToStoredMessage(msg: SDKMessage): StoredMessage | null {
-  const info = msg.info
-  if (!info) return null
-
-  const providerID = info.model?.providerID ?? info.providerID
-  const modelID = info.model?.modelID ?? info.modelID
-  const variant = info.model?.variant
-
-  if (!info.agent && !providerID && !modelID) {
-    return null
-  }
-
-  return {
-    agent: info.agent,
-    model: providerID && modelID
-      ? { providerID, modelID, ...(variant ? { variant } : {}) }
-      : undefined,
-    tools: info.tools,
-  }
-}
-
-// TODO: These SDK-based functions are exported for future use when hooks migrate to async.
-// Currently, callers still use the sync JSON-based functions which return null on beta.
-// Migration requires making callers async, which is a larger refactoring.
-// See: https://github.com/code-yeongyu/oh-my-opencode/pull/1837
-
-/**
- * Finds the nearest message with required fields using SDK (for beta/SQLite backend).
- * Uses client.session.messages() to fetch message data from SQLite.
- */
-export async function findNearestMessageWithFieldsFromSDK(
-  client: OpencodeClient,
-  sessionID: string
-): Promise<StoredMessage | null> {
-  try {
-    const response = await client.session.messages({ path: { id: sessionID } })
-    const messages = normalizeSDKResponse(response, [] as SDKMessage[], { preferResponseOnMissingData: true })
-
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const stored = convertSDKMessageToStoredMessage(messages[i])
-      if (stored?.agent && stored.model?.providerID && stored.model?.modelID) {
-        return stored
-      }
-    }
-
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const stored = convertSDKMessageToStoredMessage(messages[i])
-      if (stored?.agent || (stored?.model?.providerID && stored?.model?.modelID)) {
-        return stored
-      }
-    }
-  } catch (error) {
-    log("[hook-message-injector] SDK message fetch failed", {
-      sessionID,
-      error: String(error),
-    })
-  }
-  return null
-}
-
-/**
- * Finds the FIRST (oldest) message with agent field using SDK (for beta/SQLite backend).
- */
-export async function findFirstMessageWithAgentFromSDK(
-  client: OpencodeClient,
-  sessionID: string
-): Promise<string | null> {
-  try {
-    const response = await client.session.messages({ path: { id: sessionID } })
-    const messages = normalizeSDKResponse(response, [] as SDKMessage[], { preferResponseOnMissingData: true })
-
-    for (const msg of messages) {
-      const stored = convertSDKMessageToStoredMessage(msg)
-      if (stored?.agent) {
-        return stored.agent
-      }
-    }
-  } catch (error) {
-    log("[hook-message-injector] SDK agent fetch failed", {
-      sessionID,
-      error: String(error),
-    })
-  }
-  return null
-}
-
-/**
- * Finds the nearest message with required fields (agent, model.providerID, model.modelID).
- * Reads from JSON files - for stable (JSON) backend.
- *
- * **Version-gated behavior:**
- * - On beta (SQLite backend): Returns null immediately (no JSON storage)
- * - On stable (JSON backend): Reads from JSON files in messageDir
- *
- * @deprecated Use findNearestMessageWithFieldsFromSDK for beta/SQLite backend
- */
 export function findNearestMessageWithFields(messageDir: string): StoredMessage | null {
-  // On beta SQLite backend, skip JSON file reads entirely
-  if (isSqliteBackend()) {
-    return null
-  }
-
   try {
     const files = readdirSync(messageDir)
       .filter((f) => f.endsWith(".json"))
       .sort()
       .reverse()
 
+    // First pass: find message with ALL fields (ideal)
     for (const file of files) {
       try {
         const content = readFileSync(join(messageDir, file), "utf-8")
@@ -149,6 +30,8 @@ export function findNearestMessageWithFields(messageDir: string): StoredMessage
       }
     }
 
+    // Second pass: find message with ANY useful field (fallback)
+    // This ensures agent info isn't lost when model info is missing
     for (const file of files) {
       try {
         const content = readFileSync(join(messageDir, file), "utf-8")
@@ -168,24 +51,15 @@ export function findNearestMessageWithFields(messageDir: string): StoredMessage
 
 /**
  * Finds the FIRST (oldest) message in the session with agent field.
- * Reads from JSON files - for stable (JSON) backend.
- *
- * **Version-gated behavior:**
- * - On beta (SQLite backend): Returns null immediately (no JSON storage)
- * - On stable (JSON backend): Reads from JSON files in messageDir
- *
- * @deprecated Use findFirstMessageWithAgentFromSDK for beta/SQLite backend
+ * This is used to get the original agent that started the session,
+ * avoiding issues where newer messages may have a different agent
+ * due to OpenCode's internal agent switching.
  */
 export function findFirstMessageWithAgent(messageDir: string): string | null {
-  // On beta SQLite backend, skip JSON file reads entirely
-  if (isSqliteBackend()) {
-    return null
-  }
-
   try {
     const files = readdirSync(messageDir)
       .filter((f) => f.endsWith(".json"))
-      .sort()
+      .sort() // Oldest first (no reverse)
 
     for (const file of files) {
       try {
@@ -237,29 +111,12 @@ function getOrCreateMessageDir(sessionID: string): string {
   return directPath
 }
 
-/**
- * Injects a hook message into the session storage.
- *
- * **Version-gated behavior:**
- * - On beta (SQLite backend): Logs warning and skips injection (writes are invisible to SQLite)
- * - On stable (JSON backend): Writes message and part JSON files
- *
- * Features degraded on beta:
- * - Hook message injection (e.g., continuation prompts, context injection) won't persist
- * - Atlas hook's injected messages won't be visible in SQLite backend
- * - Todo continuation enforcer's injected prompts won't persist
- * - Ralph loop's continuation prompts won't persist
- *
- * @param sessionID - Target session ID
- * @param hookContent - Content to inject
- * @param originalMessage - Context from the original message
- * @returns true if injection succeeded, false otherwise
- */
 export function injectHookMessage(
   sessionID: string,
   hookContent: string,
   originalMessage: OriginalMessageContext
 ): boolean {
+  // Validate hook content to prevent empty message injection
   if (!hookContent || hookContent.trim().length === 0) {
     log("[hook-message-injector] Attempted to inject empty hook content, skipping injection", {
       sessionID,
@@ -269,16 +126,6 @@ export function injectHookMessage(
     return false
   }
 
-  if (isSqliteBackend()) {
-    log("[hook-message-injector] Skipping JSON message injection on SQLite backend. " +
-        "In-flight injection is handled via experimental.chat.messages.transform hook. " +
-        "JSON write path is not needed when SQLite is the storage backend.", {
-      sessionID,
-      agent: originalMessage.agent,
-    })
-    return false
-  }
-
   const messageDir = getOrCreateMessageDir(sessionID)
 
   const needsFallback =
@@ -355,21 +202,3 @@ export function injectHookMessage(
     return false
   }
 }
-
-export async function resolveMessageContext(
-  sessionID: string,
-  client: OpencodeClient,
-  messageDir: string | null
-): Promise<{ prevMessage: StoredMessage | null; firstMessageAgent: string | null }> {
-  const [prevMessage, firstMessageAgent] = isSqliteBackend()
-    ? await Promise.all([
-        findNearestMessageWithFieldsFromSDK(client, sessionID),
-        findFirstMessageWithAgentFromSDK(client, sessionID),
-      ])
-    : [
-        messageDir ? findNearestMessageWithFields(messageDir) : null,
-        messageDir ? findFirstMessageWithAgent(messageDir) : null,
-      ]
-
-  return { prevMessage, firstMessageAgent }
-}

src/features/opencode-skill-loader/agents-skills-global.test.ts

@@ -1,48 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, mock } from "bun:test"
-import { mkdirSync, writeFileSync, rmSync } from "fs"
-import { join } from "path"
-import { tmpdir } from "os"
-
-const TEST_DIR = join(tmpdir(), "agents-global-skills-test-" + Date.now())
-const TEMP_HOME = join(TEST_DIR, "home")
-
-describe("discoverGlobalAgentsSkills", () => {
-  beforeEach(() => {
-    mkdirSync(TEST_DIR, { recursive: true })
-    mkdirSync(TEMP_HOME, { recursive: true })
-  })
-
-  afterEach(() => {
-    mock.restore()
-    rmSync(TEST_DIR, { recursive: true, force: true })
-  })
-
-  it("#given a skill in ~/.agents/skills/ #when discoverGlobalAgentsSkills is called #then it discovers the skill", async () => {
-    //#given
-    const skillContent = `---
-name: agent-global-skill
-description: A skill from global .agents/skills directory
----
-Skill body.
-`
-    const agentsGlobalSkillsDir = join(TEMP_HOME, ".agents", "skills")
-    const skillDir = join(agentsGlobalSkillsDir, "agent-global-skill")
-    mkdirSync(skillDir, { recursive: true })
-    writeFileSync(join(skillDir, "SKILL.md"), skillContent)
-
-    mock.module("os", () => ({
-      homedir: () => TEMP_HOME,
-      tmpdir,
-    }))
-
-    //#when
-    const { discoverGlobalAgentsSkills } = await import("./loader")
-    const skills = await discoverGlobalAgentsSkills()
-    const skill = skills.find(s => s.name === "agent-global-skill")
-
-    //#then
-    expect(skill).toBeDefined()
-    expect(skill?.scope).toBe("user")
-    expect(skill?.definition.description).toContain("A skill from global .agents/skills directory")
-  })
-})

src/features/opencode-skill-loader/discover-worker.ts

@@ -18,6 +18,8 @@ interface WorkerOutputError {
   error: { message: string; stack?: string }
 }
 
+type WorkerOutput = WorkerOutputSuccess | WorkerOutputError
+
 const { signal } = workerData as { signal: Int32Array }
 
 if (!parentPort) {

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

@@ -552,7 +552,7 @@ Skill body.
         expect(names.length).toBe(uniqueNames.length)
       } finally {
         process.chdir(originalCwd)
-         if (originalOpenCodeConfigDir === undefined) {
+        if (originalOpenCodeConfigDir === undefined) {
           delete process.env.OPENCODE_CONFIG_DIR
         } else {
           process.env.OPENCODE_CONFIG_DIR = originalOpenCodeConfigDir
@@ -560,60 +560,4 @@ Skill body.
       }
     })
   })
-
-  describe("agents skills discovery (.agents/skills/)", () => {
-    it("#given a skill in .agents/skills/ #when discoverProjectAgentsSkills is called #then it discovers the skill", async () => {
-      //#given
-      const skillContent = `---
-name: agent-project-skill
-description: A skill from project .agents/skills directory
----
-Skill body.
-`
-      const agentsProjectSkillsDir = join(TEST_DIR, ".agents", "skills")
-      const skillDir = join(agentsProjectSkillsDir, "agent-project-skill")
-      mkdirSync(skillDir, { recursive: true })
-      writeFileSync(join(skillDir, "SKILL.md"), skillContent)
-
-      //#when
-      const { discoverProjectAgentsSkills } = await import("./loader")
-      const originalCwd = process.cwd()
-      process.chdir(TEST_DIR)
-
-      try {
-        const skills = await discoverProjectAgentsSkills()
-        const skill = skills.find(s => s.name === "agent-project-skill")
-
-        //#then
-        expect(skill).toBeDefined()
-        expect(skill?.scope).toBe("project")
-        expect(skill?.definition.description).toContain("A skill from project .agents/skills directory")
-      } finally {
-        process.chdir(originalCwd)
-      }
-    })
-
-    it("#given a skill in .agents/skills/ #when discoverProjectAgentsSkills is called with directory #then it discovers the skill", async () => {
-      //#given
-      const skillContent = `---
-name: agent-dir-skill
-description: A skill via explicit directory param
----
-Skill body.
-`
-      const agentsProjectSkillsDir = join(TEST_DIR, ".agents", "skills")
-      const skillDir = join(agentsProjectSkillsDir, "agent-dir-skill")
-      mkdirSync(skillDir, { recursive: true })
-      writeFileSync(join(skillDir, "SKILL.md"), skillContent)
-
-      //#when
-      const { discoverProjectAgentsSkills } = await import("./loader")
-      const skills = await discoverProjectAgentsSkills(TEST_DIR)
-      const skill = skills.find(s => s.name === "agent-dir-skill")
-
-      //#then
-      expect(skill).toBeDefined()
-      expect(skill?.scope).toBe("project")
-    })
-  })
 })

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

@@ -1,5 +1,4 @@
 import { join } from "path"
-import { homedir } from "os"
 import { getClaudeConfigDir } from "../../shared/claude-config-dir"
 import { getOpenCodeConfigDir } from "../../shared/opencode-config-dir"
 import type { CommandDefinition } from "../claude-code-command-loader/types"
@@ -39,25 +38,15 @@ export interface DiscoverSkillsOptions {
 }
 
 export async function discoverAllSkills(directory?: string): Promise<LoadedSkill[]> {
-  const [opencodeProjectSkills, opencodeGlobalSkills, projectSkills, userSkills, agentsProjectSkills, agentsGlobalSkills] =
-    await Promise.all([
-      discoverOpencodeProjectSkills(directory),
-      discoverOpencodeGlobalSkills(),
-      discoverProjectClaudeSkills(directory),
-      discoverUserClaudeSkills(),
-      discoverProjectAgentsSkills(directory),
-      discoverGlobalAgentsSkills(),
-    ])
-
-  // Priority: opencode-project > opencode > project (.claude + .agents) > user (.claude + .agents)
-  return deduplicateSkillsByName([
-    ...opencodeProjectSkills,
-    ...opencodeGlobalSkills,
-    ...projectSkills,
-    ...agentsProjectSkills,
-    ...userSkills,
-    ...agentsGlobalSkills,
+  const [opencodeProjectSkills, opencodeGlobalSkills, projectSkills, userSkills] = await Promise.all([
+    discoverOpencodeProjectSkills(directory),
+    discoverOpencodeGlobalSkills(),
+    discoverProjectClaudeSkills(directory),
+    discoverUserClaudeSkills(),
   ])
+
+  // Priority: opencode-project > opencode > project > user
+  return deduplicateSkillsByName([...opencodeProjectSkills, ...opencodeGlobalSkills, ...projectSkills, ...userSkills])
 }
 
 export async function discoverSkills(options: DiscoverSkillsOptions = {}): Promise<LoadedSkill[]> {
@@ -73,22 +62,13 @@ export async function discoverSkills(options: DiscoverSkillsOptions = {}): Promi
     return deduplicateSkillsByName([...opencodeProjectSkills, ...opencodeGlobalSkills])
   }
 
-  const [projectSkills, userSkills, agentsProjectSkills, agentsGlobalSkills] = await Promise.all([
+  const [projectSkills, userSkills] = await Promise.all([
     discoverProjectClaudeSkills(directory),
     discoverUserClaudeSkills(),
-    discoverProjectAgentsSkills(directory),
-    discoverGlobalAgentsSkills(),
   ])
 
-  // Priority: opencode-project > opencode > project (.claude + .agents) > user (.claude + .agents)
-  return deduplicateSkillsByName([
-    ...opencodeProjectSkills,
-    ...opencodeGlobalSkills,
-    ...projectSkills,
-    ...agentsProjectSkills,
-    ...userSkills,
-    ...agentsGlobalSkills,
-  ])
+  // Priority: opencode-project > opencode > project > user
+  return deduplicateSkillsByName([...opencodeProjectSkills, ...opencodeGlobalSkills, ...projectSkills, ...userSkills])
 }
 
 export async function getSkillByName(name: string, options: DiscoverSkillsOptions = {}): Promise<LoadedSkill | undefined> {
@@ -116,13 +96,3 @@ export async function discoverOpencodeProjectSkills(directory?: string): Promise
   const opencodeProjectDir = join(directory ?? process.cwd(), ".opencode", "skills")
   return loadSkillsFromDir({ skillsDir: opencodeProjectDir, scope: "opencode-project" })
 }
-
-export async function discoverProjectAgentsSkills(directory?: string): Promise<LoadedSkill[]> {
-  const agentsProjectDir = join(directory ?? process.cwd(), ".agents", "skills")
-  return loadSkillsFromDir({ skillsDir: agentsProjectDir, scope: "project" })
-}
-
-export async function discoverGlobalAgentsSkills(): Promise<LoadedSkill[]> {
-  const agentsGlobalDir = join(homedir(), ".agents", "skills")
-  return loadSkillsFromDir({ skillsDir: agentsGlobalDir, scope: "user" })
-}

src/features/tmux-subagent/action-executor-core.ts

@@ -1,82 +0,0 @@
-import type { TmuxConfig } from "../../config/schema"
-import type { applyLayout, closeTmuxPane, enforceMainPaneWidth, replaceTmuxPane, spawnTmuxPane } from "../../shared/tmux"
-import type { PaneAction, WindowState } from "./types"
-
-export interface ActionResult {
-	success: boolean
-	paneId?: string
-	error?: string
-}
-
-export interface ExecuteContext {
-	config: TmuxConfig
-	serverUrl: string
-	windowState: WindowState
-}
-
-export interface ActionExecutorDeps {
-	spawnTmuxPane: typeof spawnTmuxPane
-	closeTmuxPane: typeof closeTmuxPane
-	replaceTmuxPane: typeof replaceTmuxPane
-	applyLayout: typeof applyLayout
-	enforceMainPaneWidth: typeof enforceMainPaneWidth
-}
-
-async function enforceMainPane(
-	windowState: WindowState,
-	config: TmuxConfig,
-	deps: ActionExecutorDeps,
-): Promise<void> {
-	if (!windowState.mainPane) return
-	await deps.enforceMainPaneWidth(
-		windowState.mainPane.paneId,
-		windowState.windowWidth,
-		config.main_pane_size,
-	)
-}
-
-export async function executeActionWithDeps(
-	action: PaneAction,
-	ctx: ExecuteContext,
-	deps: ActionExecutorDeps,
-): Promise<ActionResult> {
-	if (action.type === "close") {
-		const success = await deps.closeTmuxPane(action.paneId)
-		if (success) {
-			await enforceMainPane(ctx.windowState, ctx.config, deps)
-		}
-		return { success }
-	}
-
-	if (action.type === "replace") {
-		const result = await deps.replaceTmuxPane(
-			action.paneId,
-			action.newSessionId,
-			action.description,
-			ctx.config,
-			ctx.serverUrl,
-		)
-		return {
-			success: result.success,
-			paneId: result.paneId,
-		}
-	}
-
-	const result = await deps.spawnTmuxPane(
-		action.sessionId,
-		action.description,
-		ctx.config,
-		ctx.serverUrl,
-		action.targetPaneId,
-		action.splitDirection,
-	)
-
-	if (result.success) {
-		await enforceMainPane(ctx.windowState, ctx.config, deps)
-	}
-
-	return {
-		success: result.success,
-		paneId: result.paneId,
-	}
-}

src/features/tmux-subagent/action-executor.test.ts

@@ -1,113 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test"
-import type { TmuxConfig } from "../../config/schema"
-import { executeActionWithDeps } from "./action-executor-core"
-import type { ActionExecutorDeps, ExecuteContext } from "./action-executor-core"
-import type { WindowState } from "./types"
-
-const mockSpawnTmuxPane = mock(async () => ({ success: true, paneId: "%7" }))
-const mockCloseTmuxPane = mock(async () => true)
-const mockEnforceMainPaneWidth = mock(async () => undefined)
-const mockReplaceTmuxPane = mock(async () => ({ success: true, paneId: "%7" }))
-const mockApplyLayout = mock(async () => undefined)
-
-const mockDeps: ActionExecutorDeps = {
-	spawnTmuxPane: mockSpawnTmuxPane,
-	closeTmuxPane: mockCloseTmuxPane,
-	enforceMainPaneWidth: mockEnforceMainPaneWidth,
-	replaceTmuxPane: mockReplaceTmuxPane,
-	applyLayout: mockApplyLayout,
-}
-
-function createConfig(overrides?: Partial<TmuxConfig>): TmuxConfig {
-	return {
-		enabled: true,
-		layout: "main-horizontal",
-		main_pane_size: 55,
-		main_pane_min_width: 120,
-		agent_pane_min_width: 40,
-		...overrides,
-	}
-}
-
-function createWindowState(overrides?: Partial<WindowState>): WindowState {
-	return {
-		windowWidth: 220,
-		windowHeight: 44,
-		mainPane: {
-			paneId: "%0",
-			width: 110,
-			height: 44,
-			left: 0,
-			top: 0,
-			title: "main",
-			isActive: true,
-		},
-		agentPanes: [],
-		...overrides,
-	}
-}
-
-function createContext(overrides?: Partial<ExecuteContext>): ExecuteContext {
-	return {
-		config: createConfig(),
-		serverUrl: "http://localhost:4096",
-		windowState: createWindowState(),
-		...overrides,
-	}
-}
-
-describe("executeAction", () => {
-	beforeEach(() => {
-		mockSpawnTmuxPane.mockClear()
-		mockCloseTmuxPane.mockClear()
-		mockEnforceMainPaneWidth.mockClear()
-		mockReplaceTmuxPane.mockClear()
-		mockApplyLayout.mockClear()
-		mockSpawnTmuxPane.mockImplementation(async () => ({ success: true, paneId: "%7" }))
-	})
-
-	test("enforces main pane width with configured percentage after successful spawn", async () => {
-		// given
-		// when
-		const result = await executeActionWithDeps(
-			{
-				type: "spawn",
-				sessionId: "ses_new",
-				description: "background task",
-				targetPaneId: "%0",
-				splitDirection: "-h",
-			},
-			createContext(),
-			mockDeps,
-		)
-
-		// then
-		expect(result).toEqual({ success: true, paneId: "%7" })
-		expect(mockApplyLayout).not.toHaveBeenCalled()
-		expect(mockEnforceMainPaneWidth).toHaveBeenCalledTimes(1)
-		expect(mockEnforceMainPaneWidth).toHaveBeenCalledWith("%0", 220, 55)
-	})
-
-	test("does not apply layout when spawn fails", async () => {
-		// given
-		mockSpawnTmuxPane.mockImplementationOnce(async () => ({ success: false }))
-
-		// when
-		const result = await executeActionWithDeps(
-			{
-				type: "spawn",
-				sessionId: "ses_new",
-				description: "background task",
-				targetPaneId: "%0",
-				splitDirection: "-h",
-			},
-			createContext(),
-			mockDeps,
-		)
-
-		// then
-		expect(result).toEqual({ success: false, paneId: undefined })
-		expect(mockApplyLayout).not.toHaveBeenCalled()
-		expect(mockEnforceMainPaneWidth).not.toHaveBeenCalled()
-	})
-})

src/features/tmux-subagent/action-executor.ts

@@ -1,14 +1,13 @@
-import type { PaneAction } from "./types"
-import { applyLayout, spawnTmuxPane, closeTmuxPane, enforceMainPaneWidth, replaceTmuxPane } from "../../shared/tmux"
+import type { TmuxConfig } from "../../config/schema"
+import type { PaneAction, WindowState } from "./types"
+import { spawnTmuxPane, closeTmuxPane, enforceMainPaneWidth, replaceTmuxPane } from "../../shared/tmux"
 import { log } from "../../shared"
-import type {
-  ActionExecutorDeps,
-  ActionResult,
-  ExecuteContext,
-} from "./action-executor-core"
-import { executeActionWithDeps } from "./action-executor-core"
 
-export type { ActionExecutorDeps, ActionResult, ExecuteContext } from "./action-executor-core"
+export interface ActionResult {
+  success: boolean
+  paneId?: string
+  error?: string
+}
 
 export interface ExecuteActionsResult {
   success: boolean
@@ -16,19 +15,60 @@ export interface ExecuteActionsResult {
   results: Array<{ action: PaneAction; result: ActionResult }>
 }
 
-const DEFAULT_DEPS: ActionExecutorDeps = {
-  spawnTmuxPane,
-  closeTmuxPane,
-  replaceTmuxPane,
-  applyLayout,
-  enforceMainPaneWidth,
+export interface ExecuteContext {
+  config: TmuxConfig
+  serverUrl: string
+  windowState: WindowState
+}
+
+async function enforceMainPane(windowState: WindowState): Promise<void> {
+  if (!windowState.mainPane) return
+  await enforceMainPaneWidth(windowState.mainPane.paneId, windowState.windowWidth)
 }
 
 export async function executeAction(
   action: PaneAction,
   ctx: ExecuteContext
 ): Promise<ActionResult> {
-  return executeActionWithDeps(action, ctx, DEFAULT_DEPS)
+  if (action.type === "close") {
+    const success = await closeTmuxPane(action.paneId)
+    if (success) {
+      await enforceMainPane(ctx.windowState)
+    }
+    return { success }
+  }
+
+  if (action.type === "replace") {
+    const result = await replaceTmuxPane(
+      action.paneId,
+      action.newSessionId,
+      action.description,
+      ctx.config,
+      ctx.serverUrl
+    )
+    return {
+      success: result.success,
+      paneId: result.paneId,
+    }
+  }
+
+  const result = await spawnTmuxPane(
+    action.sessionId,
+    action.description,
+    ctx.config,
+    ctx.serverUrl,
+    action.targetPaneId,
+    action.splitDirection
+  )
+
+  if (result.success) {
+    await enforceMainPane(ctx.windowState)
+  }
+
+  return {
+    success: result.success,
+    paneId: result.paneId,
+  }
 }
 
 export async function executeActions(