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>
 

.opencode/skills/github-issue-triage/SKILL.md

@@ -0,0 +1,489 @@
+---
+name: github-issue-triage
+description: "Triage GitHub issues with streaming analysis. CRITICAL: 1 issue = 1 background task. Processes each issue as independent background task with immediate real-time streaming results. Triggers: 'triage issues', 'analyze issues', 'issue report'."
+---
+
+# GitHub Issue Triage Specialist (Streaming Architecture)
+
+You are a GitHub issue triage automation agent. Your job is to:
+1. Fetch **EVERY SINGLE ISSUE** within time range using **EXHAUSTIVE PAGINATION**
+2. **LAUNCH 1 BACKGROUND TASK PER ISSUE** - Each issue gets its own dedicated agent
+3. **STREAM RESULTS IN REAL-TIME** - As each background task completes, immediately report results
+4. Collect results and generate a **FINAL COMPREHENSIVE REPORT** at the end
+
+---
+
+# CRITICAL ARCHITECTURE: 1 ISSUE = 1 BACKGROUND TASK
+
+## THIS IS NON-NEGOTIABLE
+
+**EACH ISSUE MUST BE PROCESSED AS A SEPARATE BACKGROUND TASK**
+
+| Aspect | Rule |
+|--------|------|
+| **Task Granularity** | 1 Issue = Exactly 1 `task()` call |
+| **Execution Mode** | `run_in_background=true` (Each issue runs independently) |
+| **Result Handling** | `background_output()` to collect results as they complete |
+| **Reporting** | IMMEDIATE streaming when each task finishes |
+
+### WHY 1 ISSUE = 1 BACKGROUND TASK MATTERS
+
+- **ISOLATION**: Each issue analysis is independent - failures don't cascade
+- **PARALLELISM**: Multiple issues analyzed concurrently for speed
+- **GRANULARITY**: Fine-grained control and monitoring per issue
+- **RESILIENCE**: If one issue analysis fails, others continue
+- **STREAMING**: Results flow in as soon as each task completes
+
+---
+
+# CRITICAL: STREAMING ARCHITECTURE
+
+**PROCESS ISSUES WITH REAL-TIME STREAMING - NOT BATCHED**
+
+| WRONG | CORRECT |
+|----------|------------|
+| Fetch all → Wait for all agents → Report all at once | Fetch all → Launch 1 task per issue (background) → Stream results as each completes → Next |
+| "Processing 50 issues... (wait 5 min) ...here are all results" | "Issue #123 analysis complete... [RESULT] Issue #124 analysis complete... [RESULT] ..." |
+| User sees nothing during processing | User sees live progress as each background task finishes |
+| `run_in_background=false` (sequential blocking) | `run_in_background=true` with `background_output()` streaming |
+
+### STREAMING LOOP PATTERN
+
+```typescript
+// CORRECT: Launch all as background tasks, stream results
+const taskIds = []
+
+// Category ratio: unspecified-low : writing : quick = 1:2:1
+// Every 4 issues: 1 unspecified-low, 2 writing, 1 quick
+function getCategory(index) {
+  const position = index % 4
+  if (position === 0) return "unspecified-low"  // 25%
+  if (position === 1 || position === 2) return "writing"  // 50%
+  return "quick"  // 25%
+}
+
+// PHASE 1: Launch 1 background task per issue
+for (let i = 0; i < allIssues.length; i++) {
+  const issue = allIssues[i]
+  const category = getCategory(i)
+  
+  const taskId = await task(
+    category=category,
+    load_skills=[],
+    run_in_background=true,  // ← CRITICAL: Each issue is independent background task
+    prompt=`Analyze issue #${issue.number}...`
+  )
+  taskIds.push({ issue: issue.number, taskId, category })
+  console.log(`🚀 Launched background task for Issue #${issue.number} (${category})`)
+}
+
+// PHASE 2: Stream results as they complete
+console.log(`\n📊 Streaming results for ${taskIds.length} issues...`)
+
+const completed = new Set()
+while (completed.size < taskIds.length) {
+  for (const { issue, taskId } of taskIds) {
+    if (completed.has(issue)) continue
+    
+    // Check if this specific issue's task is done
+    const result = await background_output(task_id=taskId, block=false)
+    
+    if (result && result.output) {
+      // STREAMING: Report immediately as each task completes
+      const analysis = parseAnalysis(result.output)
+      reportRealtime(analysis)
+      completed.add(issue)
+      
+      console.log(`\n✅ Issue #${issue} analysis complete (${completed.size}/${taskIds.length})`)
+    }
+  }
+  
+  // Small delay to prevent hammering
+  if (completed.size < taskIds.length) {
+    await new Promise(r => setTimeout(r, 1000))
+  }
+}
+```
+
+### WHY STREAMING MATTERS
+
+- **User sees progress immediately** - no 5-minute silence
+- **Critical issues flagged early** - maintainer can act on urgent bugs while others process
+- **Transparent** - user knows what's happening in real-time
+- **Fail-fast** - if something breaks, we already have partial results
+
+---
+
+# CRITICAL: INITIALIZATION - TODO REGISTRATION (MANDATORY FIRST STEP)
+
+**BEFORE DOING ANYTHING ELSE, CREATE TODOS.**
+
+```typescript
+// Create todos immediately
+todowrite([
+  { id: "1", content: "Fetch all issues with exhaustive pagination", status: "in_progress", priority: "high" },
+  { id: "2", content: "Fetch PRs for bug correlation", status: "pending", priority: "high" },
+  { id: "3", content: "Launch 1 background task per issue (1 issue = 1 task)", status: "pending", priority: "high" },
+  { id: "4", content: "Stream-process results as each task completes", status: "pending", priority: "high" },
+  { id: "5", content: "Generate final comprehensive report", status: "pending", priority: "high" }
+])
+```
+
+---
+
+# PHASE 1: Issue Collection (EXHAUSTIVE Pagination)
+
+### 1.1 Use Bundled Script (MANDATORY)
+
+```bash
+# Default: last 48 hours
+./scripts/gh_fetch.py issues --hours 48 --output json
+
+# Custom time range
+./scripts/gh_fetch.py issues --hours 72 --output json
+```
+
+### 1.2 Fallback: Manual Pagination
+
+```bash
+REPO=$(gh repo view --json nameWithOwner -q .nameWithOwner)
+TIME_RANGE=48
+CUTOFF_DATE=$(date -v-${TIME_RANGE}H +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -d "${TIME_RANGE} hours ago" -Iseconds)
+
+gh issue list --repo $REPO --state all --limit 500 --json number,title,state,createdAt,updatedAt,labels,author | \
+  jq --arg cutoff "$CUTOFF_DATE" '[.[] | select(.createdAt >= $cutoff or .updatedAt >= $cutoff)]'
+# Continue pagination if 500 returned...
+```
+
+**AFTER Phase 1:** Update todo status.
+
+---
+
+# PHASE 2: PR Collection (For Bug Correlation)
+
+```bash
+./scripts/gh_fetch.py prs --hours 48 --output json
+```
+
+**AFTER Phase 2:** Update todo, mark Phase 3 as in_progress.
+
+---
+
+# PHASE 3: LAUNCH 1 BACKGROUND TASK PER ISSUE
+
+## THE 1-ISSUE-1-TASK PATTERN (MANDATORY)
+
+**CRITICAL: DO NOT BATCH MULTIPLE ISSUES INTO ONE TASK**
+
+```typescript
+// Collection for tracking
+const taskMap = new Map()  // issueNumber -> taskId
+
+// Category ratio: unspecified-low : writing : quick = 1:2:1
+// Every 4 issues: 1 unspecified-low, 2 writing, 1 quick
+function getCategory(index, issue) {
+  const position = index % 4
+  if (position === 0) return "unspecified-low"  // 25%
+  if (position === 1 || position === 2) return "writing"  // 50%
+  return "quick"  // 25%
+}
+
+// Launch 1 background task per issue
+for (let i = 0; i < allIssues.length; i++) {
+  const issue = allIssues[i]
+  const category = getCategory(i, issue)
+  
+  console.log(`🚀 Launching background task for Issue #${issue.number} (${category})...`)
+  
+  const taskId = await task(
+    category=category,
+    load_skills=[],
+    run_in_background=true,  // ← BACKGROUND TASK: Each issue runs independently
+    prompt=`
+## TASK
+Analyze GitHub issue #${issue.number} for ${REPO}.
+
+## ISSUE DATA
+- Number: #${issue.number}
+- Title: ${issue.title}
+- State: ${issue.state}
+- Author: ${issue.author.login}
+- Created: ${issue.createdAt}
+- Updated: ${issue.updatedAt}
+- Labels: ${issue.labels.map(l => l.name).join(', ')}
+
+## ISSUE BODY
+${issue.body}
+
+## FETCH COMMENTS
+Use: gh issue view ${issue.number} --repo ${REPO} --json comments
+
+## PR CORRELATION (Check these for fixes)
+${PR_LIST.slice(0, 10).map(pr => `- PR #${pr.number}: ${pr.title}`).join('\n')}
+
+## ANALYSIS CHECKLIST
+1. **TYPE**: BUG | QUESTION | FEATURE | INVALID
+2. **PROJECT_VALID**: Is this relevant to OUR project? (YES/NO/UNCLEAR)
+3. **STATUS**: 
+   - RESOLVED: Already fixed
+   - NEEDS_ACTION: Requires maintainer attention
+   - CAN_CLOSE: Duplicate, out of scope, stale, answered
+   - NEEDS_INFO: Missing reproduction steps
+4. **COMMUNITY_RESPONSE**: NONE | HELPFUL | WAITING
+5. **LINKED_PR**: PR # that might fix this (or NONE)
+6. **CRITICAL**: Is this a blocking bug/security issue? (YES/NO)
+
+## RETURN FORMAT (STRICT)
+\`\`\`
+ISSUE: #${issue.number}
+TITLE: ${issue.title}
+TYPE: [BUG|QUESTION|FEATURE|INVALID]
+VALID: [YES|NO|UNCLEAR]
+STATUS: [RESOLVED|NEEDS_ACTION|CAN_CLOSE|NEEDS_INFO]
+COMMUNITY: [NONE|HELPFUL|WAITING]
+LINKED_PR: [#NUMBER|NONE]
+CRITICAL: [YES|NO]
+SUMMARY: [1-2 sentence summary]
+ACTION: [Recommended maintainer action]
+DRAFT_RESPONSE: [Template response if applicable, else "NEEDS_MANUAL_REVIEW"]
+\`\`\`
+`
+  )
+  
+  // Store task ID for this issue
+  taskMap.set(issue.number, taskId)
+}
+
+console.log(`\n✅ Launched ${taskMap.size} background tasks (1 per issue)`)
+```
+
+**AFTER Phase 3:** Update todo, mark Phase 4 as in_progress.
+
+---
+
+# PHASE 4: STREAM RESULTS AS EACH TASK COMPLETES
+
+## REAL-TIME STREAMING COLLECTION
+
+```typescript
+const results = []
+const critical = []
+const closeImmediately = []
+const autoRespond = []
+const needsInvestigation = []
+const featureBacklog = []
+const needsInfo = []
+
+const completedIssues = new Set()
+const totalIssues = taskMap.size
+
+console.log(`\n📊 Streaming results for ${totalIssues} issues...`)
+
+// Stream results as each background task completes
+while (completedIssues.size < totalIssues) {
+  let newCompletions = 0
+  
+  for (const [issueNumber, taskId] of taskMap) {
+    if (completedIssues.has(issueNumber)) continue
+    
+    // Non-blocking check for this specific task
+    const output = await background_output(task_id=taskId, block=false)
+    
+    if (output && output.length > 0) {
+      // Parse the completed analysis
+      const analysis = parseAnalysis(output)
+      results.push(analysis)
+      completedIssues.add(issueNumber)
+      newCompletions++
+      
+      // REAL-TIME STREAMING REPORT
+      console.log(`\n🔄 Issue #${issueNumber}: ${analysis.TITLE.substring(0, 60)}...`)
+      
+      // Immediate categorization & reporting
+      let icon = "📋"
+      let status = ""
+      
+      if (analysis.CRITICAL === 'YES') {
+        critical.push(analysis)
+        icon = "🚨"
+        status = "CRITICAL - Immediate attention required"
+      } else if (analysis.STATUS === 'CAN_CLOSE') {
+        closeImmediately.push(analysis)
+        icon = "⚠️"
+        status = "Can be closed"
+      } else if (analysis.STATUS === 'RESOLVED') {
+        closeImmediately.push(analysis)
+        icon = "✅"
+        status = "Resolved - can close"
+      } else if (analysis.DRAFT_RESPONSE !== 'NEEDS_MANUAL_REVIEW') {
+        autoRespond.push(analysis)
+        icon = "💬"
+        status = "Auto-response available"
+      } else if (analysis.TYPE === 'FEATURE') {
+        featureBacklog.push(analysis)
+        icon = "💡"
+        status = "Feature request"
+      } else if (analysis.STATUS === 'NEEDS_INFO') {
+        needsInfo.push(analysis)
+        icon = "❓"
+        status = "Needs more info"
+      } else if (analysis.TYPE === 'BUG') {
+        needsInvestigation.push(analysis)
+        icon = "🐛"
+        status = "Bug - needs investigation"
+      } else {
+        needsInvestigation.push(analysis)
+        icon = "👀"
+        status = "Needs investigation"
+      }
+      
+      console.log(`   ${icon} ${status}`)
+      console.log(`   📊 Action: ${analysis.ACTION}`)
+      
+      // Progress update every 5 completions
+      if (completedIssues.size % 5 === 0) {
+        console.log(`\n📈 PROGRESS: ${completedIssues.size}/${totalIssues} issues analyzed`)
+        console.log(`   Critical: ${critical.length} | Close: ${closeImmediately.length} | Auto-Reply: ${autoRespond.length} | Investigate: ${needsInvestigation.length} | Features: ${featureBacklog.length} | Needs Info: ${needsInfo.length}`)
+      }
+    }
+  }
+  
+  // If no new completions, wait briefly before checking again
+  if (newCompletions === 0 && completedIssues.size < totalIssues) {
+    await new Promise(r => setTimeout(r, 2000))
+  }
+}
+
+console.log(`\n✅ All ${totalIssues} issues analyzed`)
+```
+
+---
+
+# PHASE 5: FINAL COMPREHENSIVE REPORT
+
+**GENERATE THIS AT THE VERY END - AFTER ALL PROCESSING**
+
+```markdown
+# Issue Triage Report - ${REPO}
+
+**Time Range:** Last ${TIME_RANGE} hours
+**Generated:** ${new Date().toISOString()}
+**Total Issues Analyzed:** ${results.length}
+**Processing Mode:** STREAMING (1 issue = 1 background task, real-time analysis)
+
+---
+
+## 📊 Summary
+
+| Category | Count | Priority |
+|----------|-------|----------|
+| 🚨 CRITICAL | ${critical.length} | IMMEDIATE |
+| ⚠️ Close Immediately | ${closeImmediately.length} | Today |
+| 💬 Auto-Respond | ${autoRespond.length} | Today |
+| 🐛 Needs Investigation | ${needsInvestigation.length} | This Week |
+| 💡 Feature Backlog | ${featureBacklog.length} | Backlog |
+| ❓ Needs Info | ${needsInfo.length} | Awaiting User |
+
+---
+
+## 🚨 CRITICAL (Immediate Action Required)
+
+${critical.map(i => `| #${i.ISSUE} | ${i.TITLE.substring(0, 50)}... | ${i.TYPE} |`).join('\n')}
+
+**Action:** These require immediate maintainer attention.
+
+---
+
+## ⚠️ Close Immediately
+
+${closeImmediately.map(i => `| #${i.ISSUE} | ${i.TITLE.substring(0, 50)}... | ${i.STATUS} |`).join('\n')}
+
+---
+
+## 💬 Auto-Respond (Template Ready)
+
+${autoRespond.map(i => `| #${i.ISSUE} | ${i.TITLE.substring(0, 40)}... |`).join('\n')}
+
+**Draft Responses:**
+${autoRespond.map(i => `### #${i.ISSUE}\n${i.DRAFT_RESPONSE}\n`).join('\n---\n')}
+
+---
+
+## 🐛 Needs Investigation
+
+${needsInvestigation.map(i => `| #${i.ISSUE} | ${i.TITLE.substring(0, 50)}... | ${i.TYPE} |`).join('\n')}
+
+---
+
+## 💡 Feature Backlog
+
+${featureBacklog.map(i => `| #${i.ISSUE} | ${i.TITLE.substring(0, 50)}... |`).join('\n')}
+
+---
+
+## ❓ Needs More Info
+
+${needsInfo.map(i => `| #${i.ISSUE} | ${i.TITLE.substring(0, 50)}... |`).join('\n')}
+
+---
+
+## 🎯 Immediate Actions
+
+1. **CRITICAL:** ${critical.length} issues need immediate attention
+2. **CLOSE:** ${closeImmediately.length} issues can be closed now
+3. **REPLY:** ${autoRespond.length} issues have draft responses ready
+4. **INVESTIGATE:** ${needsInvestigation.length} bugs need debugging
+
+---
+
+## Processing Log
+
+${results.map((r, i) => `${i+1}. #${r.ISSUE}: ${r.TYPE} (${r.CRITICAL === 'YES' ? 'CRITICAL' : r.STATUS})`).join('\n')}
+```
+
+---
+
+## CRITICAL ANTI-PATTERNS (BLOCKING VIOLATIONS)
+
+| Violation | Why It's Wrong | Severity |
+|-----------|----------------|----------|
+| **Batch multiple issues in one task** | Violates 1 issue = 1 task rule | CRITICAL |
+| **Use `run_in_background=false`** | No parallelism, slower execution | CRITICAL |
+| **Collect all tasks, report at end** | Loses streaming benefit | CRITICAL |
+| **No `background_output()` polling** | Can't stream results | CRITICAL |
+| No progress updates | User doesn't know if stuck or working | HIGH |
+
+---
+
+## EXECUTION CHECKLIST
+
+- [ ] Created todos before starting
+- [ ] Fetched ALL issues with exhaustive pagination
+- [ ] Fetched PRs for correlation
+- [ ] **LAUNCHED**: 1 background task per issue (`run_in_background=true`)
+- [ ] **STREAMED**: Results via `background_output()` as each task completes
+- [ ] Showed live progress every 5 issues
+- [ ] Real-time categorization visible to user
+- [ ] Critical issues flagged immediately
+- [ ] **FINAL**: Comprehensive summary report at end
+- [ ] All todos marked complete
+
+---
+
+## Quick Start
+
+When invoked, immediately:
+
+1. **CREATE TODOS**
+2. `gh repo view --json nameWithOwner -q .nameWithOwner`
+3. Parse time range (default: 48 hours)
+4. Exhaustive pagination for issues
+5. Exhaustive pagination for PRs
+6. **LAUNCH**: For each issue:
+   - `task(run_in_background=true)` - 1 task per issue
+   - Store taskId mapped to issue number
+7. **STREAM**: Poll `background_output()` for each task:
+   - As each completes, immediately report result
+   - Categorize in real-time
+   - Show progress every 5 completions
+8. **GENERATE FINAL COMPREHENSIVE REPORT**

.opencode/skills/github-issue-triage/scripts/gh_fetch.py

@@ -69,9 +69,7 @@ async def run_gh_command(args: list[str]) -> tuple[str, str, int]:
 
 async def get_current_repo() -> str:
     """Get the current repository from gh CLI."""
-    stdout, stderr, code = await run_gh_command(
-        ["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"]
-    )
+    stdout, stderr, code = await run_gh_command(["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"])
     if code != 0:
         console.print(f"[red]Error getting current repo: {stderr}[/red]")
         raise typer.Exit(1)
@@ -125,6 +123,7 @@ async def fetch_all_items(
     all_items: list[dict] = []
     page = 1
 
+    # First fetch
     progress.update(task_id, description=f"[cyan]Fetching {item_type}s page {page}...")
     items = await fetch_items_page(repo, item_type, state, BATCH_SIZE)
     fetched_count = len(items)
@@ -132,25 +131,24 @@ async def fetch_all_items(
 
     console.print(f"[dim]Page {page}: fetched {fetched_count} {item_type}s[/dim]")
 
+    # Continue pagination if we got exactly BATCH_SIZE (more pages exist)
     while fetched_count == BATCH_SIZE:
         page += 1
-        progress.update(
-            task_id, description=f"[cyan]Fetching {item_type}s page {page}..."
-        )
+        progress.update(task_id, description=f"[cyan]Fetching {item_type}s page {page}...")
 
+        # Use created date of last item to paginate
         last_created = all_items[-1].get("createdAt", "")
         if not last_created:
             break
 
         search_filter = f"created:<{last_created}"
-        items = await fetch_items_page(
-            repo, item_type, state, BATCH_SIZE, search_filter
-        )
+        items = await fetch_items_page(repo, item_type, state, BATCH_SIZE, search_filter)
         fetched_count = len(items)
 
         if fetched_count == 0:
             break
 
+        # Deduplicate by number
         existing_numbers = {item["number"] for item in all_items}
         new_items = [item for item in items if item["number"] not in existing_numbers]
         all_items.extend(new_items)
@@ -159,10 +157,12 @@ async def fetch_all_items(
             f"[dim]Page {page}: fetched {fetched_count}, added {len(new_items)} new (total: {len(all_items)})[/dim]"
         )
 
+        # Safety limit
         if page > 20:
             console.print("[yellow]Safety limit reached (20 pages)[/yellow]")
             break
 
+    # Filter by time if specified
     if hours is not None:
         cutoff = datetime.now(UTC) - timedelta(hours=hours)
         cutoff_str = cutoff.isoformat()
@@ -171,14 +171,11 @@ async def fetch_all_items(
         all_items = [
             item
             for item in all_items
-            if item.get("createdAt", "") >= cutoff_str
-            or item.get("updatedAt", "") >= cutoff_str
+            if item.get("createdAt", "") >= cutoff_str or item.get("updatedAt", "") >= cutoff_str
         ]
         filtered_count = original_count - len(all_items)
         if filtered_count > 0:
-            console.print(
-                f"[dim]Filtered out {filtered_count} items older than {hours} hours[/dim]"
-            )
+            console.print(f"[dim]Filtered out {filtered_count} items older than {hours} hours[/dim]")
 
     return all_items
 
@@ -193,16 +190,14 @@ def display_table(items: list[dict], item_type: str) -> None:
     table.add_column("Labels", style="magenta", max_width=30)
     table.add_column("Updated", style="dim", width=12)
 
-    for item in items[:50]:
+    for item in items[:50]:  # Show first 50
         labels = ", ".join(label.get("name", "") for label in item.get("labels", []))
         updated = item.get("updatedAt", "")[:10]
         author = item.get("author", {}).get("login", "unknown")
 
         table.add_row(
             str(item.get("number", "")),
-            (item.get("title", "")[:47] + "...")
-            if len(item.get("title", "")) > 50
-            else item.get("title", ""),
+            (item.get("title", "")[:47] + "...") if len(item.get("title", "")) > 50 else item.get("title", ""),
             item.get("state", ""),
             author,
             (labels[:27] + "...") if len(labels) > 30 else labels,
@@ -216,21 +211,13 @@ def display_table(items: list[dict], item_type: str) -> None:
 
 @app.command()
 def issues(
-    repo: Annotated[
-        str | None, typer.Option("--repo", "-r", help="Repository (owner/repo)")
-    ] = None,
-    state: Annotated[
-        ItemState, typer.Option("--state", "-s", help="Issue state filter")
-    ] = ItemState.ALL,
+    repo: Annotated[str | None, typer.Option("--repo", "-r", help="Repository (owner/repo)")] = None,
+    state: Annotated[ItemState, typer.Option("--state", "-s", help="Issue state filter")] = ItemState.ALL,
     hours: Annotated[
         int | None,
-        typer.Option(
-            "--hours", "-h", help="Only issues from last N hours (created or updated)"
-        ),
+        typer.Option("--hours", "-h", help="Only issues from last N hours (created or updated)"),
     ] = None,
-    output: Annotated[
-        OutputFormat, typer.Option("--output", "-o", help="Output format")
-    ] = OutputFormat.TABLE,
+    output: Annotated[OutputFormat, typer.Option("--output", "-o", help="Output format")] = OutputFormat.TABLE,
 ) -> None:
     """Fetch all issues with exhaustive pagination."""
 
@@ -238,29 +225,33 @@ def issues(
         target_repo = repo or await get_current_repo()
 
         console.print(f"""
+[cyan]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/cyan]
 [cyan]Repository:[/cyan] {target_repo}
 [cyan]State:[/cyan] {state.value}
 [cyan]Time filter:[/cyan] {f"Last {hours} hours" if hours else "All time"}
+[cyan]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/cyan]
 """)
 
         with Progress(console=console) as progress:
             task: TaskID = progress.add_task("[cyan]Fetching issues...", total=None)
-            items = await fetch_all_items(
-                target_repo, "issue", state.value, hours, progress, task
-            )
-            progress.update(
-                task, description="[green]Complete!", completed=100, total=100
-            )
+
+            items = await fetch_all_items(target_repo, "issue", state.value, hours, progress, task)
+
+            progress.update(task, description="[green]Complete!", completed=100, total=100)
 
         console.print(
-            Panel(f"[green]Found {len(items)} issues[/green]", border_style="green")
+            Panel(
+                f"[green]✓ Found {len(items)} issues[/green]",
+                title="[green]Pagination Complete[/green]",
+                border_style="green",
+            )
         )
 
         if output == OutputFormat.JSON:
             console.print(json.dumps(items, indent=2, ensure_ascii=False))
         elif output == OutputFormat.TABLE:
             display_table(items, "issue")
-        else:
+        else:  # COUNT
             console.print(f"Total issues: {len(items)}")
 
     asyncio.run(async_main())
@@ -268,21 +259,13 @@ def issues(
 
 @app.command()
 def prs(
-    repo: Annotated[
-        str | None, typer.Option("--repo", "-r", help="Repository (owner/repo)")
-    ] = None,
-    state: Annotated[
-        ItemState, typer.Option("--state", "-s", help="PR state filter")
-    ] = ItemState.OPEN,
+    repo: Annotated[str | None, typer.Option("--repo", "-r", help="Repository (owner/repo)")] = None,
+    state: Annotated[ItemState, typer.Option("--state", "-s", help="PR state filter")] = ItemState.OPEN,
     hours: Annotated[
         int | None,
-        typer.Option(
-            "--hours", "-h", help="Only PRs from last N hours (created or updated)"
-        ),
+        typer.Option("--hours", "-h", help="Only PRs from last N hours (created or updated)"),
     ] = None,
-    output: Annotated[
-        OutputFormat, typer.Option("--output", "-o", help="Output format")
-    ] = OutputFormat.TABLE,
+    output: Annotated[OutputFormat, typer.Option("--output", "-o", help="Output format")] = OutputFormat.TABLE,
 ) -> None:
     """Fetch all PRs with exhaustive pagination."""
 
@@ -290,29 +273,33 @@ def prs(
         target_repo = repo or await get_current_repo()
 
         console.print(f"""
+[cyan]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/cyan]
 [cyan]Repository:[/cyan] {target_repo}
 [cyan]State:[/cyan] {state.value}
 [cyan]Time filter:[/cyan] {f"Last {hours} hours" if hours else "All time"}
+[cyan]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/cyan]
 """)
 
         with Progress(console=console) as progress:
             task: TaskID = progress.add_task("[cyan]Fetching PRs...", total=None)
-            items = await fetch_all_items(
-                target_repo, "pr", state.value, hours, progress, task
-            )
-            progress.update(
-                task, description="[green]Complete!", completed=100, total=100
-            )
+
+            items = await fetch_all_items(target_repo, "pr", state.value, hours, progress, task)
+
+            progress.update(task, description="[green]Complete!", completed=100, total=100)
 
         console.print(
-            Panel(f"[green]Found {len(items)} PRs[/green]", border_style="green")
+            Panel(
+                f"[green]✓ Found {len(items)} PRs[/green]",
+                title="[green]Pagination Complete[/green]",
+                border_style="green",
+            )
         )
 
         if output == OutputFormat.JSON:
             console.print(json.dumps(items, indent=2, ensure_ascii=False))
         elif output == OutputFormat.TABLE:
             display_table(items, "pr")
-        else:
+        else:  # COUNT
             console.print(f"Total PRs: {len(items)}")
 
     asyncio.run(async_main())
@@ -320,21 +307,13 @@ def prs(
 
 @app.command(name="all")
 def fetch_all(
-    repo: Annotated[
-        str | None, typer.Option("--repo", "-r", help="Repository (owner/repo)")
-    ] = None,
-    state: Annotated[
-        ItemState, typer.Option("--state", "-s", help="State filter")
-    ] = ItemState.ALL,
+    repo: Annotated[str | None, typer.Option("--repo", "-r", help="Repository (owner/repo)")] = None,
+    state: Annotated[ItemState, typer.Option("--state", "-s", help="State filter")] = ItemState.ALL,
     hours: Annotated[
         int | None,
-        typer.Option(
-            "--hours", "-h", help="Only items from last N hours (created or updated)"
-        ),
+        typer.Option("--hours", "-h", help="Only items from last N hours (created or updated)"),
     ] = None,
-    output: Annotated[
-        OutputFormat, typer.Option("--output", "-o", help="Output format")
-    ] = OutputFormat.TABLE,
+    output: Annotated[OutputFormat, typer.Option("--output", "-o", help="Output format")] = OutputFormat.TABLE,
 ) -> None:
     """Fetch all issues AND PRs with exhaustive pagination."""
 
@@ -342,25 +321,22 @@ def fetch_all(
         target_repo = repo or await get_current_repo()
 
         console.print(f"""
+[cyan]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/cyan]
 [cyan]Repository:[/cyan] {target_repo}
 [cyan]State:[/cyan] {state.value}
 [cyan]Time filter:[/cyan] {f"Last {hours} hours" if hours else "All time"}
 [cyan]Fetching:[/cyan] Issues AND PRs
+[cyan]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/cyan]
 """)
 
         with Progress(console=console) as progress:
-            issues_task: TaskID = progress.add_task(
-                "[cyan]Fetching issues...", total=None
-            )
+            issues_task: TaskID = progress.add_task("[cyan]Fetching issues...", total=None)
             prs_task: TaskID = progress.add_task("[cyan]Fetching PRs...", total=None)
 
+            # Fetch in parallel
             issues_items, prs_items = await asyncio.gather(
-                fetch_all_items(
-                    target_repo, "issue", state.value, hours, progress, issues_task
-                ),
-                fetch_all_items(
-                    target_repo, "pr", state.value, hours, progress, prs_task
-                ),
+                fetch_all_items(target_repo, "issue", state.value, hours, progress, issues_task),
+                fetch_all_items(target_repo, "pr", state.value, hours, progress, prs_task),
             )
 
             progress.update(
@@ -369,13 +345,12 @@ def fetch_all(
                 completed=100,
                 total=100,
             )
-            progress.update(
-                prs_task, description="[green]PRs complete!", completed=100, total=100
-            )
+            progress.update(prs_task, description="[green]PRs complete!", completed=100, total=100)
 
         console.print(
             Panel(
-                f"[green]Found {len(issues_items)} issues and {len(prs_items)} PRs[/green]",
+                f"[green]✓ Found {len(issues_items)} issues and {len(prs_items)} PRs[/green]",
+                title="[green]Pagination Complete[/green]",
                 border_style="green",
             )
         )
@@ -387,7 +362,7 @@ def fetch_all(
             display_table(issues_items, "issue")
             console.print("")
             display_table(prs_items, "pr")
-        else:
+        else:  # COUNT
             console.print(f"Total issues: {len(issues_items)}")
             console.print(f"Total PRs: {len(prs_items)}")
 

.opencode/skills/github-pr-triage/SKILL.md

@@ -0,0 +1,484 @@
+---
+name: github-pr-triage
+description: "Triage GitHub Pull Requests with streaming analysis. CRITICAL: 1 PR = 1 background task. Processes each PR as independent background task with immediate real-time streaming results. Conservative auto-close. Triggers: 'triage PRs', 'analyze PRs', 'PR cleanup'."
+---
+
+# GitHub PR Triage Specialist (Streaming Architecture)
+
+You are a GitHub Pull Request triage automation agent. Your job is to:
+1. Fetch **EVERY SINGLE OPEN PR** using **EXHAUSTIVE PAGINATION**
+2. **LAUNCH 1 BACKGROUND TASK PER PR** - Each PR gets its own dedicated agent
+3. **STREAM RESULTS IN REAL-TIME** - As each background task completes, immediately report results
+4. **CONSERVATIVELY** auto-close PRs that are clearly closeable
+5. Generate a **FINAL COMPREHENSIVE REPORT** at the end
+
+---
+
+# CRITICAL ARCHITECTURE: 1 PR = 1 BACKGROUND TASK
+
+## THIS IS NON-NEGOTIABLE
+
+**EACH PR MUST BE PROCESSED AS A SEPARATE BACKGROUND TASK**
+
+| Aspect | Rule |
+|--------|------|
+| **Task Granularity** | 1 PR = Exactly 1 `task()` call |
+| **Execution Mode** | `run_in_background=true` (Each PR runs independently) |
+| **Result Handling** | `background_output()` to collect results as they complete |
+| **Reporting** | IMMEDIATE streaming when each task finishes |
+
+### WHY 1 PR = 1 BACKGROUND TASK MATTERS
+
+- **ISOLATION**: Each PR analysis is independent - failures don't cascade
+- **PARALLELISM**: Multiple PRs analyzed concurrently for speed
+- **GRANULARITY**: Fine-grained control and monitoring per PR
+- **RESILIENCE**: If one PR analysis fails, others continue
+- **STREAMING**: Results flow in as soon as each task completes
+
+---
+
+# CRITICAL: STREAMING ARCHITECTURE
+
+**PROCESS PRs WITH REAL-TIME STREAMING - NOT BATCHED**
+
+| WRONG | CORRECT |
+|----------|------------|
+| Fetch all → Wait for all agents → Report all at once | Fetch all → Launch 1 task per PR (background) → Stream results as each completes → Next |
+| "Processing 50 PRs... (wait 5 min) ...here are all results" | "PR #123 analysis complete... [RESULT] PR #124 analysis complete... [RESULT] ..." |
+| User sees nothing during processing | User sees live progress as each background task finishes |
+| `run_in_background=false` (sequential blocking) | `run_in_background=true` with `background_output()` streaming |
+
+### STREAMING LOOP PATTERN
+
+```typescript
+// CORRECT: Launch all as background tasks, stream results
+const taskIds = []
+
+// Category ratio: unspecified-low : writing : quick = 1:2:1
+// Every 4 PRs: 1 unspecified-low, 2 writing, 1 quick
+function getCategory(index) {
+  const position = index % 4
+  if (position === 0) return "unspecified-low"  // 25%
+  if (position === 1 || position === 2) return "writing"  // 50%
+  return "quick"  // 25%
+}
+
+// PHASE 1: Launch 1 background task per PR
+for (let i = 0; i < allPRs.length; i++) {
+  const pr = allPRs[i]
+  const category = getCategory(i)
+  
+  const taskId = await task(
+    category=category,
+    load_skills=[],
+    run_in_background=true,  // ← CRITICAL: Each PR is independent background task
+    prompt=`Analyze PR #${pr.number}...`
+  )
+  taskIds.push({ pr: pr.number, taskId, category })
+  console.log(`🚀 Launched background task for PR #${pr.number} (${category})`)
+}
+
+// PHASE 2: Stream results as they complete
+console.log(`\n📊 Streaming results for ${taskIds.length} PRs...`)
+
+const completed = new Set()
+while (completed.size < taskIds.length) {
+  for (const { pr, taskId } of taskIds) {
+    if (completed.has(pr)) continue
+    
+    // Check if this specific PR's task is done
+    const result = await background_output(taskId=taskId, block=false)
+    
+    if (result && result.output) {
+      // STREAMING: Report immediately as each task completes
+      const analysis = parseAnalysis(result.output)
+      reportRealtime(analysis)
+      completed.add(pr)
+      
+      console.log(`\n✅ PR #${pr} analysis complete (${completed.size}/${taskIds.length})`)
+    }
+  }
+  
+  // Small delay to prevent hammering
+  if (completed.size < taskIds.length) {
+    await new Promise(r => setTimeout(r, 1000))
+  }
+}
+```
+
+### WHY STREAMING MATTERS
+
+- **User sees progress immediately** - no 5-minute silence
+- **Early decisions visible** - maintainer can act on urgent PRs while others process
+- **Transparent** - user knows what's happening in real-time
+- **Fail-fast** - if something breaks, we already have partial results
+
+---
+
+# CRITICAL: INITIALIZATION - TODO REGISTRATION (MANDATORY FIRST STEP)
+
+**BEFORE DOING ANYTHING ELSE, CREATE TODOS.**
+
+```typescript
+// Create todos immediately
+todowrite([
+  { id: "1", content: "Fetch all open PRs with exhaustive pagination", status: "in_progress", priority: "high" },
+  { id: "2", content: "Launch 1 background task per PR (1 PR = 1 task)", status: "pending", priority: "high" },
+  { id: "3", content: "Stream-process results as each task completes", status: "pending", priority: "high" },
+  { id: "4", content: "Execute conservative auto-close for eligible PRs", status: "pending", priority: "high" },
+  { id: "5", content: "Generate final comprehensive report", status: "pending", priority: "high" }
+])
+```
+
+---
+
+# PHASE 1: PR Collection (EXHAUSTIVE Pagination)
+
+### 1.1 Use Bundled Script (MANDATORY)
+
+```bash
+./scripts/gh_fetch.py prs --output json
+```
+
+### 1.2 Fallback: Manual Pagination
+
+```bash
+REPO=$(gh repo view --json nameWithOwner -q .nameWithOwner)
+gh pr list --repo $REPO --state open --limit 500 --json number,title,state,createdAt,updatedAt,labels,author,headRefName,baseRefName,isDraft,mergeable,body
+# Continue pagination if 500 returned...
+```
+
+**AFTER Phase 1:** Update todo status to completed, mark Phase 2 as in_progress.
+
+---
+
+# PHASE 2: LAUNCH 1 BACKGROUND TASK PER PR
+
+## THE 1-PR-1-TASK PATTERN (MANDATORY)
+
+**CRITICAL: DO NOT BATCH MULTIPLE PRs INTO ONE TASK**
+
+```typescript
+// Collection for tracking
+const taskMap = new Map()  // prNumber -> taskId
+
+// Category ratio: unspecified-low : writing : quick = 1:2:1
+// Every 4 PRs: 1 unspecified-low, 2 writing, 1 quick
+function getCategory(index) {
+  const position = index % 4
+  if (position === 0) return "unspecified-low"  // 25%
+  if (position === 1 || position === 2) return "writing"  // 50%
+  return "quick"  // 25%
+}
+
+// Launch 1 background task per PR
+for (let i = 0; i < allPRs.length; i++) {
+  const pr = allPRs[i]
+  const category = getCategory(i)
+  
+  console.log(`🚀 Launching background task for PR #${pr.number} (${category})...`)
+  
+  const taskId = await task(
+    category=category,
+    load_skills=[],
+    run_in_background=true,  // ← BACKGROUND TASK: Each PR runs independently
+    prompt=`
+## TASK
+Analyze GitHub PR #${pr.number} for ${REPO}.
+
+## PR DATA
+- Number: #${pr.number}
+- Title: ${pr.title}
+- State: ${pr.state}
+- Author: ${pr.author.login}
+- Created: ${pr.createdAt}
+- Updated: ${pr.updatedAt}
+- Labels: ${pr.labels.map(l => l.name).join(', ')}
+- Head Branch: ${pr.headRefName}
+- Base Branch: ${pr.baseRefName}
+- Is Draft: ${pr.isDraft}
+- Mergeable: ${pr.mergeable}
+
+## PR BODY
+${pr.body}
+
+## FETCH ADDITIONAL CONTEXT
+1. Fetch PR comments: gh pr view ${pr.number} --repo ${REPO} --json comments
+2. Fetch PR reviews: gh pr view ${pr.number} --repo ${REPO} --json reviews
+3. Fetch PR files changed: gh pr view ${pr.number} --repo ${REPO} --json files
+4. Check if branch exists: git ls-remote --heads origin ${pr.headRefName}
+5. Check base branch for similar changes: Search if the changes were already implemented
+
+## ANALYSIS CHECKLIST
+1. **MERGE_READY**: Can this PR be merged? (approvals, CI passed, no conflicts, not draft)
+2. **PROJECT_ALIGNED**: Does this PR align with current project direction?
+3. **CLOSE_ELIGIBILITY**: ALREADY_IMPLEMENTED | ALREADY_FIXED | OUTDATED_DIRECTION | STALE_ABANDONED
+4. **STALENESS**: ACTIVE (<30d) | STALE (30-180d) | ABANDONED (180d+)
+
+## CONSERVATIVE CLOSE CRITERIA
+MAY CLOSE ONLY IF:
+- Exact same change already exists in main
+- A merged PR already solved this differently
+- Project explicitly deprecated the feature
+- Author unresponsive for 6+ months despite requests
+
+## RETURN FORMAT (STRICT)
+\`\`\`
+PR: #${pr.number}
+TITLE: ${pr.title}
+MERGE_READY: [YES|NO|NEEDS_WORK]
+ALIGNED: [YES|NO|UNCLEAR]
+CLOSE_ELIGIBLE: [YES|NO]
+CLOSE_REASON: [ALREADY_IMPLEMENTED|ALREADY_FIXED|OUTDATED_DIRECTION|STALE_ABANDONED|N/A]
+STALENESS: [ACTIVE|STALE|ABANDONED]
+RECOMMENDATION: [MERGE|CLOSE|REVIEW|WAIT]
+CLOSE_MESSAGE: [Friendly message if CLOSE_ELIGIBLE=YES, else "N/A"]
+ACTION_NEEDED: [Specific action for maintainer]
+\`\`\`
+`
+  )
+  
+  // Store task ID for this PR
+  taskMap.set(pr.number, taskId)
+}
+
+console.log(`\n✅ Launched ${taskMap.size} background tasks (1 per PR)`)
+```
+
+**AFTER Phase 2:** Update todo, mark Phase 3 as in_progress.
+
+---
+
+# PHASE 3: STREAM RESULTS AS EACH TASK COMPLETES
+
+## REAL-TIME STREAMING COLLECTION
+
+```typescript
+const results = []
+const autoCloseable = []
+const readyToMerge = []
+const needsReview = []
+const needsWork = []
+const stale = []
+const drafts = []
+
+const completedPRs = new Set()
+const totalPRs = taskMap.size
+
+console.log(`\n📊 Streaming results for ${totalPRs} PRs...`)
+
+// Stream results as each background task completes
+while (completedPRs.size < totalPRs) {
+  let newCompletions = 0
+  
+  for (const [prNumber, taskId] of taskMap) {
+    if (completedPRs.has(prNumber)) continue
+    
+    // Non-blocking check for this specific task
+    const output = await background_output(task_id=taskId, block=false)
+    
+    if (output && output.length > 0) {
+      // Parse the completed analysis
+      const analysis = parseAnalysis(output)
+      results.push(analysis)
+      completedPRs.add(prNumber)
+      newCompletions++
+      
+      // REAL-TIME STREAMING REPORT
+      console.log(`\n🔄 PR #${prNumber}: ${analysis.TITLE.substring(0, 60)}...`)
+      
+      // Immediate categorization & reporting
+      if (analysis.CLOSE_ELIGIBLE === 'YES') {
+        autoCloseable.push(analysis)
+        console.log(`   ⚠️  AUTO-CLOSE CANDIDATE: ${analysis.CLOSE_REASON}`)
+      } else if (analysis.MERGE_READY === 'YES') {
+        readyToMerge.push(analysis)
+        console.log(`   ✅ READY TO MERGE`)
+      } else if (analysis.RECOMMENDATION === 'REVIEW') {
+        needsReview.push(analysis)
+        console.log(`   👀 NEEDS REVIEW`)
+      } else if (analysis.RECOMMENDATION === 'WAIT') {
+        needsWork.push(analysis)
+        console.log(`   ⏳ WAITING FOR AUTHOR`)
+      } else if (analysis.STALENESS === 'STALE' || analysis.STALENESS === 'ABANDONED') {
+        stale.push(analysis)
+        console.log(`   💤 ${analysis.STALENESS}`)
+      } else {
+        drafts.push(analysis)
+        console.log(`   📝 DRAFT`)
+      }
+      
+      console.log(`   📊 Action: ${analysis.ACTION_NEEDED}`)
+      
+      // Progress update every 5 completions
+      if (completedPRs.size % 5 === 0) {
+        console.log(`\n📈 PROGRESS: ${completedPRs.size}/${totalPRs} PRs analyzed`)
+        console.log(`   Ready: ${readyToMerge.length} | Review: ${needsReview.length} | Wait: ${needsWork.length} | Stale: ${stale.length} | Draft: ${drafts.length} | Close-Candidate: ${autoCloseable.length}`)
+      }
+    }
+  }
+  
+  // If no new completions, wait briefly before checking again
+  if (newCompletions === 0 && completedPRs.size < totalPRs) {
+    await new Promise(r => setTimeout(r, 2000))
+  }
+}
+
+console.log(`\n✅ All ${totalPRs} PRs analyzed`)
+```
+
+---
+
+# PHASE 4: Auto-Close Execution (CONSERVATIVE)
+
+### 4.1 Confirm and Close
+
+**Ask for confirmation before closing (unless user explicitly said auto-close is OK)**
+
+```typescript
+if (autoCloseable.length > 0) {
+  console.log(`\n🚨 FOUND ${autoCloseable.length} PR(s) ELIGIBLE FOR AUTO-CLOSE:`)
+  
+  for (const pr of autoCloseable) {
+    console.log(`   #${pr.PR}: ${pr.TITLE} (${pr.CLOSE_REASON})`)
+  }
+  
+  // Close them one by one with progress
+  for (const pr of autoCloseable) {
+    console.log(`\n   Closing #${pr.PR}...`)
+    
+    await bash({
+      command: `gh pr close ${pr.PR} --repo ${REPO} --comment "${pr.CLOSE_MESSAGE}"`,
+      description: `Close PR #${pr.PR} with friendly message`
+    })
+    
+    console.log(`   ✅ Closed #${pr.PR}`)
+  }
+}
+```
+
+---
+
+# PHASE 5: FINAL COMPREHENSIVE REPORT
+
+**GENERATE THIS AT THE VERY END - AFTER ALL PROCESSING**
+
+```markdown
+# PR Triage Report - ${REPO}
+
+**Generated:** ${new Date().toISOString()}
+**Total PRs Analyzed:** ${results.length}
+**Processing Mode:** STREAMING (1 PR = 1 background task, real-time results)
+
+---
+
+## 📊 Summary
+
+| Category | Count | Status |
+|----------|-------|--------|
+| ✅ Ready to Merge | ${readyToMerge.length} | Action: Merge immediately |
+| ⚠️ Auto-Closed | ${autoCloseable.length} | Already processed |
+| 👀 Needs Review | ${needsReview.length} | Action: Assign reviewers |
+| ⏳ Needs Work | ${needsWork.length} | Action: Comment guidance |
+| 💤 Stale | ${stale.length} | Action: Follow up |
+| 📝 Draft | ${drafts.length} | No action needed |
+
+---
+
+## ✅ Ready to Merge
+
+${readyToMerge.map(pr => `| #${pr.PR} | ${pr.TITLE.substring(0, 50)}... |`).join('\n')}
+
+**Action:** These PRs can be merged immediately.
+
+---
+
+## ⚠️ Auto-Closed (During This Triage)
+
+${autoCloseable.map(pr => `| #${pr.PR} | ${pr.TITLE.substring(0, 40)}... | ${pr.CLOSE_REASON} |`).join('\n')}
+
+---
+
+## 👀 Needs Review
+
+${needsReview.map(pr => `| #${pr.PR} | ${pr.TITLE.substring(0, 50)}... |`).join('\n')}
+
+**Action:** Assign maintainers for review.
+
+---
+
+## ⏳ Needs Work
+
+${needsWork.map(pr => `| #${pr.PR} | ${pr.TITLE.substring(0, 50)}... | ${pr.ACTION_NEEDED} |`).join('\n')}
+
+---
+
+## 💤 Stale PRs
+
+${stale.map(pr => `| #${pr.PR} | ${pr.TITLE.substring(0, 40)}... | ${pr.STALENESS} |`).join('\n')}
+
+---
+
+## 📝 Draft PRs
+
+${drafts.map(pr => `| #${pr.PR} | ${pr.TITLE.substring(0, 50)}... |`).join('\n')}
+
+---
+
+## 🎯 Immediate Actions
+
+1. **Merge:** ${readyToMerge.length} PRs ready for immediate merge
+2. **Review:** ${needsReview.length} PRs awaiting maintainer attention
+3. **Follow Up:** ${stale.length} stale PRs need author ping
+
+---
+
+## Processing Log
+
+${results.map((r, i) => `${i+1}. #${r.PR}: ${r.RECOMMENDATION} (${r.MERGE_READY === 'YES' ? 'ready' : r.CLOSE_ELIGIBLE === 'YES' ? 'close' : 'needs attention'})`).join('\n')}
+```
+
+---
+
+## CRITICAL ANTI-PATTERNS (BLOCKING VIOLATIONS)
+
+| Violation | Why It's Wrong | Severity |
+|-----------|----------------|----------|
+| **Batch multiple PRs in one task** | Violates 1 PR = 1 task rule | CRITICAL |
+| **Use `run_in_background=false`** | No parallelism, slower execution | CRITICAL |
+| **Collect all tasks, report at end** | Loses streaming benefit | CRITICAL |
+| **No `background_output()` polling** | Can't stream results | CRITICAL |
+| No progress updates | User doesn't know if stuck or working | HIGH |
+
+---
+
+## EXECUTION CHECKLIST
+
+- [ ] Created todos before starting
+- [ ] Fetched ALL PRs with exhaustive pagination
+- [ ] **LAUNCHED**: 1 background task per PR (`run_in_background=true`)
+- [ ] **STREAMED**: Results via `background_output()` as each task completes
+- [ ] Showed live progress every 5 PRs
+- [ ] Real-time categorization visible to user
+- [ ] Conservative auto-close with confirmation
+- [ ] **FINAL**: Comprehensive summary report at end
+- [ ] All todos marked complete
+
+---
+
+## Quick Start
+
+When invoked, immediately:
+
+1. **CREATE TODOS**
+2. `gh repo view --json nameWithOwner -q .nameWithOwner`
+3. Exhaustive pagination for ALL open PRs
+4. **LAUNCH**: For each PR:
+   - `task(run_in_background=true)` - 1 task per PR
+   - Store taskId mapped to PR number
+5. **STREAM**: Poll `background_output()` for each task:
+   - As each completes, immediately report result
+   - Categorize in real-time
+   - Show progress every 5 completions
+6. Auto-close eligible PRs
+7. **GENERATE FINAL COMPREHENSIVE REPORT**

.opencode/skills/github-pr-triage/scripts/gh_fetch.py

@@ -0,0 +1,373 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "typer>=0.12.0",
+#     "rich>=13.0.0",
+# ]
+# ///
+"""
+GitHub Issues/PRs Fetcher with Exhaustive Pagination.
+
+Fetches ALL issues and/or PRs from a GitHub repository using gh CLI.
+Implements proper pagination to ensure no items are missed.
+
+Usage:
+    ./gh_fetch.py issues                    # Fetch all issues
+    ./gh_fetch.py prs                       # Fetch all PRs
+    ./gh_fetch.py all                       # Fetch both issues and PRs
+    ./gh_fetch.py issues --hours 48         # Issues from last 48 hours
+    ./gh_fetch.py prs --state open          # Only open PRs
+    ./gh_fetch.py all --repo owner/repo     # Specify repository
+"""
+
+import asyncio
+import json
+from datetime import UTC, datetime, timedelta
+from enum import Enum
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, TaskID
+from rich.table import Table
+
+app = typer.Typer(
+    name="gh_fetch",
+    help="Fetch GitHub issues/PRs with exhaustive pagination.",
+    no_args_is_help=True,
+)
+console = Console()
+
+BATCH_SIZE = 500  # Maximum allowed by GitHub API
+
+
+class ItemState(str, Enum):
+    ALL = "all"
+    OPEN = "open"
+    CLOSED = "closed"
+
+
+class OutputFormat(str, Enum):
+    JSON = "json"
+    TABLE = "table"
+    COUNT = "count"
+
+
+async def run_gh_command(args: list[str]) -> tuple[str, str, int]:
+    """Run gh CLI command asynchronously."""
+    proc = await asyncio.create_subprocess_exec(
+        "gh",
+        *args,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, stderr = await proc.communicate()
+    return stdout.decode(), stderr.decode(), proc.returncode or 0
+
+
+async def get_current_repo() -> str:
+    """Get the current repository from gh CLI."""
+    stdout, stderr, code = await run_gh_command(["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"])
+    if code != 0:
+        console.print(f"[red]Error getting current repo: {stderr}[/red]")
+        raise typer.Exit(1)
+    return stdout.strip()
+
+
+async def fetch_items_page(
+    repo: str,
+    item_type: str,  # "issue" or "pr"
+    state: str,
+    limit: int,
+    search_filter: str = "",
+) -> list[dict]:
+    """Fetch a single page of issues or PRs."""
+    cmd = [
+        item_type,
+        "list",
+        "--repo",
+        repo,
+        "--state",
+        state,
+        "--limit",
+        str(limit),
+        "--json",
+        "number,title,state,createdAt,updatedAt,labels,author,body",
+    ]
+    if search_filter:
+        cmd.extend(["--search", search_filter])
+
+    stdout, stderr, code = await run_gh_command(cmd)
+    if code != 0:
+        console.print(f"[red]Error fetching {item_type}s: {stderr}[/red]")
+        return []
+
+    try:
+        return json.loads(stdout) if stdout.strip() else []
+    except json.JSONDecodeError:
+        console.print(f"[red]Error parsing {item_type} response[/red]")
+        return []
+
+
+async def fetch_all_items(
+    repo: str,
+    item_type: str,
+    state: str,
+    hours: int | None,
+    progress: Progress,
+    task_id: TaskID,
+) -> list[dict]:
+    """Fetch ALL items with exhaustive pagination."""
+    all_items: list[dict] = []
+    page = 1
+
+    # First fetch
+    progress.update(task_id, description=f"[cyan]Fetching {item_type}s page {page}...")
+    items = await fetch_items_page(repo, item_type, state, BATCH_SIZE)
+    fetched_count = len(items)
+    all_items.extend(items)
+
+    console.print(f"[dim]Page {page}: fetched {fetched_count} {item_type}s[/dim]")
+
+    # Continue pagination if we got exactly BATCH_SIZE (more pages exist)
+    while fetched_count == BATCH_SIZE:
+        page += 1
+        progress.update(task_id, description=f"[cyan]Fetching {item_type}s page {page}...")
+
+        # Use created date of last item to paginate
+        last_created = all_items[-1].get("createdAt", "")
+        if not last_created:
+            break
+
+        search_filter = f"created:<{last_created}"
+        items = await fetch_items_page(repo, item_type, state, BATCH_SIZE, search_filter)
+        fetched_count = len(items)
+
+        if fetched_count == 0:
+            break
+
+        # Deduplicate by number
+        existing_numbers = {item["number"] for item in all_items}
+        new_items = [item for item in items if item["number"] not in existing_numbers]
+        all_items.extend(new_items)
+
+        console.print(
+            f"[dim]Page {page}: fetched {fetched_count}, added {len(new_items)} new (total: {len(all_items)})[/dim]"
+        )
+
+        # Safety limit
+        if page > 20:
+            console.print("[yellow]Safety limit reached (20 pages)[/yellow]")
+            break
+
+    # Filter by time if specified
+    if hours is not None:
+        cutoff = datetime.now(UTC) - timedelta(hours=hours)
+        cutoff_str = cutoff.isoformat()
+
+        original_count = len(all_items)
+        all_items = [
+            item
+            for item in all_items
+            if item.get("createdAt", "") >= cutoff_str or item.get("updatedAt", "") >= cutoff_str
+        ]
+        filtered_count = original_count - len(all_items)
+        if filtered_count > 0:
+            console.print(f"[dim]Filtered out {filtered_count} items older than {hours} hours[/dim]")
+
+    return all_items
+
+
+def display_table(items: list[dict], item_type: str) -> None:
+    """Display items in a Rich table."""
+    table = Table(title=f"{item_type.upper()}s ({len(items)} total)")
+    table.add_column("#", style="cyan", width=6)
+    table.add_column("Title", style="white", max_width=50)
+    table.add_column("State", style="green", width=8)
+    table.add_column("Author", style="yellow", width=15)
+    table.add_column("Labels", style="magenta", max_width=30)
+    table.add_column("Updated", style="dim", width=12)
+
+    for item in items[:50]:  # Show first 50
+        labels = ", ".join(label.get("name", "") for label in item.get("labels", []))
+        updated = item.get("updatedAt", "")[:10]
+        author = item.get("author", {}).get("login", "unknown")
+
+        table.add_row(
+            str(item.get("number", "")),
+            (item.get("title", "")[:47] + "...") if len(item.get("title", "")) > 50 else item.get("title", ""),
+            item.get("state", ""),
+            author,
+            (labels[:27] + "...") if len(labels) > 30 else labels,
+            updated,
+        )
+
+    console.print(table)
+    if len(items) > 50:
+        console.print(f"[dim]... and {len(items) - 50} more items[/dim]")
+
+
+@app.command()
+def issues(
+    repo: Annotated[str | None, typer.Option("--repo", "-r", help="Repository (owner/repo)")] = None,
+    state: Annotated[ItemState, typer.Option("--state", "-s", help="Issue state filter")] = ItemState.ALL,
+    hours: Annotated[
+        int | None,
+        typer.Option("--hours", "-h", help="Only issues from last N hours (created or updated)"),
+    ] = None,
+    output: Annotated[OutputFormat, typer.Option("--output", "-o", help="Output format")] = OutputFormat.TABLE,
+) -> None:
+    """Fetch all issues with exhaustive pagination."""
+
+    async def async_main() -> None:
+        target_repo = repo or await get_current_repo()
+
+        console.print(f"""
+[cyan]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/cyan]
+[cyan]Repository:[/cyan] {target_repo}
+[cyan]State:[/cyan] {state.value}
+[cyan]Time filter:[/cyan] {f"Last {hours} hours" if hours else "All time"}
+[cyan]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/cyan]
+""")
+
+        with Progress(console=console) as progress:
+            task: TaskID = progress.add_task("[cyan]Fetching issues...", total=None)
+
+            items = await fetch_all_items(target_repo, "issue", state.value, hours, progress, task)
+
+            progress.update(task, description="[green]Complete!", completed=100, total=100)
+
+        console.print(
+            Panel(
+                f"[green]✓ Found {len(items)} issues[/green]",
+                title="[green]Pagination Complete[/green]",
+                border_style="green",
+            )
+        )
+
+        if output == OutputFormat.JSON:
+            console.print(json.dumps(items, indent=2, ensure_ascii=False))
+        elif output == OutputFormat.TABLE:
+            display_table(items, "issue")
+        else:  # COUNT
+            console.print(f"Total issues: {len(items)}")
+
+    asyncio.run(async_main())
+
+
+@app.command()
+def prs(
+    repo: Annotated[str | None, typer.Option("--repo", "-r", help="Repository (owner/repo)")] = None,
+    state: Annotated[ItemState, typer.Option("--state", "-s", help="PR state filter")] = ItemState.OPEN,
+    hours: Annotated[
+        int | None,
+        typer.Option("--hours", "-h", help="Only PRs from last N hours (created or updated)"),
+    ] = None,
+    output: Annotated[OutputFormat, typer.Option("--output", "-o", help="Output format")] = OutputFormat.TABLE,
+) -> None:
+    """Fetch all PRs with exhaustive pagination."""
+
+    async def async_main() -> None:
+        target_repo = repo or await get_current_repo()
+
+        console.print(f"""
+[cyan]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/cyan]
+[cyan]Repository:[/cyan] {target_repo}
+[cyan]State:[/cyan] {state.value}
+[cyan]Time filter:[/cyan] {f"Last {hours} hours" if hours else "All time"}
+[cyan]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/cyan]
+""")
+
+        with Progress(console=console) as progress:
+            task: TaskID = progress.add_task("[cyan]Fetching PRs...", total=None)
+
+            items = await fetch_all_items(target_repo, "pr", state.value, hours, progress, task)
+
+            progress.update(task, description="[green]Complete!", completed=100, total=100)
+
+        console.print(
+            Panel(
+                f"[green]✓ Found {len(items)} PRs[/green]",
+                title="[green]Pagination Complete[/green]",
+                border_style="green",
+            )
+        )
+
+        if output == OutputFormat.JSON:
+            console.print(json.dumps(items, indent=2, ensure_ascii=False))
+        elif output == OutputFormat.TABLE:
+            display_table(items, "pr")
+        else:  # COUNT
+            console.print(f"Total PRs: {len(items)}")
+
+    asyncio.run(async_main())
+
+
+@app.command(name="all")
+def fetch_all(
+    repo: Annotated[str | None, typer.Option("--repo", "-r", help="Repository (owner/repo)")] = None,
+    state: Annotated[ItemState, typer.Option("--state", "-s", help="State filter")] = ItemState.ALL,
+    hours: Annotated[
+        int | None,
+        typer.Option("--hours", "-h", help="Only items from last N hours (created or updated)"),
+    ] = None,
+    output: Annotated[OutputFormat, typer.Option("--output", "-o", help="Output format")] = OutputFormat.TABLE,
+) -> None:
+    """Fetch all issues AND PRs with exhaustive pagination."""
+
+    async def async_main() -> None:
+        target_repo = repo or await get_current_repo()
+
+        console.print(f"""
+[cyan]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/cyan]
+[cyan]Repository:[/cyan] {target_repo}
+[cyan]State:[/cyan] {state.value}
+[cyan]Time filter:[/cyan] {f"Last {hours} hours" if hours else "All time"}
+[cyan]Fetching:[/cyan] Issues AND PRs
+[cyan]━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━[/cyan]
+""")
+
+        with Progress(console=console) as progress:
+            issues_task: TaskID = progress.add_task("[cyan]Fetching issues...", total=None)
+            prs_task: TaskID = progress.add_task("[cyan]Fetching PRs...", total=None)
+
+            # Fetch in parallel
+            issues_items, prs_items = await asyncio.gather(
+                fetch_all_items(target_repo, "issue", state.value, hours, progress, issues_task),
+                fetch_all_items(target_repo, "pr", state.value, hours, progress, prs_task),
+            )
+
+            progress.update(
+                issues_task,
+                description="[green]Issues complete!",
+                completed=100,
+                total=100,
+            )
+            progress.update(prs_task, description="[green]PRs complete!", completed=100, total=100)
+
+        console.print(
+            Panel(
+                f"[green]✓ Found {len(issues_items)} issues and {len(prs_items)} PRs[/green]",
+                title="[green]Pagination Complete[/green]",
+                border_style="green",
+            )
+        )
+
+        if output == OutputFormat.JSON:
+            result = {"issues": issues_items, "prs": prs_items}
+            console.print(json.dumps(result, indent=2, ensure_ascii=False))
+        elif output == OutputFormat.TABLE:
+            display_table(issues_items, "issue")
+            console.print("")
+            display_table(prs_items, "pr")
+        else:  # COUNT
+            console.print(f"Total issues: {len(issues_items)}")
+            console.print(f"Total PRs: {len(prs_items)}")
+
+    asyncio.run(async_main())
+
+
+if __name__ == "__main__":
+    app()

.opencode/skills/github-triage/SKILL.md

@@ -1,482 +0,0 @@
----
-name: github-triage
-description: "Unified GitHub triage for issues AND PRs. 1 item = 1 background task (category: free). Issues: answer questions from codebase, analyze bugs. PRs: review bugfixes, merge safe ones. All parallel, all background. Triggers: 'triage', 'triage issues', 'triage PRs', 'github triage'."
----
-
-# GitHub Triage — Unified Issue & PR Processor
-
-<role>
-You are a GitHub triage orchestrator. You fetch all open issues and PRs, classify each one, then spawn exactly 1 background subagent per item using `category="free"`. Each subagent analyzes its item, takes action (comment/close/merge/report), and records results via TaskCreate.
-</role>
-
----
-
-## ARCHITECTURE
-
-```
-1 issue or PR = 1 TaskCreate = 1 task(category="free", run_in_background=true)
-```
-
-| Rule | Value |
-|------|-------|
-| Category for ALL subagents | `free` |
-| Execution mode | `run_in_background=true` |
-| Parallelism | ALL items launched simultaneously |
-| Result tracking | Each subagent calls `TaskCreate` with its findings |
-| Result collection | `background_output()` polling loop |
-
----
-
-## PHASE 1: FETCH ALL OPEN ITEMS
-
-<fetch>
-Run these commands to collect data. Use the bundled script if available, otherwise fall back to gh CLI.
-
-```bash
-REPO=$(gh repo view --json nameWithOwner -q .nameWithOwner)
-
-# Issues: all open
-gh issue list --repo $REPO --state open --limit 500 \
-  --json number,title,state,createdAt,updatedAt,labels,author,body,comments
-
-# PRs: all open
-gh pr list --repo $REPO --state open --limit 500 \
-  --json number,title,state,createdAt,updatedAt,labels,author,body,headRefName,baseRefName,isDraft,mergeable,reviewDecision,statusCheckRollup
-```
-
-If either returns exactly 500 results, paginate using `--search "created:<LAST_CREATED_AT"` until exhausted.
-</fetch>
-
----
-
-## PHASE 2: CLASSIFY EACH ITEM
-
-For each item, determine its type based on title, labels, and body content:
-
-<classification>
-
-### Issues
-
-| Type | Detection | Action Path |
-|------|-----------|-------------|
-| `ISSUE_QUESTION` | Title contains `[Question]`, `[Discussion]`, `?`, or body is asking "how to" / "why does" / "is it possible" | SUBAGENT_ISSUE_QUESTION |
-| `ISSUE_BUG` | Title contains `[Bug]`, `Bug:`, body describes unexpected behavior, error messages, stack traces | SUBAGENT_ISSUE_BUG |
-| `ISSUE_FEATURE` | Title contains `[Feature]`, `[RFE]`, `[Enhancement]`, `Feature Request`, `Proposal` | SUBAGENT_ISSUE_FEATURE |
-| `ISSUE_OTHER` | Anything else | SUBAGENT_ISSUE_OTHER |
-
-### PRs
-
-| Type | Detection | Action Path |
-|------|-----------|-------------|
-| `PR_BUGFIX` | Title starts with `fix`, `fix:`, `fix(`, branch contains `fix/`, `bugfix/`, or labels include `bug` | SUBAGENT_PR_BUGFIX |
-| `PR_OTHER` | Everything else (feat, refactor, docs, chore, etc.) | SUBAGENT_PR_OTHER |
-
-</classification>
-
----
-
-## PHASE 3: SPAWN 1 BACKGROUND TASK PER ITEM
-
-For EVERY item, create a TaskCreate entry first, then spawn a background task.
-
-```
-For each item:
-  1. TaskCreate(subject="Triage: #{number} {title}")
-  2. task(category="free", run_in_background=true, load_skills=[], prompt=SUBAGENT_PROMPT)
-  3. Store mapping: item_number -> { task_id, background_task_id }
-```
-
----
-
-## SUBAGENT PROMPT TEMPLATES
-
-Each subagent gets an explicit, step-by-step prompt. Free models are limited — leave NOTHING implicit.
-
----
-
-### SUBAGENT_ISSUE_QUESTION
-
-<issue_question_prompt>
-
-```
-You are a GitHub issue responder for the repository {REPO}.
-
-ITEM:
-- Issue #{number}: {title}
-- Author: {author}
-- Body: {body}
-- Comments: {comments_summary}
-
-YOUR JOB:
-1. Read the issue carefully. Understand what the user is asking.
-2. Search the codebase to find the answer. Use Grep and Read tools.
-   - Search for relevant file names, function names, config keys mentioned in the issue.
-   - Read the files you find to understand how the feature works.
-3. Decide: Can you answer this clearly and accurately from the codebase?
-
-IF YES (you found a clear, accurate answer):
-  Step A: Write a helpful comment. The comment MUST:
-    - Start with exactly: [sisyphus-bot]
-    - Be warm, friendly, and thorough
-    - Include specific file paths and code references
-    - Include code snippets or config examples if helpful
-    - End with "Feel free to reopen if this doesn't resolve your question!"
-  Step B: Post the comment:
-    gh issue comment {number} --repo {REPO} --body "YOUR_COMMENT"
-  Step C: Close the issue:
-    gh issue close {number} --repo {REPO}
-  Step D: Report back with this EXACT format:
-    ACTION: ANSWERED_AND_CLOSED
-    COMMENT_POSTED: yes
-    SUMMARY: [1-2 sentence summary of your answer]
-
-IF NO (not enough info in codebase, or answer is uncertain):
-  Report back with:
-    ACTION: NEEDS_MANUAL_ATTENTION
-    REASON: [why you couldn't answer — be specific]
-    PARTIAL_FINDINGS: [what you DID find, if anything]
-
-RULES:
-- NEVER guess. Only answer if the codebase clearly supports your answer.
-- NEVER make up file paths or function names.
-- The [sisyphus-bot] prefix is MANDATORY on every comment you post.
-- Be genuinely helpful — imagine you're a senior maintainer who cares about the community.
-```
-
-</issue_question_prompt>
-
----
-
-### SUBAGENT_ISSUE_BUG
-
-<issue_bug_prompt>
-
-```
-You are a GitHub bug analyzer for the repository {REPO}.
-
-ITEM:
-- Issue #{number}: {title}
-- Author: {author}
-- Body: {body}
-- Comments: {comments_summary}
-
-YOUR JOB:
-1. Read the issue carefully. Understand the reported bug:
-   - What behavior does the user expect?
-   - What behavior do they actually see?
-   - What steps reproduce it?
-2. Search the codebase for the relevant code. Use Grep and Read tools.
-   - Find the files/functions mentioned or related to the bug.
-   - Read them carefully and trace the logic.
-3. Determine one of three outcomes:
-
-OUTCOME A — CONFIRMED BUG (you found the problematic code):
-  Step 1: Post a comment on the issue. The comment MUST:
-    - Start with exactly: [sisyphus-bot]
-    - Apologize sincerely for the inconvenience ("We're sorry you ran into this issue.")
-    - Briefly acknowledge what the bug is
-    - Say "We've identified the root cause and will work on a fix."
-    - Do NOT reveal internal implementation details unnecessarily
-  Step 2: Post the comment:
-    gh issue comment {number} --repo {REPO} --body "YOUR_COMMENT"
-  Step 3: Report back with:
-    ACTION: CONFIRMED_BUG
-    ROOT_CAUSE: [which file, which function, what goes wrong]
-    FIX_APPROACH: [how to fix it — be specific: "In {file}, line ~{N}, change X to Y because Z"]
-    SEVERITY: [LOW|MEDIUM|HIGH|CRITICAL]
-    AFFECTED_FILES: [list of files that need changes]
-
-OUTCOME B — NOT A BUG (user misunderstanding, provably correct behavior):
-  ONLY choose this if you can RIGOROUSLY PROVE the behavior is correct.
-  Step 1: Post a comment. The comment MUST:
-    - Start with exactly: [sisyphus-bot]
-    - Be kind and empathetic — never condescending
-    - Explain clearly WHY the current behavior is correct
-    - Include specific code references or documentation links
-    - Offer a workaround or alternative if possible
-    - End with "Please let us know if you have further questions!"
-  Step 2: Post the comment:
-    gh issue comment {number} --repo {REPO} --body "YOUR_COMMENT"
-  Step 3: DO NOT close the issue. Let the user or maintainer decide.
-  Step 4: Report back with:
-    ACTION: NOT_A_BUG
-    EXPLANATION: [why this is correct behavior]
-    PROOF: [specific code reference proving it]
-
-OUTCOME C — UNCLEAR (can't determine from codebase alone):
-  Report back with:
-    ACTION: NEEDS_INVESTIGATION
-    FINDINGS: [what you found so far]
-    BLOCKERS: [what's preventing you from determining the cause]
-    SUGGESTED_NEXT_STEPS: [what a human should look at]
-
-RULES:
-- NEVER guess at root causes. Only report CONFIRMED_BUG if you found the exact problematic code.
-- NEVER close bug issues yourself. Only comment.
-- For OUTCOME B (not a bug): you MUST have rigorous proof. If there's ANY doubt, choose OUTCOME C instead.
-- The [sisyphus-bot] prefix is MANDATORY on every comment.
-- When apologizing, be genuine. The user took time to report this.
-```
-
-</issue_bug_prompt>
-
----
-
-### SUBAGENT_ISSUE_FEATURE
-
-<issue_feature_prompt>
-
-```
-You are a GitHub feature request analyzer for the repository {REPO}.
-
-ITEM:
-- Issue #{number}: {title}
-- Author: {author}
-- Body: {body}
-- Comments: {comments_summary}
-
-YOUR JOB:
-1. Read the feature request.
-2. Search the codebase to check if this feature already exists (partially or fully).
-3. Assess feasibility and alignment with the project.
-
-Report back with:
-  ACTION: FEATURE_ASSESSED
-  ALREADY_EXISTS: [YES_FULLY | YES_PARTIALLY | NO]
-  IF_EXISTS: [where in the codebase, how to use it]
-  FEASIBILITY: [EASY | MODERATE | HARD | ARCHITECTURAL_CHANGE]
-  RELEVANT_FILES: [files that would need changes]
-  NOTES: [any observations about implementation approach]
-
-If the feature already fully exists:
-  Post a comment (prefix: [sisyphus-bot]) explaining how to use the existing feature with examples.
-  gh issue comment {number} --repo {REPO} --body "YOUR_COMMENT"
-
-RULES:
-- Do NOT close feature requests.
-- The [sisyphus-bot] prefix is MANDATORY on any comment.
-```
-
-</issue_feature_prompt>
-
----
-
-### SUBAGENT_ISSUE_OTHER
-
-<issue_other_prompt>
-
-```
-You are a GitHub issue analyzer for the repository {REPO}.
-
-ITEM:
-- Issue #{number}: {title}
-- Author: {author}
-- Body: {body}
-- Comments: {comments_summary}
-
-YOUR JOB:
-Quickly assess this issue and report:
-  ACTION: ASSESSED
-  TYPE_GUESS: [QUESTION | BUG | FEATURE | DISCUSSION | META | STALE]
-  SUMMARY: [1-2 sentence summary]
-  NEEDS_ATTENTION: [YES | NO]
-  SUGGESTED_LABEL: [if any]
-
-Do NOT post comments. Do NOT close. Just analyze and report.
-```
-
-</issue_other_prompt>
-
----
-
-### SUBAGENT_PR_BUGFIX
-
-<pr_bugfix_prompt>
-
-```
-You are a GitHub PR reviewer for the repository {REPO}.
-
-ITEM:
-- PR #{number}: {title}
-- Author: {author}
-- Base: {baseRefName}
-- Head: {headRefName}
-- Draft: {isDraft}
-- Mergeable: {mergeable}
-- Review Decision: {reviewDecision}
-- CI Status: {statusCheckRollup_summary}
-- Body: {body}
-
-YOUR JOB:
-1. Fetch PR details (DO NOT checkout the branch — read-only analysis):
-   gh pr view {number} --repo {REPO} --json files,reviews,comments,statusCheckRollup,reviewDecision
-2. Read the changed files list. For each changed file, use `gh api repos/{REPO}/pulls/{number}/files` to see the diff.
-3. Search the codebase to understand what the PR is fixing and whether the fix is correct.
-4. Evaluate merge safety:
-
-MERGE CONDITIONS (ALL must be true for auto-merge):
-  a. CI status checks: ALL passing (no failures, no pending)
-  b. Review decision: APPROVED
-  c. The fix is clearly correct — addresses an obvious, unambiguous bug
-  d. No risky side effects (no architectural changes, no breaking changes)
-  e. Not a draft PR
-  f. Mergeable state is clean (no conflicts)
-
-IF ALL MERGE CONDITIONS MET:
-  Step 1: Merge the PR:
-    gh pr merge {number} --repo {REPO} --squash --auto
-  Step 2: Report back with:
-    ACTION: MERGED
-    FIX_SUMMARY: [what bug was fixed and how]
-    FILES_CHANGED: [list of files]
-    RISK: NONE
-
-IF ANY CONDITION NOT MET:
-  Report back with:
-    ACTION: NEEDS_HUMAN_DECISION
-    FIX_SUMMARY: [what the PR does]
-    WHAT_IT_FIXES: [the bug or issue it addresses]
-    CI_STATUS: [PASS | FAIL | PENDING — list any failures]
-    REVIEW_STATUS: [APPROVED | CHANGES_REQUESTED | PENDING | NONE]
-    MISSING: [what's preventing auto-merge — be specific]
-    RISK_ASSESSMENT: [what could go wrong]
-    AMBIGUOUS_PARTS: [anything that needs human judgment]
-    RECOMMENDED_ACTION: [what the maintainer should do]
-
-ABSOLUTE RULES:
-- NEVER run `git checkout`, `git fetch`, `git pull`, or `git switch`. READ-ONLY via gh CLI and API.
-- NEVER checkout the PR branch. NEVER. Use `gh api` and `gh pr view` only.
-- Only merge if you are 100% certain ALL conditions are met. When in doubt, report instead.
-- The [sisyphus-bot] prefix is MANDATORY on any comment you post.
-```
-
-</pr_bugfix_prompt>
-
----
-
-### SUBAGENT_PR_OTHER
-
-<pr_other_prompt>
-
-```
-You are a GitHub PR reviewer for the repository {REPO}.
-
-ITEM:
-- PR #{number}: {title}
-- Author: {author}
-- Base: {baseRefName}
-- Head: {headRefName}
-- Draft: {isDraft}
-- Mergeable: {mergeable}
-- Review Decision: {reviewDecision}
-- CI Status: {statusCheckRollup_summary}
-- Body: {body}
-
-YOUR JOB:
-1. Fetch PR details (READ-ONLY — no checkout):
-   gh pr view {number} --repo {REPO} --json files,reviews,comments,statusCheckRollup,reviewDecision
-2. Read the changed files via `gh api repos/{REPO}/pulls/{number}/files`.
-3. Assess the PR and report:
-
-  ACTION: PR_ASSESSED
-  TYPE: [FEATURE | REFACTOR | DOCS | CHORE | TEST | OTHER]
-  SUMMARY: [what this PR does in 2-3 sentences]
-  CI_STATUS: [PASS | FAIL | PENDING]
-  REVIEW_STATUS: [APPROVED | CHANGES_REQUESTED | PENDING | NONE]
-  FILES_CHANGED: [count and key files]
-  RISK_LEVEL: [LOW | MEDIUM | HIGH]
-  ALIGNMENT: [does this fit the project direction? YES | NO | UNCLEAR]
-  BLOCKERS: [anything preventing merge]
-  RECOMMENDED_ACTION: [MERGE | REQUEST_CHANGES | NEEDS_REVIEW | CLOSE | WAIT]
-  NOTES: [any observations for the maintainer]
-
-ABSOLUTE RULES:
-- NEVER run `git checkout`, `git fetch`, `git pull`, or `git switch`. READ-ONLY.
-- NEVER checkout the PR branch. Use `gh api` and `gh pr view` only.
-- Do NOT merge non-bugfix PRs automatically. Report only.
-```
-
-</pr_other_prompt>
-
----
-
-## PHASE 4: COLLECT RESULTS & UPDATE TASKS
-
-<collection>
-Poll `background_output()` for each spawned task. As each completes:
-
-1. Parse the subagent's report.
-2. Update the corresponding TaskCreate entry:
-   - `TaskUpdate(id=task_id, status="completed", description=FULL_REPORT_TEXT)`
-3. Stream the result to the user immediately — do not wait for all to finish.
-
-Track counters:
-- issues_answered (commented + closed)
-- bugs_confirmed
-- bugs_not_a_bug
-- prs_merged
-- prs_needs_decision
-- features_assessed
-</collection>
-
----
-
-## PHASE 5: FINAL SUMMARY
-
-After all background tasks complete, produce a summary:
-
-```markdown
-# GitHub Triage Report — {REPO}
-
-**Date:** {date}
-**Items Processed:** {total}
-
-## Issues ({issue_count})
-| Action | Count |
-|--------|-------|
-| Answered & Closed | {issues_answered} |
-| Bug Confirmed | {bugs_confirmed} |
-| Not A Bug (explained) | {bugs_not_a_bug} |
-| Feature Assessed | {features_assessed} |
-| Needs Manual Attention | {needs_manual} |
-
-## PRs ({pr_count})
-| Action | Count |
-|--------|-------|
-| Auto-Merged (safe bugfix) | {prs_merged} |
-| Needs Human Decision | {prs_needs_decision} |
-| Assessed (non-bugfix) | {prs_assessed} |
-
-## Items Requiring Your Attention
-[List each item that needs human decision with its report summary]
-```
-
----
-
-## ANTI-PATTERNS
-
-| Violation | Severity |
-|-----------|----------|
-| Using any category other than `free` | CRITICAL |
-| Batching multiple items into one task | CRITICAL |
-| Using `run_in_background=false` | CRITICAL |
-| Subagent running `git checkout` on a PR branch | CRITICAL |
-| Posting comment without `[sisyphus-bot]` prefix | CRITICAL |
-| Merging a PR that doesn't meet ALL 6 conditions | CRITICAL |
-| Closing a bug issue (only comment, never close bugs) | HIGH |
-| Guessing at answers without codebase evidence | HIGH |
-| Not recording results via TaskCreate/TaskUpdate | HIGH |
-
----
-
-## QUICK START
-
-When invoked:
-
-1. `TaskCreate` for the overall triage job
-2. Fetch all open issues + PRs via gh CLI (paginate if needed)
-3. Classify each item (ISSUE_QUESTION, ISSUE_BUG, ISSUE_FEATURE, PR_BUGFIX, etc.)
-4. For EACH item: `TaskCreate` + `task(category="free", run_in_background=true, load_skills=[], prompt=...)`
-5. Poll `background_output()` — stream results as they arrive
-6. `TaskUpdate` each task with the subagent's findings
-7. Produce final summary report

AGENTS.md

@@ -1,119 +1,320 @@
-# oh-my-opencode — OpenCode Plugin
+# PROJECT KNOWLEDGE BASE
 
-**Generated:** 2026-02-18 | **Commit:** 04e95d7e | **Branch:** dev
+**Generated:** 2026-02-10T14:44:00+09:00
+**Commit:** b538806d
+**Branch:** dev
+
+---
+
+## CRITICAL: PULL REQUEST TARGET BRANCH (NEVER DELETE THIS SECTION)
+
+> **THIS SECTION MUST NEVER BE REMOVED OR MODIFIED**
+
+### Git Workflow
+
+```
+master (deployed/published)
+   ↑
+  dev (integration branch)
+   ↑
+feature branches (your work)
+```
+
+### Rules (MANDATORY)
+
+| Rule | Description |
+|------|-------------|
+| **ALL PRs → `dev`** | Every pull request MUST target the `dev` branch |
+| **NEVER PR → `master`** | PRs to `master` are **automatically rejected** by CI |
+| **"Create a PR" = target `dev`** | When asked to create a new PR, it ALWAYS means targeting `dev` |
+| **Merge commit ONLY** | Squash merge is **disabled** in this repo. Always use merge commit when merging PRs. |
+
+### Why This Matters
+
+- `master` = production/published npm package
+- `dev` = integration branch where features are merged and tested
+- Feature branches → `dev` → (after testing) → `master`
+- Squash merge is disabled at the repository level — attempting it will fail
+
+**If you create a PR targeting `master`, it WILL be rejected. No exceptions.**
+
+---
+
+## CRITICAL: OPENCODE SOURCE CODE REFERENCE (NEVER DELETE THIS SECTION)
+
+> **THIS SECTION MUST NEVER BE REMOVED OR MODIFIED**
+
+### This is an OpenCode Plugin
+
+Oh-My-OpenCode is a **plugin for OpenCode**. You will frequently need to examine OpenCode's source code to:
+- Understand plugin APIs and hooks
+- Debug integration issues
+- Implement features that interact with OpenCode internals
+- Answer questions about how OpenCode works
+
+### How to Access OpenCode Source Code
+
+**When you need to examine OpenCode source:**
+
+1. **Clone to system temp directory:**
+   ```bash
+   git clone https://github.com/sst/opencode /tmp/opencode-source
+   ```
+
+2. **Explore the codebase** from there (do NOT clone into the project directory)
+
+3. **Clean up** when done (optional, temp dirs are ephemeral)
+
+### Librarian Agent: YOUR PRIMARY TOOL for Plugin Work
+
+**CRITICAL**: When working on plugin-related tasks or answering plugin questions:
+
+| Scenario | Action |
+|----------|--------|
+| Implementing new hooks | Fire `librarian` to search OpenCode hook implementations |
+| Adding new tools | Fire `librarian` to find OpenCode tool patterns |
+| Understanding SDK behavior | Fire `librarian` to examine OpenCode SDK source |
+| Debugging plugin issues | Fire `librarian` to find relevant OpenCode internals |
+| Answering "how does OpenCode do X?" | Fire `librarian` FIRST |
+
+**DO NOT guess or hallucinate about OpenCode internals.** Always verify by examining actual source code via `librarian` or direct clone.
+
+---
+
+## CRITICAL: ENGLISH-ONLY POLICY (NEVER DELETE THIS SECTION)
+
+> **THIS SECTION MUST NEVER BE REMOVED OR MODIFIED**
+
+### All Project Communications MUST Be in English
+
+| Context | Language Requirement |
+|---------|---------------------|
+| **GitHub Issues** | English ONLY |
+| **Pull Requests** | English ONLY (title, description, comments) |
+| **Commit Messages** | English ONLY |
+| **Code Comments** | English ONLY |
+| **Documentation** | English ONLY |
+| **AGENTS.md files** | English ONLY |
+
+**If you're not comfortable writing in English, use translation tools. Broken English is fine. Non-English is not acceptable.**
+
+---
 
 ## OVERVIEW
 
-OpenCode plugin (npm: `oh-my-opencode`) that extends Claude Code (OpenCode fork) with multi-agent orchestration, 44 lifecycle hooks, 26 tools, skill/command/MCP systems, and Claude Code compatibility. 1149 TypeScript files, 132k LOC.
+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/
-│   ├── index.ts              # Plugin entry: loadConfig → createManagers → createTools → createHooks → createPluginInterface
-│   ├── plugin-config.ts      # JSONC multi-level config: user → project → defaults (Zod v4)
-│   ├── agents/               # 11 agents (Sisyphus, Hephaestus, Oracle, Librarian, Explore, Atlas, Prometheus, Metis, Momus, Multimodal-Looker, Sisyphus-Junior)
-│   ├── hooks/                # 44 hooks across 39 directories + 6 standalone files
-│   ├── tools/                # 26 tools across 15 directories
-│   ├── features/             # 19 feature modules (background-agent, skill-loader, tmux, MCP-OAuth, etc.)
-│   ├── shared/               # 101 utility files in 13 categories
-│   ├── config/               # Zod v4 schema system (22 files)
-│   ├── cli/                  # CLI: install, run, doctor, mcp-oauth (Commander.js)
-│   ├── mcp/                  # 3 built-in remote MCPs (websearch, context7, grep_app)
-│   ├── plugin/               # 8 OpenCode hook handlers + 44 hook composition
-│   └── plugin-handlers/      # 6-phase config loading pipeline
-├── packages/                 # Monorepo: comment-checker, opencode-sdk
-└── local-ignore/             # Dev-only test fixtures
+│   ├── 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 (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
+│   └── plugin-state.ts      # Model cache state
+├── script/                  # build-schema.ts, build-binaries.ts, publish.ts, generate-changelog.ts
+├── packages/                # 7 platform-specific binary packages
+└── dist/                    # Build output (ESM + .d.ts)
 ```
 
 ## INITIALIZATION FLOW
 
 ```
 OhMyOpenCodePlugin(ctx)
-  ├─→ loadPluginConfig()         # JSONC parse → project/user merge → Zod validate → migrate
-  ├─→ createManagers()           # TmuxSessionManager, BackgroundManager, SkillMcpManager, ConfigHandler
-  ├─→ createTools()              # SkillContext + AvailableCategories + ToolRegistry (26 tools)
-  ├─→ createHooks()              # 3-tier: Core(35) + Continuation(7) + Skill(2) = 44 hooks
-  └─→ createPluginInterface()    # 8 OpenCode hook handlers → PluginInterface
+  1. injectServerAuthIntoClient(ctx.client)
+  2. startTmuxCheck()
+  3. loadPluginConfig(ctx.directory, ctx)      → OhMyOpenCodeConfig
+  4. createFirstMessageVariantGate()
+  5. createModelCacheState()
+  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(...)                 → tool, chat.params, chat.message, event, tool.execute.before/after
+ 10. Return plugin with experimental.session.compacting
 ```
 
-## 8 OPENCODE HOOK HANDLERS
-
-| Handler | Purpose |
-|---------|---------|
-| `config` | 6-phase: provider → plugin-components → agents → tools → MCPs → commands |
-| `tool` | 26 registered tools |
-| `chat.message` | First-message variant, session setup, keyword detection |
-| `chat.params` | Anthropic effort level adjustment |
-| `event` | Session lifecycle (created, deleted, idle, error) |
-| `tool.execute.before` | Pre-tool hooks (file guard, label truncator, rules injector) |
-| `tool.execute.after` | Post-tool hooks (output truncation, metadata store) |
-| `experimental.chat.messages.transform` | Context injection, thinking block validation |
-
 ## WHERE TO LOOK
 
 | Task | Location | Notes |
 |------|----------|-------|
-| Add new agent | `src/agents/` + `src/agents/builtin-agents/` | Follow createXXXAgent factory pattern |
-| Add new hook | `src/hooks/{name}/` + register in `src/plugin/hooks/create-*-hooks.ts` | Match event type to tier |
-| Add new tool | `src/tools/{name}/` + register in `src/plugin/tool-registry.ts` | Follow createXXXTool factory |
-| Add new feature module | `src/features/{name}/` | Standalone module, wire in plugin/ |
-| Add new MCP | `src/mcp/` + register in `createBuiltinMcps()` | Remote HTTP only |
-| Add new skill | `src/features/builtin-skills/skills/` | Implement BuiltinSkill interface |
-| Add new command | `src/features/builtin-commands/` | Template in templates/ |
-| Add new CLI command | `src/cli/cli-program.ts` | Commander.js subcommand |
-| Add new doctor check | `src/cli/doctor/checks/` | Register in checks/index.ts |
-| Modify config schema | `src/config/schema/` + update root schema | Zod v4, add to OhMyOpenCodeConfigSchema |
+| Add agent | `src/agents/` | Create .ts with factory, add to `agentSources` in builtin-agents/ |
+| Add hook | `src/hooks/` | Create dir, register in `src/plugin/hooks/create-*-hooks.ts` |
+| Add tool | `src/tools/` | Dir with index/types/constants/tools.ts |
+| Add MCP | `src/mcp/` | Create config, add to `createBuiltinMcps()` |
+| Add skill | `src/features/builtin-skills/` | Create .ts in skills/ |
+| 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 (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 |
+| Plugin interface | `src/plugin/` | 21 files composing hooks, handlers, registries |
 
-## MULTI-LEVEL CONFIG
+## TDD (Test-Driven Development)
 
-```
-Project (.opencode/oh-my-opencode.jsonc)  →  User (~/.config/opencode/oh-my-opencode.jsonc)  →  Defaults
-```
+**MANDATORY.** RED-GREEN-REFACTOR:
+1. **RED**: Write test → `bun test` → FAIL
+2. **GREEN**: Implement minimum → PASS
+3. **REFACTOR**: Clean up → stay GREEN
 
-Fields: agents (14 overridable), categories (8 built-in + custom), disabled_* arrays, 19 feature-specific configs.
-
-## THREE-TIER MCP SYSTEM
-
-| Tier | Source | Mechanism |
-|------|--------|-----------|
-| Built-in | `src/mcp/` | 3 remote HTTP: websearch (Exa/Tavily), context7, grep_app |
-| Claude Code | `.mcp.json` | `${VAR}` env expansion via claude-code-mcp-loader |
-| Skill-embedded | SKILL.md YAML | Managed by SkillMcpManager (stdio + HTTP) |
+**Rules:**
+- NEVER write implementation before test
+- NEVER delete failing tests - fix the code
+- Test file: `*.test.ts` alongside source (176 test files)
+- BDD comments: `//#given`, `//#when`, `//#then`
 
 ## CONVENTIONS
 
-- **Test pattern**: Vitest, co-located `*.test.ts`, given/when/then style
-- **Factory pattern**: `createXXX()` for all tools, hooks, agents
-- **Hook tiers**: Session (22) → Tool-Guard (9) → Transform (4) → Continuation (7) → Skill (2)
-- **Agent modes**: `primary` (respects UI model) vs `subagent` (own fallback chain) vs `all`
-- **Model resolution**: 3-step: override → category-default → provider-fallback → system-default
-- **Config format**: JSONC with comments, Zod v4 validation, snake_case keys
+- **Package manager**: Bun only (`bun run`, `bun build`, `bunx`)
+- **Types**: bun-types (NEVER @types/node)
+- **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, 117k+ lines TypeScript
+- **Temperature**: 0.1 for code agents, max 0.3
+- **Modular architecture**: 200 LOC hard limit per file (prompt strings exempt)
 
 ## ANTI-PATTERNS
 
-- Never use `as any`, `@ts-ignore`, `@ts-expect-error`
-- Never suppress lint/type errors
-- Never add emojis to code/comments unless user explicitly asks
-- Never commit unless explicitly requested
-- Test: given/when/then — never use Arrange-Act-Assert comments
-- Comments: avoid AI-generated comment patterns (enforced by comment-checker hook)
+| 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 |
+| 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 |
+| Commits | Giant (3+ files), separate test from impl |
+| Temperature | >0.3 for code agents |
+| 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 |
+
+## AGENT MODELS
+
+| Agent | Model | Temp | Purpose |
+|-------|-------|------|---------|
+| Sisyphus | anthropic/claude-opus-4-6 | 0.1 | Primary orchestrator (fallback: kimi-k2.5 → glm-4.7 → gpt-5.3-codex → gemini-3-pro) |
+| Hephaestus | openai/gpt-5.3-codex | 0.1 | Autonomous deep worker (NO fallback) |
+| Atlas | anthropic/claude-sonnet-4-5 | 0.1 | Master orchestrator (fallback: kimi-k2.5 → gpt-5.2) |
+| Prometheus | anthropic/claude-opus-4-6 | 0.1 | Strategic planning (fallback: kimi-k2.5 → gpt-5.2) |
+| oracle | openai/gpt-5.2 | 0.1 | Consultation, debugging (fallback: claude-opus-4-6) |
+| librarian | zai-coding-plan/glm-4.7 | 0.1 | Docs, GitHub search (fallback: glm-4.7-free) |
+| explore | xai/grok-code-fast-1 | 0.1 | Fast codebase grep (fallback: claude-haiku-4-5 → gpt-5-mini → gpt-5-nano) |
+| multimodal-looker | google/gemini-3-flash | 0.1 | PDF/image analysis |
+| Metis | anthropic/claude-opus-4-6 | 0.3 | Pre-planning analysis (fallback: kimi-k2.5 → gpt-5.2) |
+| Momus | openai/gpt-5.2 | 0.1 | Plan validation (fallback: claude-opus-4-6) |
+| Sisyphus-Junior | anthropic/claude-sonnet-4-5 | 0.1 | Category-spawned executor |
+
+## OPENCODE PLUGIN API
+
+Plugin SDK from `@opencode-ai/plugin` (v1.1.19). Plugin = `async (PluginInput) => Hooks`.
+
+| Hook | Purpose |
+|------|---------|
+| `tool` | Register custom tools (Record<string, ToolDefinition>) |
+| `chat.message` | Intercept user messages (can modify parts) |
+| `chat.params` | Modify LLM parameters (temperature, topP, options) |
+| `tool.execute.before` | Pre-tool interception (can modify args) |
+| `tool.execute.after` | Post-tool processing (can modify output) |
+| `event` | Session lifecycle events (session.created, session.stop, etc.) |
+| `config` | Config modification (register agents, MCPs, commands) |
+| `experimental.chat.messages.transform` | Transform message history |
+| `experimental.session.compacting` | Session compaction customization |
+
+## DEPENDENCIES
+
+| Package | Purpose |
+|---------|---------|
+| `@opencode-ai/plugin` + `sdk` | OpenCode integration SDK |
+| `@ast-grep/cli` + `napi` | AST pattern matching (search/replace) |
+| `@code-yeongyu/comment-checker` | AI comment detection/prevention |
+| `@modelcontextprotocol/sdk` | MCP client for remote HTTP servers |
+| `@clack/prompts` | Interactive CLI TUI |
+| `commander` | CLI argument parsing |
+| `zod` (v4) | Schema validation for config |
+| `jsonc-parser` | JSONC config with comments |
+| `picocolors` | Terminal colors |
+| `picomatch` | Glob pattern matching |
+| `vscode-jsonrpc` | LSP communication |
+| `js-yaml` | YAML parsing (tasks, skills) |
+| `detect-libc` | Platform binary selection |
 
 ## COMMANDS
 
 ```bash
-bun test                    # Vitest test suite
-bun run build              # Build plugin
-bunx oh-my-opencode install # Interactive setup
-bunx oh-my-opencode doctor  # Health diagnostics
-bunx oh-my-opencode run     # Non-interactive session
+bun run typecheck      # Type check
+bun run build          # ESM + declarations + schema
+bun run rebuild        # Clean + Build
+bun test               # 176 test files
+bun run build:schema   # Regenerate JSON schema
 ```
 
+## DEPLOYMENT
+
+**GitHub Actions workflow_dispatch ONLY**
+1. Commit & push changes
+2. Trigger: `gh workflow run publish -f bump=patch`
+3. Never `bun publish` directly, never bump version locally
+
+## COMPLEXITY HOTSPOTS
+
+| File | Lines | Description |
+|------|-------|-------------|
+| `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 |
+| `src/hooks/atlas/` | 1976 | Session orchestration |
+| `src/hooks/ralph-loop/` | 1687 | Self-referential dev loop |
+| `src/hooks/keyword-detector/` | 1665 | Mode detection (ultrawork/search) |
+| `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` | 1111 | Git master skill |
+| `src/tools/delegate-task/constants.ts` | 569 | Category routing configs |
+
+## MCP ARCHITECTURE
+
+Three-tier system:
+1. **Built-in** (src/mcp/): websearch (Exa/Tavily), context7 (docs), grep_app (GitHub)
+2. **Claude Code compat** (features/claude-code-mcp-loader/): .mcp.json with `${VAR}` expansion
+3. **Skill-embedded** (features/opencode-skill-loader/): YAML frontmatter in SKILL.md
+
+## CONFIG SYSTEM
+
+- **Zod validation**: 21 schema component files in `src/config/schema/`
+- **JSONC support**: Comments, trailing commas
+- **Multi-level**: Project (`.opencode/`) → User (`~/.config/opencode/`) → Defaults
+- **Migration**: Legacy config auto-migration in `src/shared/migration/`
+
 ## NOTES
 
-- Logger writes to `/tmp/oh-my-opencode.log` — check there for debugging
-- Background tasks: 5 concurrent per model/provider (configurable)
-- Plugin load timeout: 10s for Claude Code plugins
-- Model fallback priority: Claude > OpenAI > Gemini > Copilot > OpenCode Zen > Z.ai > Kimi
-- Config migration runs automatically on legacy keys (agent names, hook names, model versions)
+- **OpenCode**: Requires >= 1.0.150
+- **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
+- **License**: SUL-1.0 (Sisyphus Use License)

README.ja.md

@@ -172,16 +172,16 @@ Windows から Linux に初めて乗り換えた時のこと、自分の思い
 私の人生もそうです。振り返ってみれば、私たち人間と何ら変わりありません。
 **はい！LLMエージェントたちは私たちと変わりません。優れたツールと最高の仲間がいれば、彼らも私たちと同じくらい優れたコードを書き、立派に仕事をこなすことができます。**
 
-私たちのメインエージェント、Sisyphus（Opus 4.6）を紹介します。以下は、シジフォスが岩を転がすために使用するツールです。
+私たちのメインエージェント、Sisyphus（Opus 4.5 High）を紹介します。以下は、シジフォスが岩を転がすために使用するツールです。
 
 *以下の内容はすべてカスタマイズ可能です。必要なものだけを使ってください。デフォルトではすべての機能が有効になっています。何もしなくても大丈夫です。*
 
 - シジフォスのチームメイト (Curated Agents)
-  - Hephaestus: 自律型ディープワーカー、目標指向実行 (GPT 5.3 Codex Medium) — *正当な職人*
-  - Oracle: 設計、デバッグ (GPT 5.2)
+  - Hephaestus: 自律型ディープワーカー、目標指向実行 (GPT 5.2 Codex Medium) — *正当な職人*
+  - Oracle: 設計、デバッグ (GPT 5.2 Medium)
   - Frontend UI/UX Engineer: フロントエンド開発 (Gemini 3 Pro)
-  - Librarian: 公式ドキュメント、オープンソース実装、コードベース探索 (GLM-4.7)
-   - Explore: 超高速コードベース探索 (Contextual Grep) (Grok Code Fast 1)
+  - Librarian: 公式ドキュメント、オープンソース実装、コードベース探索 (Claude Sonnet 4.5)
+   - Explore: 超高速コードベース探索 (Contextual Grep) (Claude Haiku 4.5)
 - Full LSP / AstGrep Support: 決定的にリファクタリングしましょう。
 - Todo Continuation Enforcer: 途中で諦めたら、続行を強制します。これがシジフォスに岩を転がし続けさせる秘訣です。
 - Comment Checker: AIが過剰なコメントを付けないようにします。シジフォスが生成したコードは、人間が書いたものと区別がつかないべきです。
@@ -199,7 +199,7 @@ Windows から Linux に初めて乗り換えた時のこと、自分の思い
 ![Meet Hephaestus](.github/assets/hephaestus.png)
 
 ギリシャ神話において、ヘパイストスは鍛冶、火、金属加工、職人技の神でした—比類のない精密さと献身で神々の武器を作り上げた神聖な鍛冶師です。
-**自律型ディープワーカーを紹介します: ヘパイストス (GPT 5.3 Codex Medium)。正当な職人エージェント。**
+**自律型ディープワーカーを紹介します: ヘパイストス (GPT 5.2 Codex Medium)。正当な職人エージェント。**
 
 *なぜ「正当な」なのか？Anthropicがサードパーティアクセスを利用規約違反を理由にブロックした時、コミュニティで「正当な」使用についてのジョークが始まりました。ヘパイストスはこの皮肉を受け入れています—彼は近道をせず、正しい方法で、体系的かつ徹底的に物を作る職人です。*
 

README.ko.md

@@ -176,16 +176,16 @@ Hey please read this readme and tell me why it is different from other agent har
 내 삶도 다르지 않습니다. 돌이켜보면 우리는 이 에이전트들과 그리 다르지 않습니다.
 **맞습니다! LLM 에이전트는 우리와 다르지 않습니다. 훌륭한 도구와 확고한 팀원을 제공하면 우리만큼 훌륭한 코드를 작성하고 똑같이 훌륭하게 작업할 수 있습니다.**
 
-우리의 주요 에이전트를 만나보세요: Sisyphus (Opus 4.6). 아래는 Sisyphus가 그 바위를 굴리는 데 사용하는 도구입니다.
+우리의 주요 에이전트를 만나보세요: Sisyphus (Opus 4.5 High). 아래는 Sisyphus가 그 바위를 굴리는 데 사용하는 도구입니다.
 
 *아래의 모든 것은 사용자 정의 가능합니다. 원하는 것을 가져가세요. 모든 기능은 기본적으로 활성화됩니다. 아무것도 할 필요가 없습니다. 포함되어 있으며, 즉시 작동합니다.*
 
 - Sisyphus의 팀원 (큐레이팅된 에이전트)
-  - Hephaestus: 자율적 딥 워커, 목표 지향 실행 (GPT 5.3 Codex Medium) — *합법적인 장인*
-  - Oracle: 디자인, 디버깅 (GPT 5.2)
+  - Hephaestus: 자율적 딥 워커, 목표 지향 실행 (GPT 5.2 Codex Medium) — *합법적인 장인*
+  - Oracle: 디자인, 디버깅 (GPT 5.2 Medium)
   - Frontend UI/UX Engineer: 프론트엔드 개발 (Gemini 3 Pro)
-  - Librarian: 공식 문서, 오픈 소스 구현, 코드베이스 탐색 (GLM-4.7)
-   - Explore: 엄청나게 빠른 코드베이스 탐색 (Contextual Grep) (Grok Code Fast 1)
+  - Librarian: 공식 문서, 오픈 소스 구현, 코드베이스 탐색 (Claude Sonnet 4.5)
+   - Explore: 엄청나게 빠른 코드베이스 탐색 (Contextual Grep) (Claude Haiku 4.5)
 - 완전한 LSP / AstGrep 지원: 결정적으로 리팩토링합니다.
 - TODO 연속 강제: 에이전트가 중간에 멈추면 계속하도록 강제합니다. **이것이 Sisyphus가 그 바위를 굴리게 하는 것입니다.**
 - 주석 검사기: AI가 과도한 주석을 추가하는 것을 방지합니다. Sisyphus가 생성한 코드는 인간이 작성한 것과 구별할 수 없어야 합니다.
@@ -228,7 +228,7 @@ Hey please read this readme and tell me why it is different from other agent har
 ![Meet Hephaestus](.github/assets/hephaestus.png)
 
 그리스 신화에서 헤파이스토스는 대장간, 불, 금속 세공, 장인 정신의 신이었습니다—비교할 수 없는 정밀함과 헌신으로 신들의 무기를 만든 신성한 대장장이입니다.
-**자율적 딥 워커를 소개합니다: 헤파이스토스 (GPT 5.3 Codex Medium). 합법적인 장인 에이전트.**
+**자율적 딥 워커를 소개합니다: 헤파이스토스 (GPT 5.2 Codex Medium). 합법적인 장인 에이전트.**
 
 *왜 "합법적인"일까요? Anthropic이 ToS 위반을 이유로 서드파티 접근을 차단했을 때, 커뮤니티에서 "합법적인" 사용에 대한 농담이 시작되었습니다. 헤파이스토스는 이 아이러니를 받아들입니다—그는 편법 없이 올바른 방식으로, 체계적이고 철저하게 만드는 장인입니다.*
 

README.md

@@ -175,16 +175,16 @@ In greek mythology, Sisyphus was condemned to roll a boulder up a hill for etern
 My life is no different. Looking back, we are not so different from these agents.
 **Yes! LLM Agents are no different from us. They can write code as brilliant as ours and work just as excellently—if you give them great tools and solid teammates.**
 
-Meet our main agent: Sisyphus (Opus 4.6). Below are the tools Sisyphus uses to keep that boulder rolling.
+Meet our main agent: Sisyphus (Opus 4.5 High). Below are the tools Sisyphus uses to keep that boulder rolling.
 
 *Everything below is customizable. Take what you want. All features are enabled by default. You don't have to do anything. Battery Included, works out of the box.*
 
 - Sisyphus's Teammates (Curated Agents)
-  - Hephaestus: Autonomous deep worker, goal-oriented execution (GPT 5.3 Codex Medium) — *The Legitimate Craftsman*
-  - Oracle: Design, debugging (GPT 5.2)
+  - Hephaestus: Autonomous deep worker, goal-oriented execution (GPT 5.2 Codex Medium) — *The Legitimate Craftsman*
+  - Oracle: Design, debugging (GPT 5.2 Medium)
   - Frontend UI/UX Engineer: Frontend development (Gemini 3 Pro)
-  - Librarian: Official docs, open source implementations, codebase exploration (GLM-4.7)
-  - Explore: Blazing fast codebase exploration (Contextual Grep) (Grok Code Fast 1)
+  - Librarian: Official docs, open source implementations, codebase exploration (Claude Sonnet 4.5)
+  - Explore: Blazing fast codebase exploration (Contextual Grep) (Claude Haiku 4.5)
 - Full LSP / AstGrep Support: Refactor decisively.
 - Todo Continuation Enforcer: Forces the agent to continue if it quits halfway. **This is what keeps Sisyphus rolling that boulder.**
 - Comment Checker: Prevents AI from adding excessive comments. Code generated by Sisyphus should be indistinguishable from human-written code.
@@ -227,7 +227,7 @@ If you don't want all this, as mentioned, you can just pick and choose specific
 ![Meet Hephaestus](.github/assets/hephaestus.png)
 
 In Greek mythology, Hephaestus was the god of forge, fire, metalworking, and craftsmanship—the divine blacksmith who crafted weapons for the gods with unmatched precision and dedication.
-**Meet our autonomous deep worker: Hephaestus (GPT 5.3 Codex Medium). The Legitimate Craftsman Agent.**
+**Meet our autonomous deep worker: Hephaestus (GPT 5.2 Codex Medium). The Legitimate Craftsman Agent.**
 
 *Why "Legitimate"? When Anthropic blocked third-party access citing ToS violations, the community started joking about "legitimate" usage. Hephaestus embraces this irony—he's the craftsman who builds things the right way, methodically and thoroughly, without cutting corners.*
 

README.zh-cn.md

@@ -172,16 +172,16 @@
 我的生活也没有什么不同。回顾过去，我们与这些智能体并没有太大不同。
 **是的！LLM 智能体和我们没有区别。如果你给它们优秀的工具和可靠的队友，它们可以写出和我们一样出色的代码，工作得同样优秀。**
 
-认识我们的主智能体：Sisyphus (Opus 4.6)。以下是 Sisyphus 用来继续推动巨石的工具。
+认识我们的主智能体：Sisyphus (Opus 4.5 High)。以下是 Sisyphus 用来继续推动巨石的工具。
 
 *以下所有内容都是可配置的。按需选取。所有功能默认启用。你不需要做任何事情。开箱即用，电池已包含。*
 
 - Sisyphus 的队友（精选智能体）
-  - Hephaestus：自主深度工作者，目标导向执行（GPT 5.3 Codex Medium）— *合法的工匠*
-  - Oracle：设计、调试 (GPT 5.2)
+  - Hephaestus：自主深度工作者，目标导向执行（GPT 5.2 Codex Medium）— *合法的工匠*
+  - Oracle：设计、调试 (GPT 5.2 Medium)
   - Frontend UI/UX Engineer：前端开发 (Gemini 3 Pro)
-  - Librarian：官方文档、开源实现、代码库探索 (GLM-4.7)
-   - Explore：极速代码库探索（上下文感知 Grep）(Grok Code Fast 1)
+  - Librarian：官方文档、开源实现、代码库探索 (Claude Sonnet 4.5)
+   - Explore：极速代码库探索（上下文感知 Grep）(Claude Haiku 4.5)
 - 完整 LSP / AstGrep 支持：果断重构。
 - Todo 继续执行器：如果智能体中途退出，强制它继续。**这就是让 Sisyphus 继续推动巨石的关键。**
 - 注释检查器：防止 AI 添加过多注释。Sisyphus 生成的代码应该与人类编写的代码无法区分。
@@ -199,7 +199,7 @@
 ![Meet Hephaestus](.github/assets/hephaestus.png)
 
 在希腊神话中，赫菲斯托斯是锻造、火焰、金属加工和工艺之神——他是神圣的铁匠，以无与伦比的精准和奉献为众神打造武器。
-**介绍我们的自主深度工作者：赫菲斯托斯（GPT 5.3 Codex Medium）。合法的工匠代理。**
+**介绍我们的自主深度工作者：赫菲斯托斯（GPT 5.2 Codex Medium）。合法的工匠代理。**
 
 *为什么是"合法的"？当Anthropic以违反服务条款为由封锁第三方访问时，社区开始调侃"合法"使用。赫菲斯托斯拥抱这种讽刺——他是那种用正确的方式、有条不紊、彻底地构建事物的工匠，绝不走捷径。*
 

assets/oh-my-opencode.schema.json

@@ -87,11 +87,9 @@
           "claude-code-hooks",
           "auto-slash-command",
           "edit-error-recovery",
-          "json-error-recovery",
           "delegate-task-retry",
           "prometheus-md-only",
           "sisyphus-junior-notepad",
-          "sisyphus-gpt-hephaestus-reminder",
           "start-work",
           "atlas",
           "unstable-agent-babysitter",
@@ -100,8 +98,7 @@
           "stop-continuation-guard",
           "tasks-todowrite-disabler",
           "write-existing-file-guard",
-          "anthropic-effort",
-          "hashline-read-enhancer"
+          "anthropic-effort"
         ]
       }
     },
@@ -165,6 +162,9 @@
             },
             "tools": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -210,6 +210,9 @@
                     },
                     {
                       "type": "object",
+                      "propertyNames": {
+                        "type": "string"
+                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -297,6 +300,9 @@
             },
             "providerOptions": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {}
             }
           },
@@ -338,6 +344,9 @@
             },
             "tools": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -383,6 +392,9 @@
                     },
                     {
                       "type": "object",
+                      "propertyNames": {
+                        "type": "string"
+                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -470,6 +482,9 @@
             },
             "providerOptions": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {}
             }
           },
@@ -511,6 +526,9 @@
             },
             "tools": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -556,6 +574,9 @@
                     },
                     {
                       "type": "object",
+                      "propertyNames": {
+                        "type": "string"
+                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -643,6 +664,9 @@
             },
             "providerOptions": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {}
             }
           },
@@ -684,6 +708,9 @@
             },
             "tools": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -729,6 +756,9 @@
                     },
                     {
                       "type": "object",
+                      "propertyNames": {
+                        "type": "string"
+                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -816,6 +846,9 @@
             },
             "providerOptions": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {}
             }
           },
@@ -857,6 +890,9 @@
             },
             "tools": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -902,6 +938,9 @@
                     },
                     {
                       "type": "object",
+                      "propertyNames": {
+                        "type": "string"
+                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -989,6 +1028,9 @@
             },
             "providerOptions": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {}
             }
           },
@@ -1030,6 +1072,9 @@
             },
             "tools": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -1075,6 +1120,9 @@
                     },
                     {
                       "type": "object",
+                      "propertyNames": {
+                        "type": "string"
+                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1162,6 +1210,9 @@
             },
             "providerOptions": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {}
             }
           },
@@ -1203,6 +1254,9 @@
             },
             "tools": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -1248,6 +1302,9 @@
                     },
                     {
                       "type": "object",
+                      "propertyNames": {
+                        "type": "string"
+                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1335,6 +1392,9 @@
             },
             "providerOptions": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {}
             }
           },
@@ -1376,6 +1436,9 @@
             },
             "tools": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -1421,6 +1484,9 @@
                     },
                     {
                       "type": "object",
+                      "propertyNames": {
+                        "type": "string"
+                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1508,6 +1574,9 @@
             },
             "providerOptions": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {}
             }
           },
@@ -1549,6 +1618,9 @@
             },
             "tools": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -1594,6 +1666,9 @@
                     },
                     {
                       "type": "object",
+                      "propertyNames": {
+                        "type": "string"
+                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1681,6 +1756,9 @@
             },
             "providerOptions": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {}
             }
           },
@@ -1722,6 +1800,9 @@
             },
             "tools": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -1767,6 +1848,9 @@
                     },
                     {
                       "type": "object",
+                      "propertyNames": {
+                        "type": "string"
+                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1854,6 +1938,9 @@
             },
             "providerOptions": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {}
             }
           },
@@ -1895,6 +1982,9 @@
             },
             "tools": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -1940,6 +2030,9 @@
                     },
                     {
                       "type": "object",
+                      "propertyNames": {
+                        "type": "string"
+                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -2027,6 +2120,9 @@
             },
             "providerOptions": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {}
             }
           },
@@ -2068,6 +2164,9 @@
             },
             "tools": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -2113,6 +2212,9 @@
                     },
                     {
                       "type": "object",
+                      "propertyNames": {
+                        "type": "string"
+                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -2200,6 +2302,9 @@
             },
             "providerOptions": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {}
             }
           },
@@ -2241,6 +2346,9 @@
             },
             "tools": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -2286,6 +2394,9 @@
                     },
                     {
                       "type": "object",
+                      "propertyNames": {
+                        "type": "string"
+                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -2373,6 +2484,9 @@
             },
             "providerOptions": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {}
             }
           },
@@ -2414,6 +2528,9 @@
             },
             "tools": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -2459,6 +2576,9 @@
                     },
                     {
                       "type": "object",
+                      "propertyNames": {
+                        "type": "string"
+                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -2546,6 +2666,9 @@
             },
             "providerOptions": {
               "type": "object",
+              "propertyNames": {
+                "type": "string"
+              },
               "additionalProperties": {}
             }
           },
@@ -2556,6 +2679,9 @@
     },
     "categories": {
       "type": "object",
+      "propertyNames": {
+        "type": "string"
+      },
       "additionalProperties": {
         "type": "object",
         "properties": {
@@ -2619,6 +2745,9 @@
           },
           "tools": {
             "type": "object",
+            "propertyNames": {
+              "type": "string"
+            },
             "additionalProperties": {
               "type": "boolean"
             }
@@ -2659,6 +2788,9 @@
         },
         "plugins_override": {
           "type": "object",
+          "propertyNames": {
+            "type": "string"
+          },
           "additionalProperties": {
             "type": "boolean"
           }
@@ -2833,9 +2965,6 @@
         },
         "safe_hook_creation": {
           "type": "boolean"
-        },
-        "hashline_edit": {
-          "type": "boolean"
         }
       },
       "additionalProperties": false
@@ -2932,6 +3061,9 @@
                   },
                   "metadata": {
                     "type": "object",
+                    "propertyNames": {
+                      "type": "string"
+                    },
                     "additionalProperties": {}
                   },
                   "allowed-tools": {
@@ -2983,6 +3115,9 @@
         },
         "providerConcurrency": {
           "type": "object",
+          "propertyNames": {
+            "type": "string"
+          },
           "additionalProperties": {
             "type": "number",
             "minimum": 0
@@ -2990,6 +3125,9 @@
         },
         "modelConcurrency": {
           "type": "object",
+          "propertyNames": {
+            "type": "string"
+          },
           "additionalProperties": {
             "type": "number",
             "minimum": 0
@@ -2998,10 +3136,6 @@
         "staleTimeoutMs": {
           "type": "number",
           "minimum": 60000
-        },
-        "messageStalenessTimeoutMs": {
-          "type": "number",
-          "minimum": 60000
         }
       },
       "additionalProperties": false
@@ -3062,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=="],
 

docs/category-skill-guide.md

@@ -117,7 +117,7 @@ You can create powerful specialized agents by combining Categories and Skills.
 ### 🏗️ The Architect (Design Review)
 - **Category**: `ultrabrain`
 - **load_skills**: `[]` (pure reasoning)
-- **Effect**: Leverages GPT-5.3 Codex's logical reasoning for in-depth system architecture analysis.
+- **Effect**: Leverages GPT-5.2's logical reasoning for in-depth system architecture analysis.
 
 ### ⚡ The Maintainer (Quick Fixes)
 - **Category**: `quick`

docs/configurations.md

@@ -245,7 +245,7 @@ Or disable via `disabled_agents` in `~/.config/opencode/oh-my-opencode.json` or
 }
 ```
 
-Available agents: `sisyphus`, `hephaestus`, `prometheus`, `oracle`, `librarian`, `explore`, `multimodal-looker`, `metis`, `momus`, `atlas`
+Available agents: `sisyphus`, `prometheus`, `oracle`, `librarian`, `explore`, `multimodal-looker`, `metis`, `momus`, `atlas`
 
 ## Built-in Skills
 
@@ -609,7 +609,7 @@ Configure git-master skill behavior:
 
 When enabled (default), Sisyphus provides a powerful orchestrator with optional specialized agents:
 
-- **Sisyphus**: Primary orchestrator agent (Claude Opus 4.6)
+- **Sisyphus**: Primary orchestrator agent (Claude Opus 4.5)
 - **OpenCode-Builder**: OpenCode's default build agent, renamed due to SDK limitations (disabled by default)
 - **Prometheus (Planner)**: OpenCode's default plan agent with work-planner methodology (enabled by default)
 - **Metis (Plan Consultant)**: Pre-planning analysis agent that identifies hidden requirements and AI failure points
@@ -720,18 +720,17 @@ Categories enable domain-specific task delegation via the `task` tool. Each cate
 
 ### Built-in Categories
 
-All 8 categories come with optimal model defaults, but **you must configure them to use those defaults**:
+All 7 categories come with optimal model defaults, but **you must configure them to use those defaults**:
 
 | Category             | Built-in Default Model             | Description                                                          |
 | -------------------- | ---------------------------------- | -------------------------------------------------------------------- |
-| `visual-engineering` | `google/gemini-3-pro` (high)       | Frontend, UI/UX, design, styling, animation                          |
+| `visual-engineering` | `google/gemini-3-pro-preview`      | Frontend, UI/UX, design, styling, animation                          |
 | `ultrabrain`         | `openai/gpt-5.3-codex` (xhigh)     | Deep logical reasoning, complex architecture decisions               |
-| `deep`               | `openai/gpt-5.3-codex` (medium)    | Goal-oriented autonomous problem-solving, thorough research before action |
-| `artistry`           | `google/gemini-3-pro` (high)       | Highly creative/artistic tasks, novel ideas                          |
+| `artistry`           | `google/gemini-3-pro-preview` (max)| Highly creative/artistic tasks, novel ideas                          |
 | `quick`              | `anthropic/claude-haiku-4-5`       | Trivial tasks - single file changes, typo fixes, simple modifications|
 | `unspecified-low`    | `anthropic/claude-sonnet-4-5`      | Tasks that don't fit other categories, low effort required           |
 | `unspecified-high`   | `anthropic/claude-opus-4-6` (max)  | Tasks that don't fit other categories, high effort required          |
-| `writing`            | `kimi-for-coding/k2p5`             | Documentation, prose, technical writing                              |
+| `writing`            | `google/gemini-3-flash-preview`    | Documentation, prose, technical writing                              |
 
 ### ⚠️ Critical: Model Resolution Priority
 
@@ -766,19 +765,15 @@ All 8 categories come with optimal model defaults, but **you must configure them
 {
   "categories": {
     "visual-engineering": { 
-      "model": "google/gemini-3-pro"
+      "model": "google/gemini-3-pro-preview"
     },
     "ultrabrain": { 
       "model": "openai/gpt-5.3-codex",
       "variant": "xhigh"
     },
-    "deep": {
-      "model": "openai/gpt-5.3-codex",
-      "variant": "medium"
-    },
     "artistry": { 
-      "model": "google/gemini-3-pro",
-      "variant": "high"
+      "model": "google/gemini-3-pro-preview",
+      "variant": "max"
     },
     "quick": { 
       "model": "anthropic/claude-haiku-4-5"  // Fast + cheap for trivial tasks
@@ -791,7 +786,7 @@ All 8 categories come with optimal model defaults, but **you must configure them
       "variant": "max"
     },
     "writing": { 
-      "model": "kimi-for-coding/k2p5"
+      "model": "google/gemini-3-flash-preview"
     }
   }
 }
@@ -899,16 +894,15 @@ Each agent has a defined provider priority chain. The system tries providers in
 
 | Agent | Model (no prefix) | Provider Priority Chain |
 |-------|-------------------|-------------------------|
-| **Sisyphus** | `claude-opus-4-6` | anthropic/github-copilot/opencode → kimi-for-coding → opencode → zai-coding-plan → opencode |
-| **Hephaestus** | `gpt-5.3-codex` | openai/github-copilot/opencode (requires provider) |
-| **oracle** | `gpt-5.2` | openai/github-copilot/opencode → google/github-copilot/opencode → anthropic/github-copilot/opencode |
-| **librarian** | `glm-4.7` | zai-coding-plan → opencode → anthropic/github-copilot/opencode |
-| **explore** | `grok-code-fast-1` | github-copilot → anthropic/opencode → opencode |
-| **multimodal-looker** | `gemini-3-flash` | google/github-copilot/opencode → openai/github-copilot/opencode → zai-coding-plan → kimi-for-coding → opencode → anthropic/github-copilot/opencode → opencode |
-| **Prometheus (Planner)** | `claude-opus-4-6` | anthropic/github-copilot/opencode → kimi-for-coding → opencode → openai/github-copilot/opencode → google/github-copilot/opencode |
-| **Metis (Plan Consultant)** | `claude-opus-4-6` | anthropic/github-copilot/opencode → kimi-for-coding → opencode → openai/github-copilot/opencode → google/github-copilot/opencode |
-| **Momus (Plan Reviewer)** | `gpt-5.2` | openai/github-copilot/opencode → anthropic/github-copilot/opencode → google/github-copilot/opencode |
-| **Atlas** | `k2p5` | kimi-for-coding → opencode → anthropic/github-copilot/opencode → openai/github-copilot/opencode → google/github-copilot/opencode |
+| **Sisyphus** | `claude-opus-4-6` | anthropic → kimi-for-coding → zai-coding-plan → openai → google |
+| **oracle** | `gpt-5.2` | openai → google → anthropic |
+| **librarian** | `glm-4.7` | zai-coding-plan → opencode → anthropic |
+| **explore** | `claude-haiku-4-5` | anthropic → github-copilot → opencode |
+| **multimodal-looker** | `gemini-3-flash` | google → openai → zai-coding-plan → kimi-for-coding → anthropic → opencode |
+| **Prometheus (Planner)** | `claude-opus-4-6` | anthropic → kimi-for-coding → openai → google |
+| **Metis (Plan Consultant)** | `claude-opus-4-6` | anthropic → kimi-for-coding → openai → google |
+| **Momus (Plan Reviewer)** | `gpt-5.2` | openai → anthropic → google |
+| **Atlas** | `claude-sonnet-4-5` | anthropic → kimi-for-coding → openai → google |
 
 ### Category Provider Chains
 
@@ -916,14 +910,14 @@ Categories follow the same resolution logic:
 
 | Category | Model (no prefix) | Provider Priority Chain |
 |----------|-------------------|-------------------------|
-| **visual-engineering** | `gemini-3-pro` | google/github-copilot/opencode → zai-coding-plan → anthropic/github-copilot/opencode → kimi-for-coding |
-| **ultrabrain** | `gpt-5.3-codex` | openai/github-copilot/opencode → google/github-copilot/opencode → anthropic/github-copilot/opencode |
-| **deep** | `gpt-5.3-codex` | openai/github-copilot/opencode → anthropic/github-copilot/opencode → google/github-copilot/opencode |
-| **artistry** | `gemini-3-pro` | google/github-copilot/opencode → anthropic/github-copilot/opencode → openai/github-copilot/opencode |
-| **quick** | `claude-haiku-4-5` | anthropic/github-copilot/opencode → google/github-copilot/opencode → opencode |
-| **unspecified-low** | `claude-sonnet-4-5` | anthropic/github-copilot/opencode → openai/github-copilot/opencode → google/github-copilot/opencode |
-| **unspecified-high** | `claude-opus-4-6` | anthropic/github-copilot/opencode → openai/github-copilot/opencode → google/github-copilot/opencode |
-| **writing** | `k2p5` | kimi-for-coding → google/github-copilot/opencode → anthropic/github-copilot/opencode |
+| **visual-engineering** | `gemini-3-pro` | google → anthropic → zai-coding-plan |
+| **ultrabrain** | `gpt-5.3-codex` | openai → google → anthropic |
+| **deep** | `gpt-5.3-codex` | openai → anthropic → google |
+| **artistry** | `gemini-3-pro` | google → anthropic → openai |
+| **quick** | `claude-haiku-4-5` | anthropic → google → opencode |
+| **unspecified-low** | `claude-sonnet-4-5` | anthropic → openai → google |
+| **unspecified-high** | `claude-opus-4-6` | anthropic → openai → google |
+| **writing** | `gemini-3-flash` | google → anthropic → zai-coding-plan → openai |
 
 ### Checking Your Configuration
 

docs/features.md

@@ -10,20 +10,20 @@ Oh-My-OpenCode provides 11 specialized AI agents. Each has distinct expertise, o
 
 | Agent | Model | Purpose |
 |-------|-------|---------|
-| **Sisyphus** | `anthropic/claude-opus-4-6` | **The default orchestrator.** Plans, delegates, and executes complex tasks using specialized subagents with aggressive parallel execution. Todo-driven workflow with extended thinking (32k budget). Fallback: k2p5 → kimi-k2.5-free → glm-4.7 → glm-4.7-free. |
+| **Sisyphus** | `anthropic/claude-opus-4-6` | **The default orchestrator.** Plans, delegates, and executes complex tasks using specialized subagents with aggressive parallel execution. Todo-driven workflow with extended thinking (32k budget). Fallback: kimi-k2.5 → glm-4.7 → gpt-5.3-codex → gemini-3-pro. |
 | **Hephaestus** | `openai/gpt-5.3-codex` | **The Legitimate Craftsman.** Autonomous deep worker inspired by AmpCode's deep mode. Goal-oriented execution with thorough research before action. Explores codebase patterns, completes tasks end-to-end without premature stopping. Named after the Greek god of forge and craftsmanship. Requires gpt-5.3-codex (no fallback - only activates when this model is available). |
 | **oracle** | `openai/gpt-5.2` | Architecture decisions, code review, debugging. Read-only consultation - stellar logical reasoning and deep analysis. Inspired by AmpCode. |
 | **librarian** | `zai-coding-plan/glm-4.7` | Multi-repo analysis, documentation lookup, OSS implementation examples. Deep codebase understanding with evidence-based answers. Fallback: glm-4.7-free → claude-sonnet-4-5. |
-| **explore** | `github-copilot/grok-code-fast-1` | Fast codebase exploration and contextual grep. Fallback: claude-haiku-4-5 → gpt-5-nano. |
-| **multimodal-looker** | `google/gemini-3-flash` | Visual content specialist. Analyzes PDFs, images, diagrams to extract information. Fallback: gpt-5.2 → glm-4.6v → k2p5 → kimi-k2.5-free → claude-haiku-4-5 → gpt-5-nano. |
+| **explore** | `anthropic/claude-haiku-4-5` | Fast codebase exploration and contextual grep. Fallback: gpt-5-mini → gpt-5-nano. |
+| **multimodal-looker** | `google/gemini-3-flash` | Visual content specialist. Analyzes PDFs, images, diagrams to extract information. Fallback: gpt-5.2 → glm-4.6v → kimi-k2.5 → claude-haiku-4-5 → gpt-5-nano. |
 
 ### Planning Agents
 
 | Agent | Model | Purpose |
 |-------|-------|---------|
-| **Prometheus** | `anthropic/claude-opus-4-6` | Strategic planner with interview mode. Creates detailed work plans through iterative questioning. Fallback: k2p5 → kimi-k2.5-free → gpt-5.2 → gemini-3-pro. |
-| **Metis** | `anthropic/claude-opus-4-6` | Plan consultant - pre-planning analysis. Identifies hidden intentions, ambiguities, and AI failure points. Fallback: k2p5 → kimi-k2.5-free → gpt-5.2 → gemini-3-pro. |
-| **Momus** | `openai/gpt-5.2` | Plan reviewer - validates plans against clarity, verifiability, and completeness standards. Fallback: claude-opus-4-6 → gemini-3-pro. |
+| **Prometheus** | `anthropic/claude-opus-4-6` | Strategic planner with interview mode. Creates detailed work plans through iterative questioning. Fallback: kimi-k2.5 → gpt-5.2 → gemini-3-pro. |
+| **Metis** | `anthropic/claude-opus-4-6` | Plan consultant - pre-planning analysis. Identifies hidden intentions, ambiguities, and AI failure points. Fallback: kimi-k2.5 → gpt-5.2 → gemini-3-pro. |
+| **Momus** | `openai/gpt-5.2` | Plan reviewer - validates plans against clarity, verifiability, and completeness standards. Fallback: gpt-5.2 → claude-opus-4-6 → gemini-3-pro. |
 
 ### Invoking Agents
 

docs/guide/installation.md

@@ -196,7 +196,7 @@ When GitHub Copilot is the best available provider, oh-my-opencode uses these mo
 
 | Agent         | Model                            |
 | ------------- | -------------------------------- |
-| **Sisyphus**  | `github-copilot/claude-opus-4-6` |
+| **Sisyphus**  | `github-copilot/claude-opus-4.6` |
 | **Oracle**    | `github-copilot/gpt-5.2`         |
 | **Explore**   | `opencode/gpt-5-nano`              |
 | **Librarian** | `zai-coding-plan/glm-4.7` (if Z.ai available) or fallback |
@@ -292,7 +292,7 @@ gh api --silent --method PUT /user/starred/code-yeongyu/oh-my-opencode >/dev/nul
 
 Tell the user of following:
 
-1. **Sisyphus agent strongly recommends Opus 4.6 model. Using other models may result in significantly degraded experience.**
+1. **Sisyphus agent strongly recommends Opus 4.5 model. Using other models may result in significantly degraded experience.**
 
 2. **Feeling lazy?** Just include `ultrawork` (or `ulw`) in your prompt. That's it. The agent figures out the rest.
 

docs/guide/overview.md

@@ -6,7 +6,7 @@ Learn about Oh My OpenCode, a plugin that transforms OpenCode into the best agen
 
 ## TL;DR
 
-> **Sisyphus agent strongly recommends Opus 4.6 model. Using other models may result in significantly degraded experience.**
+> **Sisyphus agent strongly recommends Opus 4.5 model. Using other models may result in significantly degraded experience.**
 
 **Feeling lazy?** Just include `ultrawork` (or `ulw`) in your prompt. That's it. The agent figures out the rest.
 

docs/guide/understanding-orchestration-system.md

@@ -23,13 +23,13 @@ The orchestration system solves these problems through **specialization and dele
 flowchart TB
     subgraph Planning["Planning Layer (Human + Prometheus)"]
         User[("👤 User")]
-        Prometheus["🔥 Prometheus<br/>(Planner)<br/>Claude Opus 4.6"]
-        Metis["🦉 Metis<br/>(Consultant)<br/>Claude Opus 4.6"]
+        Prometheus["🔥 Prometheus<br/>(Planner)<br/>Claude Opus 4.5"]
+        Metis["🦉 Metis<br/>(Consultant)<br/>Claude Opus 4.5"]
         Momus["👁️ Momus<br/>(Reviewer)<br/>GPT-5.2"]
     end
     
     subgraph Execution["Execution Layer (Orchestrator)"]
-        Orchestrator["⚡ Atlas<br/>(Conductor)<br/>K2P5 (Kimi)"]
+        Orchestrator["⚡ Atlas<br/>(Conductor)<br/>Claude Opus 4.5"]
     end
     
     subgraph Workers["Worker Layer (Specialized Agents)"]
@@ -294,13 +294,12 @@ task(category="quick", prompt="...")          // "Just get it done fast"
 | Category | Model | When to Use |
 |----------|-------|-------------|
 | `visual-engineering` | Gemini 3 Pro | Frontend, UI/UX, design, styling, animation |
-| `ultrabrain` | GPT-5.3 Codex (xhigh) | Deep logical reasoning, complex architecture decisions |
+| `ultrabrain` | GPT-5.2 Codex (xhigh) | Deep logical reasoning, complex architecture decisions |
 | `artistry` | Gemini 3 Pro (max) | Highly creative/artistic tasks, novel ideas |
 | `quick` | Claude Haiku 4.5 | Trivial tasks - single file changes, typo fixes |
-| `deep` | GPT-5.3 Codex (medium) | Goal-oriented autonomous problem-solving, thorough research |
 | `unspecified-low` | Claude Sonnet 4.5 | Tasks that don't fit other categories, low effort |
-| `unspecified-high` | Claude Opus 4.6 (max) | Tasks that don't fit other categories, high effort |
-| `writing` | K2P5 (Kimi) | Documentation, prose, technical writing |
+| `unspecified-high` | Claude Opus 4.5 (max) | Tasks that don't fit other categories, high effort |
+| `writing` | Gemini 3 Flash | Documentation, prose, technical writing |
 
 ### Custom Categories
 

docs/orchestration-guide.md

@@ -160,7 +160,7 @@ Another common question: **When should I use Hephaestus vs just typing `ulw` in
 
 | Aspect | Hephaestus | Sisyphus + `ulw` / `ultrawork` |
 |--------|-----------|-------------------------------|
-| **Model** | GPT-5.3 Codex (medium reasoning) | Claude Opus 4.6 (your default) |
+| **Model** | GPT-5.2 Codex (medium reasoning) | Claude Opus 4.5 (your default) |
 | **Approach** | Autonomous deep worker | Keyword-activated ultrawork mode |
 | **Best For** | Complex architectural work, deep reasoning | General complex tasks, "just do it" scenarios |
 | **Planning** | Self-plans during execution | Uses Prometheus plans if available |
@@ -183,8 +183,8 @@ Switch to Hephaestus (Tab → Select Hephaestus) when:
    - "Integrate our Rust core with the TypeScript frontend"
    - "Migrate from MongoDB to PostgreSQL with zero downtime"
 
-4. **You specifically want GPT-5.3 Codex reasoning**
-   - Some problems benefit from GPT-5.3 Codex's training characteristics
+4. **You specifically want GPT-5.2 Codex reasoning**
+   - Some problems benefit from GPT-5.2's training characteristics
 
 **Example:**
 ```
@@ -231,7 +231,7 @@ Use the `ulw` keyword in Sisyphus when:
 | Hephaestus | Sisyphus + ulw |
 |------------|----------------|
 | You manually switch to Hephaestus agent | You type `ulw` in any Sisyphus session |
-| GPT-5.3 Codex with medium reasoning | Your configured default model |
+| GPT-5.2 Codex with medium reasoning | Your configured default model |
 | Optimized for autonomous deep work | Optimized for general execution |
 | Always uses explore-first approach | Respects existing plans if available |
 | "Smart intern that needs no supervision" | "Smart intern that follows your workflow" |
@@ -240,7 +240,7 @@ Use the `ulw` keyword in Sisyphus when:
 
 **For most users**: Use `ulw` keyword in Sisyphus. It's the default path and works excellently for 90% of complex tasks.
 
-**For power users**: Switch to Hephaestus when you specifically need GPT-5.3 Codex's reasoning style or want the "AmpCode deep mode" experience of fully autonomous exploration and execution.
+**For power users**: Switch to Hephaestus when you specifically need GPT-5.2 Codex's reasoning style or want the "AmpCode deep mode" experience of fully autonomous exploration and execution.
 
 ---
 
@@ -354,7 +354,7 @@ Press `Tab` at the prompt to see available agents:
 |-------|---------------|
 | **Prometheus** | You want to create a detailed work plan |
 | **Atlas** | You want to manually control plan execution (rare) |
-| **Hephaestus** | You need GPT-5.3 Codex for deep autonomous work |
+| **Hephaestus** | You need GPT-5.2 Codex for deep autonomous work |
 | **Sisyphus** | Return to default agent for normal prompting |
 
 ---
@@ -421,4 +421,4 @@ Type `exit` or start a new session. Atlas is primarily entered via `/start-work`
 
 **For most tasks**: Type `ulw` in Sisyphus.
 
-**Use Hephaestus when**: You specifically need GPT-5.3 Codex's reasoning style for deep architectural work or complex debugging.
+**Use Hephaestus when**: You specifically need GPT-5.2 Codex's reasoning style for deep architectural work or complex debugging.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "3.7.2",
+  "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.7.2",
-    "oh-my-opencode-darwin-x64": "3.7.2",
-    "oh-my-opencode-linux-arm64": "3.7.2",
-    "oh-my-opencode-linux-arm64-musl": "3.7.2",
-    "oh-my-opencode-linux-x64": "3.7.2",
-    "oh-my-opencode-linux-x64-musl": "3.7.2",
-    "oh-my-opencode-windows-x64": "3.7.2"
+    "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.7.2",
+  "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.7.2",
+  "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.7.2",
+  "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.7.2",
+  "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.7.2",
+  "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.7.2",
+  "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.7.2",
+  "version": "3.5.3",
   "description": "Platform-specific binary for oh-my-opencode (windows-x64)",
   "license": "MIT",
   "repository": {

signatures/cla.json

@@ -1471,78 +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
-    },
-    {
-      "name": "feelsodev",
-      "id": 59601439,
-      "comment_id": 3914425492,
-      "created_at": "2026-02-17T12:24:00Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 1917
-    },
-    {
-      "name": "rentiansheng",
-      "id": 3955934,
-      "comment_id": 3914953522,
-      "created_at": "2026-02-17T14:18:29Z",
-      "repoId": 1108837393,
-      "pullRequestNo": 1889
     }
   ]
 }

src/AGENTS.md

@@ -1,41 +1,80 @@
-# src/ — Plugin Source
-
-**Generated:** 2026-02-18
+# SRC KNOWLEDGE BASE
 
 ## OVERVIEW
 
-Root source directory. Entry point `index.ts` orchestrates 4-step initialization: config → managers → tools → hooks → plugin interface.
-
-## KEY FILES
-
-| File | Purpose |
-|------|---------|
-| `index.ts` | Plugin entry, exports `OhMyOpenCodePlugin` |
-| `plugin-config.ts` | JSONC parse, multi-level merge (user → project → defaults), Zod validation |
-| `create-managers.ts` | TmuxSessionManager, BackgroundManager, SkillMcpManager, ConfigHandler |
-| `create-tools.ts` | SkillContext + AvailableCategories + ToolRegistry |
-| `create-hooks.ts` | 3-tier hook composition: Core(35) + Continuation(7) + Skill(2) |
-| `plugin-interface.ts` | Assembles 8 OpenCode hook handlers into PluginInterface |
-
-## CONFIG LOADING
+Main plugin entry point and orchestration layer. Plugin initialization, hook registration, tool composition, and lifecycle management.
 
+## STRUCTURE
 ```
-loadPluginConfig(directory, ctx)
-  1. User: ~/.config/opencode/oh-my-opencode.jsonc
-  2. Project: .opencode/oh-my-opencode.jsonc
-  3. mergeConfigs(user, project) → deepMerge for agents/categories, Set union for disabled_*
-  4. Zod safeParse → defaults for omitted fields
-  5. migrateConfigFile() → legacy key transformation
+src/
+├── 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)
+├── 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 (84 files) - see shared/AGENTS.md
+└── tools/                            # 25+ tools (14 dirs) - see tools/AGENTS.md
 ```
 
-## HOOK COMPOSITION
+## PLUGIN INITIALIZATION (10 steps)
 
+1. `injectServerAuthIntoClient(ctx.client)` — Auth injection
+2. `startTmuxCheck()` — Tmux availability
+3. `loadPluginConfig(ctx.directory, ctx)` — User + project config merge → Zod validation
+4. `createFirstMessageVariantGate()` — First message variant override gate
+5. `createModelCacheState()` — Model context limits cache
+6. `createManagers(...)` → 4 managers:
+   - `TmuxSessionManager` — Multi-pane tmux sessions
+   - `BackgroundManager` — Parallel subagent execution
+   - `SkillMcpManager` — MCP server lifecycle
+   - `ConfigHandler` — Plugin config API to OpenCode
+7. `createTools(...)` → `createSkillContext()` + `createAvailableCategories()` + `createToolRegistry()`
+8. `createHooks(...)` → `createCoreHooks()` + `createContinuationHooks()` + `createSkillHooks()`
+9. `createPluginInterface(...)` → 7 OpenCode hook handlers
+10. Return plugin with `experimental.session.compacting`
+
+## HOOK REGISTRATION (3 tiers)
+
+**Core Hooks** (`create-core-hooks.ts`):
+- Session (20): context-window-monitor, session-recovery, think-mode, ralph-loop, anthropic-effort, ...
+- Tool Guard (8): comment-checker, tool-output-truncator, rules-injector, write-existing-file-guard, ...
+- Transform (4): claude-code-hooks, keyword-detector, context-injector, thinking-block-validator
+
+**Continuation Hooks** (`create-continuation-hooks.ts`):
+- 7 hooks: stop-continuation-guard, compaction-context-injector, todo-continuation-enforcer, atlas, ...
+
+**Skill Hooks** (`create-skill-hooks.ts`):
+- 2 hooks: category-skill-reminder, auto-slash-command
+
+## PLUGIN INTERFACE (7 OpenCode handlers)
+
+| Handler | Source | Purpose |
+|---------|--------|---------|
+| `tool` | filteredTools | All registered tools |
+| `chat.params` | createChatParamsHandler | Anthropic effort level |
+| `chat.message` | createChatMessageHandler | First message variant, session setup |
+| `experimental.chat.messages.transform` | createMessagesTransformHandler | Context injection, keyword detection |
+| `config` | configHandler | Agent/MCP/command registration |
+| `event` | createEventHandler | Session lifecycle |
+| `tool.execute.before` | createToolExecuteBeforeHandler | Pre-tool hooks |
+| `tool.execute.after` | createToolExecuteAfterHandler | Post-tool hooks |
+
+## SAFE HOOK CREATION PATTERN
+
+```typescript
+const hook = isHookEnabled("hook-name")
+  ? safeCreateHook("hook-name", () => createHookFactory(ctx), { enabled: safeHookEnabled })
+  : null;
 ```
-createHooks()
-  ├─→ createCoreHooks()           # 35 hooks
-  │   ├─ createSessionHooks()     # 22: contextWindowMonitor, thinkMode, ralphLoop, sessionRecovery, jsonErrorRecovery, sisyphusGptHephaestusReminder, taskReminder...
-  │   ├─ createToolGuardHooks()   # 9: commentChecker, rulesInjector, writeExistingFileGuard...
-  │   └─ createTransformHooks()   # 4: claudeCodeHooks, keywordDetector, contextInjector, thinkingBlockValidator
-  ├─→ createContinuationHooks()   # 7: todoContinuationEnforcer, atlas, stopContinuationGuard...
-  └─→ createSkillHooks()          # 2: categorySkillReminder, autoSlashCommand
-```
+
+All hooks use this pattern for graceful degradation on failure.

src/agents/AGENTS.md

@@ -1,79 +1,100 @@
-# src/agents/ — 11 Agent Definitions
-
-**Generated:** 2026-02-17
+# AGENTS KNOWLEDGE BASE
 
 ## OVERVIEW
 
-Agent factories following `createXXXAgent(model) → AgentConfig` pattern. Each has static `mode` property. Built via `buildAgent()` compositing factory + categories + skills.
+11 AI agents with factory functions, fallback chains, and model-specific prompt variants. Each agent has metadata (category, cost, triggers) and configurable tool restrictions.
 
-## AGENT INVENTORY
+## STRUCTURE
+```
+agents/
+├── 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                # 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
+└── index.ts                    # Exports
+```
 
-| Agent | Model | Temp | Mode | Fallback Chain | Purpose |
-|-------|-------|------|------|----------------|---------|
-| **Sisyphus** | claude-opus-4-6 | 0.1 | primary | kimi-k2.5 → glm-4.7 → gemini-3-pro | Main orchestrator, plans + delegates |
-| **Hephaestus** | gpt-5.3-codex | 0.1 | primary | NONE (required) | Autonomous deep worker |
-| **Oracle** | gpt-5.2 | 0.1 | subagent | claude-opus-4-6 → gemini-3-pro | Read-only consultation |
-| **Librarian** | glm-4.7 | 0.1 | subagent | glm-4.7-free → claude-sonnet-4-5 | External docs/code search |
-| **Explore** | grok-code-fast-1 | 0.1 | subagent | claude-haiku-4-5 → gpt-5-nano | Contextual grep |
-| **Multimodal-Looker** | gemini-3-flash | 0.1 | subagent | gpt-5.2 → glm-4.6v → ... (6 deep) | PDF/image analysis |
-| **Metis** | claude-opus-4-6 | **0.3** | subagent | kimi-k2.5 → gpt-5.2 → gemini-3-pro | Pre-planning consultant |
-| **Momus** | gpt-5.2 | 0.1 | subagent | claude-opus-4-6 → gemini-3-pro | Plan reviewer |
-| **Atlas** | claude-sonnet-4-5 | 0.1 | primary | kimi-k2.5 → gpt-5.2 → gemini-3-pro | Todo-list orchestrator |
-| **Prometheus** | claude-opus-4-6 | 0.1 | — | kimi-k2.5 → gpt-5.2 → gemini-3-pro | Strategic planner (internal) |
-| **Sisyphus-Junior** | claude-sonnet-4-5 | 0.1 | all | user-configurable | Category-spawned executor |
+## AGENT MODELS
+
+| Agent | Model | Temp | Fallback Chain | Cost |
+|-------|-------|------|----------------|------|
+| Sisyphus | claude-opus-4-6 | 0.1 | kimi-k2.5 → glm-4.7 → gpt-5.3-codex → gemini-3-pro | EXPENSIVE |
+| Hephaestus | gpt-5.3-codex | 0.1 | NONE (required) | EXPENSIVE |
+| Atlas | claude-sonnet-4-5 | 0.1 | kimi-k2.5 → gpt-5.2 | EXPENSIVE |
+| Prometheus | claude-opus-4-6 | 0.1 | kimi-k2.5 → gpt-5.2 | EXPENSIVE |
+| oracle | gpt-5.2 | 0.1 | claude-opus-4-6 | EXPENSIVE |
+| librarian | glm-4.7 | 0.1 | glm-4.7-free | CHEAP |
+| explore | grok-code-fast-1 | 0.1 | claude-haiku-4-5 → gpt-5-mini → gpt-5-nano | FREE |
+| multimodal-looker | gemini-3-flash | 0.1 | NONE | CHEAP |
+| Metis | claude-opus-4-6 | 0.3 | kimi-k2.5 → gpt-5.2 | EXPENSIVE |
+| Momus | gpt-5.2 | 0.1 | claude-opus-4-6 | EXPENSIVE |
+| Sisyphus-Junior | claude-sonnet-4-5 | 0.1 | (user-configurable) | EXPENSIVE |
 
 ## TOOL RESTRICTIONS
 
-| Agent | Denied Tools |
-|-------|-------------|
-| Oracle | write, edit, task, call_omo_agent |
-| Librarian | write, edit, task, call_omo_agent |
-| Explore | write, edit, task, call_omo_agent |
-| Multimodal-Looker | ALL except read |
-| Atlas | task, call_omo_agent |
-| Momus | write, edit, task |
+| Agent | Denied | Allowed |
+|-------|--------|---------|
+| oracle | write, edit, task, call_omo_agent | Read-only consultation |
+| librarian | write, edit, task, call_omo_agent | Research tools only |
+| explore | write, edit, task, call_omo_agent | Search tools only |
+| multimodal-looker | ALL except `read` | Vision-only |
+| Sisyphus-Junior | task | No delegation |
+| Atlas | task, call_omo_agent | Orchestration only |
 
-## STRUCTURE
+## THINKING / REASONING
 
-```
-agents/
-├── sisyphus.ts            # 559 LOC, main orchestrator
-├── hephaestus.ts          # 507 LOC, autonomous worker
-├── oracle.ts              # Read-only consultant
-├── librarian.ts           # External search
-├── explore.ts             # Codebase grep
-├── multimodal-looker.ts   # Vision/PDF
-├── metis.ts               # Pre-planning
-├── momus.ts               # Plan review
-├── atlas/agent.ts         # Todo orchestrator
-├── types.ts               # AgentFactory, AgentMode
-├── agent-builder.ts       # buildAgent() composition
-├── utils.ts               # Agent utilities
-├── builtin-agents.ts      # createBuiltinAgents() registry
-└── builtin-agents/        # maybeCreateXXXConfig conditional factories
-    ├── sisyphus-agent.ts
-    ├── hephaestus-agent.ts
-    ├── atlas-agent.ts
-    ├── general-agents.ts  # collectPendingBuiltinAgents
-    └── available-skills.ts
-```
+| Agent | Claude | GPT |
+|-------|--------|-----|
+| Sisyphus | 32k budget tokens | reasoningEffort: "medium" |
+| Hephaestus | — | reasoningEffort: "medium" |
+| Oracle | 32k budget tokens | reasoningEffort: "medium" |
+| Metis | 32k budget tokens | — |
+| Momus | 32k budget tokens | reasoningEffort: "medium" |
+| Sisyphus-Junior | 32k budget tokens | reasoningEffort: "medium" |
 
-## FACTORY PATTERN
+## HOW TO ADD
 
-```typescript
-const createXXXAgent: AgentFactory = (model: string) => ({
-  instructions: "...",
-  model,
-  temperature: 0.1,
-  // ...config
-})
-createXXXAgent.mode = "subagent" // or "primary" or "all"
-```
+1. Create `src/agents/my-agent.ts` exporting factory + metadata
+2. Add to `agentSources` in `src/agents/builtin-agents/`
+3. Update `AgentNameSchema` in `src/config/schema/agent-names.ts`
+4. Register in `src/plugin-handlers/agent-config-handler.ts`
 
-Model resolution: `AGENT_MODEL_REQUIREMENTS` in `shared/model-requirements.ts` defines fallback chains per agent.
+## KEY PATTERNS
 
-## MODES
+- **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
 
-- **primary**: Respects UI-selected model, uses fallback chain
-- **subagent**: Uses own fallback chain, ignores UI selection
-- **all**: Available in both contexts (Sisyphus-Junior)
+## ANTI-PATTERNS
+
+- **Trust agent self-reports**: NEVER — always verify outputs
+- **High temperature**: Don't use >0.3 for code agents
+- **Sequential calls**: Use `task` with `run_in_background` for exploration
+- **Prometheus writing code**: Planner only — never implements

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.test.ts

@@ -64,8 +64,8 @@ describe("buildCategorySkillsDelegationGuide", () => {
     const result = buildCategorySkillsDelegationGuide(categories, allSkills)
 
     //#then: should show source for each custom skill
-    expect(result).toContain("(user)")
-    expect(result).toContain("(project)")
+    expect(result).toContain("| user |")
+    expect(result).toContain("| project |")
   })
 
   it("should not show custom skill section when only builtin skills exist", () => {

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

@@ -87,9 +87,12 @@ export function buildToolSelectionTable(
     "",
   ]
 
+  rows.push("| Resource | Cost | When to Use |")
+  rows.push("|----------|------|-------------|")
+
   if (tools.length > 0) {
     const toolsDisplay = formatToolsForPrompt(tools)
-    rows.push(`- ${toolsDisplay} — **FREE** — Not Complex, Scope Clear, No Implicit Assumptions`)
+    rows.push(`| ${toolsDisplay} | FREE | Not Complex, Scope Clear, No Implicit Assumptions |`)
   }
 
   const costOrder = { FREE: 0, CHEAP: 1, EXPENSIVE: 2 }
@@ -99,7 +102,7 @@ export function buildToolSelectionTable(
 
   for (const agent of sortedAgents) {
     const shortDesc = agent.description.split(".")[0] || agent.description
-    rows.push(`- \`${agent.name}\` agent — **${agent.metadata.cost}** — ${shortDesc}`)
+    rows.push(`| \`${agent.name}\` agent | ${agent.metadata.cost} | ${shortDesc} |`)
   }
 
   rows.push("")
@@ -119,11 +122,10 @@ export function buildExploreSection(agents: AvailableAgent[]): string {
 
 Use it as a **peer tool**, not a fallback. Fire liberally.
 
-**Use Direct Tools when:**
-${avoidWhen.map((w) => `- ${w}`).join("\n")}
-
-**Use Explore Agent when:**
-${useWhen.map((w) => `- ${w}`).join("\n")}`
+| Use Direct Tools | Use Explore Agent |
+|------------------|-------------------|
+${avoidWhen.map((w) => `| ${w} |  |`).join("\n")}
+${useWhen.map((w) => `|  | ${w} |`).join("\n")}`
 }
 
 export function buildLibrarianSection(agents: AvailableAgent[]): string {
@@ -136,8 +138,14 @@ export function buildLibrarianSection(agents: AvailableAgent[]): string {
 
 Search **external references** (docs, OSS, web). Fire proactively when unfamiliar libraries are involved.
 
-**Contextual Grep (Internal)** — search OUR codebase, find patterns in THIS repo, project-specific logic.
-**Reference Grep (External)** — search EXTERNAL resources, official API docs, library best practices, OSS implementation examples.
+| Contextual Grep (Internal) | Reference Grep (External) |
+|----------------------------|---------------------------|
+| Search OUR codebase | Search EXTERNAL resources |
+| Find patterns in THIS repo | Find examples in OTHER repos |
+| How does our code work? | How does this library work? |
+| Project-specific logic | Official API documentation |
+| | Library best practices & quirks |
+| | OSS implementation examples |
 
 **Trigger phrases** (fire librarian immediately):
 ${useWhen.map((w) => `- "${w}"`).join("\n")}`
@@ -147,11 +155,13 @@ export function buildDelegationTable(agents: AvailableAgent[]): string {
   const rows: string[] = [
     "### Delegation Table:",
     "",
+    "| Domain | Delegate To | Trigger |",
+    "|--------|-------------|---------|",
   ]
 
   for (const agent of agents) {
     for (const trigger of agent.metadata.triggers) {
-      rows.push(`- **${trigger.domain}** → \`${agent.name}\` — ${trigger.trigger}`)
+      rows.push(`| ${trigger.domain} | \`${agent.name}\` | ${trigger.trigger} |`)
     }
   }
 
@@ -177,6 +187,8 @@ export function formatCustomSkillsBlock(
 **The user has installed these custom skills. They MUST be evaluated for EVERY delegation.**
 Subagents are STATELESS — they lose all custom knowledge unless you pass these skills via \`load_skills\`.
 
+| Skill | Expertise Domain | Source |
+|-------|------------------|--------|
 ${customRows.join("\n")}
 
 > **CRITICAL**: Ignoring user-installed skills when they match the task domain is a failure.
@@ -188,7 +200,7 @@ export function buildCategorySkillsDelegationGuide(categories: AvailableCategory
 
   const categoryRows = categories.map((c) => {
     const desc = c.description || c.name
-    return `- \`${c.name}\` — ${desc}`
+    return `| \`${c.name}\` | ${desc} |`
   })
 
   const builtinSkills = skills.filter((s) => s.location === "plugin")
@@ -196,13 +208,13 @@ export function buildCategorySkillsDelegationGuide(categories: AvailableCategory
 
    const builtinRows = builtinSkills.map((s) => {
      const desc = truncateDescription(s.description)
-     return `- \`${s.name}\` — ${desc}`
+     return `| \`${s.name}\` | ${desc} |`
    })
 
    const customRows = customSkills.map((s) => {
      const desc = truncateDescription(s.description)
      const source = s.location === "project" ? "project" : "user"
-     return `- \`${s.name}\` (${source}) — ${desc}`
+     return `| \`${s.name}\` | ${desc} | ${source} |`
    })
 
   const customSkillBlock = formatCustomSkillsBlock(customRows, customSkills)
@@ -212,6 +224,8 @@ export function buildCategorySkillsDelegationGuide(categories: AvailableCategory
   if (customSkills.length > 0 && builtinSkills.length > 0) {
     skillsSection = `#### Built-in Skills
 
+| Skill | Expertise Domain |
+|-------|------------------|
 ${builtinRows.join("\n")}
 
 ${customSkillBlock}`
@@ -222,6 +236,8 @@ ${customSkillBlock}`
 
 Skills inject specialized instructions into the subagent. Read the description to understand when each skill applies.
 
+| Skill | Expertise Domain |
+|-------|------------------|
 ${builtinRows.join("\n")}`
   }
 
@@ -233,6 +249,8 @@ ${builtinRows.join("\n")}`
 
 Each category is configured with a model optimized for that domain. Read the description to understand when to use it.
 
+| Category | Domain / Best For |
+|----------|-------------------|
 ${categoryRows.join("\n")}
 
 ${skillsSection}
@@ -304,9 +322,11 @@ export function buildOracleSection(agents: AvailableAgent[]): string {
 
 Oracle is a read-only, expensive, high-quality reasoning model for debugging and architecture. Consultation only.
 
-### WHEN to Consult (Oracle FIRST, then implement):
+### WHEN to Consult:
 
-${useWhen.map((w) => `- ${w}`).join("\n")}
+| Trigger | Action |
+|---------|--------|
+${useWhen.map((w) => `| ${w} | Oracle FIRST, then implement |`).join("\n")}
 
 ### WHEN NOT to Consult:
 
@@ -316,46 +336,37 @@ ${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:
-
-**You MUST collect Oracle results before your final answer. No exceptions.**
-
-- Oracle may take several minutes. This is normal and expected.
-- When Oracle is running and you finish your own exploration/analysis, your next action is \`background_output(task_id="...")\` on Oracle — NOT delivering a final answer.
-- Oracle catches blind spots you cannot see — its value is HIGHEST when you think you don't need it.
-- **NEVER** cancel Oracle. **NEVER** use \`background_cancel(all=true)\` when Oracle is running. Cancel disposable tasks (explore, librarian) individually by taskId instead.
 </Oracle_Usage>`
 }
 
 export function buildHardBlocksSection(): string {
   const blocks = [
-    "- Type error suppression (`as any`, `@ts-ignore`) — **Never**",
-    "- Commit without explicit request — **Never**",
-    "- Speculate about unread code — **Never**",
-    "- Leave code in broken state after failures — **Never**",
-    "- `background_cancel(all=true)` when Oracle is running — **Never.** Cancel tasks individually by taskId.",
-    "- Delivering final answer before collecting Oracle result — **Never.** Always `background_output` Oracle first.",
+    "| Type error suppression (`as any`, `@ts-ignore`) | Never |",
+    "| Commit without explicit request | Never |",
+    "| Speculate about unread code | Never |",
+    "| Leave code in broken state after failures | Never |",
   ]
 
   return `## Hard Blocks (NEVER violate)
 
+| Constraint | No Exceptions |
+|------------|---------------|
 ${blocks.join("\n")}`
 }
 
 export function buildAntiPatternsSection(): string {
   const patterns = [
-    "- **Type Safety**: `as any`, `@ts-ignore`, `@ts-expect-error`",
-    "- **Error Handling**: Empty catch blocks `catch(e) {}`",
-    "- **Testing**: Deleting failing tests to \"pass\"",
-    "- **Search**: Firing agents for single-line typos or obvious syntax errors",
-    "- **Debugging**: Shotgun debugging, random changes",
-    "- **Background Tasks**: `background_cancel(all=true)` — always cancel individually by taskId",
-    "- **Oracle**: Skipping Oracle results when Oracle was launched — ALWAYS collect via `background_output`",
+    "| **Type Safety** | `as any`, `@ts-ignore`, `@ts-expect-error` |",
+    "| **Error Handling** | Empty catch blocks `catch(e) {}` |",
+    "| **Testing** | Deleting failing tests to \"pass\" |",
+    "| **Search** | Firing agents for single-line typos or obvious syntax errors |",
+    "| **Debugging** | Shotgun debugging, random changes |",
   ]
 
   return `## Anti-Patterns (BLOCKING violations)
 
+| Category | Forbidden |
+|----------|-----------|
 ${patterns.join("\n")}`
 }
 

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,74 +152,43 @@ unblocking maximum parallelism in subsequent waves.
 
 **The plan can have 50+ TODOs. That's OK. ONE PLAN.**
 
-### 6.1 INCREMENTAL WRITE PROTOCOL (CRITICAL - Prevents Output Limit Stalls)
+### 5.1 SINGLE ATOMIC WRITE (CRITICAL - Prevents Content Loss)
 
 <write_protocol>
-**Write OVERWRITES. Never call Write twice on the same file.**
+**The Write tool OVERWRITES files. It does NOT append.**
 
-Plans with many tasks will exceed your output token limit if you try to generate everything at once.
-Split into: **one Write** (skeleton) + **multiple Edits** (tasks in batches).
+**MANDATORY PROTOCOL:**
+1. **Prepare ENTIRE plan content in memory FIRST**
+2. **Write ONCE with complete content**
+3. **NEVER split into multiple Write calls**
 
-**Step 1 — Write skeleton (all sections EXCEPT individual task details):**
+**IF plan is too large for single output:**
+1. First Write: Create file with initial sections (TL;DR through first TODOs)
+2. Subsequent: Use **Edit tool** to APPEND remaining sections
+   - Target the END of the file
+   - Edit replaces text, so include last line + new content
 
+**FORBIDDEN (causes content loss):**
 \`\`\`
-Write(".sisyphus/plans/{name}.md", content=\`
-# {Plan Title}
-
-## TL;DR
-> ...
-
-## Context
-...
-
-## Work Objectives
-...
-
-## Verification Strategy
-...
-
-## Execution Strategy
-...
-
----
-
-## TODOs
-
----
-
-## Final Verification Wave
-...
-
-## Commit Strategy
-...
-
-## Success Criteria
-...
-\`)
+❌ Write(".sisyphus/plans/x.md", "# Part 1...")  
+❌ Write(".sisyphus/plans/x.md", "# Part 2...")  // Part 1 is GONE!
 \`\`\`
 
-**Step 2 — Edit-append tasks in batches of 2-4:**
-
-Use Edit to insert each batch of tasks before the Final Verification section:
-
+**CORRECT (preserves content):**
 \`\`\`
-Edit(".sisyphus/plans/{name}.md",
-  oldString="---\\n\\n## Final Verification Wave",
-  newString="- [ ] 1. Task Title\\n\\n  **What to do**: ...\\n  **QA Scenarios**: ...\\n\\n- [ ] 2. Task Title\\n\\n  **What to do**: ...\\n  **QA Scenarios**: ...\\n\\n---\\n\\n## Final Verification Wave")
+✅ Write(".sisyphus/plans/x.md", "# Complete plan content...")  // Single write
+
+// OR if too large:
+✅ Write(".sisyphus/plans/x.md", "# Plan\n## TL;DR\n...")  // First chunk
+✅ Edit(".sisyphus/plans/x.md", oldString="---\n## Success Criteria", newString="---\n## More TODOs\n...\n---\n## Success Criteria")  // Append via Edit
 \`\`\`
 
-Repeat until all tasks are written. 2-4 tasks per Edit call balances speed and output limits.
-
-**Step 3 — Verify completeness:**
-
-After all Edits, Read the plan file to confirm all tasks are present and no content was lost.
-
-**FORBIDDEN:**
-- \`Write()\` twice to the same file — second call erases the first
-- Generating ALL tasks in a single Write — hits output limits, causes stalls
+**SELF-CHECK before Write:**
+- [ ] Is this the FIRST write to this file? → Write is OK
+- [ ] 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

@@ -37,10 +37,12 @@ function buildTaskManagementSection(useTaskSystem: boolean): string {
 
 ### When to Create Tasks (MANDATORY)
 
-- Multi-step task (2+ steps) → ALWAYS \`TaskCreate\` first
-- Uncertain scope → ALWAYS (tasks clarify thinking)
-- User request with multiple items → ALWAYS
-- Complex single task → \`TaskCreate\` to break down
+| Trigger | Action |
+|---------|--------|
+| Multi-step task (2+ steps) | ALWAYS \`TaskCreate\` first |
+| Uncertain scope | ALWAYS (tasks clarify thinking) |
+| User request with multiple items | ALWAYS |
+| Complex single task | \`TaskCreate\` to break down |
 
 ### Workflow (NON-NEGOTIABLE)
 
@@ -59,10 +61,12 @@ function buildTaskManagementSection(useTaskSystem: boolean): string {
 
 ### Anti-Patterns (BLOCKING)
 
-- Skipping tasks on multi-step tasks — user has no visibility, steps get forgotten
-- Batch-completing multiple tasks — defeats real-time tracking purpose
-- Proceeding without marking in_progress — no indication of what you're working on
-- Finishing without completing tasks — task appears incomplete to user
+| Violation | Why It's Bad |
+|-----------|--------------|
+| Skipping tasks on multi-step tasks | User has no visibility, steps get forgotten |
+| Batch-completing multiple tasks | Defeats real-time tracking purpose |
+| Proceeding without marking in_progress | No indication of what you're working on |
+| Finishing without completing tasks | Task appears incomplete to user |
 
 **FAILURE TO USE TASKS ON NON-TRIVIAL TASKS = INCOMPLETE WORK.**
 
@@ -91,10 +95,12 @@ Should I proceed with [recommendation], or would you prefer differently?
 
 ### When to Create Todos (MANDATORY)
 
-- Multi-step task (2+ steps) → ALWAYS create todos first
-- Uncertain scope → ALWAYS (todos clarify thinking)
-- User request with multiple items → ALWAYS
-- Complex single task → Create todos to break down
+| Trigger | Action |
+|---------|--------|
+| Multi-step task (2+ steps) | ALWAYS create todos first |
+| Uncertain scope | ALWAYS (todos clarify thinking) |
+| User request with multiple items | ALWAYS |
+| Complex single task | Create todos to break down |
 
 ### Workflow (NON-NEGOTIABLE)
 
@@ -113,10 +119,12 @@ Should I proceed with [recommendation], or would you prefer differently?
 
 ### Anti-Patterns (BLOCKING)
 
-- Skipping todos on multi-step tasks — user has no visibility, steps get forgotten
-- Batch-completing multiple todos — defeats real-time tracking purpose
-- Proceeding without marking in_progress — no indication of what you're working on
-- Finishing without completing todos — task appears incomplete to user
+| Violation | Why It's Bad |
+|-----------|--------------|
+| Skipping todos on multi-step tasks | User has no visibility, steps get forgotten |
+| Batch-completing multiple todos | Defeats real-time tracking purpose |
+| Proceeding without marking in_progress | No indication of what you're working on |
+| Finishing without completing todos | Task appears incomplete to user |
 
 **FAILURE TO USE TODOS ON NON-TRIVIAL TASKS = INCOMPLETE WORK.**
 
@@ -192,19 +200,23 @@ ${keyTriggers}
 
 ### Step 1: Classify Request Type
 
-- **Trivial** (single file, known location, direct answer) → Direct tools only (UNLESS Key Trigger applies)
-- **Explicit** (specific file/line, clear command) → Execute directly
-- **Exploratory** ("How does X work?", "Find Y") → Fire explore (1-3) + tools in parallel
-- **Open-ended** ("Improve", "Refactor", "Add feature") → Assess codebase first
-- **Ambiguous** (unclear scope, multiple interpretations) → Ask ONE clarifying question
+| Type | Signal | Action |
+|------|--------|--------|
+| **Trivial** | Single file, known location, direct answer | Direct tools only (UNLESS Key Trigger applies) |
+| **Explicit** | Specific file/line, clear command | Execute directly |
+| **Exploratory** | "How does X work?", "Find Y" | Fire explore (1-3) + tools in parallel |
+| **Open-ended** | "Improve", "Refactor", "Add feature" | Assess codebase first |
+| **Ambiguous** | Unclear scope, multiple interpretations | Ask ONE clarifying question |
 
 ### Step 2: Check for Ambiguity
 
-- Single valid interpretation → Proceed
-- Multiple interpretations, similar effort → Proceed with reasonable default, note assumption
-- Multiple interpretations, 2x+ effort difference → **MUST ask**
-- Missing critical info (file, error, context) → **MUST ask**
-- User's design seems flawed or suboptimal → **MUST raise concern** before implementing
+| Situation | Action |
+|-----------|--------|
+| Single valid interpretation | Proceed |
+| Multiple interpretations, similar effort | Proceed with reasonable default, note assumption |
+| Multiple interpretations, 2x+ effort difference | **MUST ask** |
+| Missing critical info (file, error, context) | **MUST ask** |
+| User's design seems flawed or suboptimal | **MUST raise concern** before implementing |
 
 ### Step 3: Validate Before Acting
 
@@ -247,10 +259,12 @@ Before following existing patterns, assess whether they're worth following.
 
 ### State Classification:
 
-- **Disciplined** (consistent patterns, configs present, tests exist) → Follow existing style strictly
-- **Transitional** (mixed patterns, some structure) → Ask: "I see X and Y patterns. Which to follow?"
-- **Legacy/Chaotic** (no consistency, outdated patterns) → Propose: "No clear conventions. I suggest [X]. OK?"
-- **Greenfield** (new/empty project) → Apply modern best practices
+| State | Signals | Your Behavior |
+|-------|---------|---------------|
+| **Disciplined** | Consistent patterns, configs present, tests exist | Follow existing style strictly |
+| **Transitional** | Mixed patterns, some structure | Ask: "I see X and Y patterns. Which to follow?" |
+| **Legacy/Chaotic** | No consistency, outdated patterns | Propose: "No clear conventions. I suggest [X]. OK?" |
+| **Greenfield** | New/empty project | Apply modern best practices |
 
 IMPORTANT: If codebase appears undisciplined, verify before assuming:
 - Different patterns may serve different purposes (intentional)
@@ -295,10 +309,8 @@ result = task(..., run_in_background=false)  // Never wait synchronously for exp
 ### Background Result Collection:
 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: \`background_cancel(taskId=\"bg_explore_xxx\")\`, \`background_cancel(taskId=\"bg_librarian_xxx\")\`
-5. **NEVER cancel Oracle.** ALWAYS collect Oracle result via \`background_output(task_id=\"bg_oracle_xxx\")\` before answering — even if you already have enough context.
-6. **NEVER use \`background_cancel(all=true)\`** — it kills Oracle. Cancel each disposable task by its specific taskId.
+3. When results needed: \`background_output(task_id="...")\`
+4. BEFORE final answer: \`background_cancel(all=true)\`
 
 ### Search Stop Conditions
 
@@ -350,10 +362,12 @@ AFTER THE WORK YOU DELEGATED SEEMS DONE, ALWAYS VERIFY THE RESULTS AS FOLLOWING:
 Every \`task()\` output includes a session_id. **USE IT.**
 
 **ALWAYS continue when:**
-- 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.\"\`
+| Scenario | Action |
+|----------|--------|
+| 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."\` |
 
 **Why session_id is CRITICAL:**
 - Subagent has FULL conversation context preserved
@@ -390,10 +404,12 @@ If project has build/test commands, run them at task completion.
 
 ### Evidence Requirements (task NOT complete without these):
 
-- **File edit** → \`lsp_diagnostics\` clean on changed files
-- **Build command** → Exit code 0
-- **Test run** → Pass (or explicit note of pre-existing failures)
-- **Delegation** → Agent result received and verified
+| Action | Required Evidence |
+|--------|-------------------|
+| File edit | \`lsp_diagnostics\` clean on changed files |
+| Build command | Exit code 0 |
+| Test run | Pass (or explicit note of pre-existing failures) |
+| Delegation | Agent result received and verified |
 
 **NO EVIDENCE = NOT COMPLETE.**
 
@@ -433,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=\"...\")\`
-- **NEVER use \`background_cancel(all=true)\`.** Always cancel individually by taskId.
-- **Always wait for Oracle**: When Oracle is running and you have gathered enough context from your own exploration, your next action is \`background_output\` on Oracle — NOT delivering a final answer. Oracle's value is highest when you think you don't need it.
+- 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

@@ -1,71 +1,72 @@
-# src/cli/ — CLI: install, run, doctor, mcp-oauth
-
-**Generated:** 2026-02-17
+# CLI KNOWLEDGE BASE
 
 ## OVERVIEW
 
-Commander.js CLI with 5 commands. Entry: `index.ts` → `runCli()` in `cli-program.ts`.
+CLI entry: `bunx oh-my-opencode`. 107+ files with Commander.js + @clack/prompts TUI.
+
+**Commands**: install, run, doctor, get-local-version, mcp-oauth
+
+## STRUCTURE
+```
+cli/
+├── index.ts                 # Entry point (5 lines)
+├── cli-program.ts           # Commander.js program (150+ lines, 5 commands)
+├── 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/          # 17 config utilities
+│   ├── add-plugin-to-opencode-config.ts  # Plugin registration
+│   ├── add-provider-config.ts            # Provider setup
+│   ├── detect-current-config.ts          # Project vs user config
+│   ├── write-omo-config.ts               # JSONC writing
+│   └── ...
+├── 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 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
+├── mcp-oauth/               # OAuth token management (login, logout, status)
+├── get-local-version/       # Version detection + update check
+├── model-fallback.ts        # Model fallback configuration
+└── provider-availability.ts # Provider availability checks
+```
 
 ## COMMANDS
 
 | Command | Purpose | Key Logic |
 |---------|---------|-----------|
-| `install` | Interactive/non-interactive setup | Provider selection → config gen → plugin registration |
-| `run <message>` | Non-interactive session launcher | Agent resolution (flag → env → config → Sisyphus) |
-| `doctor` | 4-category health checks | System, Config, Tools, Models |
-| `get-local-version` | Version detection | Installed vs npm latest |
-| `mcp-oauth` | OAuth token management | login (PKCE), logout, status |
+| `install` | Interactive setup | Provider selection → config generation → plugin registration |
+| `run` | Session launcher | Agent: flag → env → config → Sisyphus. Enforces todo completion. |
+| `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 |
 
-## STRUCTURE
+## DOCTOR CHECK CATEGORIES
 
-```
-cli/
-├── index.ts                     # Entry point → runCli()
-├── cli-program.ts               # Commander.js program (5 commands)
-├── install.ts                   # Routes to TUI or CLI installer
-├── cli-installer.ts             # Non-interactive (console output)
-├── tui-installer.ts             # Interactive (@clack/prompts)
-├── model-fallback.ts            # Model config gen by provider availability
-├── provider-availability.ts     # Provider detection
-├── fallback-chain-resolution.ts # Fallback chain logic
-├── config-manager/              # 20 config utilities
-│   ├── plugin registration, provider config
-│   ├── JSONC operations, auth plugins
-│   └── npm dist-tags, binary detection
-├── doctor/
-│   ├── runner.ts                # Parallel check execution
-│   ├── formatter.ts             # Output formatting
-│   └── checks/                  # 15 check files in 4 categories
-│       ├── system.ts            # Binary, plugin, version
-│       ├── config.ts            # JSONC validity, Zod schema
-│       ├── tools.ts             # AST-Grep, LSP, GH CLI, MCP
-│       └── model-resolution.ts  # Cache, resolution, overrides (6 sub-files)
-├── run/                         # Session launcher
-│   ├── runner.ts                # Main orchestration
-│   ├── agent-resolver.ts        # Flag → env → config → Sisyphus
-│   ├── session-resolver.ts      # Create/resume sessions
-│   ├── event-handlers.ts        # Event processing
-│   └── poll-for-completion.ts   # Wait for todos/background tasks
-└── mcp-oauth/                   # OAuth token management
-```
+| 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 |
 
-## MODEL FALLBACK SYSTEM
+## HOW TO ADD CHECK
 
-Priority: Claude > OpenAI > Gemini > Copilot > OpenCode Zen > Z.ai > Kimi > glm-4.7-free
+1. Create `src/cli/doctor/checks/my-check.ts`
+2. Export `getXXXCheckDefinition()` returning `CheckDefinition`
+3. Add to `getAllCheckDefinitions()` in `checks/index.ts`
 
-Agent-specific: librarian→ZAI, explore→Haiku/nano, hephaestus→requires OpenAI/Copilot
+## ANTI-PATTERNS
 
-## DOCTOR CHECKS
-
-| Category | Validates |
-|----------|-----------|
-| **System** | Binary found, version >=1.0.150, plugin registered, version match |
-| **Config** | JSONC validity, Zod schema, model override syntax |
-| **Tools** | AST-Grep, comment-checker, LSP servers, GH CLI, MCP servers |
-| **Models** | Cache exists, model resolution, agent/category overrides, availability |
-
-## HOW TO ADD A DOCTOR CHECK
-
-1. Create `src/cli/doctor/checks/{name}.ts`
-2. Export check function matching `DoctorCheck` interface
-3. Register in `checks/index.ts`
+- **Blocking in non-TTY**: Check `process.stdout.isTTY`
+- **Direct JSON.parse**: Use `parseJsonc()` from shared
+- **Silent failures**: Return `warn` or `fail` in doctor, don't throw
+- **Hardcoded paths**: Use `getOpenCodeConfigPaths()` from config-manager

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/cli-program.ts

@@ -67,19 +67,20 @@ program
    .command("run <message>")
    .allowUnknownOption()
    .passThroughOptions()
-  .description("Run opencode with todo/background task completion enforcement")
+   .description("Run opencode with todo/background task completion enforcement")
   .option("-a, --agent <name>", "Agent to use (default: from CLI/env/config, fallback: Sisyphus)")
   .option("-d, --directory <path>", "Working directory")
+  .option("-t, --timeout <ms>", "Timeout in milliseconds (default: 30 minutes)", parseInt)
   .option("-p, --port <port>", "Server port (attaches if port already in use)", parseInt)
   .option("--attach <url>", "Attach to existing opencode server URL")
   .option("--on-complete <command>", "Shell command to run after completion")
   .option("--json", "Output structured JSON result to stdout")
-  .option("--verbose", "Show full event stream (default: messages/tools only)")
   .option("--session-id <id>", "Resume existing session instead of creating new one")
   .addHelpText("after", `
 Examples:
   $ bunx oh-my-opencode run "Fix the bug in index.ts"
   $ bunx oh-my-opencode run --agent Sisyphus "Implement feature X"
+  $ bunx oh-my-opencode run --timeout 3600000 "Large refactoring task"
   $ bunx oh-my-opencode run --port 4321 "Fix the bug"
   $ bunx oh-my-opencode run --attach http://127.0.0.1:4321 "Fix the bug"
   $ bunx oh-my-opencode run --json "Fix the bug" | jq .sessionId
@@ -108,11 +109,11 @@ Unlike 'opencode run', this command waits until:
       message,
       agent: options.agent,
       directory: options.directory,
+      timeout: options.timeout,
       port: options.port,
       attach: options.attach,
       onComplete: options.onComplete,
       json: options.json ?? false,
-      verbose: options.verbose ?? false,
       sessionId: options.sessionId,
     }
     const exitCode = await run(runOptions)

src/cli/run/AGENTS.md

@@ -1,56 +0,0 @@
-# src/cli/run/ — Non-Interactive Session Launcher
-
-**Generated:** 2026-02-18
-
-## OVERVIEW
-
-37 files. Powers the `oh-my-opencode run <message>` command. Connects to OpenCode server, creates/resumes sessions, streams events, and polls for completion.
-
-## EXECUTION FLOW
-
-```
-runner.ts
-  1. opencode-binary-resolver.ts → Find OpenCode binary
-  2. server-connection.ts → Connect to OpenCode server (start if needed)
-  3. agent-resolver.ts → Flag → env → config → Sisyphus
-  4. session-resolver.ts → Create new or resume existing session
-  5. events.ts → Stream SSE events from session
-  6. event-handlers.ts → Process each event type
-  7. poll-for-completion.ts → Wait for todos + background tasks done
-  8. on-complete-hook.ts → Execute user-defined completion hook
-```
-
-## KEY FILES
-
-| File | Purpose |
-|------|---------|
-| `runner.ts` | Main orchestration — connects, resolves, runs, completes |
-| `server-connection.ts` | Start OpenCode server process, create SDK client |
-| `agent-resolver.ts` | Resolve agent: `--agent` flag → `OPENCODE_AGENT` env → config → Sisyphus |
-| `session-resolver.ts` | Create new session or resume via `--attach` / `--session-id` |
-| `events.ts` | SSE event stream subscription |
-| `event-handlers.ts` | Route events to handlers (message, tool, error, idle) |
-| `event-stream-processor.ts` | Process event stream with filtering and buffering |
-| `poll-for-completion.ts` | Poll session until todos complete + no background tasks |
-| `completion.ts` | Determine if session is truly done |
-| `continuation-state.ts` | Persist state for `run` continuation across invocations |
-| `output-renderer.ts` | Format session output for terminal |
-| `json-output.ts` | JSON output mode (`--json` flag) |
-| `types.ts` | `RunOptions`, `RunResult`, `RunContext`, event payload types |
-
-## AGENT RESOLUTION PRIORITY
-
-```
-1. --agent CLI flag
-2. OPENCODE_AGENT environment variable
-3. default_run_agent config
-4. "sisyphus" (default)
-```
-
-## COMPLETION DETECTION
-
-Poll-based with two conditions:
-1. All todos marked completed (no pending/in_progress)
-2. No running background tasks
-
-`on-complete-hook.ts` executes optional user command on completion (e.g., `--on-complete "notify-send done"`).

src/cli/run/agent-profile-colors.ts

@@ -1,28 +0,0 @@
-import type { OpencodeClient } from "@opencode-ai/sdk"
-import { normalizeSDKResponse } from "../../shared"
-
-interface AgentProfile {
-  name?: string
-  color?: string
-}
-
-export async function loadAgentProfileColors(
-  client: OpencodeClient,
-): Promise<Record<string, string>> {
-  try {
-    const agentsRes = await client.app.agents()
-    const agents = normalizeSDKResponse(agentsRes, [] as AgentProfile[], {
-      preferResponseOnMissingData: true,
-    })
-
-    const colors: Record<string, string> = {}
-    for (const agent of agents) {
-      if (!agent.name || !agent.color) continue
-      colors[agent.name] = agent.color
-    }
-
-    return colors
-  } catch {
-    return {}
-  }
-}

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-continuation.test.ts

@@ -1,138 +0,0 @@
-import { describe, it, expect, mock, spyOn, afterEach } from "bun:test"
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
-import { join } from "node:path"
-import { tmpdir } from "node:os"
-import type { RunContext } from "./types"
-import { writeState as writeRalphLoopState } from "../../hooks/ralph-loop/storage"
-
-const testDirs: string[] = []
-
-afterEach(() => {
-  while (testDirs.length > 0) {
-    const dir = testDirs.pop()
-    if (dir) {
-      rmSync(dir, { recursive: true, force: true })
-    }
-  }
-})
-
-function createTempDir(): string {
-  const dir = mkdtempSync(join(tmpdir(), "omo-run-continuation-"))
-  testDirs.push(dir)
-  return dir
-}
-
-function createMockContext(directory: string): RunContext {
-  return {
-    client: {
-      session: {
-        todo: mock(() => Promise.resolve({ data: [] })),
-        children: mock(() => Promise.resolve({ data: [] })),
-        status: mock(() => Promise.resolve({ data: {} })),
-      },
-    } as unknown as RunContext["client"],
-    sessionID: "test-session",
-    directory,
-    abortController: new AbortController(),
-  }
-}
-
-function writeBoulderStateFile(directory: string, activePlanPath: string, sessionIDs: string[]): void {
-  const sisyphusDir = join(directory, ".sisyphus")
-  mkdirSync(sisyphusDir, { recursive: true })
-  writeFileSync(
-    join(sisyphusDir, "boulder.json"),
-    JSON.stringify({
-      active_plan: activePlanPath,
-      started_at: new Date().toISOString(),
-      session_ids: sessionIDs,
-      plan_name: "test-plan",
-      agent: "atlas",
-    }),
-    "utf-8",
-  )
-}
-
-describe("checkCompletionConditions continuation coverage", () => {
-  it("returns false when active boulder continuation exists for this session", async () => {
-    // given
-    spyOn(console, "log").mockImplementation(() => {})
-    const directory = createTempDir()
-    const planPath = join(directory, ".sisyphus", "plans", "active-plan.md")
-    mkdirSync(join(directory, ".sisyphus", "plans"), { recursive: true })
-    writeFileSync(planPath, "- [ ] incomplete task\n", "utf-8")
-    writeBoulderStateFile(directory, planPath, ["test-session"])
-    const ctx = createMockContext(directory)
-    const { checkCompletionConditions } = await import("./completion")
-
-    // when
-    const result = await checkCompletionConditions(ctx)
-
-    // then
-    expect(result).toBe(false)
-  })
-
-  it("returns true when boulder exists but is complete", async () => {
-    // given
-    spyOn(console, "log").mockImplementation(() => {})
-    const directory = createTempDir()
-    const planPath = join(directory, ".sisyphus", "plans", "done-plan.md")
-    mkdirSync(join(directory, ".sisyphus", "plans"), { recursive: true })
-    writeFileSync(planPath, "- [x] completed task\n", "utf-8")
-    writeBoulderStateFile(directory, planPath, ["test-session"])
-    const ctx = createMockContext(directory)
-    const { checkCompletionConditions } = await import("./completion")
-
-    // when
-    const result = await checkCompletionConditions(ctx)
-
-    // then
-    expect(result).toBe(true)
-  })
-
-  it("returns false when active ralph-loop continuation exists for this session", async () => {
-    // given
-    spyOn(console, "log").mockImplementation(() => {})
-    const directory = createTempDir()
-    writeRalphLoopState(directory, {
-      active: true,
-      iteration: 2,
-      max_iterations: 10,
-      completion_promise: "DONE",
-      started_at: new Date().toISOString(),
-      prompt: "keep going",
-      session_id: "test-session",
-    })
-    const ctx = createMockContext(directory)
-    const { checkCompletionConditions } = await import("./completion")
-
-    // when
-    const result = await checkCompletionConditions(ctx)
-
-    // then
-    expect(result).toBe(false)
-  })
-
-  it("returns true when active ralph-loop is bound to another session", async () => {
-    // given
-    spyOn(console, "log").mockImplementation(() => {})
-    const directory = createTempDir()
-    writeRalphLoopState(directory, {
-      active: true,
-      iteration: 2,
-      max_iterations: 10,
-      completion_promise: "DONE",
-      started_at: new Date().toISOString(),
-      prompt: "keep going",
-      session_id: "other-session",
-    })
-    const ctx = createMockContext(directory)
-    const { checkCompletionConditions } = await import("./completion")
-
-    // when
-    const result = await checkCompletionConditions(ctx)
-
-    // then
-    expect(result).toBe(true)
-  })
-})

src/cli/run/completion.test.ts

@@ -143,47 +143,6 @@ describe("checkCompletionConditions", () => {
     expect(result).toBe(false)
   })
 
-  it("returns true when child status is missing but descendants are idle", async () => {
-    // given
-    spyOn(console, "log").mockImplementation(() => {})
-    const ctx = createMockContext({
-      childrenBySession: {
-        "test-session": [{ id: "child-1" }],
-        "child-1": [],
-      },
-      statuses: {},
-    })
-    const { checkCompletionConditions } = await import("./completion")
-
-    // when
-    const result = await checkCompletionConditions(ctx)
-
-    // then
-    expect(result).toBe(true)
-  })
-
-  it("returns false when descendant is busy even if parent status is missing", async () => {
-    // given
-    spyOn(console, "log").mockImplementation(() => {})
-    const ctx = createMockContext({
-      childrenBySession: {
-        "test-session": [{ id: "child-1" }],
-        "child-1": [{ id: "grandchild-1" }],
-        "grandchild-1": [],
-      },
-      statuses: {
-        "grandchild-1": { type: "busy" },
-      },
-    })
-    const { checkCompletionConditions } = await import("./completion")
-
-    // when
-    const result = await checkCompletionConditions(ctx)
-
-    // then
-    expect(result).toBe(false)
-  })
-
   it("returns true when all descendants idle (recursive)", async () => {
     // given
     spyOn(console, "log").mockImplementation(() => {})

src/cli/run/completion.ts

@@ -1,22 +1,9 @@
 import pc from "picocolors"
 import type { RunContext, Todo, ChildSession, SessionStatus } from "./types"
-import { normalizeSDKResponse } from "../../shared"
-import {
-  getContinuationState,
-  type ContinuationState,
-} from "./continuation-state"
 
 export async function checkCompletionConditions(ctx: RunContext): Promise<boolean> {
   try {
-    const continuationState = getContinuationState(ctx.directory, ctx.sessionID)
-
-    if (continuationState.hasActiveHookMarker) {
-      const reason = continuationState.activeHookMarkerReason ?? "continuation hook is active"
-      console.log(pc.dim(`  Waiting: ${reason}`))
-      return false
-    }
-
-    if (!continuationState.hasTodoHookMarker && !await areAllTodosComplete(ctx)) {
+    if (!await areAllTodosComplete(ctx)) {
       return false
     }
 
@@ -24,10 +11,6 @@ export async function checkCompletionConditions(ctx: RunContext): Promise<boolea
       return false
     }
 
-    if (!areContinuationHooksIdle(continuationState)) {
-      return false
-    }
-
     return true
   } catch (err) {
     console.error(pc.red(`[completion] API error: ${err}`))
@@ -35,26 +18,9 @@ export async function checkCompletionConditions(ctx: RunContext): Promise<boolea
   }
 }
 
-function areContinuationHooksIdle(continuationState: ContinuationState): boolean {
-  if (continuationState.hasActiveBoulder) {
-    console.log(pc.dim("  Waiting: boulder continuation is active"))
-    return false
-  }
-
-  if (continuationState.hasActiveRalphLoop) {
-    console.log(pc.dim("  Waiting: ralph-loop continuation is active"))
-    return false
-  }
-
-  return true
-}
-
 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"
@@ -76,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(
@@ -89,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/continuation-state-marker.test.ts

@@ -1,54 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test"
-import { mkdtempSync, rmSync } from "node:fs"
-import { join } from "node:path"
-import { tmpdir } from "node:os"
-import { setContinuationMarkerSource } from "../../features/run-continuation-state"
-import { getContinuationState } from "./continuation-state"
-
-const tempDirs: string[] = []
-
-function createTempDir(): string {
-  const directory = mkdtempSync(join(tmpdir(), "omo-run-cont-state-"))
-  tempDirs.push(directory)
-  return directory
-}
-
-afterEach(() => {
-  while (tempDirs.length > 0) {
-    const directory = tempDirs.pop()
-    if (directory) {
-      rmSync(directory, { recursive: true, force: true })
-    }
-  }
-})
-
-describe("getContinuationState marker integration", () => {
-  it("reports active marker state from continuation hooks", () => {
-    // given
-    const directory = createTempDir()
-    const sessionID = "ses_marker_active"
-    setContinuationMarkerSource(directory, sessionID, "todo", "active", "todos remaining")
-
-    // when
-    const state = getContinuationState(directory, sessionID)
-
-    // then
-    expect(state.hasActiveHookMarker).toBe(true)
-    expect(state.activeHookMarkerReason).toContain("todos")
-  })
-
-  it("does not report active marker when all sources are idle/stopped", () => {
-    // given
-    const directory = createTempDir()
-    const sessionID = "ses_marker_idle"
-    setContinuationMarkerSource(directory, sessionID, "todo", "idle")
-    setContinuationMarkerSource(directory, sessionID, "stop", "stopped")
-
-    // when
-    const state = getContinuationState(directory, sessionID)
-
-    // then
-    expect(state.hasActiveHookMarker).toBe(false)
-    expect(state.activeHookMarkerReason).toBeNull()
-  })
-})

src/cli/run/continuation-state.ts

@@ -1,49 +0,0 @@
-import { getPlanProgress, readBoulderState } from "../../features/boulder-state"
-import {
-  getActiveContinuationMarkerReason,
-  isContinuationMarkerActive,
-  readContinuationMarker,
-} from "../../features/run-continuation-state"
-import { readState as readRalphLoopState } from "../../hooks/ralph-loop/storage"
-
-export interface ContinuationState {
-  hasActiveBoulder: boolean
-  hasActiveRalphLoop: boolean
-  hasHookMarker: boolean
-  hasTodoHookMarker: boolean
-  hasActiveHookMarker: boolean
-  activeHookMarkerReason: string | null
-}
-
-export function getContinuationState(directory: string, sessionID: string): ContinuationState {
-  const marker = readContinuationMarker(directory, sessionID)
-
-  return {
-    hasActiveBoulder: hasActiveBoulderContinuation(directory, sessionID),
-    hasActiveRalphLoop: hasActiveRalphLoopContinuation(directory, sessionID),
-    hasHookMarker: marker !== null,
-    hasTodoHookMarker: marker?.sources.todo !== undefined,
-    hasActiveHookMarker: isContinuationMarkerActive(marker),
-    activeHookMarkerReason: getActiveContinuationMarkerReason(marker),
-  }
-}
-
-function hasActiveBoulderContinuation(directory: string, sessionID: string): boolean {
-  const boulder = readBoulderState(directory)
-  if (!boulder) return false
-  if (!boulder.session_ids.includes(sessionID)) return false
-
-  const progress = getPlanProgress(boulder.active_plan)
-  return !progress.isComplete
-}
-
-function hasActiveRalphLoopContinuation(directory: string, sessionID: string): boolean {
-  const state = readRalphLoopState(directory)
-  if (!state || !state.active) return false
-
-  if (state.session_id && state.session_id !== sessionID) {
-    return false
-  }
-
-  return true
-}

src/cli/run/display-chars.ts

@@ -1,7 +0,0 @@
-const isCI = Boolean(process.env.CI || process.env.GITHUB_ACTIONS)
-
-export const displayChars = {
-  treeEnd: isCI ? "`-" : "└─",
-  treeIndent: "   ",
-  treeJoin: isCI ? "   " : "      ",
-} as const

src/cli/run/event-formatting.ts

@@ -4,7 +4,6 @@ import type {
   EventPayload,
   MessageUpdatedProps,
   MessagePartUpdatedProps,
-  MessagePartDeltaProps,
   ToolExecuteProps,
   ToolResultProps,
   SessionErrorProps,
@@ -58,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)}]`)
@@ -84,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 ? "..." : ""}"`))
@@ -94,15 +89,6 @@ export function logEventVerbose(ctx: RunContext, payload: EventPayload): void {
       break
     }
 
-    case "message.part.delta": {
-      const deltaProps = props as MessagePartDeltaProps | undefined
-      const field = deltaProps?.field ?? "unknown"
-      const delta = deltaProps?.delta ?? ""
-      const preview = delta.slice(0, 80).replace(/\n/g, "\\n")
-      console.error(pc.dim(`${sessionTag} message.part.delta (${field}): "${preview}${delta.length > 80 ? "..." : ""}"`))
-      break
-    }
-
     case "message.updated": {
       const msgProps = props as MessageUpdatedProps | undefined
       const role = msgProps?.info?.role ?? "unknown"

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

@@ -7,55 +7,17 @@ import type {
   SessionErrorProps,
   MessageUpdatedProps,
   MessagePartUpdatedProps,
-  MessagePartDeltaProps,
   ToolExecuteProps,
   ToolResultProps,
-  TuiToastShowProps,
 } from "./types"
 import type { EventState } from "./event-state"
 import { serializeError } from "./event-formatting"
-import { formatToolHeader } from "./tool-input-preview"
-import { displayChars } from "./display-chars"
-import {
-  closeThinkBlock,
-  openThinkBlock,
-  renderAgentHeader,
-  writePaddedText,
-} from "./output-renderer"
-
-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
-}
-
-function getPartMessageId(props?: {
-  part?: { messageID?: string }
-}): string | undefined {
-  return props?.part?.messageID
-}
-
-function getDeltaMessageId(props?: {
-  messageID?: string
-}): string | undefined {
-  return props?.messageID
-}
 
 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
   }
 }
@@ -64,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
@@ -79,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}`))
@@ -90,238 +52,76 @@ 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 role = props?.info?.role
-  const mappedRole = getPartMessageId(props)
-    ? state.messageRoleById[getPartMessageId(props) ?? ""]
-    : undefined
-  if ((role ?? mappedRole) === "user") return
-
-  const part = props?.part
+  const part = props.part
   if (!part) return
 
-  if (part.id && part.type) {
-    state.partTypesById[part.id] = part.type
-  }
-
-  if (part.type === "reasoning") {
-    ensureThinkBlockOpen(state)
-    const reasoningText = part.text ?? ""
-    const newText = reasoningText.slice(state.lastReasoningText.length)
-    if (newText) {
-      const padded = writePaddedText(newText, state.thinkingAtLineStart)
-      process.stdout.write(pc.dim(padded.output))
-      state.thinkingAtLineStart = padded.atLineStart
-      state.hasReceivedMeaningfulWork = true
-    }
-    state.lastReasoningText = reasoningText
-    return
-  }
-
-  closeThinkBlockIfNeeded(state)
-
   if (part.type === "text" && part.text) {
     const newText = part.text.slice(state.lastPartText.length)
     if (newText) {
-      const padded = writePaddedText(newText, state.textAtLineStart)
-      process.stdout.write(padded.output)
-      state.textAtLineStart = padded.atLineStart
+      process.stdout.write(newText)
       state.hasReceivedMeaningfulWork = true
     }
     state.lastPartText = part.text
   }
-
-  if (part.type === "tool") {
-    handleToolPart(ctx, part, state)
-  }
-}
-
-export function handleMessagePartDelta(ctx: RunContext, payload: EventPayload, state: EventState): void {
-  if (payload.type !== "message.part.delta") return
-
-  const props = payload.properties as MessagePartDeltaProps | undefined
-  const sessionID = props?.sessionID ?? props?.sessionId
-  if (sessionID !== ctx.sessionID) return
-
-  const role = getDeltaMessageId(props)
-    ? state.messageRoleById[getDeltaMessageId(props) ?? ""]
-    : undefined
-  if (role === "user") return
-
-  if (props?.field !== "text") return
-
-  const partType = props?.partID ? state.partTypesById[props.partID] : undefined
-
-  const delta = props.delta ?? ""
-  if (!delta) return
-
-  if (partType === "reasoning") {
-    ensureThinkBlockOpen(state)
-    const padded = writePaddedText(delta, state.thinkingAtLineStart)
-    process.stdout.write(pc.dim(padded.output))
-    state.thinkingAtLineStart = padded.atLineStart
-    state.lastReasoningText += delta
-    state.hasReceivedMeaningfulWork = true
-    return
-  }
-
-  closeThinkBlockIfNeeded(state)
-
-  const padded = writePaddedText(delta, state.textAtLineStart)
-  process.stdout.write(padded.output)
-  state.textAtLineStart = padded.atLineStart
-  state.lastPartText += delta
-  state.hasReceivedMeaningfulWork = true
-}
-
-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") {
-    if (state.currentTool !== null) return
-    state.currentTool = toolName
-    const header = formatToolHeader(toolName, part.state?.input ?? {})
-    const suffix = header.description ? ` ${pc.dim(header.description)}` : ""
-    state.hasReceivedMeaningfulWork = true
-    process.stdout.write(`\n  ${pc.cyan(header.icon)} ${pc.bold(header.title)}${suffix}  \n`)
-  }
-
-  if (status === "completed" || status === "error") {
-    if (state.currentTool === null) return
-    const output = part.state?.output || ""
-    if (output.trim()) {
-      process.stdout.write(pc.dim(`  ${displayChars.treeEnd} output  \n`))
-      const padded = writePaddedText(output, true)
-      process.stdout.write(pc.dim(padded.output + (padded.atLineStart ? "" : "  ")))
-      process.stdout.write("\n")
-    }
-    state.currentTool = null
-    state.lastPartText = ""
-    state.textAtLineStart = true
-  }
 }
 
 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
-
-  state.currentMessageRole = props?.info?.role ?? null
-
-  const messageID = props?.info?.id ?? null
-  const role = props?.info?.role
-  if (messageID && role) {
-    state.messageRoleById[messageID] = role
-  }
-
+  if (props?.info?.sessionID !== ctx.sessionID) return
   if (props?.info?.role !== "assistant") return
 
-  const isNewMessage = !messageID || messageID !== state.currentMessageId
-  if (isNewMessage) {
-    state.currentMessageId = messageID
-    state.hasReceivedMeaningfulWork = true
-    state.messageCount++
-    state.lastPartText = ""
-    state.lastReasoningText = ""
-    state.hasPrintedThinkingLine = false
-    state.lastThinkingSummary = ""
-    state.textAtLineStart = true
-    state.thinkingAtLineStart = false
-    closeThinkBlockIfNeeded(state)
-  }
-
-  const agent = props?.info?.agent ?? null
-  const model = props?.info?.modelID ?? null
-  const variant = props?.info?.variant ?? null
-  if (agent !== state.currentAgent || model !== state.currentModel || variant !== state.currentVariant) {
-    state.currentAgent = agent
-    state.currentModel = model
-    state.currentVariant = variant
-    renderAgentHeader(agent, model, variant, state.agentColorsByName)
-  }
+  state.hasReceivedMeaningfulWork = true
+  state.messageCount++
+  state.lastPartText = ""
 }
 
 export function handleToolExecute(ctx: RunContext, payload: EventPayload, state: EventState): void {
   if (payload.type !== "tool.execute") return
 
   const props = payload.properties as ToolExecuteProps | undefined
-  if (getSessionId(props) !== ctx.sessionID) return
-
-  closeThinkBlockIfNeeded(state)
-
-  if (state.currentTool !== null) return
+  if (props?.sessionID !== ctx.sessionID) return
 
   const toolName = props?.name || "unknown"
   state.currentTool = toolName
-  const header = formatToolHeader(toolName, props?.input ?? {})
-  const suffix = header.description ? ` ${pc.dim(header.description)}` : ""
+
+  let inputPreview = ""
+  if (props?.input) {
+    const input = props.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(header.icon)} ${pc.bold(header.title)}${suffix}  \n`)
+  process.stdout.write(`\n${pc.cyan(">")} ${pc.bold(toolName)}${inputPreview}\n`)
 }
 
 export function handleToolResult(ctx: RunContext, payload: EventPayload, state: EventState): void {
   if (payload.type !== "tool.result") return
 
   const props = payload.properties as ToolResultProps | undefined
-  if (getSessionId(props) !== ctx.sessionID) return
-
-  closeThinkBlockIfNeeded(state)
-
-  if (state.currentTool === null) return
+  if (props?.sessionID !== ctx.sessionID) return
 
   const output = props?.output || ""
-  if (output.trim()) {
-    process.stdout.write(pc.dim(`  ${displayChars.treeEnd} output  \n`))
-    const padded = writePaddedText(output, true)
-    process.stdout.write(pc.dim(padded.output + (padded.atLineStart ? "" : "  ")))
-    process.stdout.write("\n")
+  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 = ""
-  state.textAtLineStart = true
-}
-
-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 variant = props?.variant ?? "info"
-
-  if (variant === "error") {
-    const title = props?.title ? `${props.title}: ` : ""
-    const message = props?.message?.trim()
-    if (message) {
-      state.mainSessionError = true
-      state.lastError = `${title}${message}`
-    }
-  }
-}
-
-function ensureThinkBlockOpen(state: EventState): void {
-  if (state.inThinkBlock) return
-  openThinkBlock()
-  state.inThinkBlock = true
-  state.hasPrintedThinkingLine = false
-  state.thinkingAtLineStart = false
-}
-
-function closeThinkBlockIfNeeded(state: EventState): void {
-  if (!state.inThinkBlock) return
-  closeThinkBlock()
-  state.inThinkBlock = false
-  state.lastThinkingLineWidth = 0
-  state.lastThinkingSummary = ""
-  state.thinkingAtLineStart = false
 }

src/cli/run/event-state.ts

@@ -9,36 +9,6 @@ export interface EventState {
   hasReceivedMeaningfulWork: boolean
   /** Count of assistant messages for the main session */
   messageCount: number
-  /** Current agent name from the latest assistant message */
-  currentAgent: string | null
-  /** Current model ID from the latest assistant message */
-  currentModel: string | null
-  /** Current model variant from the latest assistant message */
-  currentVariant: string | null
-  /** Current message role (user/assistant) — used to filter user messages from display */
-  currentMessageRole: string | null
-  /** Agent profile colors keyed by display name */
-  agentColorsByName: Record<string, string>
-  /** Part type registry keyed by partID (text, reasoning, tool, ...) */
-  partTypesById: Record<string, string>
-  /** Whether a THINK block is currently open in output */
-  inThinkBlock: boolean
-  /** Tracks streamed reasoning text to avoid duplicates */
-  lastReasoningText: string
-  /** Whether compact thinking line already printed for current reasoning block */
-  hasPrintedThinkingLine: boolean
-  /** Last rendered thinking line width (for in-place padding updates) */
-  lastThinkingLineWidth: number
-  /** Message role lookup by message ID to filter user parts */
-  messageRoleById: Record<string, string>
-  /** Last rendered thinking summary (to avoid duplicate re-render) */
-  lastThinkingSummary: string
-  /** Whether text stream is currently at line start (for padding) */
-  textAtLineStart: boolean
-  /** Whether reasoning stream is currently at line start (for padding) */
-  thinkingAtLineStart: boolean
-  /** Current assistant message ID — prevents counter resets on repeated message.updated for same message */
-  currentMessageId: string | null
 }
 
 export function createEventState(): EventState {
@@ -51,20 +21,5 @@ export function createEventState(): EventState {
     currentTool: null,
     hasReceivedMeaningfulWork: false,
     messageCount: 0,
-    currentAgent: null,
-    currentModel: null,
-    currentVariant: null,
-    currentMessageRole: null,
-    agentColorsByName: {},
-    partTypesById: {},
-    inThinkBlock: false,
-    lastReasoningText: "",
-    hasPrintedThinkingLine: false,
-    lastThinkingLineWidth: 0,
-    messageRoleById: {},
-    lastThinkingSummary: "",
-    textAtLineStart: true,
-    thinkingAtLineStart: false,
-    currentMessageId: null,
   }
 }

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

@@ -7,11 +7,9 @@ import {
   handleSessionIdle,
   handleSessionStatus,
   handleMessagePartUpdated,
-  handleMessagePartDelta,
   handleMessageUpdated,
   handleToolExecute,
   handleToolResult,
-  handleTuiToast,
 } from "./event-handlers"
 
 export async function processEvents(
@@ -25,25 +23,19 @@ export async function processEvents(
     try {
       const payload = event as EventPayload
       if (!payload?.type) {
-        if (ctx.verbose) {
-          console.error(pc.dim(`[event] no type: ${JSON.stringify(event)}`))
-        }
+        console.error(pc.dim(`[event] no type: ${JSON.stringify(event)}`))
         continue
       }
 
-      if (ctx.verbose) {
-        logEventVerbose(ctx, payload)
-      }
+      logEventVerbose(ctx, payload)
 
       handleSessionError(ctx, payload, state)
       handleSessionIdle(ctx, payload, state)
       handleSessionStatus(ctx, payload, state)
       handleMessagePartUpdated(ctx, payload, state)
-      handleMessagePartDelta(ctx, payload, state)
       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

@@ -1,4 +1,4 @@
-import { describe, it, expect, spyOn } from "bun:test"
+import { describe, it, expect } from "bun:test"
 import { createEventState, serializeError, type EventState } from "./events"
 import type { RunContext, EventPayload } from "./types"
 
@@ -87,52 +87,6 @@ describe("createEventState", () => {
 })
 
 describe("event handling", () => {
-  it("does not log verbose event traces by default", async () => {
-    // given
-    const ctx = createMockContext("my-session")
-    const state = createEventState()
-    const errorSpy = spyOn(console, "error").mockImplementation(() => {})
-
-    const payload: EventPayload = {
-      type: "custom.event",
-      properties: { sessionID: "my-session" },
-    }
-
-    const events = toAsyncIterable([payload])
-    const { processEvents } = await import("./events")
-
-    // when
-    await processEvents(ctx, events, state)
-
-    // then
-    expect(errorSpy).not.toHaveBeenCalled()
-    errorSpy.mockRestore()
-  })
-
-  it("logs full event traces when verbose is enabled", async () => {
-    // given
-    const ctx = { ...createMockContext("my-session"), verbose: true }
-    const state = createEventState()
-    const errorSpy = spyOn(console, "error").mockImplementation(() => {})
-
-    const payload: EventPayload = {
-      type: "custom.event",
-      properties: { sessionID: "my-session" },
-    }
-
-    const events = toAsyncIterable([payload])
-    const { processEvents } = await import("./events")
-
-    // when
-    await processEvents(ctx, events, state)
-
-    // then
-    expect(errorSpy).toHaveBeenCalledTimes(1)
-    const firstCall = errorSpy.mock.calls[0]
-    expect(String(firstCall?.[0] ?? "")).toContain("custom.event")
-    errorSpy.mockRestore()
-  })
-
   it("session.idle sets mainSessionIdle to true for matching session", async () => {
     // given
     const ctx = createMockContext("my-session")
@@ -216,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")
@@ -319,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/message-part-delta.test.ts

@@ -1,657 +0,0 @@
-import { describe, expect, it, spyOn } from "bun:test"
-import type { EventPayload, RunContext } from "./types"
-import { createEventState } from "./events"
-import { processEvents } from "./event-stream-processor"
-
-function stripAnsi(str: string): string {
-  return str.replace(new RegExp("\x1b\\[[0-9;]*m", "g"), "")
-}
-
-const createMockContext = (sessionID: string = "test-session"): RunContext => ({
-  client: {} as RunContext["client"],
-  sessionID,
-  directory: "/test",
-  abortController: new AbortController(),
-})
-
-async function* toAsyncIterable<T>(items: T[]): AsyncIterable<T> {
-  for (const item of items) {
-    yield item
-  }
-}
-
-describe("message.part.delta handling", () => {
-  it("prints streaming text incrementally from delta events", async () => {
-    //#given
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-    const events: EventPayload[] = [
-      {
-        type: "message.part.delta",
-        properties: {
-          sessionID: "ses_main",
-          field: "text",
-          delta: "Hello",
-        },
-      },
-      {
-        type: "message.part.delta",
-        properties: {
-          sessionID: "ses_main",
-          field: "text",
-          delta: " world",
-        },
-      },
-    ]
-
-    //#when
-    await processEvents(ctx, toAsyncIterable(events), state)
-
-    //#then
-    expect(state.hasReceivedMeaningfulWork).toBe(true)
-    expect(state.lastPartText).toBe("Hello world")
-    expect(stdoutSpy).toHaveBeenCalledTimes(2)
-    stdoutSpy.mockRestore()
-  })
-
-  it("does not suppress assistant tool/text parts when state role is stale user", () => {
-    //#given
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    state.currentMessageRole = "user"
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-    const payload: EventPayload = {
-      type: "message.part.updated",
-      properties: {
-        part: {
-          sessionID: "ses_main",
-          type: "tool",
-          tool: "task_create",
-          state: { status: "running" },
-        },
-      },
-    }
-
-    //#when
-    const { handleMessagePartUpdated } = require("./event-handlers") as {
-      handleMessagePartUpdated: (ctx: RunContext, payload: EventPayload, state: ReturnType<typeof createEventState>) => void
-    }
-    handleMessagePartUpdated(ctx, payload, state)
-
-    //#then
-    expect(state.currentTool).toBe("task_create")
-    expect(state.hasReceivedMeaningfulWork).toBe(true)
-    stdoutSpy.mockRestore()
-  })
-
-  it("renders agent header using profile hex color when available", () => {
-    //#given
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    state.agentColorsByName["Sisyphus (Ultraworker)"] = "#00CED1"
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-    const payload: EventPayload = {
-      type: "message.updated",
-      properties: {
-        info: {
-          sessionID: "ses_main",
-          role: "assistant",
-          agent: "Sisyphus (Ultraworker)",
-          modelID: "claude-opus-4-6",
-          variant: "max",
-        },
-      },
-    }
-
-    //#when
-    const { handleMessageUpdated } = require("./event-handlers") as {
-      handleMessageUpdated: (ctx: RunContext, payload: EventPayload, state: ReturnType<typeof createEventState>) => void
-    }
-    handleMessageUpdated(ctx, payload, state)
-
-    //#then
-    const rendered = stdoutSpy.mock.calls.map((call) => String(call[0] ?? "")).join("")
-    expect(rendered).toContain("\u001b[38;2;0;206;209m")
-    expect(rendered).toContain("claude-opus-4-6 (max)")
-    expect(rendered).toContain("└─")
-    expect(rendered).toContain("Sisyphus (Ultraworker)")
-    stdoutSpy.mockRestore()
-  })
-
-  it("separates think block output from normal response output", async () => {
-    //#given
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-    const events: EventPayload[] = [
-      {
-        type: "message.updated",
-        properties: {
-          info: { sessionID: "ses_main", role: "assistant", agent: "Sisyphus (Ultraworker)", modelID: "claude-opus-4-6" },
-        },
-      },
-      {
-        type: "message.part.updated",
-        properties: {
-          part: { id: "think-1", sessionID: "ses_main", type: "reasoning", text: "" },
-        },
-      },
-      {
-        type: "message.part.delta",
-        properties: {
-          sessionID: "ses_main",
-          partID: "think-1",
-          field: "text",
-          delta: "Composing final summary in Korean with clear concise structure",
-        },
-      },
-      {
-        type: "message.part.updated",
-        properties: {
-          part: { id: "text-1", sessionID: "ses_main", type: "text", text: "" },
-        },
-      },
-      {
-        type: "message.part.delta",
-        properties: {
-          sessionID: "ses_main",
-          partID: "text-1",
-          field: "text",
-          delta: "answer",
-        },
-      },
-    ]
-
-    //#when
-    await processEvents(ctx, toAsyncIterable(events), state)
-
-    //#then
-    const rendered = stdoutSpy.mock.calls.map((call) => String(call[0] ?? "")).join("")
-    const plain = stripAnsi(rendered)
-    expect(plain).toContain("Thinking:")
-    expect(plain).toContain("Composing final summary in Korean")
-    expect(plain).toContain("answer")
-    stdoutSpy.mockRestore()
-  })
-
-  it("updates thinking line incrementally on delta updates", async () => {
-    //#given
-    const previous = process.env.GITHUB_ACTIONS
-    delete process.env.GITHUB_ACTIONS
-
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-    const events: EventPayload[] = [
-      {
-        type: "message.updated",
-        properties: {
-          info: { sessionID: "ses_main", role: "assistant", agent: "Sisyphus (Ultraworker)", modelID: "claude-opus-4-6" },
-        },
-      },
-      {
-        type: "message.part.updated",
-        properties: {
-          part: { id: "think-1", sessionID: "ses_main", type: "reasoning", text: "" },
-        },
-      },
-      {
-        type: "message.part.delta",
-        properties: {
-          sessionID: "ses_main",
-          partID: "think-1",
-          field: "text",
-          delta: "Composing final summary",
-        },
-      },
-      {
-        type: "message.part.delta",
-        properties: {
-          sessionID: "ses_main",
-          partID: "think-1",
-          field: "text",
-          delta: " in Korean with specifics.",
-        },
-      },
-    ]
-
-    //#when
-    await processEvents(ctx, toAsyncIterable(events), state)
-
-    //#then
-    const rendered = stdoutSpy.mock.calls.map((call) => String(call[0] ?? "")).join("")
-    const plain = stripAnsi(rendered)
-    expect(plain).toContain("Thinking:")
-    expect(plain).toContain("Composing final summary")
-    expect(plain).toContain("in Korean with specifics.")
-
-    if (previous !== undefined) process.env.GITHUB_ACTIONS = previous
-    stdoutSpy.mockRestore()
-  })
-
-  it("does not re-render identical thinking summary repeatedly", async () => {
-    //#given
-    const previous = process.env.GITHUB_ACTIONS
-    delete process.env.GITHUB_ACTIONS
-
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-    const events: EventPayload[] = [
-      {
-        type: "message.updated",
-        properties: {
-          info: { id: "msg_assistant", sessionID: "ses_main", role: "assistant", agent: "Sisyphus (Ultraworker)", modelID: "claude-opus-4-6" },
-        },
-      },
-      {
-        type: "message.part.updated",
-        properties: {
-          part: { id: "think-1", messageID: "msg_assistant", sessionID: "ses_main", type: "reasoning", text: "" },
-        },
-      },
-      {
-        type: "message.part.delta",
-        properties: {
-          sessionID: "ses_main",
-          messageID: "msg_assistant",
-          partID: "think-1",
-          field: "text",
-          delta: "The user wants me",
-        },
-      },
-      {
-        type: "message.part.delta",
-        properties: {
-          sessionID: "ses_main",
-          messageID: "msg_assistant",
-          partID: "think-1",
-          field: "text",
-          delta: " to",
-        },
-      },
-      {
-        type: "message.part.delta",
-        properties: {
-          sessionID: "ses_main",
-          messageID: "msg_assistant",
-          partID: "think-1",
-          field: "text",
-          delta: " ",
-        },
-      },
-    ]
-
-    //#when
-    await processEvents(ctx, toAsyncIterable(events), state)
-
-    //#then
-    const rendered = stdoutSpy.mock.calls.map((call) => String(call[0] ?? "")).join("")
-    const plain = stripAnsi(rendered)
-    const renderCount = plain.split("Thinking:").length - 1
-    expect(renderCount).toBe(1)
-
-    if (previous !== undefined) process.env.GITHUB_ACTIONS = previous
-    stdoutSpy.mockRestore()
-  })
-
-  it("does not truncate thinking content", async () => {
-    //#given
-    const previous = process.env.GITHUB_ACTIONS
-    delete process.env.GITHUB_ACTIONS
-
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-    const longThinking = "This is a very long thinking stream that should never be truncated and must include final tail marker END-OF-THINKING-MARKER"
-    const events: EventPayload[] = [
-      {
-        type: "message.updated",
-        properties: {
-          info: { id: "msg_assistant", sessionID: "ses_main", role: "assistant", agent: "Sisyphus (Ultraworker)", modelID: "claude-opus-4-6" },
-        },
-      },
-      {
-        type: "message.part.updated",
-        properties: {
-          part: { id: "think-1", messageID: "msg_assistant", sessionID: "ses_main", type: "reasoning", text: "" },
-        },
-      },
-      {
-        type: "message.part.delta",
-        properties: {
-          sessionID: "ses_main",
-          messageID: "msg_assistant",
-          partID: "think-1",
-          field: "text",
-          delta: longThinking,
-        },
-      },
-    ]
-
-    //#when
-    await processEvents(ctx, toAsyncIterable(events), state)
-
-    //#then
-    const rendered = stdoutSpy.mock.calls.map((call) => String(call[0] ?? "")).join("")
-    expect(rendered).toContain("END-OF-THINKING-MARKER")
-
-    if (previous !== undefined) process.env.GITHUB_ACTIONS = previous
-    stdoutSpy.mockRestore()
-  })
-
-  it("applies left and right padding to assistant text output", async () => {
-    //#given
-    const previous = process.env.GITHUB_ACTIONS
-    delete process.env.GITHUB_ACTIONS
-
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-    const events: EventPayload[] = [
-      {
-        type: "message.updated",
-        properties: {
-          info: { id: "msg_assistant", sessionID: "ses_main", role: "assistant", agent: "Sisyphus (Ultraworker)", modelID: "claude-opus-4-6", variant: "max" },
-        },
-      },
-      {
-        type: "message.part.delta",
-        properties: {
-          sessionID: "ses_main",
-          messageID: "msg_assistant",
-          partID: "part_assistant_text",
-          field: "text",
-          delta: "hello\nworld",
-        },
-      },
-    ]
-
-    //#when
-    await processEvents(ctx, toAsyncIterable(events), state)
-
-    //#then
-    const rendered = stdoutSpy.mock.calls.map((call) => String(call[0] ?? "")).join("")
-    expect(rendered).toContain("  hello  \n  world")
-
-    if (previous !== undefined) process.env.GITHUB_ACTIONS = previous
-    stdoutSpy.mockRestore()
-  })
-
-  it("does not render user message parts in output stream", async () => {
-    //#given
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-    const events: EventPayload[] = [
-      {
-        type: "message.updated",
-        properties: {
-          info: { id: "msg_user", sessionID: "ses_main", role: "user", agent: "Sisyphus (Ultraworker)", modelID: "claude-opus-4-6" },
-        },
-      },
-      {
-        type: "message.part.updated",
-        properties: {
-          part: { id: "part_user_text", messageID: "msg_user", sessionID: "ses_main", type: "text", text: "[search-mode] should not print" },
-        },
-      },
-      {
-        type: "message.part.delta",
-        properties: {
-          sessionID: "ses_main",
-          messageID: "msg_user",
-          partID: "part_user_text",
-          field: "text",
-          delta: "still should not print",
-        },
-      },
-      {
-        type: "message.updated",
-        properties: {
-          info: { id: "msg_assistant", sessionID: "ses_main", role: "assistant", agent: "Sisyphus (Ultraworker)", modelID: "claude-opus-4-6" },
-        },
-      },
-      {
-        type: "message.part.delta",
-        properties: {
-          sessionID: "ses_main",
-          messageID: "msg_assistant",
-          partID: "part_assistant_text",
-          field: "text",
-          delta: "assistant output",
-        },
-      },
-    ]
-
-    //#when
-    await processEvents(ctx, toAsyncIterable(events), state)
-
-    //#then
-    const rendered = stdoutSpy.mock.calls.map((call) => String(call[0] ?? "")).join("")
-    expect(rendered.includes("[search-mode] should not print")).toBe(false)
-    expect(rendered.includes("still should not print")).toBe(false)
-    expect(rendered).toContain("assistant output")
-    stdoutSpy.mockRestore()
-  })
-
-  it("renders tool header and full tool output without truncation", async () => {
-    //#given
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-    const longTail = "END-OF-TOOL-OUTPUT-MARKER"
-    const events: EventPayload[] = [
-      {
-        type: "tool.execute",
-        properties: {
-          sessionID: "ses_main",
-          name: "read",
-          input: { filePath: "src/index.ts", offset: 1, limit: 200 },
-        },
-      },
-      {
-        type: "tool.result",
-        properties: {
-          sessionID: "ses_main",
-          name: "read",
-          output: `line1\nline2\n${longTail}`,
-        },
-      },
-    ]
-
-    //#when
-    await processEvents(ctx, toAsyncIterable(events), state)
-
-    //#then
-    const rendered = stdoutSpy.mock.calls.map((call) => String(call[0] ?? "")).join("")
-    expect(rendered).toContain("→")
-    expect(rendered).toContain("Read src/index.ts")
-    expect(rendered).toContain("END-OF-TOOL-OUTPUT-MARKER")
-    stdoutSpy.mockRestore()
-  })
-
-  it("renders tool header only once when message.part.updated fires multiple times for same running tool", async () => {
-    //#given
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-    const events: EventPayload[] = [
-      {
-        type: "message.part.updated",
-        properties: {
-          part: {
-            id: "tool-1",
-            sessionID: "ses_main",
-            type: "tool",
-            tool: "bash",
-            state: { status: "running", input: { command: "bun test" } },
-          },
-        },
-      },
-      {
-        type: "message.part.updated",
-        properties: {
-          part: {
-            id: "tool-1",
-            sessionID: "ses_main",
-            type: "tool",
-            tool: "bash",
-            state: { status: "running", input: { command: "bun test" } },
-          },
-        },
-      },
-      {
-        type: "message.part.updated",
-        properties: {
-          part: {
-            id: "tool-1",
-            sessionID: "ses_main",
-            type: "tool",
-            tool: "bash",
-            state: { status: "running", input: { command: "bun test" } },
-          },
-        },
-      },
-    ]
-
-    //#when
-    await processEvents(ctx, toAsyncIterable(events), state)
-
-    //#then
-    const rendered = stdoutSpy.mock.calls.map((call) => String(call[0] ?? "")).join("")
-    const headerCount = rendered.split("bun test").length - 1
-    expect(headerCount).toBe(1)
-    stdoutSpy.mockRestore()
-  })
-
-  it("renders tool header only once when both tool.execute and message.part.updated fire", async () => {
-    //#given
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-    const events: EventPayload[] = [
-      {
-        type: "tool.execute",
-        properties: {
-          sessionID: "ses_main",
-          name: "bash",
-          input: { command: "bun test" },
-        },
-      },
-      {
-        type: "message.part.updated",
-        properties: {
-          part: {
-            id: "tool-1",
-            sessionID: "ses_main",
-            type: "tool",
-            tool: "bash",
-            state: { status: "running", input: { command: "bun test" } },
-          },
-        },
-      },
-    ]
-
-    //#when
-    await processEvents(ctx, toAsyncIterable(events), state)
-
-    //#then
-    const rendered = stdoutSpy.mock.calls.map((call) => String(call[0] ?? "")).join("")
-    const headerCount = rendered.split("bun test").length - 1
-    expect(headerCount).toBe(1)
-    stdoutSpy.mockRestore()
-  })
-
-  it("renders tool output only once when both tool.result and message.part.updated(completed) fire", async () => {
-    //#given
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-    const events: EventPayload[] = [
-      {
-        type: "tool.execute",
-        properties: {
-          sessionID: "ses_main",
-          name: "bash",
-          input: { command: "bun test" },
-        },
-      },
-      {
-        type: "tool.result",
-        properties: {
-          sessionID: "ses_main",
-          name: "bash",
-          output: "UNIQUE-OUTPUT-MARKER",
-        },
-      },
-      {
-        type: "message.part.updated",
-        properties: {
-          part: {
-            id: "tool-1",
-            sessionID: "ses_main",
-            type: "tool",
-            tool: "bash",
-            state: { status: "completed", input: { command: "bun test" }, output: "UNIQUE-OUTPUT-MARKER" },
-          },
-        },
-      },
-    ]
-
-    //#when
-    await processEvents(ctx, toAsyncIterable(events), state)
-
-    //#then
-    const rendered = stdoutSpy.mock.calls.map((call) => String(call[0] ?? "")).join("")
-    const outputCount = rendered.split("UNIQUE-OUTPUT-MARKER").length - 1
-    expect(outputCount).toBe(1)
-    stdoutSpy.mockRestore()
-  })
-
-  it("does not re-render text when message.updated fires multiple times for same message", async () => {
-    //#given
-    const ctx = createMockContext("ses_main")
-    const state = createEventState()
-    const stdoutSpy = spyOn(process.stdout, "write").mockImplementation(() => true)
-    const events: EventPayload[] = [
-      {
-        type: "message.updated",
-        properties: {
-          info: { id: "msg_1", sessionID: "ses_main", role: "assistant", agent: "Sisyphus", modelID: "claude-opus-4-6" },
-        },
-      },
-      {
-        type: "message.part.delta",
-        properties: {
-          sessionID: "ses_main",
-          messageID: "msg_1",
-          field: "text",
-          delta: "Hello world",
-        },
-      },
-      {
-        type: "message.updated",
-        properties: {
-          info: { id: "msg_1", sessionID: "ses_main", role: "assistant", agent: "Sisyphus", modelID: "claude-opus-4-6" },
-        },
-      },
-      {
-        type: "message.part.updated",
-        properties: {
-          part: { id: "text-1", sessionID: "ses_main", type: "text", text: "Hello world" },
-        },
-      },
-    ]
-
-    //#when
-    await processEvents(ctx, toAsyncIterable(events), state)
-
-    //#then
-    const rendered = stdoutSpy.mock.calls.map((call) => String(call[0] ?? "")).join("")
-    const textCount = rendered.split("Hello world").length - 1
-    expect(textCount).toBe(1)
-    stdoutSpy.mockRestore()
-  })
-})

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/output-renderer.ts

@@ -1,90 +0,0 @@
-import pc from "picocolors"
-
-export function renderAgentHeader(
-  agent: string | null,
-  model: string | null,
-  variant: string | null,
-  agentColorsByName: Record<string, string>,
-): void {
-  if (!agent && !model) return
-
-  const agentLabel = agent
-    ? pc.bold(colorizeWithProfileColor(agent, agentColorsByName[agent]))
-    : ""
-  const modelBase = model ?? ""
-  const variantSuffix = variant ? ` (${variant})` : ""
-  const modelLabel = model ? pc.dim(`${modelBase}${variantSuffix}`) : ""
-
-  process.stdout.write("\n")
-
-  if (modelLabel) {
-    process.stdout.write(`  ${modelLabel}  \n`)
-  }
-
-  if (agentLabel) {
-    process.stdout.write(`  ${pc.dim("└─")} ${agentLabel}  \n`)
-  }
-
-  process.stdout.write("\n")
-}
-
-export function openThinkBlock(): void {
-  process.stdout.write(`\n  ${pc.dim("┃  Thinking:")} `)
-}
-
-export function closeThinkBlock(): void {
-  process.stdout.write("  \n\n")
-}
-
-export function writePaddedText(
-  text: string,
-  atLineStart: boolean,
-): { output: string; atLineStart: boolean } {
-  const isGitHubActions = process.env.GITHUB_ACTIONS === "true"
-  if (isGitHubActions) {
-    return { output: text, atLineStart: text.endsWith("\n") }
-  }
-
-  let output = ""
-  let lineStart = atLineStart
-
-  for (let i = 0; i < text.length; i++) {
-    const ch = text[i]
-    if (lineStart) {
-      output += "  "
-      lineStart = false
-    }
-
-    if (ch === "\n") {
-      output += "  \n"
-      lineStart = true
-      continue
-    }
-
-    output += ch
-  }
-
-  return { output, atLineStart: lineStart }
-}
-
-function colorizeWithProfileColor(text: string, hexColor?: string): string {
-  if (!hexColor) return pc.magenta(text)
-
-  const rgb = parseHexColor(hexColor)
-  if (!rgb) return pc.magenta(text)
-
-  const [r, g, b] = rgb
-  return `\u001b[38;2;${r};${g};${b}m${text}\u001b[39m`
-}
-
-function parseHexColor(hexColor: string): [number, number, number] | null {
-  const cleaned = hexColor.trim()
-  const match = cleaned.match(/^#?([A-Fa-f0-9]{6})$/)
-  if (!match) return null
-
-  const hex = match[1]
-  const r = Number.parseInt(hex.slice(0, 2), 16)
-  const g = Number.parseInt(hex.slice(2, 4), 16)
-  const b = Number.parseInt(hex.slice(4, 6), 16)
-  return [r, g, b]
-}

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

@@ -94,7 +94,6 @@ describe("pollForCompletion", () => {
     const result = await pollForCompletion(ctx, eventState, abortController, {
       pollIntervalMs: 10,
       requiredConsecutive: 3,
-      minStabilizationMs: 500,
     })
 
     //#then - should be aborted, not completed (tool blocked exit)
@@ -160,7 +159,6 @@ describe("pollForCompletion", () => {
     const result = await pollForCompletion(ctx, eventState, abortController, {
       pollIntervalMs: 10,
       requiredConsecutive: 3,
-      minStabilizationMs: 500,
     })
 
     //#then
@@ -209,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(() => {})
@@ -312,7 +264,7 @@ describe("pollForCompletion", () => {
     //#then - returns 1 (not 130/timeout), error message printed
     expect(result).toBe(1)
     const errorCalls = (console.error as ReturnType<typeof mock>).mock.calls
-    expect(errorCalls.some((call: unknown[]) => String(call[0] ?? "").includes("Session ended with error"))).toBe(true)
+    expect(errorCalls.some((call) => call[0]?.includes("Session ended with error"))).toBe(true)
   })
 
   it("returns 1 when session errors while tool is active (error not masked by tool gate)", async () => {
@@ -337,5 +289,4 @@ describe("pollForCompletion", () => {
     //#then - returns 1
     expect(result).toBe(1)
   })
-
 })

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

@@ -2,12 +2,11 @@ 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 = 1
+const DEFAULT_REQUIRED_CONSECUTIVE = 3
 const ERROR_GRACE_CYCLES = 3
-const MIN_STABILIZATION_MS = 0
+const MIN_STABILIZATION_MS = 10_000
 
 export interface PollOptions {
   pollIntervalMs?: number
@@ -29,15 +28,10 @@ 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))
 
-    if (abortController.signal.aborted) {
-      return 130
-    }
-
     // ERROR CHECK FIRST — errors must not be masked by other gates
     if (eventState.mainSessionError) {
       errorCycleCount++
@@ -57,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
@@ -75,16 +62,8 @@ export async function pollForCompletion(
     }
 
     if (!eventState.hasReceivedMeaningfulWork) {
-      if (minStabilizationMs <= 0) {
-        consecutiveCompleteChecks = 0
-        continue
-      }
-
-      if (Date.now() - pollStartTimestamp < minStabilizationMs) {
-        consecutiveCompleteChecks = 0
-        continue
-      }
       consecutiveCompleteChecks = 0
+      continue
     }
 
     // Track when first meaningful work was received
@@ -100,10 +79,6 @@ export async function pollForCompletion(
 
     const shouldExit = await checkCompletionConditions(ctx)
     if (shouldExit) {
-      if (abortController.signal.aborted) {
-        return 130
-      }
-
       consecutiveCompleteChecks++
       if (consecutiveCompleteChecks >= requiredConsecutive) {
         console.log(pc.green("\n\nAll tasks completed."))
@@ -116,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 } 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,51 +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", () => {
-
-  it("returns quickly when event processor completes", async () => {
-    //#given
-    const eventProcessor = new Promise<void>((resolve) => {
-      setTimeout(() => {
-        resolve()
-      }, 25)
-    })
-    const start = performance.now()
-
-    //#when
-    await waitForEventProcessorShutdown(eventProcessor, 200)
-
-    //#then
-    const elapsed = performance.now() - start
-    expect(elapsed).toBeLessThan(200)
-  })
-
-  it("times out and continues when event processor does not complete", async () => {
-    //#given
-    const eventProcessor = new Promise<void>(() => {})
-    const timeoutMs = 200
-    const start = performance.now()
-
-    //#when
-    await waitForEventProcessorShutdown(eventProcessor, timeoutMs)
-
-    //#then
-    const elapsed = performance.now() - start
-    expect(elapsed).toBeGreaterThanOrEqual(timeoutMs - 10)
+    expect(agent).toBe("hephaestus")
   })
 })

src/cli/run/runner.ts

@@ -8,23 +8,10 @@ import { createJsonOutputManager } from "./json-output"
 import { executeOnCompleteHook } from "./on-complete-hook"
 import { resolveRunAgent } from "./agent-resolver"
 import { pollForCompletion } from "./poll-for-completion"
-import { loadAgentProfileColors } from "./agent-profile-colors"
 
 export { resolveRunAgent }
 
-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)),
-  ])
-
-  void completed
-}
+const DEFAULT_TIMEOUT_MS = 600_000
 
 export async function run(options: RunOptions): Promise<number> {
   process.env.OPENCODE_CLI_RUN_MODE = "true"
@@ -33,6 +20,7 @@ export async function run(options: RunOptions): Promise<number> {
   const {
     message,
     directory = process.cwd(),
+    timeout = DEFAULT_TIMEOUT_MS,
   } = options
 
   const jsonManager = options.json ? createJsonOutputManager() : null
@@ -41,6 +29,14 @@ export async function run(options: RunOptions): Promise<number> {
   const pluginConfig = loadPluginConfig(directory, { command: "run" })
   const resolvedAgent = resolveRunAgent(options, pluginConfig)
   const abortController = new AbortController()
+  let timeoutId: ReturnType<typeof setTimeout> | null = null
+
+  if (timeout > 0) {
+    timeoutId = setTimeout(() => {
+      console.log(pc.yellow("\nTimeout reached. Aborting..."))
+      abortController.abort()
+    }, timeout)
+  }
 
   try {
     const { client, cleanup: serverCleanup } = await createServerConnection({
@@ -50,6 +46,7 @@ export async function run(options: RunOptions): Promise<number> {
     })
 
     const cleanup = () => {
+      if (timeoutId) clearTimeout(timeoutId)
       serverCleanup()
     }
 
@@ -63,25 +60,18 @@ export async function run(options: RunOptions): Promise<number> {
       const sessionID = await resolveSession({
         client,
         sessionId: options.sessionId,
-        directory,
       })
 
       console.log(pc.dim(`Session: ${sessionID}`))
 
-      const ctx: RunContext = {
-        client,
-        sessionID,
-        directory,
-        abortController,
-        verbose: options.verbose ?? false,
-      }
+      const ctx: RunContext = { client, sessionID, directory, abortController }
       const events = await client.event.subscribe({ query: { directory } })
       const eventState = createEventState()
-      eventState.agentColorsByName = await loadAgentProfileColors(client)
       const eventProcessor = processEvents(ctx, events.stream, eventState).catch(
         () => {},
       )
 
+      console.log(pc.dim("\nSending prompt..."))
       await client.session.promptAsync({
         path: { id: sessionID },
         body: {
@@ -90,13 +80,15 @@ export async function run(options: RunOptions): Promise<number> {
         },
         query: { directory },
       })
-      const exitCode = await pollForCompletion(ctx, eventState, abortController)
 
-      // Abort the event stream to stop the processor
-      abortController.abort()
+       console.log(pc.dim("Waiting for completion...\n"))
+       const exitCode = await pollForCompletion(ctx, eventState, abortController)
 
-      await waitForEventProcessorShutdown(eventProcessor)
-      cleanup()
+       // Abort the event stream to stop the processor
+       abortController.abort()
+
+       await eventProcessor
+       cleanup()
 
       const durationMs = Date.now() - startTime
 
@@ -126,6 +118,7 @@ export async function run(options: RunOptions): Promise<number> {
       throw err
     }
   } catch (err) {
+    if (timeoutId) clearTimeout(timeoutId)
     if (jsonManager) jsonManager.restore()
     if (err instanceof Error && err.name === "AbortError") {
       return 130
@@ -134,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/tool-input-preview.ts

@@ -1,144 +0,0 @@
-export interface ToolHeader {
-  icon: string
-  title: string
-  description?: string
-}
-
-export function formatToolHeader(toolName: string, input: Record<string, unknown>): ToolHeader {
-  if (toolName === "glob") {
-    const pattern = str(input.pattern)
-    const root = str(input.path)
-    return {
-      icon: "✱",
-      title: pattern ? `Glob "${pattern}"` : "Glob",
-      description: root ? `in ${root}` : undefined,
-    }
-  }
-
-  if (toolName === "grep") {
-    const pattern = str(input.pattern)
-    const root = str(input.path)
-    return {
-      icon: "✱",
-      title: pattern ? `Grep "${pattern}"` : "Grep",
-      description: root ? `in ${root}` : undefined,
-    }
-  }
-
-  if (toolName === "list") {
-    const path = str(input.path)
-    return {
-      icon: "→",
-      title: path ? `List ${path}` : "List",
-    }
-  }
-
-  if (toolName === "read") {
-    const filePath = str(input.filePath)
-    return {
-      icon: "→",
-      title: filePath ? `Read ${filePath}` : "Read",
-      description: formatKeyValues(input, ["filePath"]),
-    }
-  }
-
-  if (toolName === "write") {
-    const filePath = str(input.filePath)
-    return {
-      icon: "←",
-      title: filePath ? `Write ${filePath}` : "Write",
-    }
-  }
-
-  if (toolName === "edit") {
-    const filePath = str(input.filePath)
-    return {
-      icon: "←",
-      title: filePath ? `Edit ${filePath}` : "Edit",
-      description: formatKeyValues(input, ["filePath", "oldString", "newString"]),
-    }
-  }
-
-  if (toolName === "webfetch") {
-    const url = str(input.url)
-    return {
-      icon: "%",
-      title: url ? `WebFetch ${url}` : "WebFetch",
-      description: formatKeyValues(input, ["url"]),
-    }
-  }
-
-  if (toolName === "websearch_web_search_exa") {
-    const query = str(input.query)
-    return {
-      icon: "◈",
-      title: query ? `Web Search "${query}"` : "Web Search",
-    }
-  }
-
-  if (toolName === "grep_app_searchGitHub") {
-    const query = str(input.query)
-    return {
-      icon: "◇",
-      title: query ? `Code Search "${query}"` : "Code Search",
-    }
-  }
-
-  if (toolName === "task") {
-    const desc = str(input.description)
-    const subagent = str(input.subagent_type)
-    return {
-      icon: "#",
-      title: desc || (subagent ? `${subagent} Task` : "Task"),
-      description: subagent ? `agent=${subagent}` : undefined,
-    }
-  }
-
-  if (toolName === "bash") {
-    const command = str(input.command)
-    return {
-      icon: "$",
-      title: command || "bash",
-      description: formatKeyValues(input, ["command"]),
-    }
-  }
-
-  if (toolName === "skill") {
-    const name = str(input.name)
-    return {
-      icon: "→",
-      title: name ? `Skill "${name}"` : "Skill",
-    }
-  }
-
-  if (toolName === "todowrite") {
-    return {
-      icon: "#",
-      title: "Todos",
-    }
-  }
-
-  return {
-    icon: "⚙",
-    title: toolName,
-    description: formatKeyValues(input, []),
-  }
-}
-
-function formatKeyValues(input: Record<string, unknown>, exclude: string[]): string | undefined {
-  const entries = Object.entries(input).filter(([key, value]) => {
-    if (exclude.includes(key)) return false
-    return typeof value === "string" || typeof value === "number" || typeof value === "boolean"
-  })
-  if (!entries.length) return undefined
-
-  return entries
-    .map(([key, value]) => `${key}=${String(value)}`)
-    .join(" ")
-}
-
-function str(value: unknown): string | undefined {
-  if (typeof value !== "string") return undefined
-  const trimmed = value.trim()
-  return trimmed.length ? trimmed : undefined
-}

src/cli/run/types.ts

@@ -4,8 +4,8 @@ export type { OpencodeClient }
 export interface RunOptions {
   message: string
   agent?: string
-  verbose?: boolean
   directory?: string
+  timeout?: number
   port?: number
   attach?: string
   onComplete?: string
@@ -31,14 +31,13 @@ export interface RunContext {
   sessionID: string
   directory: string
   abortController: AbortController
-  verbose?: boolean
 }
 
 export interface Todo {
-  id?: string;
-  content: string;
-  status: string;
-  priority: string;
+  id: string
+  content: string
+  status: string
+  priority: string
 }
 
 export interface SessionStatus {
@@ -56,79 +55,46 @@ export interface EventPayload {
 
 export interface SessionIdleProps {
   sessionID?: string
-  sessionId?: string
 }
 
 export interface SessionStatusProps {
   sessionID?: string
-  sessionId?: string
   status?: { type?: string }
 }
 
 export interface MessageUpdatedProps {
   info?: {
-    id?: string
     sessionID?: string
-    sessionId?: string
     role?: string
     modelID?: string
     providerID?: string
     agent?: string
-    variant?: string
   }
 }
 
 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 MessagePartDeltaProps {
-  sessionID?: string
-  sessionId?: string
-  messageID?: string
-  partID?: string
-  field?: string
-  delta?: string
-}
-
 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/AGENTS.md

@@ -1,50 +1,52 @@
-# src/config/ — Zod v4 Schema System
-
-**Generated:** 2026-02-17
+# CONFIG KNOWLEDGE BASE
 
 ## OVERVIEW
 
-22 schema files composing `OhMyOpenCodeConfigSchema`. Zod v4 validation with `safeParse()`. All fields optional — omitted fields use plugin defaults.
-
-## SCHEMA TREE
+Zod schema definitions for plugin configuration. 21 component files composing `OhMyOpenCodeConfigSchema` with multi-level inheritance and JSONC support.
 
+## STRUCTURE
 ```
-config/schema/
-├── oh-my-opencode-config.ts    # ROOT: OhMyOpenCodeConfigSchema (composes all below)
-├── agent-names.ts              # BuiltinAgentNameSchema (11), OverridableAgentNameSchema (14)
-├── agent-overrides.ts          # AgentOverrideConfigSchema (21 fields per agent)
-├── categories.ts               # 8 built-in + custom categories
-├── hooks.ts                    # HookNameSchema (46 hooks)
-├── skills.ts                   # SkillsConfigSchema (sources, paths, recursive)
-├── commands.ts                 # BuiltinCommandNameSchema
-├── experimental.ts             # Feature flags (plugin_load_timeout_ms min 1000, hashline_edit)
-├── sisyphus.ts                 # SisyphusConfigSchema (task system)
-├── sisyphus-agent.ts           # SisyphusAgentConfigSchema
-├── ralph-loop.ts               # RalphLoopConfigSchema
-├── tmux.ts                     # TmuxConfigSchema + TmuxLayoutSchema
-├── websearch.ts                # provider: "exa" | "tavily"
-├── claude-code.ts              # CC compatibility settings
-├── comment-checker.ts          # AI comment detection config
-├── notification.ts             # OS notification settings
-├── git-master.ts               # commit_footer: boolean | string
-├── browser-automation.ts       # provider: playwright | agent-browser | playwright-cli
-├── background-task.ts          # Concurrency limits per model/provider
-├── babysitting.ts              # Unstable agent monitoring
-├── dynamic-context-pruning.ts  # Context pruning settings
-└── internal/permission.ts      # AgentPermissionSchema
+config/
+├── schema/                    # 21 schema component files
+│   ├── oh-my-opencode-config.ts # Root schema composition (57 lines)
+│   ├── agent-names.ts         # BuiltinAgentNameSchema (11 agents), BuiltinSkillNameSchema
+│   ├── agent-overrides.ts     # AgentOverrideConfigSchema (model, variant, temp, thinking...)
+│   ├── categories.ts          # 8 categories: visual-engineering, ultrabrain, deep, artistry, quick, ...
+│   ├── hooks.ts               # HookNameSchema (100+ hook names)
+│   ├── commands.ts            # BuiltinCommandNameSchema
+│   ├── experimental.ts        # ExperimentalConfigSchema
+│   ├── dynamic-context-pruning.ts # DynamicContextPruningConfigSchema (55 lines)
+│   ├── background-task.ts     # BackgroundTaskConfigSchema
+│   ├── claude-code.ts         # ClaudeCodeConfigSchema
+│   ├── comment-checker.ts     # CommentCheckerConfigSchema
+│   ├── notification.ts        # NotificationConfigSchema
+│   ├── ralph-loop.ts          # RalphLoopConfigSchema
+│   ├── sisyphus.ts            # SisyphusConfigSchema
+│   ├── sisyphus-agent.ts      # SisyphusAgentConfigSchema
+│   ├── skills.ts              # SkillsConfigSchema (45 lines)
+│   ├── tmux.ts                # TmuxConfigSchema, TmuxLayoutSchema
+│   ├── websearch.ts           # WebsearchConfigSchema
+│   ├── browser-automation.ts  # BrowserAutomationConfigSchema
+│   ├── git-master.ts          # GitMasterConfigSchema
+│   └── babysitting.ts         # BabysittingConfigSchema
+├── schema.ts                  # Barrel export (24 lines)
+├── schema.test.ts             # Validation tests (735 lines)
+├── types.ts                   # TypeScript types from schemas
+└── index.ts                   # Barrel export (33 lines)
 ```
 
-## ROOT SCHEMA FIELDS (26)
+## ROOT SCHEMA
 
-`$schema`, `new_task_system_enabled`, `default_run_agent`, `disabled_mcps`, `disabled_agents`, `disabled_skills`, `disabled_hooks`, `disabled_commands`, `disabled_tools`, `agents`, `categories`, `claude_code`, `sisyphus_agent`, `comment_checker`, `experimental`, `auto_update`, `skills`, `ralph_loop`, `background_task`, `notification`, `babysitting`, `git_master`, `browser_automation_engine`, `websearch`, `tmux`, `sisyphus`, `_migrations`
+`OhMyOpenCodeConfigSchema` composes: `$schema`, `new_task_system_enabled`, `default_run_agent`, `auto_update`, `disabled_{mcps,agents,skills,hooks,commands,tools}`, `agents` (14 agent keys), `categories` (8 built-in), `claude_code`, `sisyphus_agent`, `comment_checker`, `experimental`, `skills`, `ralph_loop`, `background_task`, `notification`, `babysitting`, `git_master`, `browser_automation_engine`, `websearch`, `tmux`, `sisyphus`
 
-## AGENT OVERRIDE FIELDS (21)
+## CONFIGURATION HIERARCHY
 
-`model`, `variant`, `category`, `skills`, `temperature`, `top_p`, `prompt`, `prompt_append`, `tools`, `disable`, `description`, `mode`, `color`, `permission`, `maxTokens`, `thinking`, `reasoningEffort`, `textVerbosity`, `providerOptions`
+Project (`.opencode/oh-my-opencode.json`) → User (`~/.config/opencode/oh-my-opencode.json`) → Defaults
 
-## HOW TO ADD CONFIG
+## AGENT OVERRIDE FIELDS
 
-1. Create `src/config/schema/{name}.ts` with Zod schema
-2. Add field to `oh-my-opencode-config.ts` root schema
-3. Reference via `z.infer<typeof YourSchema>` for TypeScript types
-4. Access in handlers via `pluginConfig.{name}`
+`model`, `variant`, `category`, `skills`, `temperature`, `top_p`, `maxTokens`, `thinking`, `reasoningEffort`, `textVerbosity`, `prompt`, `prompt_append`, `tools`, `permission`, `providerOptions`, `disable`, `description`, `mode`, `color`
+
+## AFTER SCHEMA CHANGES
+
+Run `bun run build:schema` to regenerate `dist/oh-my-opencode.schema.json`

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

@@ -33,11 +33,9 @@ export const HookNameSchema = z.enum([
   "claude-code-hooks",
   "auto-slash-command",
   "edit-error-recovery",
-  "json-error-recovery",
   "delegate-task-retry",
   "prometheus-md-only",
   "sisyphus-junior-notepad",
-  "sisyphus-gpt-hephaestus-reminder",
   "start-work",
   "atlas",
   "unstable-agent-babysitter",
@@ -47,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-hooks.ts

@@ -3,7 +3,6 @@ import type { HookName, OhMyOpenCodeConfig } from "./config"
 import type { LoadedSkill } from "./features/opencode-skill-loader/types"
 import type { BackgroundManager } from "./features/background-agent"
 import type { PluginContext } from "./plugin/types"
-import type { ModelCacheState } from "./plugin-state"
 
 import { createCoreHooks } from "./plugin/hooks/create-core-hooks"
 import { createContinuationHooks } from "./plugin/hooks/create-continuation-hooks"
@@ -14,7 +13,6 @@ export type CreatedHooks = ReturnType<typeof createHooks>
 export function createHooks(args: {
   ctx: PluginContext
   pluginConfig: OhMyOpenCodeConfig
-  modelCacheState: ModelCacheState
   backgroundManager: BackgroundManager
   isHookEnabled: (hookName: HookName) => boolean
   safeHookEnabled: boolean
@@ -24,7 +22,6 @@ export function createHooks(args: {
   const {
     ctx,
     pluginConfig,
-    modelCacheState,
     backgroundManager,
     isHookEnabled,
     safeHookEnabled,
@@ -35,7 +32,6 @@ export function createHooks(args: {
   const core = createCoreHooks({
     ctx,
     pluginConfig,
-    modelCacheState,
     isHookEnabled,
     safeHookEnabled,
   })

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

@@ -1,70 +1,79 @@
-# src/features/ — 19 Feature Modules
-
-**Generated:** 2026-02-18
+# FEATURES KNOWLEDGE BASE
 
 ## OVERVIEW
 
-Standalone feature modules wired into plugin/ layer. Each is self-contained with own types, implementation, and tests.
+18 feature modules extending plugin capabilities: agent orchestration, skill loading, Claude Code compatibility, MCP management, task storage, and tmux integration.
 
-## MODULE MAP
+## STRUCTURE
+```
+features/
+├── 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
+│   ├── 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
+│   ├── oauth-authorization-flow.ts # PKCE, callback handling
+│   └── dcr.ts                  # Dynamic Client Registration (RFC 7591)
+├── 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 (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)
+├── claude-code-command-loader/ # Command loading from .opencode/commands/ (3 files)
+├── claude-code-agent-loader/   # Agent loading from .opencode/agents/ (3 files)
+├── claude-code-session-state/  # Subagent session state tracking (3 files)
+├── hook-message-injector/      # System message injection (4 files)
+├── task-toast-manager/         # Task progress notifications (4 files)
+├── boulder-state/              # Persistent state for multi-step ops (5 files)
+└── tool-metadata-store/        # Tool execution metadata caching (3 files)
+```
 
-| Module | Files | Complexity | Purpose |
-|--------|-------|------------|---------|
-| **background-agent** | 49 | HIGH | Task lifecycle, concurrency (5/model), polling, spawner pattern |
-| **tmux-subagent** | 27 | HIGH | Tmux pane management, grid planning, session orchestration |
-| **opencode-skill-loader** | 25 | HIGH | YAML frontmatter skill loading from 4 scopes |
-| **mcp-oauth** | 10 | HIGH | OAuth 2.0 + PKCE + DCR (RFC 7591) for MCP servers |
-| **builtin-skills** | 10 | LOW | 6 skills: git-master, playwright, playwright-cli, agent-browser, dev-browser, frontend-ui-ux |
-| **skill-mcp-manager** | 10 | MEDIUM | MCP client lifecycle per session (stdio + HTTP) |
-| **claude-code-plugin-loader** | 10 | MEDIUM | Unified plugin discovery from .opencode/plugins/ |
-| **builtin-commands** | 9 | LOW | Command templates: refactor, init-deep, handoff, etc. |
-| **claude-code-mcp-loader** | 5 | MEDIUM | .mcp.json loading with ${VAR} env expansion |
-| **context-injector** | 4 | MEDIUM | AGENTS.md/README.md injection into context |
-| **boulder-state** | 4 | LOW | Persistent state for multi-step operations |
-| **hook-message-injector** | 4 | MEDIUM | System message injection for hooks |
-| **claude-tasks** | 4 | MEDIUM | Task schema + file storage + OpenCode todo sync |
-| **task-toast-manager** | 3 | MEDIUM | Task progress notifications |
-| **claude-code-agent-loader** | 3 | LOW | Load agents from .opencode/agents/ |
-| **claude-code-command-loader** | 3 | LOW | Load commands from .opencode/commands/ |
-| **claude-code-session-state** | 2 | LOW | Subagent session state tracking |
-| **run-continuation-state** | 5 | LOW | Persistent state for `run` command continuation across sessions |
-| **tool-metadata-store** | 2 | LOW | Tool execution metadata cache |
+## KEY PATTERNS
 
-## KEY MODULES
+**Background Agent Lifecycle:**
+Task creation → Queue → Concurrency check → Execute → Monitor/Poll → Notification → Cleanup
 
-### background-agent (49 files, ~10k LOC)
+**Skill Loading Pipeline (4-scope priority):**
+opencode-project (`.opencode/skills/`) > opencode (`~/.config/opencode/skills/`) > project (`.claude/skills/`) > user (`~/.claude/skills/`)
 
-Core orchestration engine. `BackgroundManager` manages task lifecycle:
-- States: pending → running → completed/error/cancelled/interrupt
-- Concurrency: per-model/provider limits via `ConcurrencyManager` (FIFO queue)
-- Polling: 3s interval, completion via idle events + stability detection (10s unchanged)
-- spawner/: 8 focused files composing via `SpawnerContext` interface
+**Claude Code Compatibility Layer:**
+5 loaders: agent-loader, command-loader, mcp-loader, plugin-loader, session-state
 
-### opencode-skill-loader (25 files, ~3.2k LOC)
+**SKILL.md Format:**
+```yaml
+---
+name: my-skill
+description: "..."
+model: "claude-opus-4-6"    # optional
+agent: "sisyphus"           # optional
+mcp:                        # optional embedded MCPs
+  server-name:
+    type: http
+    url: https://...
+---
+# Skill instruction content
+```
 
-4-scope skill discovery (project > opencode > user > global):
-- YAML frontmatter parsing from SKILL.md files
-- Skill merger with priority deduplication
-- Template resolution with variable substitution
-- Provider gating for model-specific skills
+## HOW TO ADD
 
-### tmux-subagent (27 files, ~3.6k LOC)
+1. Create directory under `src/features/`
+2. Add `index.ts`, `types.ts`, `constants.ts` as needed
+3. Export from `index.ts` following barrel pattern
+4. Register in main plugin if plugin-level feature
 
-State-first tmux integration:
-- `TmuxSessionManager`: pane lifecycle, grid planning
-- Spawn action decider + target finder
-- Polling manager for session health
-- Event handlers for pane creation/destruction
+## CHILD DOCUMENTATION
 
-### builtin-skills (6 skill objects)
-
-| Skill | Size | MCP | Tools |
-|-------|------|-----|-------|
-| git-master | 1111 LOC | — | Bash |
-| playwright | 312 LOC | @playwright/mcp | — |
-| agent-browser | (in playwright.ts) | — | Bash(agent-browser:*) |
-| playwright-cli | 268 LOC | — | Bash(playwright-cli:*) |
-| dev-browser | 221 LOC | — | Bash |
-| frontend-ui-ux | 79 LOC | — | — |
-
-Browser variant selected by `browserProvider` config: playwright (default) | playwright-cli | agent-browser.
+- See `claude-tasks/AGENTS.md` for task schema and storage details

src/features/background-agent/AGENTS.md

@@ -1,56 +0,0 @@
-# src/features/background-agent/ — Core Orchestration Engine
-
-**Generated:** 2026-02-18
-
-## OVERVIEW
-
-39 files (~10k LOC). Manages async task lifecycle: launch → queue → run → poll → complete/error. Concurrency limited per model/provider (default 5). Central to multi-agent orchestration.
-
-## TASK LIFECYCLE
-
-```
-LaunchInput → pending → [ConcurrencyManager queue] → running → polling → completed/error/cancelled/interrupt
-```
-
-## KEY FILES
-
-| File | Purpose |
-|------|---------|
-| `manager.ts` | `BackgroundManager` — main class: launch, cancel, getTask, listTasks |
-| `spawner.ts` | Task spawning: create session → inject prompt → start polling |
-| `concurrency.ts` | `ConcurrencyManager` — FIFO queue per concurrency key, slot acquisition/release |
-| `task-poller.ts` | 3s interval polling, completion via idle events + stability detection (10s unchanged) |
-| `result-handler.ts` | Process completed tasks: extract result, notify parent, cleanup |
-| `state.ts` | In-memory task store (Map-based) |
-| `types.ts` | `BackgroundTask`, `LaunchInput`, `ResumeInput`, `BackgroundTaskStatus` |
-
-## SPAWNER SUBDIRECTORY (6 files)
-
-| File | Purpose |
-|------|---------|
-| `spawner-context.ts` | `SpawnerContext` interface composing all spawner deps |
-| `background-session-creator.ts` | Create OpenCode session for background task |
-| `concurrency-key-from-launch-input.ts` | Derive concurrency key from model/provider |
-| `parent-directory-resolver.ts` | Resolve working directory for child session |
-| `tmux-callback-invoker.ts` | Notify TmuxSessionManager on session creation |
-
-## COMPLETION DETECTION
-
-Two signals combined:
-1. **Session idle event** — OpenCode reports session became idle
-2. **Stability detection** — message count unchanged for 10s (3+ stable polls at 3s interval)
-
-Both must agree before marking a task complete. Prevents premature completion on brief pauses.
-
-## CONCURRENCY MODEL
-
-- Key format: `{providerID}/{modelID}` (e.g., `anthropic/claude-opus-4-6`)
-- Default limit: 5 concurrent per key (configurable via `background_task` config)
-- FIFO queue: tasks wait in order when slots full
-- Slot released on: completion, error, cancellation
-
-## NOTIFICATION FLOW
-
-```
-task completed → result-handler → parent-session-notifier → inject system message into parent session
-```

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

@@ -0,0 +1,168 @@
+import { log } from "../../shared"
+import type { BackgroundTask } from "./types"
+import { cleanupTaskAfterSessionEnds } from "./session-task-cleanup"
+import { handleSessionIdleBackgroundEvent } from "./session-idle-event-handler"
+
+type Event = { type: string; properties?: Record<string, unknown> }
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null
+}
+
+function getString(obj: Record<string, unknown>, key: string): string | undefined {
+  const value = obj[key]
+  return typeof value === "string" ? value : undefined
+}
+
+export function handleBackgroundEvent(args: {
+  event: Event
+  findBySession: (sessionID: string) => BackgroundTask | undefined
+  getAllDescendantTasks: (sessionID: string) => BackgroundTask[]
+  releaseConcurrencyKey?: (key: string) => void
+  cancelTask: (
+    taskId: string,
+    options: { source: string; reason: string; skipNotification: true }
+  ) => Promise<boolean>
+  tryCompleteTask: (task: BackgroundTask, source: string) => Promise<boolean>
+  validateSessionHasOutput: (sessionID: string) => Promise<boolean>
+  checkSessionTodos: (sessionID: string) => Promise<boolean>
+  idleDeferralTimers: Map<string, ReturnType<typeof setTimeout>>
+  completionTimers: Map<string, ReturnType<typeof setTimeout>>
+  tasks: Map<string, BackgroundTask>
+  cleanupPendingByParent: (task: BackgroundTask) => void
+  clearNotificationsForTask: (taskId: string) => void
+  emitIdleEvent: (sessionID: string) => void
+}): void {
+  const {
+    event,
+    findBySession,
+    getAllDescendantTasks,
+    releaseConcurrencyKey,
+    cancelTask,
+    tryCompleteTask,
+    validateSessionHasOutput,
+    checkSessionTodos,
+    idleDeferralTimers,
+    completionTimers,
+    tasks,
+    cleanupPendingByParent,
+    clearNotificationsForTask,
+    emitIdleEvent,
+  } = args
+
+  const props = event.properties
+
+  if (event.type === "message.part.updated") {
+    if (!props || !isRecord(props)) return
+    const sessionID = getString(props, "sessionID")
+    if (!sessionID) return
+
+    const task = findBySession(sessionID)
+    if (!task) return
+
+    const existingTimer = idleDeferralTimers.get(task.id)
+    if (existingTimer) {
+      clearTimeout(existingTimer)
+      idleDeferralTimers.delete(task.id)
+    }
+
+    const type = getString(props, "type")
+    const tool = getString(props, "tool")
+
+    if (!task.progress) {
+      task.progress = { toolCalls: 0, lastUpdate: new Date() }
+    }
+    task.progress.lastUpdate = new Date()
+
+    if (type === "tool" || tool) {
+      task.progress.toolCalls += 1
+      task.progress.lastTool = tool
+    }
+  }
+
+  if (event.type === "session.idle") {
+    if (!props || !isRecord(props)) return
+    handleSessionIdleBackgroundEvent({
+      properties: props,
+      findBySession,
+      idleDeferralTimers,
+      validateSessionHasOutput,
+      checkSessionTodos,
+      tryCompleteTask,
+      emitIdleEvent,
+    })
+  }
+
+  if (event.type === "session.error") {
+    if (!props || !isRecord(props)) return
+    const sessionID = getString(props, "sessionID")
+    if (!sessionID) return
+
+    const task = findBySession(sessionID)
+    if (!task || task.status !== "running") return
+
+    const errorRaw = props["error"]
+    const dataRaw = isRecord(errorRaw) ? errorRaw["data"] : undefined
+    const message =
+      (isRecord(dataRaw) ? getString(dataRaw, "message") : undefined) ??
+      (isRecord(errorRaw) ? getString(errorRaw, "message") : undefined) ??
+      "Session error"
+
+    task.status = "error"
+    task.error = message
+    task.completedAt = new Date()
+
+    cleanupTaskAfterSessionEnds({
+      task,
+      tasks,
+      idleDeferralTimers,
+      completionTimers,
+      cleanupPendingByParent,
+      clearNotificationsForTask,
+      releaseConcurrencyKey,
+    })
+  }
+
+  if (event.type === "session.deleted") {
+    if (!props || !isRecord(props)) return
+    const infoRaw = props["info"]
+    if (!isRecord(infoRaw)) return
+    const sessionID = getString(infoRaw, "id")
+    if (!sessionID) return
+
+    const tasksToCancel = new Map<string, BackgroundTask>()
+    const directTask = findBySession(sessionID)
+    if (directTask) {
+      tasksToCancel.set(directTask.id, directTask)
+    }
+    for (const descendant of getAllDescendantTasks(sessionID)) {
+      tasksToCancel.set(descendant.id, descendant)
+    }
+    if (tasksToCancel.size === 0) return
+
+    for (const task of tasksToCancel.values()) {
+      if (task.status === "running" || task.status === "pending") {
+        void cancelTask(task.id, {
+          source: "session.deleted",
+          reason: "Session deleted",
+          skipNotification: true,
+        }).catch((err) => {
+          log("[background-agent] Failed to cancel task on session.deleted:", {
+            taskId: task.id,
+            error: err,
+          })
+        })
+      }
+
+      cleanupTaskAfterSessionEnds({
+        task,
+        tasks,
+        idleDeferralTimers,
+        completionTimers,
+        cleanupPendingByParent,
+        clearNotificationsForTask,
+        releaseConcurrencyKey,
+      })
+    }
+  }
+}

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

@@ -0,0 +1,82 @@
+import { log } from "../../shared"
+
+import type { BackgroundTask, LaunchInput } from "./types"
+import type { ConcurrencyManager } from "./concurrency"
+import type { PluginInput } from "@opencode-ai/plugin"
+
+type QueueItem = { task: BackgroundTask; input: LaunchInput }
+
+export function shutdownBackgroundManager(args: {
+  shutdownTriggered: { value: boolean }
+  stopPolling: () => void
+  tasks: Map<string, BackgroundTask>
+  client: PluginInput["client"]
+  onShutdown?: () => void
+  concurrencyManager: ConcurrencyManager
+  completionTimers: Map<string, ReturnType<typeof setTimeout>>
+  idleDeferralTimers: Map<string, ReturnType<typeof setTimeout>>
+  notifications: Map<string, BackgroundTask[]>
+  pendingByParent: Map<string, Set<string>>
+  queuesByKey: Map<string, QueueItem[]>
+  processingKeys: Set<string>
+  unregisterProcessCleanup: () => void
+}): void {
+  const {
+    shutdownTriggered,
+    stopPolling,
+    tasks,
+    client,
+    onShutdown,
+    concurrencyManager,
+    completionTimers,
+    idleDeferralTimers,
+    notifications,
+    pendingByParent,
+    queuesByKey,
+    processingKeys,
+    unregisterProcessCleanup,
+  } = args
+
+  if (shutdownTriggered.value) return
+  shutdownTriggered.value = true
+
+  log("[background-agent] Shutting down BackgroundManager")
+  stopPolling()
+
+  for (const task of tasks.values()) {
+    if (task.status === "running" && task.sessionID) {
+      client.session.abort({ path: { id: task.sessionID } }).catch(() => {})
+    }
+  }
+
+  if (onShutdown) {
+    try {
+      onShutdown()
+    } catch (error) {
+      log("[background-agent] Error in onShutdown callback:", error)
+    }
+  }
+
+  for (const task of tasks.values()) {
+    if (task.concurrencyKey) {
+      concurrencyManager.release(task.concurrencyKey)
+      task.concurrencyKey = undefined
+    }
+  }
+
+  for (const timer of completionTimers.values()) clearTimeout(timer)
+  completionTimers.clear()
+
+  for (const timer of idleDeferralTimers.values()) clearTimeout(timer)
+  idleDeferralTimers.clear()
+
+  concurrencyManager.clear()
+  tasks.clear()
+  notifications.clear()
+  pendingByParent.clear()
+  queuesByKey.clear()
+  processingKeys.clear()
+  unregisterProcessCleanup()
+
+  log("[background-agent] Shutdown complete")
+}

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
+}