release: v3.7.2

Add newlines around agent header for visual separation, dim the thinking
label, and add trailing newline after think block close.

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

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

@@ -1,489 +0,0 @@
----
-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-pr-triage/SKILL.md

@@ -1,484 +0,0 @@
----
-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

@@ -1,373 +0,0 @@
-#!/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

@@ -0,0 +1,482 @@
+---
+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

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

@@ -69,7 +69,9 @@ 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)
@@ -123,7 +125,6 @@ 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)
@@ -131,24 +132,25 @@ 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)
@@ -157,12 +159,10 @@ 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,11 +171,14 @@ 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
 
@@ -190,14 +193,16 @@ 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]:  # Show first 50
+    for item in items[: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,
@@ -211,13 +216,21 @@ 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."""
 
@@ -225,33 +238,29 @@ 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]",
-                title="[green]Pagination Complete[/green]",
-                border_style="green",
-            )
+            Panel(f"[green]Found {len(items)} issues[/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
+        else:
             console.print(f"Total issues: {len(items)}")
 
     asyncio.run(async_main())
@@ -259,13 +268,21 @@ 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."""
 
@@ -273,33 +290,29 @@ 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]",
-                title="[green]Pagination Complete[/green]",
-                border_style="green",
-            )
+            Panel(f"[green]Found {len(items)} PRs[/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
+        else:
             console.print(f"Total PRs: {len(items)}")
 
     asyncio.run(async_main())
@@ -307,13 +320,21 @@ 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."""
 
@@ -321,22 +342,25 @@ 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(
@@ -345,12 +369,13 @@ 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]",
-                title="[green]Pagination Complete[/green]",
+                f"[green]Found {len(issues_items)} issues and {len(prs_items)} PRs[/green]",
                 border_style="green",
             )
         )
@@ -362,7 +387,7 @@ def fetch_all(
             display_table(issues_items, "issue")
             console.print("")
             display_table(prs_items, "pr")
-        else:  # COUNT
+        else:
             console.print(f"Total issues: {len(issues_items)}")
             console.print(f"Total PRs: {len(prs_items)}")
 

AGENTS.md

@@ -1,320 +1,119 @@
-# PROJECT KNOWLEDGE BASE
+# oh-my-opencode — OpenCode Plugin
 
-**Generated:** 2026-02-16T14:58:00+09:00
-**Commit:** 28cd34c3
-**Branch:** fuck-v1.2
-
----
-
-## 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.**
-
----
+**Generated:** 2026-02-18 | **Commit:** 04e95d7e | **Branch:** dev
 
 ## OVERVIEW
 
-OpenCode plugin (oh-my-opencode): multi-model agent orchestration with 11 specialized agents, 41 lifecycle hooks across 7 event types, 26 tools (LSP, AST-Grep, delegation, task management), full Claude Code compatibility layer, 4-scope skill loading, background agent concurrency, tmux integration, and 3-tier MCP system. "oh-my-zsh" for OpenCode.
+OpenCode plugin (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.
 
 ## STRUCTURE
 
 ```
 oh-my-opencode/
 ├── src/
-│   ├── agents/              # 11 AI agents — see src/agents/AGENTS.md
-│   ├── hooks/               # 41 lifecycle hooks — see src/hooks/AGENTS.md
-│   ├── tools/               # 26 tools — see src/tools/AGENTS.md
-│   ├── features/            # Background agents, skills, CC compat — see src/features/AGENTS.md
-│   ├── shared/              # Cross-cutting utilities — see src/shared/AGENTS.md
-│   ├── cli/                 # CLI installer, doctor — see src/cli/AGENTS.md
-│   ├── mcp/                 # Built-in MCPs — see src/mcp/AGENTS.md
-│   ├── config/              # Zod schema — see src/config/AGENTS.md
-│   ├── plugin-handlers/     # Config loading pipeline — see src/plugin-handlers/AGENTS.md
-│   ├── plugin/              # Plugin interface composition (21 files)
-│   ├── index.ts             # Main plugin entry (106 lines)
-│   ├── create-hooks.ts      # Hook creation coordination (62 lines)
-│   ├── create-managers.ts   # Manager initialization (80 lines)
-│   ├── create-tools.ts      # Tool registry composition (54 lines)
-│   ├── plugin-interface.ts  # Plugin interface assembly (66 lines)
-│   ├── plugin-config.ts     # Config loading orchestration (180 lines)
-│   └── plugin-state.ts      # Model cache state (12 lines)
-├── script/                  # build-schema.ts, build-binaries.ts, publish.ts, generate-changelog.ts
-├── packages/                # 11 platform-specific binary packages
-└── dist/                    # Build output (ESM + .d.ts)
+│   ├── 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
 ```
 
 ## INITIALIZATION FLOW
 
 ```
 OhMyOpenCodePlugin(ctx)
-  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(...)                 → 7 OpenCode hook handlers
- 10. Return plugin with experimental.session.compacting
+  ├─→ 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
 ```
 
+## 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 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 (1701 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 |
+| 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 |
 
-## TDD (Test-Driven Development)
+## MULTI-LEVEL CONFIG
 
-**MANDATORY.** RED-GREEN-REFACTOR:
-1. **RED**: Write test → `bun test` → FAIL
-2. **GREEN**: Implement minimum → PASS
-3. **REFACTOR**: Clean up → stay GREEN
+```
+Project (.opencode/oh-my-opencode.jsonc)  →  User (~/.config/opencode/oh-my-opencode.jsonc)  →  Defaults
+```
 
-**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`
+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) |
 
 ## CONVENTIONS
 
-- **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, 1130 TypeScript files
-- **Temperature**: 0.1 for code agents, max 0.3
-- **Modular architecture**: 200 LOC hard limit per file (prompt strings exempt)
+- **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
 
 ## ANTI-PATTERNS
 
-| 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`. 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 |
+- 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)
 
 ## COMMANDS
 
 ```bash
-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
+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
 ```
 
-## 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` | 1701 | 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` | 1112 | 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
 
-- **OpenCode**: Requires >= 1.0.150
-- **1130 TypeScript files**, 176 test files, 127k+ 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)
+- 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)

README.ja.md

@@ -172,16 +172,16 @@ Windows から Linux に初めて乗り換えた時のこと、自分の思い
 私の人生もそうです。振り返ってみれば、私たち人間と何ら変わりありません。
 **はい！LLMエージェントたちは私たちと変わりません。優れたツールと最高の仲間がいれば、彼らも私たちと同じくらい優れたコードを書き、立派に仕事をこなすことができます。**
 
-私たちのメインエージェント、Sisyphus（Opus 4.5 High）を紹介します。以下は、シジフォスが岩を転がすために使用するツールです。
+私たちのメインエージェント、Sisyphus（Opus 4.6）を紹介します。以下は、シジフォスが岩を転がすために使用するツールです。
 
 *以下の内容はすべてカスタマイズ可能です。必要なものだけを使ってください。デフォルトではすべての機能が有効になっています。何もしなくても大丈夫です。*
 
 - シジフォスのチームメイト (Curated Agents)
-  - Hephaestus: 自律型ディープワーカー、目標指向実行 (GPT 5.2 Codex Medium) — *正当な職人*
-  - Oracle: 設計、デバッグ (GPT 5.2 Medium)
+  - Hephaestus: 自律型ディープワーカー、目標指向実行 (GPT 5.3 Codex Medium) — *正当な職人*
+  - Oracle: 設計、デバッグ (GPT 5.2)
   - Frontend UI/UX Engineer: フロントエンド開発 (Gemini 3 Pro)
-  - Librarian: 公式ドキュメント、オープンソース実装、コードベース探索 (Claude Sonnet 4.5)
-   - Explore: 超高速コードベース探索 (Contextual Grep) (Claude Haiku 4.5)
+  - Librarian: 公式ドキュメント、オープンソース実装、コードベース探索 (GLM-4.7)
+   - Explore: 超高速コードベース探索 (Contextual Grep) (Grok Code Fast 1)
 - Full LSP / AstGrep Support: 決定的にリファクタリングしましょう。
 - Todo Continuation Enforcer: 途中で諦めたら、続行を強制します。これがシジフォスに岩を転がし続けさせる秘訣です。
 - Comment Checker: AIが過剰なコメントを付けないようにします。シジフォスが生成したコードは、人間が書いたものと区別がつかないべきです。
@@ -199,7 +199,7 @@ Windows から Linux に初めて乗り換えた時のこと、自分の思い
 ![Meet Hephaestus](.github/assets/hephaestus.png)
 
 ギリシャ神話において、ヘパイストスは鍛冶、火、金属加工、職人技の神でした—比類のない精密さと献身で神々の武器を作り上げた神聖な鍛冶師です。
-**自律型ディープワーカーを紹介します: ヘパイストス (GPT 5.2 Codex Medium)。正当な職人エージェント。**
+**自律型ディープワーカーを紹介します: ヘパイストス (GPT 5.3 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.5 High). 아래는 Sisyphus가 그 바위를 굴리는 데 사용하는 도구입니다.
+우리의 주요 에이전트를 만나보세요: Sisyphus (Opus 4.6). 아래는 Sisyphus가 그 바위를 굴리는 데 사용하는 도구입니다.
 
 *아래의 모든 것은 사용자 정의 가능합니다. 원하는 것을 가져가세요. 모든 기능은 기본적으로 활성화됩니다. 아무것도 할 필요가 없습니다. 포함되어 있으며, 즉시 작동합니다.*
 
 - Sisyphus의 팀원 (큐레이팅된 에이전트)
-  - Hephaestus: 자율적 딥 워커, 목표 지향 실행 (GPT 5.2 Codex Medium) — *합법적인 장인*
-  - Oracle: 디자인, 디버깅 (GPT 5.2 Medium)
+  - Hephaestus: 자율적 딥 워커, 목표 지향 실행 (GPT 5.3 Codex Medium) — *합법적인 장인*
+  - Oracle: 디자인, 디버깅 (GPT 5.2)
   - Frontend UI/UX Engineer: 프론트엔드 개발 (Gemini 3 Pro)
-  - Librarian: 공식 문서, 오픈 소스 구현, 코드베이스 탐색 (Claude Sonnet 4.5)
-   - Explore: 엄청나게 빠른 코드베이스 탐색 (Contextual Grep) (Claude Haiku 4.5)
+  - Librarian: 공식 문서, 오픈 소스 구현, 코드베이스 탐색 (GLM-4.7)
+   - Explore: 엄청나게 빠른 코드베이스 탐색 (Contextual Grep) (Grok Code Fast 1)
 - 완전한 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.2 Codex Medium). 합법적인 장인 에이전트.**
+**자율적 딥 워커를 소개합니다: 헤파이스토스 (GPT 5.3 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.5 High). Below are the tools Sisyphus uses to keep that boulder rolling.
+Meet our main agent: Sisyphus (Opus 4.6). 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.2 Codex Medium) — *The Legitimate Craftsman*
-  - Oracle: Design, debugging (GPT 5.2 Medium)
+  - Hephaestus: Autonomous deep worker, goal-oriented execution (GPT 5.3 Codex Medium) — *The Legitimate Craftsman*
+  - Oracle: Design, debugging (GPT 5.2)
   - Frontend UI/UX Engineer: Frontend development (Gemini 3 Pro)
-  - Librarian: Official docs, open source implementations, codebase exploration (Claude Sonnet 4.5)
-  - Explore: Blazing fast codebase exploration (Contextual Grep) (Claude Haiku 4.5)
+  - Librarian: Official docs, open source implementations, codebase exploration (GLM-4.7)
+  - Explore: Blazing fast codebase exploration (Contextual Grep) (Grok Code Fast 1)
 - 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.2 Codex Medium). The Legitimate Craftsman Agent.**
+**Meet our autonomous deep worker: Hephaestus (GPT 5.3 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.5 High)。以下是 Sisyphus 用来继续推动巨石的工具。
+认识我们的主智能体：Sisyphus (Opus 4.6)。以下是 Sisyphus 用来继续推动巨石的工具。
 
 *以下所有内容都是可配置的。按需选取。所有功能默认启用。你不需要做任何事情。开箱即用，电池已包含。*
 
 - Sisyphus 的队友（精选智能体）
-  - Hephaestus：自主深度工作者，目标导向执行（GPT 5.2 Codex Medium）— *合法的工匠*
-  - Oracle：设计、调试 (GPT 5.2 Medium)
+  - Hephaestus：自主深度工作者，目标导向执行（GPT 5.3 Codex Medium）— *合法的工匠*
+  - Oracle：设计、调试 (GPT 5.2)
   - Frontend UI/UX Engineer：前端开发 (Gemini 3 Pro)
-  - Librarian：官方文档、开源实现、代码库探索 (Claude Sonnet 4.5)
-   - Explore：极速代码库探索（上下文感知 Grep）(Claude Haiku 4.5)
+  - Librarian：官方文档、开源实现、代码库探索 (GLM-4.7)
+   - Explore：极速代码库探索（上下文感知 Grep）(Grok Code Fast 1)
 - 完整 LSP / AstGrep 支持：果断重构。
 - Todo 继续执行器：如果智能体中途退出，强制它继续。**这就是让 Sisyphus 继续推动巨石的关键。**
 - 注释检查器：防止 AI 添加过多注释。Sisyphus 生成的代码应该与人类编写的代码无法区分。
@@ -199,7 +199,7 @@
 ![Meet Hephaestus](.github/assets/hephaestus.png)
 
 在希腊神话中，赫菲斯托斯是锻造、火焰、金属加工和工艺之神——他是神圣的铁匠，以无与伦比的精准和奉献为众神打造武器。
-**介绍我们的自主深度工作者：赫菲斯托斯（GPT 5.2 Codex Medium）。合法的工匠代理。**
+**介绍我们的自主深度工作者：赫菲斯托斯（GPT 5.3 Codex Medium）。合法的工匠代理。**
 
 *为什么是"合法的"？当Anthropic以违反服务条款为由封锁第三方访问时，社区开始调侃"合法"使用。赫菲斯托斯拥抱这种讽刺——他是那种用正确的方式、有条不紊、彻底地构建事物的工匠，绝不走捷径。*
 

assets/oh-my-opencode.schema.json

@@ -87,9 +87,11 @@
           "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",
@@ -163,9 +165,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -211,9 +210,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -301,9 +297,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -345,9 +338,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -393,9 +383,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -483,9 +470,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -527,9 +511,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -575,9 +556,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -665,9 +643,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -709,9 +684,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -757,9 +729,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -847,9 +816,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -891,9 +857,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -939,9 +902,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1029,9 +989,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -1073,9 +1030,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -1121,9 +1075,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1211,9 +1162,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -1255,9 +1203,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -1303,9 +1248,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1393,9 +1335,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -1437,9 +1376,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -1485,9 +1421,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1575,9 +1508,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -1619,9 +1549,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -1667,9 +1594,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1757,9 +1681,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -1801,9 +1722,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -1849,9 +1767,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -1939,9 +1854,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -1983,9 +1895,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -2031,9 +1940,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -2121,9 +2027,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -2165,9 +2068,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -2213,9 +2113,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -2303,9 +2200,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -2347,9 +2241,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -2395,9 +2286,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -2485,9 +2373,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -2529,9 +2414,6 @@
             },
             "tools": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {
                 "type": "boolean"
               }
@@ -2577,9 +2459,6 @@
                     },
                     {
                       "type": "object",
-                      "propertyNames": {
-                        "type": "string"
-                      },
                       "additionalProperties": {
                         "type": "string",
                         "enum": [
@@ -2667,9 +2546,6 @@
             },
             "providerOptions": {
               "type": "object",
-              "propertyNames": {
-                "type": "string"
-              },
               "additionalProperties": {}
             }
           },
@@ -2680,9 +2556,6 @@
     },
     "categories": {
       "type": "object",
-      "propertyNames": {
-        "type": "string"
-      },
       "additionalProperties": {
         "type": "object",
         "properties": {
@@ -2746,9 +2619,6 @@
           },
           "tools": {
             "type": "object",
-            "propertyNames": {
-              "type": "string"
-            },
             "additionalProperties": {
               "type": "boolean"
             }
@@ -2789,9 +2659,6 @@
         },
         "plugins_override": {
           "type": "object",
-          "propertyNames": {
-            "type": "string"
-          },
           "additionalProperties": {
             "type": "boolean"
           }
@@ -3065,9 +2932,6 @@
                   },
                   "metadata": {
                     "type": "object",
-                    "propertyNames": {
-                      "type": "string"
-                    },
                     "additionalProperties": {}
                   },
                   "allowed-tools": {
@@ -3119,9 +2983,6 @@
         },
         "providerConcurrency": {
           "type": "object",
-          "propertyNames": {
-            "type": "string"
-          },
           "additionalProperties": {
             "type": "number",
             "minimum": 0
@@ -3129,9 +2990,6 @@
         },
         "modelConcurrency": {
           "type": "object",
-          "propertyNames": {
-            "type": "string"
-          },
           "additionalProperties": {
             "type": "number",
             "minimum": 0

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.2's logical reasoning for in-depth system architecture analysis.
+- **Effect**: Leverages GPT-5.3 Codex'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`, `prometheus`, `oracle`, `librarian`, `explore`, `multimodal-looker`, `metis`, `momus`, `atlas`
+Available agents: `sisyphus`, `hephaestus`, `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.5)
+- **Sisyphus**: Primary orchestrator agent (Claude Opus 4.6)
 - **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,17 +720,18 @@ Categories enable domain-specific task delegation via the `task` tool. Each cate
 
 ### Built-in Categories
 
-All 7 categories come with optimal model defaults, but **you must configure them to use those defaults**:
+All 8 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-preview`      | Frontend, UI/UX, design, styling, animation                          |
+| `visual-engineering` | `google/gemini-3-pro` (high)       | Frontend, UI/UX, design, styling, animation                          |
 | `ultrabrain`         | `openai/gpt-5.3-codex` (xhigh)     | Deep logical reasoning, complex architecture decisions               |
-| `artistry`           | `google/gemini-3-pro-preview` (max)| Highly creative/artistic tasks, novel ideas                          |
+| `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                          |
 | `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`            | `google/gemini-3-flash-preview`    | Documentation, prose, technical writing                              |
+| `writing`            | `kimi-for-coding/k2p5`             | Documentation, prose, technical writing                              |
 
 ### ⚠️ Critical: Model Resolution Priority
 
@@ -765,15 +766,19 @@ All 7 categories come with optimal model defaults, but **you must configure them
 {
   "categories": {
     "visual-engineering": { 
-      "model": "google/gemini-3-pro-preview"
+      "model": "google/gemini-3-pro"
     },
     "ultrabrain": { 
       "model": "openai/gpt-5.3-codex",
       "variant": "xhigh"
     },
+    "deep": {
+      "model": "openai/gpt-5.3-codex",
+      "variant": "medium"
+    },
     "artistry": { 
-      "model": "google/gemini-3-pro-preview",
-      "variant": "max"
+      "model": "google/gemini-3-pro",
+      "variant": "high"
     },
     "quick": { 
       "model": "anthropic/claude-haiku-4-5"  // Fast + cheap for trivial tasks
@@ -786,7 +791,7 @@ All 7 categories come with optimal model defaults, but **you must configure them
       "variant": "max"
     },
     "writing": { 
-      "model": "google/gemini-3-flash-preview"
+      "model": "kimi-for-coding/k2p5"
     }
   }
 }
@@ -894,15 +899,16 @@ 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 → 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 |
+| **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 |
 
 ### Category Provider Chains
 
@@ -910,14 +916,14 @@ Categories follow the same resolution logic:
 
 | Category | Model (no prefix) | Provider Priority Chain |
 |----------|-------------------|-------------------------|
-| **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 |
+| **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 |
 
 ### 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: kimi-k2.5 → glm-4.7 → gpt-5.3-codex → gemini-3-pro. |
+| **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. |
 | **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** | `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. |
+| **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. |
 
 ### Planning Agents
 
 | Agent | Model | Purpose |
 |-------|-------|---------|
-| **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. |
+| **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. |
 
 ### 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.5 model. Using other models may result in significantly degraded experience.**
+1. **Sisyphus agent strongly recommends Opus 4.6 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.5 model. Using other models may result in significantly degraded experience.**
+> **Sisyphus agent strongly recommends Opus 4.6 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.5"]
-        Metis["🦉 Metis<br/>(Consultant)<br/>Claude Opus 4.5"]
+        Prometheus["🔥 Prometheus<br/>(Planner)<br/>Claude Opus 4.6"]
+        Metis["🦉 Metis<br/>(Consultant)<br/>Claude Opus 4.6"]
         Momus["👁️ Momus<br/>(Reviewer)<br/>GPT-5.2"]
     end
     
     subgraph Execution["Execution Layer (Orchestrator)"]
-        Orchestrator["⚡ Atlas<br/>(Conductor)<br/>Claude Opus 4.5"]
+        Orchestrator["⚡ Atlas<br/>(Conductor)<br/>K2P5 (Kimi)"]
     end
     
     subgraph Workers["Worker Layer (Specialized Agents)"]
@@ -294,12 +294,13 @@ 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.2 Codex (xhigh) | Deep logical reasoning, complex architecture decisions |
+| `ultrabrain` | GPT-5.3 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.5 (max) | Tasks that don't fit other categories, high effort |
-| `writing` | Gemini 3 Flash | Documentation, prose, technical writing |
+| `unspecified-high` | Claude Opus 4.6 (max) | Tasks that don't fit other categories, high effort |
+| `writing` | K2P5 (Kimi) | 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.2 Codex (medium reasoning) | Claude Opus 4.5 (your default) |
+| **Model** | GPT-5.3 Codex (medium reasoning) | Claude Opus 4.6 (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.2 Codex reasoning**
-   - Some problems benefit from GPT-5.2's training characteristics
+4. **You specifically want GPT-5.3 Codex reasoning**
+   - Some problems benefit from GPT-5.3 Codex'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.2 Codex with medium reasoning | Your configured default model |
+| GPT-5.3 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.2 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.3 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.2 Codex for deep autonomous work |
+| **Hephaestus** | You need GPT-5.3 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.2 Codex's reasoning style for deep architectural work or complex debugging.
+**Use Hephaestus when**: You specifically need GPT-5.3 Codex's reasoning style for deep architectural work or complex debugging.

package.json

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

packages/darwin-arm64/package.json

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

packages/darwin-x64/package.json

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

packages/linux-arm64-musl/package.json

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

packages/linux-arm64/package.json

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

packages/linux-x64-musl/package.json

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

packages/linux-x64/package.json

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

packages/windows-x64/package.json

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

signatures/cla.json

@@ -1527,6 +1527,22 @@
       "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,81 +1,41 @@
-# SRC KNOWLEDGE BASE
+# src/ — Plugin Source
+
+**Generated:** 2026-02-18
 
 ## OVERVIEW
 
-Main plugin entry point and orchestration layer. Plugin initialization, hook registration, tool composition, and lifecycle management.
+Root source directory. Entry point `index.ts` orchestrates 4-step initialization: config → managers → tools → hooks → plugin interface.
 
-## STRUCTURE
+## 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
 
 ```
-src/
-├── index.ts                          # Main plugin entry (106 lines) — OhMyOpenCodePlugin factory
-├── create-hooks.ts                   # Hook coordination: core, continuation, skill (62 lines)
-├── create-managers.ts                # Manager initialization: Tmux, Background, SkillMcp, Config (80 lines)
-├── create-tools.ts                   # Tool registry + skill context composition (54 lines)
-├── plugin-interface.ts               # Plugin interface assembly — 7 OpenCode hooks (66 lines)
-├── plugin-config.ts                  # Config loading orchestration (user + project merge, 180 lines)
-├── plugin-state.ts                   # Model cache state (context limits, anthropic 1M flag, 12 lines)
-├── agents/                           # 11 AI agents (32 files) — see agents/AGENTS.md
-├── cli/                              # CLI installer, doctor (107+ files) — see cli/AGENTS.md
-├── config/                           # Zod schema (21 component files) — see config/AGENTS.md
-├── features/                         # Background agents, skills, commands (18 dirs) — see features/AGENTS.md
-├── hooks/                            # 41 lifecycle hooks (36 dirs) — see hooks/AGENTS.md
-├── mcp/                              # Built-in MCPs (6 files) — see mcp/AGENTS.md
-├── plugin/                           # Plugin interface composition (21 files)
-├── plugin-handlers/                  # Config loading, plan inheritance (15 files) — see plugin-handlers/AGENTS.md
-├── shared/                           # Cross-cutting utilities (96 files) — see shared/AGENTS.md
-└── tools/                            # 26 tools (14 dirs) — see tools/AGENTS.md
+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
 ```
 
-## PLUGIN INITIALIZATION (10 steps)
+## HOOK COMPOSITION
 
-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;
 ```
-
-All hooks use this pattern for graceful degradation on failure.
+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
+```

src/agents/AGENTS.md

@@ -1,85 +1,79 @@
-# AGENTS KNOWLEDGE BASE
+# src/agents/ — 11 Agent Definitions
+
+**Generated:** 2026-02-17
 
 ## OVERVIEW
 
-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 factories following `createXXXAgent(model) → AgentConfig` pattern. Each has static `mode` property. Built via `buildAgent()` compositing factory + categories + skills.
 
-## STRUCTURE
-```
-agents/
-├── sisyphus.ts                 # Main orchestrator (559 lines)
-├── hephaestus.ts               # Autonomous deep worker (651 lines)
-├── oracle.ts                   # Strategic advisor (171 lines)
-├── librarian.ts                # Multi-repo research (329 lines)
-├── explore.ts                  # Fast codebase grep (125 lines)
-├── multimodal-looker.ts        # Media analyzer (59 lines)
-├── metis.ts                    # Pre-planning analysis (347 lines)
-├── momus.ts                    # Plan validator (244 lines)
-├── atlas/                      # Master orchestrator (agent.ts + default.ts + gpt.ts)
-├── prometheus/                 # Planning agent (8 files, plan-template 423 lines)
-├── sisyphus-junior/            # Delegated task executor (agent.ts + default.ts + gpt.ts)
-├── dynamic-agent-prompt-builder.ts  # Dynamic prompt generation (433 lines)
-├── builtin-agents/             # Agent registry + model resolution
-├── agent-builder.ts            # Agent construction with category merging (51 lines)
-├── utils.ts                    # Agent creation, model fallback resolution (571 lines)
-├── types.ts                    # AgentModelConfig, AgentPromptMetadata (106 lines)
-└── index.ts                    # Exports
-```
+## AGENT INVENTORY
 
-## 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 |
+| 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 |
 
 ## TOOL RESTRICTIONS
 
-| 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 |
+| 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 |
 
-## THINKING / REASONING
+## STRUCTURE
 
-| 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" |
+```
+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
+```
 
-## KEY PROMPT PATTERNS
+## FACTORY PATTERN
 
-- **Sisyphus/Hephaestus**: Dynamic prompts via `dynamic-agent-prompt-builder.ts` injecting available tools/skills/categories
-- **Atlas, Sisyphus-Junior**: Model-specific prompts (Claude vs GPT variants)
-- **Prometheus**: 6-section modular prompt (identity → interview → plan-generation → high-accuracy → template → behavioral)
+```typescript
+const createXXXAgent: AgentFactory = (model: string) => ({
+  instructions: "...",
+  model,
+  temperature: 0.1,
+  // ...config
+})
+createXXXAgent.mode = "subagent" // or "primary" or "all"
+```
 
-## HOW TO ADD
+Model resolution: `AGENT_MODEL_REQUIREMENTS` in `shared/model-requirements.ts` defines fallback chains per agent.
 
-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`
+## MODES
 
-## 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
+- **primary**: Respects UI-selected model, uses fallback chain
+- **subagent**: Uses own fallback chain, ignores UI selection
+- **all**: Available in both contexts (Sisyphus-Junior)

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,12 +87,9 @@ 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 }
@@ -102,7 +99,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("")
@@ -122,10 +119,11 @@ export function buildExploreSection(agents: AvailableAgent[]): string {
 
 Use it as a **peer tool**, not a fallback. Fire liberally.
 
-| Use Direct Tools | Use Explore Agent |
-|------------------|-------------------|
-${avoidWhen.map((w) => `| ${w} |  |`).join("\n")}
-${useWhen.map((w) => `|  | ${w} |`).join("\n")}`
+**Use Direct Tools when:**
+${avoidWhen.map((w) => `- ${w}`).join("\n")}
+
+**Use Explore Agent when:**
+${useWhen.map((w) => `- ${w}`).join("\n")}`
 }
 
 export function buildLibrarianSection(agents: AvailableAgent[]): string {
@@ -138,14 +136,8 @@ export function buildLibrarianSection(agents: AvailableAgent[]): string {
 
 Search **external references** (docs, OSS, web). Fire proactively when unfamiliar libraries are involved.
 
-| 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 |
+**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.
 
 **Trigger phrases** (fire librarian immediately):
 ${useWhen.map((w) => `- "${w}"`).join("\n")}`
@@ -155,13 +147,11 @@ 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}`)
     }
   }
 
@@ -187,8 +177,6 @@ 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.
@@ -200,7 +188,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")
@@ -208,13 +196,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}\` | ${desc} | ${source} |`
+     return `- \`${s.name}\` (${source}) — ${desc}`
    })
 
   const customSkillBlock = formatCustomSkillsBlock(customRows, customSkills)
@@ -224,8 +212,6 @@ export function buildCategorySkillsDelegationGuide(categories: AvailableCategory
   if (customSkills.length > 0 && builtinSkills.length > 0) {
     skillsSection = `#### Built-in Skills
 
-| Skill | Expertise Domain |
-|-------|------------------|
 ${builtinRows.join("\n")}
 
 ${customSkillBlock}`
@@ -236,8 +222,6 @@ ${customSkillBlock}`
 
 Skills inject specialized instructions into the subagent. Read the description to understand when each skill applies.
 
-| Skill | Expertise Domain |
-|-------|------------------|
 ${builtinRows.join("\n")}`
   }
 
@@ -249,8 +233,6 @@ ${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}
@@ -322,11 +304,9 @@ 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:
+### WHEN to Consult (Oracle FIRST, then implement):
 
-| Trigger | Action |
-|---------|--------|
-${useWhen.map((w) => `| ${w} | Oracle FIRST, then implement |`).join("\n")}
+${useWhen.map((w) => `- ${w}`).join("\n")}
 
 ### WHEN NOT to Consult:
 
@@ -338,39 +318,44 @@ Briefly announce "Consulting Oracle for [reason]" before invocation.
 **Exception**: This is the ONLY case where you announce before acting. For all other work, start immediately without status updates.
 
 ### Oracle Background Task Policy:
-- Oracle takes 20+ min by design. Always wait for Oracle results via \`background_output\` before final answer.
-- Oracle provides independent analysis from a different angle that catches blind spots — even when you believe you already have sufficient context, Oracle's perspective is worth the wait.
+
+**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 |",
+    "- 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.",
   ]
 
   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 |",
+    "- **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`",
   ]
 
   return `## Anti-Patterns (BLOCKING violations)
 
-| Category | Forbidden |
-|----------|-----------|
 ${patterns.join("\n")}`
 }
 

src/agents/prometheus/identity-constraints.ts

@@ -166,40 +166,71 @@ unblocking maximum parallelism in subsequent waves.
 
 **The plan can have 50+ TODOs. That's OK. ONE PLAN.**
 
-### 6.1 SINGLE ATOMIC WRITE (CRITICAL - Prevents Content Loss)
+### 6.1 INCREMENTAL WRITE PROTOCOL (CRITICAL - Prevents Output Limit Stalls)
 
 <write_protocol>
-**The Write tool OVERWRITES files. It does NOT append.**
+**Write OVERWRITES. Never call Write twice on the same file.**
 
-**MANDATORY PROTOCOL:**
-1. **Prepare ENTIRE plan content in memory FIRST**
-2. **Write ONCE with complete content**
-3. **NEVER split into multiple Write calls**
+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).
 
-**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
+**Step 1 — Write skeleton (all sections EXCEPT individual task details):**
 
-**FORBIDDEN (causes content loss):**
 \`\`\`
-❌ Write(".sisyphus/plans/x.md", "# Part 1...")  
-❌ Write(".sisyphus/plans/x.md", "# Part 2...")  // Part 1 is GONE!
+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
+...
+\`)
 \`\`\`
 
-**CORRECT (preserves content):**
-\`\`\`
-✅ Write(".sisyphus/plans/x.md", "# Complete plan content...")  // Single write
+**Step 2 — Edit-append tasks in batches of 2-4:**
 
-// 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
+Use Edit to insert each batch of tasks before the Final Verification section:
+
+\`\`\`
+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")
 \`\`\`
 
-**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
+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
 </write_protocol>
 
 ### 7. DRAFT AS WORKING MEMORY (MANDATORY)

src/agents/sisyphus.ts

@@ -37,12 +37,10 @@ function buildTaskManagementSection(useTaskSystem: boolean): string {
 
 ### When to Create Tasks (MANDATORY)
 
-| 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 |
+- 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)
 
@@ -61,12 +59,10 @@ function buildTaskManagementSection(useTaskSystem: boolean): string {
 
 ### Anti-Patterns (BLOCKING)
 
-| 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 |
+- 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.**
 
@@ -95,12 +91,10 @@ Should I proceed with [recommendation], or would you prefer differently?
 
 ### When to Create Todos (MANDATORY)
 
-| 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 |
+- 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)
 
@@ -119,12 +113,10 @@ Should I proceed with [recommendation], or would you prefer differently?
 
 ### Anti-Patterns (BLOCKING)
 
-| 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 |
+- 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.**
 
@@ -200,23 +192,19 @@ ${keyTriggers}
 
 ### Step 1: Classify Request Type
 
-| 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 |
+- **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
 
-| 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 |
+- 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
 
@@ -259,12 +247,10 @@ Before following existing patterns, assess whether they're worth following.
 
 ### State Classification:
 
-| 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 |
+- **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)
@@ -309,8 +295,10 @@ 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 via \`background_cancel(taskId="...")\`. Always wait for Oracle — collect its result via \`background_output\` before answering.
+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.
 
 ### Search Stop Conditions
 
@@ -362,12 +350,10 @@ 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:**
-| 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."\` |
+- 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
@@ -404,12 +390,10 @@ If project has build/test commands, run them at task completion.
 
 ### Evidence Requirements (task NOT complete without these):
 
-| 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 |
+- **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.**
 
@@ -449,9 +433,9 @@ If verification fails:
 3. Report: "Done. Note: found N pre-existing lint errors unrelated to my changes."
 
 ### Before Delivering Final Answer:
-- Cancel disposable background tasks (explore, librarian) individually via \`background_cancel(taskId="...")\`
-- **Always wait for Oracle**: Oracle takes 20+ min by design and always provides valuable independent analysis from a different angle — even when you already have enough context. Collect Oracle results via \`background_output\` before answering.
-- When Oracle is running, cancel disposable tasks individually instead of using \`background_cancel(all=true)\`.
+- Cancel 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.
 </Behavior_Instructions>
 
 ${oracleSection}

src/cli/AGENTS.md

@@ -1,69 +1,71 @@
-# CLI KNOWLEDGE BASE
+# src/cli/ — CLI: install, run, doctor, mcp-oauth
+
+**Generated:** 2026-02-17
 
 ## OVERVIEW
 
-CLI entry: `bunx oh-my-opencode`. 107+ files with Commander.js + @clack/prompts TUI. 5 commands: install, run, doctor, get-local-version, mcp-oauth.
-
-## 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/          # 20 config utilities
-│   ├── add-plugin-to-opencode-config.ts  # Plugin registration
-│   ├── add-provider-config.ts            # Provider setup (Google/Antigravity)
-│   ├── detect-current-config.ts          # Installed providers detection
-│   ├── write-omo-config.ts               # JSONC writing
-│   ├── generate-omo-config.ts            # Config generation
-│   ├── jsonc-provider-editor.ts          # JSONC editing
-│   └── ...                               # 14 more utilities
-├── doctor/                  # 4 check categories, 21 check files
-│   ├── runner.ts            # Parallel check execution + result aggregation
-│   ├── formatter.ts         # Colored output (default/status/verbose/JSON)
-│   └── checks/              # system (4), config (1), tools (4), models (6 sub-checks)
-├── run/                     # Session launcher (24 files)
-│   ├── runner.ts            # Run orchestration (126 lines)
-│   ├── agent-resolver.ts    # Agent: flag → env → config → Sisyphus
-│   ├── session-resolver.ts  # Session create or resume with retries
-│   ├── 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
-```
+Commander.js CLI with 5 commands. Entry: `index.ts` → `runCli()` in `cli-program.ts`.
 
 ## COMMANDS
 
 | Command | Purpose | Key Logic |
 |---------|---------|-----------|
-| `install` | Interactive setup | Provider selection → config generation → plugin registration |
-| `run` | Session launcher | Agent: flag → env → config → Sisyphus. Enforces todo completion. |
-| `doctor` | 4-category health checks | system, config, tools, models (6 sub-checks) |
-| `get-local-version` | Version check | Detects installed, compares with npm latest |
-| `mcp-oauth` | OAuth tokens | login (PKCE flow), logout, status |
+| `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 |
 
-## RUN SESSION LIFECYCLE
+## STRUCTURE
 
-1. Load config, resolve agent (CLI > env > config > Sisyphus)
-2. Create server connection (port/attach), setup cleanup/signal handlers
-3. Resolve session (create new or resume with retries)
-4. Send prompt, start event processing, poll for completion
-5. Execute on-complete hook, output JSON if requested, cleanup
+```
+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
+```
 
-## HOW TO ADD CHECK
+## MODEL FALLBACK SYSTEM
 
-1. Create `src/cli/doctor/checks/my-check.ts`
-2. Export `getXXXCheckDefinition()` returning `CheckDefinition`
-3. Add to `getAllCheckDefinitions()` in `checks/index.ts`
+Priority: Claude > OpenAI > Gemini > Copilot > OpenCode Zen > Z.ai > Kimi > glm-4.7-free
 
-## ANTI-PATTERNS
+Agent-specific: librarian→ZAI, explore→Haiku/nano, hephaestus→requires OpenAI/Copilot
 
-- **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
+## 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`

src/cli/cli-program.ts

@@ -67,20 +67,19 @@ 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
@@ -109,11 +108,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

@@ -0,0 +1,56 @@
+# 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

@@ -0,0 +1,28 @@
+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/completion-continuation.test.ts

@@ -0,0 +1,138 @@
+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,6 +143,47 @@ 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,10 +1,22 @@
 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 {
-    if (!await areAllTodosComplete(ctx)) {
+    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)) {
       return false
     }
 
@@ -12,6 +24,10 @@ 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}`))
@@ -19,6 +35,20 @@ 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 },

src/cli/run/continuation-state-marker.test.ts

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,7 @@
+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,6 +4,7 @@ import type {
   EventPayload,
   MessageUpdatedProps,
   MessagePartUpdatedProps,
+  MessagePartDeltaProps,
   ToolExecuteProps,
   ToolResultProps,
   SessionErrorProps,
@@ -93,6 +94,15 @@ 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.ts

@@ -7,12 +7,21 @@ 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
@@ -30,6 +39,18 @@ function getPartSessionId(props?: {
   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
 
@@ -74,13 +95,41 @@ export function handleMessagePartUpdated(ctx: RunContext, payload: EventPayload,
   const infoSid = getInfoSessionId(props)
   if ((partSid ?? infoSid) !== ctx.sessionID) return
 
+  const role = props?.info?.role
+  const mappedRole = getPartMessageId(props)
+    ? state.messageRoleById[getPartMessageId(props) ?? ""]
+    : undefined
+  if ((role ?? mappedRole) === "user") return
+
   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) {
-      process.stdout.write(newText)
+      const padded = writePaddedText(newText, state.textAtLineStart)
+      process.stdout.write(padded.output)
+      state.textAtLineStart = padded.atLineStart
       state.hasReceivedMeaningfulWork = true
     }
     state.lastPartText = part.text
@@ -91,6 +140,44 @@ export function handleMessagePartUpdated(ctx: RunContext, payload: EventPayload,
   }
 }
 
+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"]>,
@@ -100,34 +187,26 @@ function handleToolPart(
   const status = part.state?.status
 
   if (status === "running") {
+    if (state.currentTool !== null) return
     state.currentTool = toolName
-    let inputPreview = ""
-    const input = part.state?.input
-    if (input) {
-      if (input.command) {
-        inputPreview = ` ${pc.dim(String(input.command).slice(0, 60))}`
-      } else if (input.pattern) {
-        inputPreview = ` ${pc.dim(String(input.pattern).slice(0, 40))}`
-      } else if (input.filePath) {
-        inputPreview = ` ${pc.dim(String(input.filePath))}`
-      } else if (input.query) {
-        inputPreview = ` ${pc.dim(String(input.query).slice(0, 40))}`
-      }
-    }
+    const header = formatToolHeader(toolName, part.state?.input ?? {})
+    const suffix = header.description ? ` ${pc.dim(header.description)}` : ""
     state.hasReceivedMeaningfulWork = true
-    process.stdout.write(`\n${pc.cyan(">")} ${pc.bold(toolName)}${inputPreview}\n`)
+    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 || ""
-    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`))
+    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
   }
 }
 
@@ -136,11 +215,40 @@ export function handleMessageUpdated(ctx: RunContext, payload: EventPayload, sta
 
   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?.role !== "assistant") return
 
-  state.hasReceivedMeaningfulWork = true
-  state.messageCount++
-  state.lastPartText = ""
+  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)
+  }
 }
 
 export function handleToolExecute(ctx: RunContext, payload: EventPayload, state: EventState): void {
@@ -149,25 +257,17 @@ export function handleToolExecute(ctx: RunContext, payload: EventPayload, state:
   const props = payload.properties as ToolExecuteProps | undefined
   if (getSessionId(props) !== ctx.sessionID) return
 
+  closeThinkBlockIfNeeded(state)
+
+  if (state.currentTool !== null) return
+
   const toolName = props?.name || "unknown"
   state.currentTool = toolName
-
-  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))}`
-    }
-  }
+  const header = formatToolHeader(toolName, props?.input ?? {})
+  const suffix = header.description ? ` ${pc.dim(header.description)}` : ""
 
   state.hasReceivedMeaningfulWork = true
-  process.stdout.write(`\n${pc.cyan(">")} ${pc.bold(toolName)}${inputPreview}\n`)
+  process.stdout.write(`\n  ${pc.cyan(header.icon)} ${pc.bold(header.title)}${suffix}  \n`)
 }
 
 export function handleToolResult(ctx: RunContext, payload: EventPayload, state: EventState): void {
@@ -176,36 +276,52 @@ export function handleToolResult(ctx: RunContext, payload: EventPayload, state:
   const props = payload.properties as ToolResultProps | undefined
   if (getSessionId(props) !== ctx.sessionID) return
 
-  const output = props?.output || ""
-  const maxLen = 200
-  const preview = output.length > maxLen ? output.slice(0, maxLen) + "..." : output
+  closeThinkBlockIfNeeded(state)
 
-  if (preview.trim()) {
-    const lines = preview.split("\n").slice(0, 3)
-    process.stdout.write(pc.dim(`   └─ ${lines.join("\n      ")}\n`))
+  if (state.currentTool === null) 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")
   }
 
   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 title = props?.title ? `${props.title}: ` : ""
-  const message = props?.message?.trim()
   const variant = props?.variant ?? "info"
 
-  if (!message) return
-
   if (variant === "error") {
-    state.mainSessionError = true
-    state.lastError = `${title}${message}`
-    console.error(pc.red(`\n[tui.toast.error] ${state.lastError}`))
-    return
+    const title = props?.title ? `${props.title}: ` : ""
+    const message = props?.message?.trim()
+    if (message) {
+      state.mainSessionError = true
+      state.lastError = `${title}${message}`
+    }
   }
-
-  const colorize = variant === "warning" ? pc.yellow : pc.dim
-  console.log(colorize(`[toast:${variant}] ${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,6 +9,36 @@ 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 {
@@ -21,5 +51,20 @@ 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,6 +7,7 @@ import {
   handleSessionIdle,
   handleSessionStatus,
   handleMessagePartUpdated,
+  handleMessagePartDelta,
   handleMessageUpdated,
   handleToolExecute,
   handleToolResult,
@@ -24,16 +25,21 @@ export async function processEvents(
     try {
       const payload = event as EventPayload
       if (!payload?.type) {
-        console.error(pc.dim(`[event] no type: ${JSON.stringify(event)}`))
+        if (ctx.verbose) {
+          console.error(pc.dim(`[event] no type: ${JSON.stringify(event)}`))
+        }
         continue
       }
 
-      logEventVerbose(ctx, payload)
+      if (ctx.verbose) {
+        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)

src/cli/run/events.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "bun:test"
+import { describe, it, expect, spyOn } from "bun:test"
 import { createEventState, serializeError, type EventState } from "./events"
 import type { RunContext, EventPayload } from "./types"
 
@@ -87,6 +87,52 @@ 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")

src/cli/run/message-part-delta.test.ts

@@ -0,0 +1,657 @@
+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/output-renderer.ts

@@ -0,0 +1,90 @@
+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,6 +94,7 @@ describe("pollForCompletion", () => {
     const result = await pollForCompletion(ctx, eventState, abortController, {
       pollIntervalMs: 10,
       requiredConsecutive: 3,
+      minStabilizationMs: 500,
     })
 
     //#then - should be aborted, not completed (tool blocked exit)
@@ -159,6 +160,7 @@ describe("pollForCompletion", () => {
     const result = await pollForCompletion(ctx, eventState, abortController, {
       pollIntervalMs: 10,
       requiredConsecutive: 3,
+      minStabilizationMs: 500,
     })
 
     //#then
@@ -310,7 +312,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) => call[0]?.includes("Session ended with error"))).toBe(true)
+    expect(errorCalls.some((call: unknown[]) => String(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 () => {
@@ -335,4 +337,5 @@ describe("pollForCompletion", () => {
     //#then - returns 1
     expect(result).toBe(1)
   })
+
 })

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

@@ -5,9 +5,9 @@ import { checkCompletionConditions } from "./completion"
 import { normalizeSDKResponse } from "../../shared"
 
 const DEFAULT_POLL_INTERVAL_MS = 500
-const DEFAULT_REQUIRED_CONSECUTIVE = 3
+const DEFAULT_REQUIRED_CONSECUTIVE = 1
 const ERROR_GRACE_CYCLES = 3
-const MIN_STABILIZATION_MS = 10_000
+const MIN_STABILIZATION_MS = 0
 
 export interface PollOptions {
   pollIntervalMs?: number
@@ -34,6 +34,10 @@ export async function pollForCompletion(
   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++
@@ -71,6 +75,11 @@ export async function pollForCompletion(
     }
 
     if (!eventState.hasReceivedMeaningfulWork) {
+      if (minStabilizationMs <= 0) {
+        consecutiveCompleteChecks = 0
+        continue
+      }
+
       if (Date.now() - pollStartTimestamp < minStabilizationMs) {
         consecutiveCompleteChecks = 0
         continue
@@ -91,6 +100,10 @@ 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."))

src/cli/run/runner.test.ts

@@ -1,6 +1,6 @@
 /// <reference types="bun-types" />
 
-import { describe, it, expect, spyOn, afterEach } from "bun:test"
+import { describe, it, expect } from "bun:test"
 import type { OhMyOpenCodeConfig } from "../../config"
 import { resolveRunAgent, waitForEventProcessorShutdown } from "./runner"
 
@@ -83,14 +83,6 @@ describe("resolveRunAgent", () => {
 })
 
 describe("waitForEventProcessorShutdown", () => {
-  let consoleLogSpy: ReturnType<typeof spyOn<typeof console, "log">> | null = null
-
-  afterEach(() => {
-    if (consoleLogSpy) {
-      consoleLogSpy.mockRestore()
-      consoleLogSpy = null
-    }
-  })
 
   it("returns quickly when event processor completes", async () => {
     //#given
@@ -99,7 +91,6 @@ describe("waitForEventProcessorShutdown", () => {
         resolve()
       }, 25)
     })
-    consoleLogSpy = spyOn(console, "log").mockImplementation(() => {})
     const start = performance.now()
 
     //#when
@@ -108,29 +99,19 @@ describe("waitForEventProcessorShutdown", () => {
     //#then
     const elapsed = performance.now() - start
     expect(elapsed).toBeLessThan(200)
-    expect(console.log).not.toHaveBeenCalledWith(
-      "[run] Event stream did not close within 200ms after abort; continuing shutdown.",
-    )
   })
 
   it("times out and continues when event processor does not complete", async () => {
     //#given
     const eventProcessor = new Promise<void>(() => {})
-    const spy = spyOn(console, "log").mockImplementation(() => {})
-    consoleLogSpy = spy
     const timeoutMs = 200
     const start = performance.now()
 
-    try {
-      //#when
-      await waitForEventProcessorShutdown(eventProcessor, timeoutMs)
+    //#when
+    await waitForEventProcessorShutdown(eventProcessor, timeoutMs)
 
-      //#then
-      const elapsed = performance.now() - start
-      expect(elapsed).toBeGreaterThanOrEqual(timeoutMs - 10)
-      expect(spy.mock.calls.length).toBeGreaterThanOrEqual(1)
-    } finally {
-      spy.mockRestore()
-    }
+    //#then
+    const elapsed = performance.now() - start
+    expect(elapsed).toBeGreaterThanOrEqual(timeoutMs - 10)
   })
 })

src/cli/run/runner.ts

@@ -8,10 +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 DEFAULT_TIMEOUT_MS = 600_000
 const EVENT_PROCESSOR_SHUTDOWN_TIMEOUT_MS = 2_000
 
 export async function waitForEventProcessorShutdown(
@@ -23,13 +23,7 @@ export async function waitForEventProcessorShutdown(
     new Promise<boolean>((resolve) => setTimeout(() => resolve(false), timeoutMs)),
   ])
 
-  if (!completed) {
-    console.log(
-      pc.dim(
-        `[run] Event stream did not close within ${timeoutMs}ms after abort; continuing shutdown.`,
-      ),
-    )
-  }
+  void completed
 }
 
 export async function run(options: RunOptions): Promise<number> {
@@ -39,7 +33,6 @@ export async function run(options: RunOptions): Promise<number> {
   const {
     message,
     directory = process.cwd(),
-    timeout = DEFAULT_TIMEOUT_MS,
   } = options
 
   const jsonManager = options.json ? createJsonOutputManager() : null
@@ -48,14 +41,6 @@ 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({
@@ -65,7 +50,6 @@ export async function run(options: RunOptions): Promise<number> {
     })
 
     const cleanup = () => {
-      if (timeoutId) clearTimeout(timeoutId)
       serverCleanup()
     }
 
@@ -84,14 +68,20 @@ export async function run(options: RunOptions): Promise<number> {
 
       console.log(pc.dim(`Session: ${sessionID}`))
 
-      const ctx: RunContext = { client, sessionID, directory, abortController }
+      const ctx: RunContext = {
+        client,
+        sessionID,
+        directory,
+        abortController,
+        verbose: options.verbose ?? false,
+      }
       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: {
@@ -100,8 +90,6 @@ export async function run(options: RunOptions): Promise<number> {
         },
         query: { directory },
       })
-
-      console.log(pc.dim("Waiting for completion...\n"))
       const exitCode = await pollForCompletion(ctx, eventState, abortController)
 
       // Abort the event stream to stop the processor
@@ -138,7 +126,6 @@ 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

src/cli/run/tool-input-preview.ts

@@ -0,0 +1,144 @@
+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,6 +31,7 @@ export interface RunContext {
   sessionID: string
   directory: string
   abortController: AbortController
+  verbose?: boolean
 }
 
 export interface Todo {
@@ -66,12 +67,14 @@ export interface SessionStatusProps {
 
 export interface MessageUpdatedProps {
   info?: {
+    id?: string
     sessionID?: string
     sessionId?: string
     role?: string
     modelID?: string
     providerID?: string
     agent?: string
+    variant?: string
   }
 }
 
@@ -95,6 +98,15 @@ export interface MessagePartUpdatedProps {
   }
 }
 
+export interface MessagePartDeltaProps {
+  sessionID?: string
+  sessionId?: string
+  messageID?: string
+  partID?: string
+  field?: string
+  delta?: string
+}
+
 export interface ToolExecuteProps {
   sessionID?: string
   sessionId?: string

src/config/AGENTS.md

@@ -1,52 +1,50 @@
-# CONFIG KNOWLEDGE BASE
+# src/config/ — Zod v4 Schema System
+
+**Generated:** 2026-02-17
 
 ## OVERVIEW
 
-Zod schema definitions for plugin configuration. 21 component files composing `OhMyOpenCodeConfigSchema` with multi-level inheritance and JSONC support.
+22 schema files composing `OhMyOpenCodeConfigSchema`. Zod v4 validation with `safeParse()`. All fields optional — omitted fields use plugin defaults.
+
+## SCHEMA TREE
 
-## STRUCTURE
 ```
-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)
+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
 ```
 
-## ROOT SCHEMA
+## ROOT SCHEMA FIELDS (26)
 
-`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`
+`$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`
 
-## CONFIGURATION HIERARCHY
+## AGENT OVERRIDE FIELDS (21)
 
-Project (`.opencode/oh-my-opencode.json`) → User (`~/.config/opencode/oh-my-opencode.json`) → Defaults
+`model`, `variant`, `category`, `skills`, `temperature`, `top_p`, `prompt`, `prompt_append`, `tools`, `disable`, `description`, `mode`, `color`, `permission`, `maxTokens`, `thinking`, `reasoningEffort`, `textVerbosity`, `providerOptions`
 
-## AGENT OVERRIDE FIELDS
+## HOW TO ADD CONFIG
 
-`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`
+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}`

src/config/schema/hooks.ts

@@ -33,9 +33,11 @@ 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",

src/create-hooks.ts

@@ -3,6 +3,7 @@ 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"
@@ -13,6 +14,7 @@ export type CreatedHooks = ReturnType<typeof createHooks>
 export function createHooks(args: {
   ctx: PluginContext
   pluginConfig: OhMyOpenCodeConfig
+  modelCacheState: ModelCacheState
   backgroundManager: BackgroundManager
   isHookEnabled: (hookName: HookName) => boolean
   safeHookEnabled: boolean
@@ -22,6 +24,7 @@ export function createHooks(args: {
   const {
     ctx,
     pluginConfig,
+    modelCacheState,
     backgroundManager,
     isHookEnabled,
     safeHookEnabled,
@@ -32,6 +35,7 @@ export function createHooks(args: {
   const core = createCoreHooks({
     ctx,
     pluginConfig,
+    modelCacheState,
     isHookEnabled,
     safeHookEnabled,
   })

src/features/AGENTS.md

@@ -1,83 +1,70 @@
-# FEATURES KNOWLEDGE BASE
+# src/features/ — 19 Feature Modules
+
+**Generated:** 2026-02-18
 
 ## OVERVIEW
 
-18 feature modules extending plugin capabilities: agent orchestration, skill loading, Claude Code compatibility, MCP management, task storage, and tmux integration.
+Standalone feature modules wired into plugin/ layer. Each is self-contained with own types, implementation, and tests.
 
-## STRUCTURE
-```
-features/
-├── background-agent/           # Task lifecycle, concurrency (56 files, 1701-line manager)
-│   ├── manager.ts              # Main task orchestration (1701 lines)
-│   ├── concurrency.ts          # Parallel execution limits per provider/model (137 lines)
-│   ├── task-history.ts         # Task execution history per parent session (76 lines)
-│   └── spawner/                # Task spawning: factory, starter, resumer, tmux (8 files)
-├── tmux-subagent/              # Tmux integration (28 files, 3303 LOC)
-│   └── manager.ts              # Pane management, grid planning (350 lines)
-├── opencode-skill-loader/      # YAML frontmatter skill loading (28 files, 2967 LOC)
-│   ├── loader.ts               # Skill discovery (4 scopes)
-│   ├── skill-directory-loader.ts # Recursive directory scanning (maxDepth=2)
-│   ├── skill-discovery.ts      # getAllSkills() with caching + provider gating
-│   └── 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 (1112), playwright (313), dev-browser (222), frontend-ui-ux (80)
-├── builtin-commands/           # 7 command templates (11 files, 1511 LOC)
-│   └── templates/              # refactor (620), init-deep (306), handoff (178), start-work, ralph-loop, stop-continuation
-├── claude-tasks/               # Task schema + storage (7 files) — see AGENTS.md
-├── 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 MAP
 
-## KEY PATTERNS
+| 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 |
 
-**Background Agent Lifecycle:**
-pending → running → completed/error/cancelled/interrupt
-- Concurrency: Per provider/model limits (default: 5), queue-based FIFO
-- Events: session.idle + session.error drive completion detection
-- Key methods: `launch()`, `resume()`, `cancelTask()`, `getTask()`, `getAllDescendantTasks()`
+## KEY MODULES
 
-**Skill Loading Pipeline (4-scope priority):**
-opencode-project (`.opencode/skills/`) > opencode (`~/.config/opencode/skills/`) > project (`.claude/skills/`) > user (`~/.claude/skills/`)
+### background-agent (49 files, ~10k LOC)
 
-**Claude Code Compatibility Layer:**
-5 loaders: agent-loader, command-loader, mcp-loader, plugin-loader, session-state
+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
 
-**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
-```
+### opencode-skill-loader (25 files, ~3.2k LOC)
 
-## HOW TO ADD
+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
 
-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
+### tmux-subagent (27 files, ~3.6k LOC)
 
-## CHILD DOCUMENTATION
+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
 
-- See `claude-tasks/AGENTS.md` for task schema and storage details
+### 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.

src/features/background-agent/AGENTS.md

@@ -0,0 +1,56 @@
+# 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

@@ -1,168 +0,0 @@
-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" || event.type === "message.part.delta") {
-    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

@@ -1,82 +0,0 @@
-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/notification-tracker.ts

@@ -1,52 +0,0 @@
-import type { BackgroundTask } from "./types"
-
-export function markForNotification(
-  notifications: Map<string, BackgroundTask[]>,
-  task: BackgroundTask
-): void {
-  const queue = notifications.get(task.parentSessionID) ?? []
-  queue.push(task)
-  notifications.set(task.parentSessionID, queue)
-}
-
-export function getPendingNotifications(
-  notifications: Map<string, BackgroundTask[]>,
-  sessionID: string
-): BackgroundTask[] {
-  return notifications.get(sessionID) ?? []
-}
-
-export function clearNotifications(
-  notifications: Map<string, BackgroundTask[]>,
-  sessionID: string
-): void {
-  notifications.delete(sessionID)
-}
-
-export function clearNotificationsForTask(
-  notifications: Map<string, BackgroundTask[]>,
-  taskId: string
-): void {
-  for (const [sessionID, tasks] of notifications.entries()) {
-    const filtered = tasks.filter((t) => t.id !== taskId)
-    if (filtered.length === 0) {
-      notifications.delete(sessionID)
-    } else {
-      notifications.set(sessionID, filtered)
-    }
-  }
-}
-
-export function cleanupPendingByParent(
-  pendingByParent: Map<string, Set<string>>,
-  task: BackgroundTask
-): void {
-  if (!task.parentSessionID) return
-  const pending = pendingByParent.get(task.parentSessionID)
-  if (!pending) return
-
-  pending.delete(task.id)
-  if (pending.size === 0) {
-    pendingByParent.delete(task.parentSessionID)
-  }
-}

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

@@ -1,193 +0,0 @@
-import { log, normalizeSDKResponse } from "../../shared"
-
-import { findNearestMessageWithFields } from "../hook-message-injector"
-import { getTaskToastManager } from "../task-toast-manager"
-
-import { TASK_CLEANUP_DELAY_MS } from "./constants"
-import { formatDuration } from "./format-duration"
-import { isAbortedSessionError } from "./error-classifier"
-import { getMessageDir } from "./message-dir"
-import { buildBackgroundTaskNotificationText } from "./notification-builder"
-
-import type { BackgroundTask } from "./types"
-import type { OpencodeClient } from "./opencode-client"
-
-type AgentModel = { providerID: string; modelID: string }
-
-type MessageInfo = {
-  agent?: string
-  model?: AgentModel
-  providerID?: string
-  modelID?: string
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null
-}
-
-function extractMessageInfo(message: unknown): MessageInfo {
-  if (!isRecord(message)) return {}
-  const info = message["info"]
-  if (!isRecord(info)) return {}
-
-  const agent = typeof info["agent"] === "string" ? info["agent"] : undefined
-  const modelObj = info["model"]
-  if (isRecord(modelObj)) {
-    const providerID = modelObj["providerID"]
-    const modelID = modelObj["modelID"]
-    if (typeof providerID === "string" && typeof modelID === "string") {
-      return { agent, model: { providerID, modelID } }
-    }
-  }
-
-  const providerID = info["providerID"]
-  const modelID = info["modelID"]
-  if (typeof providerID === "string" && typeof modelID === "string") {
-    return { agent, model: { providerID, modelID } }
-  }
-
-  return { agent }
-}
-
-export async function notifyParentSession(args: {
-  task: BackgroundTask
-  tasks: Map<string, BackgroundTask>
-  pendingByParent: Map<string, Set<string>>
-  completionTimers: Map<string, ReturnType<typeof setTimeout>>
-  clearNotificationsForTask: (taskId: string) => void
-  client: OpencodeClient
-}): Promise<void> {
-  const { task, tasks, pendingByParent, completionTimers, clearNotificationsForTask, client } = args
-
-  const duration = formatDuration(task.startedAt ?? new Date(), task.completedAt)
-  log("[background-agent] notifyParentSession called for task:", task.id)
-
-  const toastManager = getTaskToastManager()
-  if (toastManager) {
-    toastManager.showCompletionToast({
-      id: task.id,
-      description: task.description,
-      duration,
-    })
-  }
-
-  const pendingSet = pendingByParent.get(task.parentSessionID)
-  if (pendingSet) {
-    pendingSet.delete(task.id)
-    if (pendingSet.size === 0) {
-      pendingByParent.delete(task.parentSessionID)
-    }
-  }
-
-  const allComplete = !pendingSet || pendingSet.size === 0
-  const remainingCount = pendingSet?.size ?? 0
-
-  const completedTasks = allComplete
-    ? Array.from(tasks.values()).filter(
-        (t) =>
-          t.parentSessionID === task.parentSessionID &&
-          t.status !== "running" &&
-          t.status !== "pending"
-      )
-    : []
-
-  const notification = buildBackgroundTaskNotificationText({
-    task,
-    duration,
-    allComplete,
-    remainingCount,
-    completedTasks,
-  })
-
-  let agent: string | undefined = task.parentAgent
-  let model: AgentModel | undefined
-
-  try {
-    const messagesResp = await client.session.messages({
-      path: { id: task.parentSessionID },
-    })
-    const raw = normalizeSDKResponse(messagesResp, [] as unknown[])
-    const messages = Array.isArray(raw) ? raw : []
-
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const extracted = extractMessageInfo(messages[i])
-      if (extracted.agent || extracted.model) {
-        agent = extracted.agent ?? task.parentAgent
-        model = extracted.model
-        break
-      }
-    }
-  } catch (error) {
-    if (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 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 (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) return
-
-  for (const completedTask of completedTasks) {
-    const taskId = completedTask.id
-    const existingTimer = completionTimers.get(taskId)
-    if (existingTimer) {
-      clearTimeout(existingTimer)
-      completionTimers.delete(taskId)
-    }
-
-    const timer = setTimeout(() => {
-      completionTimers.delete(taskId)
-      if (tasks.has(taskId)) {
-        clearNotificationsForTask(taskId)
-        tasks.delete(taskId)
-        log("[background-agent] Removed completed task from memory:", taskId)
-      }
-    }, TASK_CLEANUP_DELAY_MS)
-
-    completionTimers.set(taskId, timer)
-  }
-}

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

@@ -1,181 +0,0 @@
-import { log, normalizeSDKResponse } from "../../shared"
-
-import {
-  MIN_STABILITY_TIME_MS,
-} from "./constants"
-
-import type { BackgroundTask } from "./types"
-import type { OpencodeClient } from "./opencode-client"
-
-type SessionStatusMap = Record<string, { type: string }>
-
-type MessagePart = {
-  type?: string
-  tool?: string
-  name?: string
-  text?: string
-}
-
-type SessionMessage = {
-  info?: { role?: string }
-  parts?: MessagePart[]
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null
-}
-
-function asSessionMessages(value: unknown): SessionMessage[] {
-  if (!Array.isArray(value)) return []
-  return value.filter(isRecord) as SessionMessage[]
-}
-
-export async function pollRunningTasks(args: {
-  tasks: Iterable<BackgroundTask>
-  client: OpencodeClient
-  pruneStaleTasksAndNotifications: () => void
-  checkAndInterruptStaleTasks: (statuses: Record<string, { type: string }>) => Promise<void>
-  validateSessionHasOutput: (sessionID: string) => Promise<boolean>
-  checkSessionTodos: (sessionID: string) => Promise<boolean>
-  tryCompleteTask: (task: BackgroundTask, source: string) => Promise<boolean>
-  hasRunningTasks: () => boolean
-  stopPolling: () => void
-}): Promise<void> {
-  const {
-    tasks,
-    client,
-    pruneStaleTasksAndNotifications,
-    checkAndInterruptStaleTasks,
-    validateSessionHasOutput,
-    checkSessionTodos,
-    tryCompleteTask,
-    hasRunningTasks,
-    stopPolling,
-  } = args
-
-  pruneStaleTasksAndNotifications()
-
-  const statusResult = await client.session.status()
-  const allStatuses = normalizeSDKResponse(statusResult, {} as SessionStatusMap)
-
-  await checkAndInterruptStaleTasks(allStatuses)
-
-  for (const task of tasks) {
-    if (task.status !== "running") continue
-
-    const sessionID = task.sessionID
-    if (!sessionID) continue
-
-    try {
-      const sessionStatus = allStatuses[sessionID]
-      if (sessionStatus?.type === "idle") {
-        const hasValidOutput = await validateSessionHasOutput(sessionID)
-        if (!hasValidOutput) {
-          log("[background-agent] Polling idle but no valid output yet, waiting:", task.id)
-          continue
-        }
-
-        if (task.status !== "running") continue
-
-        const hasIncompleteTodos = await checkSessionTodos(sessionID)
-        if (hasIncompleteTodos) {
-          log("[background-agent] Task has incomplete todos via polling, waiting:", task.id)
-          continue
-        }
-
-        await tryCompleteTask(task, "polling (idle status)")
-        continue
-      }
-
-      const messagesResult = await client.session.messages({
-        path: { id: sessionID },
-      })
-
-      if ((messagesResult as { error?: unknown }).error) {
-        continue
-      }
-
-      const messages = asSessionMessages(normalizeSDKResponse(messagesResult, [] as SessionMessage[], {
-        preferResponseOnMissingData: true,
-      }))
-      const assistantMsgs = messages.filter((m) => m.info?.role === "assistant")
-
-      let toolCalls = 0
-      let lastTool: string | undefined
-      let lastMessage: string | undefined
-
-      for (const msg of assistantMsgs) {
-        const parts = msg.parts ?? []
-        for (const part of parts) {
-          if (part.type === "tool_use" || part.tool) {
-            toolCalls += 1
-            lastTool = part.tool || part.name || "unknown"
-          }
-          if (part.type === "text" && part.text) {
-            lastMessage = part.text
-          }
-        }
-      }
-
-      if (!task.progress) {
-        task.progress = { toolCalls: 0, lastUpdate: new Date() }
-      }
-      task.progress.toolCalls = toolCalls
-      task.progress.lastTool = lastTool
-      task.progress.lastUpdate = new Date()
-      if (lastMessage) {
-        task.progress.lastMessage = lastMessage
-        task.progress.lastMessageAt = new Date()
-      }
-
-      const currentMsgCount = messages.length
-      const startedAt = task.startedAt
-      if (!startedAt) continue
-
-      const elapsedMs = Date.now() - startedAt.getTime()
-      if (elapsedMs >= MIN_STABILITY_TIME_MS) {
-        if (task.lastMsgCount === currentMsgCount) {
-          task.stablePolls = (task.stablePolls ?? 0) + 1
-          if (task.stablePolls >= 3) {
-            const recheckStatus = await client.session.status()
-            const recheckData = normalizeSDKResponse(recheckStatus, {} as SessionStatusMap)
-            const currentStatus = recheckData[sessionID]
-
-            if (currentStatus?.type !== "idle") {
-              log("[background-agent] Stability reached but session not idle, resetting:", {
-                taskId: task.id,
-                sessionStatus: currentStatus?.type ?? "not_in_status",
-              })
-              task.stablePolls = 0
-              continue
-            }
-
-            const hasValidOutput = await validateSessionHasOutput(sessionID)
-            if (!hasValidOutput) {
-              log("[background-agent] Stability reached but no valid output, waiting:", task.id)
-              continue
-            }
-
-            if (task.status !== "running") continue
-
-            const hasIncompleteTodos = await checkSessionTodos(sessionID)
-            if (!hasIncompleteTodos) {
-              await tryCompleteTask(task, "stability detection")
-              continue
-            }
-          }
-        } else {
-          task.stablePolls = 0
-        }
-      }
-
-      task.lastMsgCount = currentMsgCount
-    } catch (error) {
-      log("[background-agent] Poll error for task:", { taskId: task.id, error })
-    }
-  }
-
-  if (!hasRunningTasks()) {
-    stopPolling()
-  }
-}

src/features/background-agent/process-signal.ts

@@ -1,19 +0,0 @@
-export type ProcessCleanupEvent = NodeJS.Signals | "beforeExit" | "exit"
-
-export function registerProcessSignal(
-  signal: ProcessCleanupEvent,
-  handler: () => void,
-  exitAfter: boolean
-): () => void {
-  const listener = () => {
-    handler()
-    if (exitAfter) {
-      // Set exitCode and schedule exit after delay to allow other handlers to complete async cleanup
-      // Use 6s delay to accommodate LSP cleanup (5s timeout + 1s SIGKILL wait)
-      process.exitCode = 0
-      setTimeout(() => process.exit(), 6000)
-    }
-  }
-  process.on(signal, listener)
-  return listener
-}

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

@@ -1,114 +0,0 @@
-import { log, normalizeSDKResponse } from "../../shared"
-
-import type { OpencodeClient } from "./opencode-client"
-
-type Todo = {
-  content: string
-  status: string
-  priority: string
-  id: string
-}
-
-type SessionMessage = {
-  info?: { role?: string }
-  parts?: unknown
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null
-}
-
-function asSessionMessages(value: unknown): SessionMessage[] {
-  if (!Array.isArray(value)) return []
-  return value as SessionMessage[]
-}
-
-function asParts(value: unknown): Array<Record<string, unknown>> {
-  if (!Array.isArray(value)) return []
-  return value.filter(isRecord)
-}
-
-function hasNonEmptyText(value: unknown): boolean {
-  return typeof value === "string" && value.trim().length > 0
-}
-
-function isToolResultContentNonEmpty(content: unknown): boolean {
-  if (typeof content === "string") return content.trim().length > 0
-  if (Array.isArray(content)) return content.length > 0
-  return false
-}
-
-/**
- * Validates that a session has actual assistant/tool output before marking complete.
- * Prevents premature completion when session.idle fires before agent responds.
- */
-export async function validateSessionHasOutput(
-  client: OpencodeClient,
-  sessionID: string
-): Promise<boolean> {
-  try {
-    const response = await client.session.messages({
-      path: { id: sessionID },
-    })
-
-    const messages = asSessionMessages(normalizeSDKResponse(response, [] as SessionMessage[], {
-      preferResponseOnMissingData: true,
-    }))
-
-    const hasAssistantOrToolMessage = messages.some(
-      (m) => m.info?.role === "assistant" || m.info?.role === "tool"
-    )
-    if (!hasAssistantOrToolMessage) {
-      log("[background-agent] No assistant/tool messages found in session:", sessionID)
-      return false
-    }
-
-    const hasContent = messages.some((m) => {
-      if (m.info?.role !== "assistant" && m.info?.role !== "tool") return false
-
-      const parts = asParts(m.parts)
-      return parts.some((part) => {
-        const type = part.type
-        if (type === "tool") return true
-        if (type === "text" && hasNonEmptyText(part.text)) return true
-        if (type === "reasoning" && hasNonEmptyText(part.text)) return true
-        if (type === "tool_result" && isToolResultContentNonEmpty(part.content)) return true
-        return false
-      })
-    })
-
-    if (!hasContent) {
-      log("[background-agent] Messages exist but no content found in session:", sessionID)
-      return false
-    }
-
-    return true
-  } catch (error) {
-    log("[background-agent] Error validating session output:", error)
-    // On error, allow completion to proceed (don't block indefinitely)
-    return true
-  }
-}
-
-export async function checkSessionTodos(
-  client: OpencodeClient,
-  sessionID: string
-): Promise<boolean> {
-  try {
-    const response = await client.session.todo({
-      path: { id: sessionID },
-    })
-
-    const todos = normalizeSDKResponse(response, [] as Todo[], {
-      preferResponseOnMissingData: true,
-    })
-    if (todos.length === 0) return false
-
-    const incomplete = todos.filter(
-      (t) => t.status !== "completed" && t.status !== "cancelled"
-    )
-    return incomplete.length > 0
-  } catch {
-    return false
-  }
-}

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

@@ -1,19 +0,0 @@
-import { randomUUID } from "crypto"
-import type { BackgroundTask, LaunchInput } from "../types"
-
-export function createTask(input: LaunchInput): BackgroundTask {
-  return {
-    id: `bg_${randomUUID().slice(0, 8)}`,
-    status: "pending",
-    queuedAt: new Date(),
-    description: input.description,
-    prompt: input.prompt,
-    agent: input.agent,
-    parentSessionID: input.parentSessionID,
-    parentMessageID: input.parentMessageID,
-    parentModel: input.parentModel,
-    parentAgent: input.parentAgent,
-    parentTools: input.parentTools,
-    model: input.model,
-  }
-}

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

@@ -1,99 +0,0 @@
-import type { BackgroundTask, ResumeInput } from "../types"
-import { log, getAgentToolRestrictions } from "../../../shared"
-import { setSessionTools } from "../../../shared/session-tools-store"
-import type { SpawnerContext } from "./spawner-context"
-import { subagentSessions } from "../../claude-code-session-state"
-import { getTaskToastManager } from "../../task-toast-manager"
-
-export async function resumeTask(
-  task: BackgroundTask,
-  input: ResumeInput,
-  ctx: Pick<SpawnerContext, "client" | "concurrencyManager" | "onTaskError">
-): Promise<void> {
-  const { client, concurrencyManager, onTaskError } = ctx
-
-  if (!task.sessionID) {
-    throw new Error(`Task has no sessionID: ${task.id}`)
-  }
-
-  if (task.status === "running") {
-    log("[background-agent] Resume skipped - task already running:", {
-      taskId: task.id,
-      sessionID: task.sessionID,
-    })
-    return
-  }
-
-  const concurrencyKey = task.concurrencyGroup ?? task.agent
-  await concurrencyManager.acquire(concurrencyKey)
-  task.concurrencyKey = concurrencyKey
-  task.concurrencyGroup = concurrencyKey
-
-  task.status = "running"
-  task.completedAt = undefined
-  task.error = undefined
-  task.parentSessionID = input.parentSessionID
-  task.parentMessageID = input.parentMessageID
-  task.parentModel = input.parentModel
-  task.parentAgent = input.parentAgent
-  if (input.parentTools) {
-    task.parentTools = input.parentTools
-  }
-  task.startedAt = new Date()
-
-  task.progress = {
-    toolCalls: task.progress?.toolCalls ?? 0,
-    lastUpdate: new Date(),
-  }
-
-  subagentSessions.add(task.sessionID)
-
-  const toastManager = getTaskToastManager()
-  if (toastManager) {
-    toastManager.addTask({
-      id: task.id,
-      description: task.description,
-      agent: task.agent,
-      isBackground: true,
-    })
-  }
-
-  log("[background-agent] Resuming task:", { taskId: task.id, sessionID: task.sessionID })
-
-  log("[background-agent] Resuming task - calling prompt (fire-and-forget) with:", {
-    sessionID: task.sessionID,
-    agent: task.agent,
-    model: task.model,
-    promptLength: input.prompt.length,
-  })
-
-  const resumeModel = task.model
-    ? { providerID: task.model.providerID, modelID: task.model.modelID }
-    : undefined
-  const resumeVariant = task.model?.variant
-
-  client.session
-    .promptAsync({
-      path: { id: task.sessionID },
-      body: {
-        agent: task.agent,
-        ...(resumeModel ? { model: resumeModel } : {}),
-        ...(resumeVariant ? { variant: resumeVariant } : {}),
-        tools: (() => {
-          const tools = {
-            ...getAgentToolRestrictions(task.agent),
-            task: false,
-            call_omo_agent: true,
-            question: false,
-          }
-          setSessionTools(task.sessionID!, tools)
-          return tools
-        })(),
-        parts: [{ type: "text", text: input.prompt }],
-      },
-    })
-    .catch((error: unknown) => {
-      log("[background-agent] resume prompt error:", error)
-      onTaskError(task, error instanceof Error ? error : new Error(String(error)))
-    })
-}

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

@@ -1,99 +0,0 @@
-import type { QueueItem } from "../constants"
-import { log, getAgentToolRestrictions, promptWithModelSuggestionRetry } from "../../../shared"
-import { setSessionTools } from "../../../shared/session-tools-store"
-import { subagentSessions } from "../../claude-code-session-state"
-import { getTaskToastManager } from "../../task-toast-manager"
-import { createBackgroundSession } from "./background-session-creator"
-import { getConcurrencyKeyFromLaunchInput } from "./concurrency-key-from-launch-input"
-import { resolveParentDirectory } from "./parent-directory-resolver"
-import type { SpawnerContext } from "./spawner-context"
-import { maybeInvokeTmuxCallback } from "./tmux-callback-invoker"
-
-export async function startTask(item: QueueItem, ctx: SpawnerContext): Promise<void> {
-  const { task, input } = item
-  const { client, directory, concurrencyManager, tmuxEnabled, onSubagentSessionCreated, onTaskError } = ctx
-
-  log("[background-agent] Starting task:", {
-    taskId: task.id,
-    agent: input.agent,
-    model: input.model,
-  })
-
-  const concurrencyKey = getConcurrencyKeyFromLaunchInput(input)
-  const parentDirectory = await resolveParentDirectory({
-    client,
-    parentSessionID: input.parentSessionID,
-    defaultDirectory: directory,
-  })
-
-  const sessionID = await createBackgroundSession({
-    client,
-    input,
-    parentDirectory,
-    concurrencyManager,
-    concurrencyKey,
-  })
-  subagentSessions.add(sessionID)
-
-  await maybeInvokeTmuxCallback({
-    onSubagentSessionCreated,
-    tmuxEnabled,
-    sessionID,
-    parentID: input.parentSessionID,
-    title: input.description,
-  })
-
-  task.status = "running"
-  task.startedAt = new Date()
-  task.sessionID = sessionID
-  task.progress = {
-    toolCalls: 0,
-    lastUpdate: new Date(),
-  }
-  task.concurrencyKey = concurrencyKey
-  task.concurrencyGroup = concurrencyKey
-
-  log("[background-agent] Launching task:", { taskId: task.id, sessionID, agent: input.agent })
-
-  const toastManager = getTaskToastManager()
-  if (toastManager) {
-    toastManager.updateTask(task.id, "running")
-  }
-
-  log("[background-agent] Calling prompt (fire-and-forget) for launch with:", {
-    sessionID,
-    agent: input.agent,
-    model: input.model,
-    hasSkillContent: !!input.skillContent,
-    promptLength: input.prompt.length,
-  })
-
-  const launchModel = input.model
-    ? { providerID: input.model.providerID, modelID: input.model.modelID }
-    : undefined
-  const launchVariant = input.model?.variant
-
-  promptWithModelSuggestionRetry(client, {
-    path: { id: sessionID },
-    body: {
-      agent: input.agent,
-      ...(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
-      })(),
-      parts: [{ type: "text", text: input.prompt }],
-    },
-  }).catch((error: unknown) => {
-    log("[background-agent] promptAsync error:", error)
-    onTaskError(task, error instanceof Error ? error : new Error(String(error)))
-  })
-}

src/features/background-agent/stale-task-pruner.ts

@@ -1,77 +0,0 @@
-import { log } from "../../shared"
-
-import { TASK_TTL_MS } from "./constants"
-import { subagentSessions } from "../claude-code-session-state"
-import { pruneStaleTasksAndNotifications } from "./task-poller"
-
-import type { BackgroundTask, LaunchInput } from "./types"
-import type { ConcurrencyManager } from "./concurrency"
-
-type QueueItem = { task: BackgroundTask; input: LaunchInput }
-
-export function pruneStaleState(args: {
-  tasks: Map<string, BackgroundTask>
-  notifications: Map<string, BackgroundTask[]>
-  queuesByKey: Map<string, QueueItem[]>
-  concurrencyManager: ConcurrencyManager
-  cleanupPendingByParent: (task: BackgroundTask) => void
-  clearNotificationsForTask: (taskId: string) => void
-}): void {
-  const {
-    tasks,
-    notifications,
-    queuesByKey,
-    concurrencyManager,
-    cleanupPendingByParent,
-    clearNotificationsForTask,
-  } = args
-
-  pruneStaleTasksAndNotifications({
-    tasks,
-    notifications,
-    onTaskPruned: (taskId, task, errorMessage) => {
-      const wasPending = task.status === "pending"
-      const now = Date.now()
-      const timestamp = task.status === "pending"
-        ? task.queuedAt?.getTime()
-        : task.startedAt?.getTime()
-      const age = timestamp ? now - timestamp : TASK_TTL_MS
-
-      log("[background-agent] Pruning stale task:", {
-        taskId,
-        status: task.status,
-        age: Math.round(age / 1000) + "s",
-      })
-
-      task.status = "error"
-      task.error = errorMessage
-      task.completedAt = new Date()
-      if (task.concurrencyKey) {
-        concurrencyManager.release(task.concurrencyKey)
-        task.concurrencyKey = undefined
-      }
-
-      cleanupPendingByParent(task)
-      if (wasPending) {
-        const key = task.model
-          ? `${task.model.providerID}/${task.model.modelID}`
-          : task.agent
-        const queue = queuesByKey.get(key)
-        if (queue) {
-          const index = queue.findIndex((item) => item.task.id === taskId)
-          if (index !== -1) {
-            queue.splice(index, 1)
-            if (queue.length === 0) {
-              queuesByKey.delete(key)
-            }
-          }
-        }
-      }
-      clearNotificationsForTask(taskId)
-      tasks.delete(taskId)
-      if (task.sessionID) {
-        subagentSessions.delete(task.sessionID)
-      }
-    },
-  })
-}

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

@@ -1,117 +0,0 @@
-import { log } from "../../shared"
-
-import type { BackgroundTask } from "./types"
-import type { LaunchInput } from "./types"
-import type { ConcurrencyManager } from "./concurrency"
-import type { OpencodeClient } from "./opencode-client"
-
-type QueueItem = { task: BackgroundTask; input: LaunchInput }
-
-export async function cancelBackgroundTask(args: {
-  taskId: string
-  options?: {
-    source?: string
-    reason?: string
-    abortSession?: boolean
-    skipNotification?: boolean
-  }
-  tasks: Map<string, BackgroundTask>
-  queuesByKey: Map<string, QueueItem[]>
-  completionTimers: Map<string, ReturnType<typeof setTimeout>>
-  idleDeferralTimers: Map<string, ReturnType<typeof setTimeout>>
-  concurrencyManager: ConcurrencyManager
-  client: OpencodeClient
-  cleanupPendingByParent: (task: BackgroundTask) => void
-  markForNotification: (task: BackgroundTask) => void
-  notifyParentSession: (task: BackgroundTask) => Promise<void>
-}): Promise<boolean> {
-  const {
-    taskId,
-    options,
-    tasks,
-    queuesByKey,
-    completionTimers,
-    idleDeferralTimers,
-    concurrencyManager,
-    client,
-    cleanupPendingByParent,
-    markForNotification,
-    notifyParentSession,
-  } = args
-
-  const task = tasks.get(taskId)
-  if (!task || (task.status !== "running" && task.status !== "pending")) {
-    return false
-  }
-
-  const source = options?.source ?? "cancel"
-  const abortSession = options?.abortSession !== false
-  const reason = options?.reason
-
-  if (task.status === "pending") {
-    const key = task.model
-      ? `${task.model.providerID}/${task.model.modelID}`
-      : task.agent
-    const queue = queuesByKey.get(key)
-    if (queue) {
-      const index = queue.findIndex((item) => item.task.id === taskId)
-      if (index !== -1) {
-        queue.splice(index, 1)
-        if (queue.length === 0) {
-          queuesByKey.delete(key)
-        }
-      }
-    }
-    log("[background-agent] Cancelled pending task:", { taskId, key })
-  }
-
-  task.status = "cancelled"
-  task.completedAt = new Date()
-  if (reason) {
-    task.error = reason
-  }
-
-  if (task.concurrencyKey) {
-    concurrencyManager.release(task.concurrencyKey)
-    task.concurrencyKey = undefined
-  }
-
-  const completionTimer = completionTimers.get(task.id)
-  if (completionTimer) {
-    clearTimeout(completionTimer)
-    completionTimers.delete(task.id)
-  }
-
-  const idleTimer = idleDeferralTimers.get(task.id)
-  if (idleTimer) {
-    clearTimeout(idleTimer)
-    idleDeferralTimers.delete(task.id)
-  }
-
-  cleanupPendingByParent(task)
-
-  if (abortSession && task.sessionID) {
-    client.session.abort({
-      path: { id: task.sessionID },
-    }).catch(() => {})
-  }
-
-  if (options?.skipNotification) {
-    log(`[background-agent] Task cancelled via ${source} (notification skipped):`, task.id)
-    return true
-  }
-
-  markForNotification(task)
-
-  try {
-    await notifyParentSession(task)
-    log(`[background-agent] Task cancelled via ${source}:`, task.id)
-  } catch (err) {
-    log("[background-agent] Error in notifyParentSession for cancelled task:", {
-      taskId: task.id,
-      error: err,
-    })
-  }
-
-  return true
-}

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

@@ -1,68 +0,0 @@
-import { log } from "../../shared"
-
-import type { BackgroundTask } from "./types"
-import type { ConcurrencyManager } from "./concurrency"
-import type { OpencodeClient } from "./opencode-client"
-
-export async function tryCompleteBackgroundTask(args: {
-  task: BackgroundTask
-  source: string
-  concurrencyManager: ConcurrencyManager
-  idleDeferralTimers: Map<string, ReturnType<typeof setTimeout>>
-  client: OpencodeClient
-  markForNotification: (task: BackgroundTask) => void
-  cleanupPendingByParent: (task: BackgroundTask) => void
-  notifyParentSession: (task: BackgroundTask) => Promise<void>
-}): Promise<boolean> {
-  const {
-    task,
-    source,
-    concurrencyManager,
-    idleDeferralTimers,
-    client,
-    markForNotification,
-    cleanupPendingByParent,
-    notifyParentSession,
-  } = args
-
-  if (task.status !== "running") {
-    log("[background-agent] Task already completed, skipping:", {
-      taskId: task.id,
-      status: task.status,
-      source,
-    })
-    return false
-  }
-
-  task.status = "completed"
-  task.completedAt = new Date()
-
-  if (task.concurrencyKey) {
-    concurrencyManager.release(task.concurrencyKey)
-    task.concurrencyKey = undefined
-  }
-
-  markForNotification(task)
-  cleanupPendingByParent(task)
-
-  const idleTimer = idleDeferralTimers.get(task.id)
-  if (idleTimer) {
-    clearTimeout(idleTimer)
-    idleDeferralTimers.delete(task.id)
-  }
-
-  if (task.sessionID) {
-    client.session.abort({
-      path: { id: task.sessionID },
-    }).catch(() => {})
-  }
-
-  try {
-    await notifyParentSession(task)
-    log(`[background-agent] Task completed via ${source}:`, task.id)
-  } catch (err) {
-    log("[background-agent] Error in notifyParentSession:", { taskId: task.id, error: err })
-  }
-
-  return true
-}

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

@@ -1,77 +0,0 @@
-import { getTaskToastManager } from "../task-toast-manager"
-import { log } from "../../shared"
-
-import type { BackgroundTask } from "./types"
-import type { LaunchInput } from "./types"
-
-type QueueItem = {
-  task: BackgroundTask
-  input: LaunchInput
-}
-
-export function launchBackgroundTask(args: {
-  input: LaunchInput
-  tasks: Map<string, BackgroundTask>
-  pendingByParent: Map<string, Set<string>>
-  queuesByKey: Map<string, QueueItem[]>
-  getConcurrencyKeyFromInput: (input: LaunchInput) => string
-  processKey: (key: string) => void
-}): BackgroundTask {
-  const { input, tasks, pendingByParent, queuesByKey, getConcurrencyKeyFromInput, processKey } = args
-
-  log("[background-agent] launch() called with:", {
-    agent: input.agent,
-    model: input.model,
-    description: input.description,
-    parentSessionID: input.parentSessionID,
-  })
-
-  if (!input.agent || input.agent.trim() === "") {
-    throw new Error("Agent parameter is required")
-  }
-
-  const task: BackgroundTask = {
-    id: `bg_${crypto.randomUUID().slice(0, 8)}`,
-    status: "pending",
-    queuedAt: new Date(),
-    description: input.description,
-    prompt: input.prompt,
-    agent: input.agent,
-    parentSessionID: input.parentSessionID,
-    parentMessageID: input.parentMessageID,
-    parentModel: input.parentModel,
-    parentAgent: input.parentAgent,
-    model: input.model,
-    category: input.category,
-  }
-
-  tasks.set(task.id, task)
-
-  if (input.parentSessionID) {
-    const pending = pendingByParent.get(input.parentSessionID) ?? new Set<string>()
-    pending.add(task.id)
-    pendingByParent.set(input.parentSessionID, pending)
-  }
-
-  const key = getConcurrencyKeyFromInput(input)
-  const queue = queuesByKey.get(key) ?? []
-  queue.push({ task, input })
-  queuesByKey.set(key, queue)
-
-  log("[background-agent] Task queued:", { taskId: task.id, key, queueLength: queue.length })
-
-  const toastManager = getTaskToastManager()
-  if (toastManager) {
-    toastManager.addTask({
-      id: task.id,
-      description: input.description,
-      agent: input.agent,
-      isBackground: true,
-      status: "queued",
-      skills: input.skills,
-    })
-  }
-
-  processKey(key)
-  return task
-}

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

@@ -1,56 +0,0 @@
-import type { BackgroundTask } from "./types"
-
-export function getTasksByParentSession(
-  tasks: Iterable<BackgroundTask>,
-  sessionID: string
-): BackgroundTask[] {
-  const result: BackgroundTask[] = []
-  for (const task of tasks) {
-    if (task.parentSessionID === sessionID) {
-      result.push(task)
-    }
-  }
-  return result
-}
-
-export function getAllDescendantTasks(
-  tasksByParent: (sessionID: string) => BackgroundTask[],
-  sessionID: string
-): BackgroundTask[] {
-  const result: BackgroundTask[] = []
-  const directChildren = tasksByParent(sessionID)
-
-  for (const child of directChildren) {
-    result.push(child)
-    if (child.sessionID) {
-      result.push(...getAllDescendantTasks(tasksByParent, child.sessionID))
-    }
-  }
-
-  return result
-}
-
-export function findTaskBySession(
-  tasks: Iterable<BackgroundTask>,
-  sessionID: string
-): BackgroundTask | undefined {
-  for (const task of tasks) {
-    if (task.sessionID === sessionID) return task
-  }
-  return undefined
-}
-
-export function getRunningTasks(tasks: Iterable<BackgroundTask>): BackgroundTask[] {
-  return Array.from(tasks).filter((t) => t.status === "running")
-}
-
-export function getNonRunningTasks(tasks: Iterable<BackgroundTask>): BackgroundTask[] {
-  return Array.from(tasks).filter((t) => t.status !== "running")
-}
-
-export function hasRunningTasks(tasks: Iterable<BackgroundTask>): boolean {
-  for (const task of tasks) {
-    if (task.status === "running") return true
-  }
-  return false
-}

src/features/background-agent/task-queue-processor.ts

@@ -1,52 +0,0 @@
-import { log } from "../../shared"
-
-import type { BackgroundTask } from "./types"
-import type { ConcurrencyManager } from "./concurrency"
-
-type QueueItem = {
-  task: BackgroundTask
-  input: import("./types").LaunchInput
-}
-
-export async function processConcurrencyKeyQueue(args: {
-  key: string
-  queuesByKey: Map<string, QueueItem[]>
-  processingKeys: Set<string>
-  concurrencyManager: ConcurrencyManager
-  startTask: (item: QueueItem) => Promise<void>
-}): Promise<void> {
-  const { key, queuesByKey, processingKeys, concurrencyManager, startTask } = args
-
-  if (processingKeys.has(key)) return
-  processingKeys.add(key)
-
-  try {
-    const queue = queuesByKey.get(key)
-    while (queue && queue.length > 0) {
-      const item = queue[0]
-
-      await concurrencyManager.acquire(key)
-
-      if (item.task.status === "cancelled" || item.task.status === "error") {
-        concurrencyManager.release(key)
-        queue.shift()
-        continue
-      }
-
-      try {
-        await startTask(item)
-      } catch (error) {
-        log("[background-agent] Error starting task:", error)
-        // Release concurrency slot if startTask failed and didn't release it itself
-        // This prevents slot leaks when errors occur after acquire but before task.concurrencyKey is set
-        if (!item.task.concurrencyKey) {
-          concurrencyManager.release(key)
-        }
-      }
-
-      queue.shift()
-    }
-  } finally {
-    processingKeys.delete(key)
-  }
-}

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

@@ -1,148 +0,0 @@
-import { log, getAgentToolRestrictions } from "../../shared"
-import { subagentSessions } from "../claude-code-session-state"
-import { getTaskToastManager } from "../task-toast-manager"
-
-import type { BackgroundTask, ResumeInput } from "./types"
-import type { ConcurrencyManager } from "./concurrency"
-import type { OpencodeClient } from "./opencode-client"
-
-type ModelRef = { providerID: string; modelID: string }
-
-export async function resumeBackgroundTask(args: {
-  input: ResumeInput
-  findBySession: (sessionID: string) => BackgroundTask | undefined
-  client: OpencodeClient
-  concurrencyManager: ConcurrencyManager
-  pendingByParent: Map<string, Set<string>>
-  startPolling: () => void
-  markForNotification: (task: BackgroundTask) => void
-  cleanupPendingByParent: (task: BackgroundTask) => void
-  notifyParentSession: (task: BackgroundTask) => Promise<void>
-}): Promise<BackgroundTask> {
-  const {
-    input,
-    findBySession,
-    client,
-    concurrencyManager,
-    pendingByParent,
-    startPolling,
-    markForNotification,
-    cleanupPendingByParent,
-    notifyParentSession,
-  } = args
-
-  const existingTask = findBySession(input.sessionId)
-  if (!existingTask) {
-    throw new Error(`Task not found for session: ${input.sessionId}`)
-  }
-
-  if (!existingTask.sessionID) {
-    throw new Error(`Task has no sessionID: ${existingTask.id}`)
-  }
-
-  if (existingTask.status === "running") {
-    log("[background-agent] Resume skipped - task already running:", {
-      taskId: existingTask.id,
-      sessionID: existingTask.sessionID,
-    })
-    return existingTask
-  }
-
-  const concurrencyKey =
-    existingTask.concurrencyGroup ??
-    (existingTask.model
-      ? `${existingTask.model.providerID}/${existingTask.model.modelID}`
-      : existingTask.agent)
-  await concurrencyManager.acquire(concurrencyKey)
-  existingTask.concurrencyKey = concurrencyKey
-  existingTask.concurrencyGroup = concurrencyKey
-
-  existingTask.status = "running"
-  existingTask.completedAt = undefined
-  existingTask.error = undefined
-  existingTask.parentSessionID = input.parentSessionID
-  existingTask.parentMessageID = input.parentMessageID
-  existingTask.parentModel = input.parentModel
-  existingTask.parentAgent = input.parentAgent
-  existingTask.startedAt = new Date()
-
-  existingTask.progress = {
-    toolCalls: existingTask.progress?.toolCalls ?? 0,
-    lastUpdate: new Date(),
-  }
-
-  startPolling()
-  if (existingTask.sessionID) {
-    subagentSessions.add(existingTask.sessionID)
-  }
-
-  if (input.parentSessionID) {
-    const pending = pendingByParent.get(input.parentSessionID) ?? new Set<string>()
-    pending.add(existingTask.id)
-    pendingByParent.set(input.parentSessionID, pending)
-  }
-
-  const toastManager = getTaskToastManager()
-  if (toastManager) {
-    toastManager.addTask({
-      id: existingTask.id,
-      description: existingTask.description,
-      agent: existingTask.agent,
-      isBackground: true,
-    })
-  }
-
-  log("[background-agent] Resuming task:", { taskId: existingTask.id, sessionID: existingTask.sessionID })
-  log("[background-agent] Resuming task - calling prompt (fire-and-forget) with:", {
-    sessionID: existingTask.sessionID,
-    agent: existingTask.agent,
-    model: existingTask.model,
-    promptLength: input.prompt.length,
-  })
-
-  const resumeModel: ModelRef | undefined = existingTask.model
-    ? { providerID: existingTask.model.providerID, modelID: existingTask.model.modelID }
-    : undefined
-  const resumeVariant = existingTask.model?.variant
-
-  client.session.promptAsync({
-    path: { id: existingTask.sessionID },
-    body: {
-      agent: existingTask.agent,
-      ...(resumeModel ? { model: resumeModel } : {}),
-      ...(resumeVariant ? { variant: resumeVariant } : {}),
-      tools: {
-        ...getAgentToolRestrictions(existingTask.agent),
-        task: false,
-        call_omo_agent: true,
-        question: false,
-      },
-      parts: [{ type: "text", text: input.prompt }],
-    },
-  }).catch((error) => {
-    log("[background-agent] resume prompt error:", error)
-    existingTask.status = "interrupt"
-    const errorMessage = error instanceof Error ? error.message : String(error)
-    existingTask.error = errorMessage
-    existingTask.completedAt = new Date()
-
-    if (existingTask.concurrencyKey) {
-      concurrencyManager.release(existingTask.concurrencyKey)
-      existingTask.concurrencyKey = undefined
-    }
-
-    if (existingTask.sessionID) {
-      client.session.abort({
-        path: { id: existingTask.sessionID },
-      }).catch(() => {})
-    }
-
-    markForNotification(existingTask)
-    cleanupPendingByParent(existingTask)
-    notifyParentSession(existingTask).catch((err) => {
-      log("[background-agent] Failed to notify on resume error:", err)
-    })
-  })
-
-  return existingTask
-}

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

@@ -1,190 +0,0 @@
-import { log, getAgentToolRestrictions, promptWithModelSuggestionRetry } from "../../shared"
-import { isInsideTmux } from "../../shared/tmux"
-
-import { subagentSessions } from "../claude-code-session-state"
-import { getTaskToastManager } from "../task-toast-manager"
-
-import type { BackgroundTask } from "./types"
-import type { LaunchInput } from "./types"
-import type { ConcurrencyManager } from "./concurrency"
-import type { OpencodeClient } from "./opencode-client"
-
-type QueueItem = {
-  task: BackgroundTask
-  input: LaunchInput
-}
-
-type ModelRef = { providerID: string; modelID: string }
-
-export async function startQueuedTask(args: {
-  item: QueueItem
-  client: OpencodeClient
-  defaultDirectory: string
-  tmuxEnabled: boolean
-  onSubagentSessionCreated?: (event: { sessionID: string; parentID: string; title: string }) => Promise<void>
-  startPolling: () => void
-  getConcurrencyKeyFromInput: (input: LaunchInput) => string
-  concurrencyManager: ConcurrencyManager
-  findBySession: (sessionID: string) => BackgroundTask | undefined
-  markForNotification: (task: BackgroundTask) => void
-  cleanupPendingByParent: (task: BackgroundTask) => void
-  notifyParentSession: (task: BackgroundTask) => Promise<void>
-}): Promise<void> {
-  const {
-    item,
-    client,
-    defaultDirectory,
-    tmuxEnabled,
-    onSubagentSessionCreated,
-    startPolling,
-    getConcurrencyKeyFromInput,
-    concurrencyManager,
-    findBySession,
-    markForNotification,
-    cleanupPendingByParent,
-    notifyParentSession,
-  } = args
-
-  const { task, input } = item
-
-  log("[background-agent] Starting task:", {
-    taskId: task.id,
-    agent: input.agent,
-    model: input.model,
-  })
-
-  const concurrencyKey = getConcurrencyKeyFromInput(input)
-
-  const parentSession = await client.session.get({
-    path: { id: input.parentSessionID },
-  }).catch((err) => {
-    log(`[background-agent] Failed to get parent session: ${err}`)
-    return null
-  })
-
-  const parentDirectory = parentSession?.data?.directory ?? defaultDirectory
-  log(`[background-agent] Parent dir: ${parentSession?.data?.directory}, using: ${parentDirectory}`)
-
-  const createResult = await client.session.create({
-    body: {
-      parentID: input.parentSessionID,
-      title: `${input.description} (@${input.agent} subagent)`,
-    } as any,
-    query: {
-      directory: parentDirectory,
-    },
-  })
-
-  if (createResult.error) {
-    throw new Error(`Failed to create background session: ${createResult.error}`)
-  }
-
-  if (!createResult.data?.id) {
-    throw new Error("Failed to create background session: API returned no session ID")
-  }
-
-  const sessionID = createResult.data.id
-  subagentSessions.add(sessionID)
-
-  log("[background-agent] tmux callback check", {
-    hasCallback: !!onSubagentSessionCreated,
-    tmuxEnabled,
-    isInsideTmux: isInsideTmux(),
-    sessionID,
-    parentID: input.parentSessionID,
-  })
-
-  if (onSubagentSessionCreated && tmuxEnabled && isInsideTmux()) {
-    log("[background-agent] Invoking tmux callback NOW", { sessionID })
-    await onSubagentSessionCreated({
-      sessionID,
-      parentID: input.parentSessionID,
-      title: input.description,
-    }).catch((err) => {
-      log("[background-agent] Failed to spawn tmux pane:", err)
-    })
-    log("[background-agent] tmux callback completed, waiting 200ms")
-    await new Promise<void>((resolve) => {
-      setTimeout(() => resolve(), 200)
-    })
-  } else {
-    log("[background-agent] SKIP tmux callback - conditions not met")
-  }
-
-  task.status = "running"
-  task.startedAt = new Date()
-  task.sessionID = sessionID
-  task.progress = {
-    toolCalls: 0,
-    lastUpdate: new Date(),
-  }
-  task.concurrencyKey = concurrencyKey
-  task.concurrencyGroup = concurrencyKey
-
-  startPolling()
-
-  log("[background-agent] Launching task:", { taskId: task.id, sessionID, agent: input.agent })
-
-  const toastManager = getTaskToastManager()
-  if (toastManager) {
-    toastManager.updateTask(task.id, "running")
-  }
-
-  log("[background-agent] Calling prompt (fire-and-forget) for launch with:", {
-    sessionID,
-    agent: input.agent,
-    model: input.model,
-    hasSkillContent: !!input.skillContent,
-    promptLength: input.prompt.length,
-  })
-
-  const launchModel: ModelRef | undefined = input.model
-    ? { providerID: input.model.providerID, modelID: input.model.modelID }
-    : undefined
-  const launchVariant = input.model?.variant
-
-  promptWithModelSuggestionRetry(client, {
-    path: { id: sessionID },
-    body: {
-      agent: input.agent,
-      ...(launchModel ? { model: launchModel } : {}),
-      ...(launchVariant ? { variant: launchVariant } : {}),
-      system: input.skillContent,
-      tools: {
-        ...getAgentToolRestrictions(input.agent),
-        task: false,
-        call_omo_agent: true,
-        question: false,
-      },
-      parts: [{ type: "text", text: input.prompt }],
-    },
-  }).catch((error) => {
-    log("[background-agent] promptAsync error:", error)
-    const existingTask = findBySession(sessionID)
-    if (!existingTask) return
-
-    existingTask.status = "interrupt"
-    const errorMessage = error instanceof Error ? error.message : String(error)
-    if (errorMessage.includes("agent.name") || errorMessage.includes("undefined")) {
-      existingTask.error = `Agent "${input.agent}" not found. Make sure the agent is registered in your opencode.json or provided by a plugin.`
-    } else {
-      existingTask.error = errorMessage
-    }
-    existingTask.completedAt = new Date()
-
-    if (existingTask.concurrencyKey) {
-      concurrencyManager.release(existingTask.concurrencyKey)
-      existingTask.concurrencyKey = undefined
-    }
-
-    client.session.abort({
-      path: { id: sessionID },
-    }).catch(() => {})
-
-    markForNotification(existingTask)
-    cleanupPendingByParent(existingTask)
-    notifyParentSession(existingTask).catch((err) => {
-      log("[background-agent] Failed to notify on error:", err)
-    })
-  })
-}

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

@@ -1,97 +0,0 @@
-import { log } from "../../shared"
-import { subagentSessions } from "../claude-code-session-state"
-
-import type { BackgroundTask } from "./types"
-import type { ConcurrencyManager } from "./concurrency"
-
-export async function trackExternalTask(args: {
-  input: {
-    taskId: string
-    sessionID: string
-    parentSessionID: string
-    description: string
-    agent?: string
-    parentAgent?: string
-    concurrencyKey?: string
-  }
-  tasks: Map<string, BackgroundTask>
-  pendingByParent: Map<string, Set<string>>
-  concurrencyManager: ConcurrencyManager
-  startPolling: () => void
-  cleanupPendingByParent: (task: BackgroundTask) => void
-}): Promise<BackgroundTask> {
-  const { input, tasks, pendingByParent, concurrencyManager, startPolling, cleanupPendingByParent } = args
-
-  const existingTask = tasks.get(input.taskId)
-  if (existingTask) {
-    const parentChanged = input.parentSessionID !== existingTask.parentSessionID
-    if (parentChanged) {
-      cleanupPendingByParent(existingTask)
-      existingTask.parentSessionID = input.parentSessionID
-    }
-    if (input.parentAgent !== undefined) {
-      existingTask.parentAgent = input.parentAgent
-    }
-    if (!existingTask.concurrencyGroup) {
-      existingTask.concurrencyGroup = input.concurrencyKey ?? existingTask.agent
-    }
-
-    if (existingTask.sessionID) {
-      subagentSessions.add(existingTask.sessionID)
-    }
-    startPolling()
-
-    if (existingTask.status === "pending" || existingTask.status === "running") {
-      const pending = pendingByParent.get(input.parentSessionID) ?? new Set<string>()
-      pending.add(existingTask.id)
-      pendingByParent.set(input.parentSessionID, pending)
-    } else if (!parentChanged) {
-      cleanupPendingByParent(existingTask)
-    }
-
-    log("[background-agent] External task already registered:", {
-      taskId: existingTask.id,
-      sessionID: existingTask.sessionID,
-      status: existingTask.status,
-    })
-
-    return existingTask
-  }
-
-  const concurrencyGroup = input.concurrencyKey ?? input.agent ?? "task"
-  if (input.concurrencyKey) {
-    await concurrencyManager.acquire(input.concurrencyKey)
-  }
-
-  const task: BackgroundTask = {
-    id: input.taskId,
-    sessionID: input.sessionID,
-    parentSessionID: input.parentSessionID,
-    parentMessageID: "",
-    description: input.description,
-    prompt: "",
-    agent: input.agent || "task",
-    status: "running",
-    startedAt: new Date(),
-    progress: {
-      toolCalls: 0,
-      lastUpdate: new Date(),
-    },
-    parentAgent: input.parentAgent,
-    concurrencyKey: input.concurrencyKey,
-    concurrencyGroup,
-  }
-
-  tasks.set(task.id, task)
-  subagentSessions.add(input.sessionID)
-  startPolling()
-
-  if (input.parentSessionID) {
-    const pending = pendingByParent.get(input.parentSessionID) ?? new Set<string>()
-    pending.add(task.id)
-    pendingByParent.set(input.parentSessionID, pending)
-  }
-
-  log("[background-agent] Registered external task:", { taskId: task.id, sessionID: input.sessionID })
-  return task
-}

src/features/claude-tasks/AGENTS.md

@@ -1,68 +1,43 @@
-# CLAUDE TASKS KNOWLEDGE BASE
+# src/features/claude-tasks/ — Task Schema + Storage
+
+**Generated:** 2026-02-17
 
 ## OVERVIEW
 
-Claude Code compatible task schema and storage. Core task management with file-based persistence, atomic writes, and OpenCode todo sync.
-
-## STRUCTURE
-```
-claude-tasks/
-├── types.ts               # Task schema (Zod)
-├── types.test.ts          # Schema validation tests
-├── storage.ts             # File operations (atomic write, locking)
-├── storage.test.ts        # Storage tests (30 tests, 543 lines)
-├── session-storage.ts     # Session-scoped task storage
-├── session-storage.test.ts
-└── index.ts               # Barrel exports
-```
+4 non-test files (~622 LOC). File-based task persistence with atomic writes, locking, and OpenCode todo API sync.
 
 ## TASK SCHEMA
 
 ```typescript
-type TaskStatus = "pending" | "in_progress" | "completed" | "deleted"
 interface Task {
-  id: string                    // T-{uuid}
-  subject: string               // Imperative: "Run tests"
-  description: string
-  status: TaskStatus
-  activeForm?: string           // Present continuous: "Running tests"
-  blocks: string[]              // Task IDs this task blocks
-  blockedBy: string[]           // Task IDs blocking this task
-  owner?: string                // Agent name
+  id: string              // T-{uuid} auto-generated
+  subject: string         // Short title
+  description?: string    // Detailed description
+  status: "pending" | "in_progress" | "completed" | "deleted"
+  activeForm?: string     // Current form/template
+  blocks?: string[]       // Tasks this blocks
+  blockedBy?: string[]    // Tasks blocking this
+  owner?: string          // Agent/session
   metadata?: Record<string, unknown>
-  repoURL?: string
-  parentID?: string
-  threadID?: string
+  repoURL?: string        // Associated repository
+  parentID?: string       // Parent task ID
+  threadID?: string       // Session ID (auto-recorded)
 }
 ```
 
-## STORAGE UTILITIES
+## FILES
 
-| Function | Purpose |
-|----------|---------|
-| `getTaskDir(config)` | Task storage directory path |
-| `resolveTaskListId(config)` | Task list ID (env → config → cwd) |
-| `readJsonSafe(path, schema)` | Parse + validate, null on failure |
-| `writeJsonAtomic(path, data)` | Atomic write via temp + rename |
-| `acquireLock(dirPath)` | File lock with 30s stale threshold |
-| `generateTaskId()` | `T-{uuid}` format |
-| `findTaskAcrossSessions(config, taskId)` | Locate task in any session |
+| File | Purpose |
+|------|---------|
+| `types.ts` | Task interface + status types |
+| `storage.ts` | `readJsonSafe()`, `writeJsonAtomic()`, `acquireLock()`, `generateTaskId()` |
+| `session-storage.ts` | Per-session task storage, threadID auto-recording |
+| `index.ts` | Barrel exports |
 
-## TODO SYNC
+## STORAGE
 
-Automatic bidirectional sync between tasks and OpenCode's todo system.
-
-| Task Status | Todo Status |
-|-------------|-------------|
-| `pending` | `pending` |
-| `in_progress` | `in_progress` |
-| `completed` | `completed` |
-| `deleted` | `null` (removed) |
-
-Sync triggers: `task_create`, `task_update`.
-
-## ANTI-PATTERNS
-
-- Direct fs operations (use storage utilities)
-- Skipping lock acquisition for writes
-- Using old field names (title → subject, dependsOn → blockedBy)
+- Location: `.sisyphus/tasks/` directory
+- Format: JSON files, one per task
+- Atomic writes: temp file → rename
+- Locking: file-based lock for concurrent access
+- Sync: Changes pushed to OpenCode Todo API after each update

src/features/mcp-oauth/callback-server.test.ts

@@ -1,38 +1,8 @@
 import { afterEach, describe, expect, it } from "bun:test"
-import { findAvailablePort, startCallbackServer, type CallbackServer } from "./callback-server"
+import { startCallbackServer, type CallbackServer } from "./callback-server"
 
 const nativeFetch = Bun.fetch.bind(Bun)
 
-describe("findAvailablePort", () => {
-  it("returns the start port when it is available", async () => {
-    // given
-    const startPort = 19877
-
-    // when
-    const port = await findAvailablePort(startPort)
-
-    // then
-    expect(port).toBeGreaterThanOrEqual(startPort)
-    expect(port).toBeLessThan(startPort + 20)
-  })
-
-  it("skips busy ports and returns next available", async () => {
-    // given
-    const blocker = Bun.serve({
-      port: 19877,
-      hostname: "127.0.0.1",
-      fetch: () => new Response(),
-    })
-
-    // when
-    const port = await findAvailablePort(19877)
-
-    // then
-    expect(port).toBeGreaterThan(19877)
-    blocker.stop(true)
-  })
-})
-
 describe("startCallbackServer", () => {
   let server: CallbackServer | null = null
 

src/features/mcp-oauth/callback-server.ts

@@ -1,5 +1,6 @@
+import { findAvailablePort as findAvailablePortShared } from "../../shared/port-utils"
+
 const DEFAULT_PORT = 19877
-const MAX_PORT_ATTEMPTS = 20
 const TIMEOUT_MS = 5 * 60 * 1000
 
 export type OAuthCallbackResult = {
@@ -33,28 +34,8 @@ const SUCCESS_HTML = `<!DOCTYPE html>
 </body>
 </html>`
 
-async function isPortAvailable(port: number): Promise<boolean> {
-  try {
-    const server = Bun.serve({
-      port,
-      hostname: "127.0.0.1",
-      fetch: () => new Response(),
-    })
-    server.stop(true)
-    return true
-  } catch {
-    return false
-  }
-}
-
 export async function findAvailablePort(startPort: number = DEFAULT_PORT): Promise<number> {
-  for (let attempt = 0; attempt < MAX_PORT_ATTEMPTS; attempt++) {
-    const port = startPort + attempt
-    if (await isPortAvailable(port)) {
-      return port
-    }
-  }
-  throw new Error(`No available port found in range ${startPort}-${startPort + MAX_PORT_ATTEMPTS - 1}`)
+  return findAvailablePortShared(startPort)
 }
 
 export async function startCallbackServer(startPort: number = DEFAULT_PORT): Promise<CallbackServer> {

src/features/opencode-skill-loader/AGENTS.md

@@ -0,0 +1,59 @@
+# src/features/opencode-skill-loader/ — 4-Scope Skill Discovery
+
+**Generated:** 2026-02-18
+
+## OVERVIEW
+
+28 files (~3.2k LOC). Discovers, parses, merges, and resolves SKILL.md files from 4 scopes with priority deduplication.
+
+## 4-SCOPE PRIORITY (highest → lowest)
+
+```
+1. Project (.opencode/skills/)
+2. OpenCode config (~/.config/opencode/skills/)
+3. User (~/.config/opencode/oh-my-opencode/skills/)
+4. Global (built-in skills)
+```
+
+Same-named skill at higher scope overrides lower.
+
+## KEY FILES
+
+| File | Purpose |
+|------|---------|
+| `loader.ts` | Main `loadSkills()` — orchestrates discovery → parse → merge |
+| `async-loader.ts` | Async variant for non-blocking skill loading |
+| `blocking.ts` | Sync variant for initial load |
+| `merger.ts` | Priority-based deduplication across scopes |
+| `skill-content.ts` | YAML frontmatter parsing from SKILL.md |
+| `skill-discovery.ts` | Find SKILL.md files in directory trees |
+| `skill-directory-loader.ts` | Load all skills from a single directory |
+| `config-source-discovery.ts` | Discover scope directories from config |
+| `skill-template-resolver.ts` | Variable substitution in skill templates |
+| `skill-mcp-config.ts` | Extract MCP configs from skill YAML |
+| `types.ts` | `LoadedSkill`, `SkillScope`, `SkillDiscoveryResult` |
+
+## SKILL FORMAT (SKILL.md)
+
+```markdown
+---
+name: my-skill
+description: What this skill does
+tools: [Bash, Read, Write]
+mcp:
+  - name: my-mcp
+    type: stdio
+    command: npx
+    args: [-y, my-mcp-server]
+---
+
+Skill content (instructions for the agent)...
+```
+
+## MERGER SUBDIRECTORY
+
+Handles complex merge logic when skills from multiple scopes have overlapping names or MCP configs.
+
+## TEMPLATE RESOLUTION
+
+Variables like `{{directory}}`, `{{agent}}` in skill content get resolved at load time based on current context.

src/features/run-continuation-state/constants.ts

@@ -0,0 +1 @@
+export const CONTINUATION_MARKER_DIR = ".sisyphus/run-continuation"

src/features/run-continuation-state/index.ts

@@ -0,0 +1,3 @@
+export * from "./types"
+export * from "./constants"
+export * from "./storage"

src/features/run-continuation-state/storage.test.ts

@@ -0,0 +1,91 @@
+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 {
+  clearContinuationMarker,
+  isContinuationMarkerActive,
+  readContinuationMarker,
+  setContinuationMarkerSource,
+} from "./storage"
+
+const tempDirs: string[] = []
+
+function createTempDir(): string {
+  const directory = mkdtempSync(join(tmpdir(), "omo-run-marker-"))
+  tempDirs.push(directory)
+  return directory
+}
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    const directory = tempDirs.pop()
+    if (directory) {
+      rmSync(directory, { recursive: true, force: true })
+    }
+  }
+})
+
+describe("run-continuation-state storage", () => {
+  it("stores and reads per-source marker state", () => {
+    // given
+    const directory = createTempDir()
+    const sessionID = "ses_test"
+
+    // when
+    setContinuationMarkerSource(directory, sessionID, "todo", "active", "2 todos remaining")
+    setContinuationMarkerSource(directory, sessionID, "stop", "stopped", "user requested stop")
+    const marker = readContinuationMarker(directory, sessionID)
+
+    // then
+    expect(marker).not.toBeNull()
+    expect(marker?.sessionID).toBe(sessionID)
+    expect(marker?.sources.todo?.state).toBe("active")
+    expect(marker?.sources.todo?.reason).toBe("2 todos remaining")
+    expect(marker?.sources.stop?.state).toBe("stopped")
+  })
+
+  it("treats marker as active when any source is active", () => {
+    // given
+    const directory = createTempDir()
+    const sessionID = "ses_active"
+    setContinuationMarkerSource(directory, sessionID, "todo", "active", "pending")
+    setContinuationMarkerSource(directory, sessionID, "stop", "idle")
+    const marker = readContinuationMarker(directory, sessionID)
+
+    // when
+    const isActive = isContinuationMarkerActive(marker)
+
+    // then
+    expect(isActive).toBe(true)
+  })
+
+  it("returns inactive when no source is active", () => {
+    // given
+    const directory = createTempDir()
+    const sessionID = "ses_idle"
+    setContinuationMarkerSource(directory, sessionID, "todo", "idle")
+    setContinuationMarkerSource(directory, sessionID, "stop", "stopped")
+    const marker = readContinuationMarker(directory, sessionID)
+
+    // when
+    const isActive = isContinuationMarkerActive(marker)
+
+    // then
+    expect(isActive).toBe(false)
+  })
+
+  it("clears marker for a session", () => {
+    // given
+    const directory = createTempDir()
+    const sessionID = "ses_clear"
+    setContinuationMarkerSource(directory, sessionID, "todo", "active")
+
+    // when
+    clearContinuationMarker(directory, sessionID)
+    const marker = readContinuationMarker(directory, sessionID)
+
+    // then
+    expect(marker).toBeNull()
+  })
+})

src/features/run-continuation-state/storage.ts

@@ -0,0 +1,80 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { CONTINUATION_MARKER_DIR } from "./constants"
+import type {
+  ContinuationMarker,
+  ContinuationMarkerSource,
+  ContinuationMarkerState,
+} from "./types"
+
+function getMarkerPath(directory: string, sessionID: string): string {
+  return join(directory, CONTINUATION_MARKER_DIR, `${sessionID}.json`)
+}
+
+export function readContinuationMarker(
+  directory: string,
+  sessionID: string,
+): ContinuationMarker | null {
+  const markerPath = getMarkerPath(directory, sessionID)
+  if (!existsSync(markerPath)) return null
+
+  try {
+    const raw = readFileSync(markerPath, "utf-8")
+    const parsed = JSON.parse(raw)
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null
+    return parsed as ContinuationMarker
+  } catch {
+    return null
+  }
+}
+
+export function setContinuationMarkerSource(
+  directory: string,
+  sessionID: string,
+  source: ContinuationMarkerSource,
+  state: ContinuationMarkerState,
+  reason?: string,
+): ContinuationMarker {
+  const now = new Date().toISOString()
+  const existing = readContinuationMarker(directory, sessionID)
+  const next: ContinuationMarker = {
+    sessionID,
+    updatedAt: now,
+    sources: {
+      ...(existing?.sources ?? {}),
+      [source]: {
+        state,
+        ...(reason ? { reason } : {}),
+        updatedAt: now,
+      },
+    },
+  }
+
+  const markerPath = getMarkerPath(directory, sessionID)
+  mkdirSync(join(directory, CONTINUATION_MARKER_DIR), { recursive: true })
+  writeFileSync(markerPath, JSON.stringify(next, null, 2), "utf-8")
+  return next
+}
+
+export function clearContinuationMarker(directory: string, sessionID: string): void {
+  const markerPath = getMarkerPath(directory, sessionID)
+  if (!existsSync(markerPath)) return
+
+  try {
+    rmSync(markerPath)
+  } catch {
+  }
+}
+
+export function isContinuationMarkerActive(marker: ContinuationMarker | null): boolean {
+  if (!marker) return false
+  return Object.values(marker.sources).some((entry) => entry?.state === "active")
+}
+
+export function getActiveContinuationMarkerReason(marker: ContinuationMarker | null): string | null {
+  if (!marker) return null
+  const active = Object.entries(marker.sources).find(([, entry]) => entry?.state === "active")
+  if (!active || !active[1]) return null
+  const [source, entry] = active
+  return entry.reason ?? `${source} continuation is active`
+}

src/features/run-continuation-state/types.ts

@@ -0,0 +1,15 @@
+export type ContinuationMarkerSource = "todo" | "stop"
+
+export type ContinuationMarkerState = "idle" | "active" | "stopped"
+
+export interface ContinuationMarkerSourceEntry {
+  state: ContinuationMarkerState
+  reason?: string
+  updatedAt: string
+}
+
+export interface ContinuationMarker {
+  sessionID: string
+  updatedAt: string
+  sources: Partial<Record<ContinuationMarkerSource, ContinuationMarkerSourceEntry>>
+}

src/features/tmux-subagent/AGENTS.md

@@ -0,0 +1,52 @@
+# src/features/tmux-subagent/ — Tmux Pane Management
+
+**Generated:** 2026-02-18
+
+## OVERVIEW
+
+28 files. State-first tmux integration managing panes for background agent sessions. Handles split decisions, grid planning, polling, and lifecycle events.
+
+## CORE ARCHITECTURE
+
+```
+TmuxSessionManager (manager.ts)
+  ├─→ DecisionEngine: Should we spawn/close panes?
+  ├─→ ActionExecutor: Execute spawn/close/replace actions
+  ├─→ PollingManager: Monitor pane health
+  └─→ EventHandlers: React to session create/delete
+```
+
+## KEY FILES
+
+| File | Purpose |
+|------|---------|
+| `manager.ts` | `TmuxSessionManager` — main class, session tracking, event routing |
+| `decision-engine.ts` | Evaluate window state → produce `SpawnDecision` with actions |
+| `action-executor.ts` | Execute `PaneAction[]` (close, spawn, replace) |
+| `grid-planning.ts` | Calculate pane layout given window dimensions |
+| `spawn-action-decider.ts` | Decide spawn vs replace vs skip |
+| `spawn-target-finder.ts` | Find best pane to split or replace |
+| `polling-manager.ts` | Health polling for tracked sessions |
+| `types.ts` | `TrackedSession`, `WindowState`, `PaneAction`, `SpawnDecision` |
+
+## PANE LIFECYCLE
+
+```
+session.created → spawn-action-decider → grid-planning → action-executor → track session
+session.deleted → cleanup tracked session → close pane if empty
+```
+
+## LAYOUT CONSTRAINTS
+
+- `MIN_PANE_WIDTH`: 52 chars
+- `MIN_PANE_HEIGHT`: 11 lines
+- Main pane preserved (never split below minimum)
+- Agent panes split from remaining space
+
+## EVENT HANDLERS
+
+| File | Event |
+|------|-------|
+| `session-created-handler.ts` | New background session → spawn pane |
+| `session-deleted-handler.ts` | Session ended → close pane |
+| `session-created-event.ts` | Event type definition |

src/features/tmux-subagent/manager-cleanup.ts

@@ -1,43 +0,0 @@
-import type { TmuxConfig } from "../../config/schema"
-import type { TrackedSession } from "./types"
-import { log } from "../../shared"
-import { queryWindowState } from "./pane-state-querier"
-import { executeAction } from "./action-executor"
-import { TmuxPollingManager } from "./polling-manager"
-
-export class ManagerCleanup {
-  constructor(
-    private sessions: Map<string, TrackedSession>,
-    private sourcePaneId: string | undefined,
-    private pollingManager: TmuxPollingManager,
-    private tmuxConfig: TmuxConfig,
-    private serverUrl: string
-  ) {}
-
-  async cleanup(): Promise<void> {
-    this.pollingManager.stopPolling()
-
-    if (this.sessions.size > 0) {
-      log("[tmux-session-manager] closing all panes", { count: this.sessions.size })
-      const state = this.sourcePaneId ? await queryWindowState(this.sourcePaneId) : null
-      
-      if (state) {
-        const closePromises = Array.from(this.sessions.values()).map((s) =>
-          executeAction(
-            { type: "close", paneId: s.paneId, sessionId: s.sessionId },
-            { config: this.tmuxConfig, serverUrl: this.serverUrl, windowState: state }
-          ).catch((err) =>
-            log("[tmux-session-manager] cleanup error for pane", {
-              paneId: s.paneId,
-              error: String(err),
-            }),
-          ),
-        )
-        await Promise.all(closePromises)
-      }
-      this.sessions.clear()
-    }
-
-    log("[tmux-session-manager] cleanup complete")
-  }
-}

src/features/tmux-subagent/pane-split-availability.ts

@@ -1,11 +1,10 @@
 import { MIN_PANE_WIDTH } from "./types"
 import type { SplitDirection, TmuxPaneInfo } from "./types"
 import {
-	DIVIDER_SIZE,
-	MAX_COLS,
-	MAX_ROWS,
-	MIN_SPLIT_HEIGHT,
-	MIN_SPLIT_WIDTH,
+  DIVIDER_SIZE,
+  MAX_COLS,
+  MAX_ROWS,
+  MIN_SPLIT_HEIGHT,
 } from "./tmux-grid-constants"
 
 function minSplitWidthFor(minPaneWidth: number): number {

src/features/tmux-subagent/session-cleaner.ts

@@ -1,80 +0,0 @@
-import type { TmuxConfig } from "../../config/schema"
-import type { TrackedSession } from "./types"
-import type { SessionMapping } from "./decision-engine"
-import { log } from "../../shared"
-import { queryWindowState } from "./pane-state-querier"
-import { decideCloseAction } from "./decision-engine"
-import { executeAction } from "./action-executor"
-import { TmuxPollingManager } from "./polling-manager"
-
-export interface TmuxUtilDeps {
-  isInsideTmux: () => boolean
-  getCurrentPaneId: () => string | undefined
-}
-
-export class SessionCleaner {
-  constructor(
-    private tmuxConfig: TmuxConfig,
-    private deps: TmuxUtilDeps,
-    private sessions: Map<string, TrackedSession>,
-    private sourcePaneId: string | undefined,
-    private getSessionMappings: () => SessionMapping[],
-    private pollingManager: TmuxPollingManager,
-    private serverUrl: string
-  ) {}
-
-  private isEnabled(): boolean {
-    return this.tmuxConfig.enabled && this.deps.isInsideTmux()
-  }
-
-  async onSessionDeleted(event: { sessionID: string }): Promise<void> {
-    if (!this.isEnabled()) return
-    if (!this.sourcePaneId) return
-
-    const tracked = this.sessions.get(event.sessionID)
-    if (!tracked) return
-
-    log("[tmux-session-manager] onSessionDeleted", { sessionId: event.sessionID })
-
-    const state = await queryWindowState(this.sourcePaneId)
-    if (!state) {
-      this.sessions.delete(event.sessionID)
-      return
-    }
-
-    const closeAction = decideCloseAction(state, event.sessionID, this.getSessionMappings())
-    if (closeAction) {
-      await executeAction(closeAction, { config: this.tmuxConfig, serverUrl: this.serverUrl, windowState: state })
-    }
-
-    this.sessions.delete(event.sessionID)
-
-    if (this.sessions.size === 0) {
-      this.pollingManager.stopPolling()
-    }
-  }
-
-  async closeSessionById(sessionId: string): Promise<void> {
-    const tracked = this.sessions.get(sessionId)
-    if (!tracked) return
-
-    log("[tmux-session-manager] closing session pane", {
-      sessionId,
-      paneId: tracked.paneId,
-    })
-
-    const state = this.sourcePaneId ? await queryWindowState(this.sourcePaneId) : null
-    if (state) {
-      await executeAction(
-        { type: "close", paneId: tracked.paneId, sessionId },
-        { config: this.tmuxConfig, serverUrl: this.serverUrl, windowState: state }
-      )
-    }
-
-    this.sessions.delete(sessionId)
-
-    if (this.sessions.size === 0) {
-      this.pollingManager.stopPolling()
-    }
-  }
-}

src/features/tmux-subagent/session-spawner.ts

@@ -1,177 +0,0 @@
-import type { TmuxConfig } from "../../config/schema"
-import type { TrackedSession, CapacityConfig } from "./types"
-import { log } from "../../shared"
-import { queryWindowState } from "./pane-state-querier"
-import { decideSpawnActions, type SessionMapping } from "./decision-engine"
-import { executeActions } from "./action-executor"
-import { TmuxPollingManager } from "./polling-manager"
-
-interface SessionCreatedEvent {
-  type: string
-  properties?: { info?: { id?: string; parentID?: string; title?: string } }
-}
-
-export interface TmuxUtilDeps {
-  isInsideTmux: () => boolean
-  getCurrentPaneId: () => string | undefined
-}
-
-export class SessionSpawner {
-  constructor(
-    private tmuxConfig: TmuxConfig,
-    private deps: TmuxUtilDeps,
-    private sessions: Map<string, TrackedSession>,
-    private pendingSessions: Set<string>,
-    private sourcePaneId: string | undefined,
-    private getCapacityConfig: () => CapacityConfig,
-    private getSessionMappings: () => SessionMapping[],
-    private waitForSessionReady: (sessionId: string) => Promise<boolean>,
-    private pollingManager: TmuxPollingManager,
-    private serverUrl: string
-  ) {}
-
-  private isEnabled(): boolean {
-    return this.tmuxConfig.enabled && this.deps.isInsideTmux()
-  }
-
-  async onSessionCreated(event: SessionCreatedEvent): Promise<void> {
-    const enabled = this.isEnabled()
-    log("[tmux-session-manager] onSessionCreated called", {
-      enabled,
-      tmuxConfigEnabled: this.tmuxConfig.enabled,
-      isInsideTmux: this.deps.isInsideTmux(),
-      eventType: event.type,
-      infoId: event.properties?.info?.id,
-      infoParentID: event.properties?.info?.parentID,
-    })
-
-    if (!enabled) return
-    if (event.type !== "session.created") return
-
-    const info = event.properties?.info
-    if (!info?.id || !info?.parentID) return
-
-    const sessionId = info.id
-    const title = info.title ?? "Subagent"
-
-    if (this.sessions.has(sessionId) || this.pendingSessions.has(sessionId)) {
-      log("[tmux-session-manager] session already tracked or pending", { sessionId })
-      return
-    }
-
-    if (!this.sourcePaneId) {
-      log("[tmux-session-manager] no source pane id")
-      return
-    }
-
-    this.pendingSessions.add(sessionId)
-
-    try {
-      const state = await queryWindowState(this.sourcePaneId)
-      if (!state) {
-        log("[tmux-session-manager] failed to query window state")
-        return
-      }
-
-      log("[tmux-session-manager] window state queried", {
-        windowWidth: state.windowWidth,
-        mainPane: state.mainPane?.paneId,
-        agentPaneCount: state.agentPanes.length,
-        agentPanes: state.agentPanes.map((p) => p.paneId),
-      })
-
-      const decision = decideSpawnActions(
-        state,
-        sessionId,
-        title,
-        this.getCapacityConfig(),
-        this.getSessionMappings()
-      )
-
-      log("[tmux-session-manager] spawn decision", {
-        canSpawn: decision.canSpawn,
-        reason: decision.reason,
-        actionCount: decision.actions.length,
-        actions: decision.actions.map((a) => {
-          if (a.type === "close") return { type: "close", paneId: a.paneId }
-          if (a.type === "replace") return { type: "replace", paneId: a.paneId, newSessionId: a.newSessionId }
-          return { type: "spawn", sessionId: a.sessionId }
-        }),
-      })
-
-      if (!decision.canSpawn) {
-        log("[tmux-session-manager] cannot spawn", { reason: decision.reason })
-        return
-      }
-
-      const result = await executeActions(
-        decision.actions,
-        { config: this.tmuxConfig, serverUrl: this.serverUrl, windowState: state }
-      )
-
-      for (const { action, result: actionResult } of result.results) {
-        if (action.type === "close" && actionResult.success) {
-          this.sessions.delete(action.sessionId)
-          log("[tmux-session-manager] removed closed session from cache", {
-            sessionId: action.sessionId,
-          })
-        }
-        if (action.type === "replace" && actionResult.success) {
-          this.sessions.delete(action.oldSessionId)
-          log("[tmux-session-manager] removed replaced session from cache", {
-            oldSessionId: action.oldSessionId,
-            newSessionId: action.newSessionId,
-          })
-        }
-      }
-
-      if (result.success && result.spawnedPaneId) {
-        const sessionReady = await this.waitForSessionReady(sessionId)
-        
-        if (!sessionReady) {
-          log("[tmux-session-manager] session not ready after timeout, closing spawned pane", {
-            sessionId,
-            paneId: result.spawnedPaneId,
-          })
-
-          await executeActions(
-            [{ type: "close", paneId: result.spawnedPaneId, sessionId }],
-            {
-              config: this.tmuxConfig,
-              serverUrl: this.serverUrl,
-              windowState: state,
-            },
-          )
-
-          return
-        }
-        
-        const now = Date.now()
-        this.sessions.set(sessionId, {
-          sessionId,
-          paneId: result.spawnedPaneId,
-          description: title,
-          createdAt: new Date(now),
-          lastSeenAt: new Date(now),
-        })
-        log("[tmux-session-manager] pane spawned and tracked", {
-          sessionId,
-          paneId: result.spawnedPaneId,
-          sessionReady,
-        })
-        this.pollingManager.startPolling()
-      } else {
-        log("[tmux-session-manager] spawn failed", {
-          success: result.success,
-          results: result.results.map((r) => ({
-            type: r.action.type,
-            success: r.result.success,
-            error: r.result.error,
-          })),
-        })
-      }
-    } finally {
-      this.pendingSessions.delete(sessionId)
-    }
-  }
-}

src/hooks/AGENTS.md

@@ -1,95 +1,116 @@
-# HOOKS KNOWLEDGE BASE
+# src/hooks/ — 44 Lifecycle Hooks
+
+**Generated:** 2026-02-18
 
 ## OVERVIEW
 
-41 lifecycle hooks intercepting/modifying agent behavior across 7 event types. Three-tier registration: Core (32) → Continuation (7) → Skill (2).
+44 hooks across 39 directories + 6 standalone files. Three-tier composition: Core(35) + Continuation(7) + Skill(2). All hooks follow `createXXXHook(deps) → HookFunction` factory pattern.
 
-## STRUCTURE
-```
-hooks/
-├── agent-usage-reminder/         # Specialized agent hints (109 lines)
-├── anthropic-context-window-limit-recovery/ # Auto-summarize on limit (2232 lines, 29 files)
-├── anthropic-effort/             # Effort=max for Opus max variant (56 lines)
-├── atlas/                        # Main orchestration hook (1976 lines, 17 files)
-├── auto-slash-command/           # Detects /command patterns (1134 lines)
-├── auto-update-checker/          # Plugin update check (1140 lines, 20 files)
-├── background-notification/      # OS notifications (33 lines)
-├── category-skill-reminder/      # Category+skill delegation reminders (597 lines)
-├── claude-code-hooks/            # settings.json compat (2110 lines) — see AGENTS.md
-├── comment-checker/              # Prevents AI slop comments (710 lines)
-├── compaction-context-injector/  # Injects context on compaction (128 lines)
-├── compaction-todo-preserver/    # Preserves todos during compaction (203 lines)
-├── context-window-monitor.ts     # Reminds of headroom at 70% (100 lines)
-├── delegate-task-retry/          # Retries failed delegations (266 lines)
-├── directory-agents-injector/    # Auto-injects AGENTS.md (195 lines)
-├── directory-readme-injector/    # Auto-injects README.md (190 lines)
-├── edit-error-recovery/          # Recovers from edit failures (188 lines)
-├── empty-task-response-detector.ts # Detects empty responses (27 lines)
-├── interactive-bash-session/     # Tmux session management (695 lines)
-├── keyword-detector/             # ultrawork/search/analyze modes (1665 lines)
-├── non-interactive-env/          # Non-TTY handling (483 lines)
-├── preemptive-compaction.ts      # Auto-compact at 78% usage (108 lines)
-├── prometheus-md-only/           # Planner read-only mode (955 lines)
-├── question-label-truncator/     # Truncates labels to 30 chars (199 lines)
-├── ralph-loop/                   # Self-referential dev loop (1687 lines)
-├── rules-injector/               # Conditional .sisyphus/rules injection (1604 lines)
-├── session-notification.ts       # OS idle notifications (108 lines)
-├── session-recovery/             # Auto-recovers from crashes (1279 lines, 14 files)
-├── sisyphus-junior-notepad/      # Junior notepad directive (76 lines)
-├── start-work/                   # Sisyphus work session starter (648 lines)
-├── stop-continuation-guard/      # Guards stop continuation (214 lines)
-├── subagent-question-blocker/    # Blocks subagent questions (112 lines)
-├── task-reminder/                # Task progress reminders (210 lines)
-├── task-resume-info/             # Resume info for cancelled tasks (39 lines)
-├── tasks-todowrite-disabler/     # Disables TodoWrite when tasks active (202 lines)
-├── think-mode/                   # Dynamic thinking budget (1365 lines)
-├── thinking-block-validator/     # Validates thinking blocks (169 lines)
-├── todo-continuation-enforcer/   # Force TODO completion — boulder mechanism (2061 lines)
-├── tool-output-truncator.ts      # Prevents context bloat (62 lines)
-├── unstable-agent-babysitter/    # Monitors unstable behavior (451 lines)
-└── write-existing-file-guard/    # Guards against file overwrite (356 lines)
-```
+## HOOK TIERS
 
-## EVENT TYPES
+### Tier 1: Session Hooks (22) — `create-session-hooks.ts`
 
-| Event | Hook Method | Can Block | Count |
-|-------|-------------|-----------|-------|
-| UserPromptSubmit | `chat.message` | Yes | 4 |
-| ChatParams | `chat.params` | No | 2 |
-| PreToolUse | `tool.execute.before` | Yes | 13 |
-| PostToolUse | `tool.execute.after` | No | 15 |
-| SessionEvent | `event` | No | 17 |
-| MessagesTransform | `experimental.chat.messages.transform` | No | 1 |
-| Compaction | `onSummarize` | No | 2 |
+| Hook | Event | Purpose |
+|------|-------|---------|
+| contextWindowMonitor | session.idle | Track context window usage |
+| preemptiveCompaction | session.idle | Trigger compaction before limit |
+| sessionRecovery | session.error | Auto-retry on recoverable errors |
+| sessionNotification | session.idle | OS notifications on completion |
+| thinkMode | chat.params | Model variant switching (extended thinking) |
+| anthropicContextWindowLimitRecovery | session.error | Multi-strategy context recovery (truncation, compaction) |
+| autoUpdateChecker | session.created | Check npm for plugin updates |
+| agentUsageReminder | chat.message | Remind about available agents |
+| nonInteractiveEnv | chat.message | Adjust behavior for `run` command |
+| interactiveBashSession | tool.execute | Tmux session for interactive tools |
+| ralphLoop | event | Self-referential dev loop (boulder continuation) |
+| editErrorRecovery | tool.execute.after | Retry failed file edits |
+| delegateTaskRetry | tool.execute.after | Retry failed task delegations |
+| startWork | chat.message | `/start-work` command handler |
+| prometheusMdOnly | tool.execute.before | Enforce .md-only writes for Prometheus |
+| sisyphusJuniorNotepad | chat.message | Notepad injection for subagents |
+| questionLabelTruncator | tool.execute.before | Truncate long question labels |
+| taskResumeInfo | chat.message | Inject task context on resume |
+| anthropicEffort | chat.params | Adjust reasoning effort level |
+| jsonErrorRecovery | tool.execute.after | Detect JSON parse errors, inject correction reminder |
+| sisyphusGptHephaestusReminder | chat.message | Toast warning when Sisyphus uses GPT model |
+| taskReminder | tool.execute.after | Remind about task tools after 10 turns without usage |
 
-## BLOCKING HOOKS (8)
+### Tier 2: Tool Guard Hooks (9) — `create-tool-guard-hooks.ts`
 
-| Hook | Event | Blocks When |
-|------|-------|-------------|
-| auto-slash-command | chat.message | Command execution fails |
-| keyword-detector | chat.message | Keyword injection fails |
-| non-interactive-env | tool.execute.before | Interactive command in non-TTY |
-| prometheus-md-only | tool.execute.before | Write outside .sisyphus/*.md |
-| subagent-question-blocker | tool.execute.before | Question tool in subagent |
-| tasks-todowrite-disabler | tool.execute.before | TodoWrite with task system |
-| write-existing-file-guard | tool.execute.before | Write to existing file |
-| claude-code-hooks | tool.execute.before | Exit code 2 from settings.json hook |
+| Hook | Event | Purpose |
+|------|-------|---------|
+| commentChecker | tool.execute.after | Block AI-generated comment patterns |
+| toolOutputTruncator | tool.execute.after | Truncate oversized tool output |
+| directoryAgentsInjector | tool.execute.before | Inject dir AGENTS.md into context |
+| directoryReadmeInjector | tool.execute.before | Inject dir README.md into context |
+| emptyTaskResponseDetector | tool.execute.after | Detect empty task responses |
+| rulesInjector | tool.execute.before | Conditional rules injection (AGENTS.md, config) |
+| tasksTodowriteDisabler | tool.execute.before | Disable TodoWrite when task system active |
+| writeExistingFileGuard | tool.execute.before | Require Read before Write on existing files |
+| hashlineReadEnhancer | tool.execute.after | Enhance Read output with line hashes |
 
-## EXECUTION ORDER
+### Tier 3: Transform Hooks (4) — `create-transform-hooks.ts`
 
-**UserPromptSubmit**: keywordDetector → claudeCodeHooks → autoSlashCommand → startWork
-**PreToolUse**: subagentQuestionBlocker → questionLabelTruncator → claudeCodeHooks → nonInteractiveEnv → commentChecker → directoryAgentsInjector → directoryReadmeInjector → rulesInjector → prometheusMdOnly → sisyphusJuniorNotepad → writeExistingFileGuard → tasksToDoWriteDisabler → atlasHook
-**PostToolUse**: claudeCodeHooks → toolOutputTruncator → contextWindowMonitor → commentChecker → directoryAgentsInjector → directoryReadmeInjector → rulesInjector → emptyTaskResponseDetector → agentUsageReminder → interactiveBashSession → editErrorRecovery → delegateTaskRetry → atlasHook → taskResumeInfo → taskReminder
+| Hook | Event | Purpose |
+|------|-------|---------|
+| claudeCodeHooks | messages.transform | Claude Code settings.json compatibility |
+| keywordDetector | messages.transform | Detect ultrawork/search/analyze modes |
+| contextInjectorMessagesTransform | messages.transform | Inject AGENTS.md/README.md into context |
+| thinkingBlockValidator | messages.transform | Validate thinking block structure |
 
-## HOW TO ADD
+### Tier 4: Continuation Hooks (7) — `create-continuation-hooks.ts`
 
-1. Create `src/hooks/name/` with `index.ts` exporting `createMyHook(ctx)`
-2. Add hook name to `HookNameSchema` in `src/config/schema/hooks.ts`
-3. Register in appropriate `src/plugin/hooks/create-*-hooks.ts`
+| Hook | Event | Purpose |
+|------|-------|---------|
+| stopContinuationGuard | chat.message | `/stop-continuation` command handler |
+| compactionContextInjector | session.compacted | Re-inject context after compaction |
+| compactionTodoPreserver | session.compacted | Preserve todos through compaction |
+| todoContinuationEnforcer | session.idle | **Boulder**: force continuation on incomplete todos |
+| unstableAgentBabysitter | session.idle | Monitor unstable agent behavior |
+| backgroundNotificationHook | event | Background task completion notifications |
+| atlasHook | event | Master orchestrator for boulder/background sessions |
 
-## ANTI-PATTERNS
+### Tier 5: Skill Hooks (2) — `create-skill-hooks.ts`
 
-- **Heavy PreToolUse**: Runs before EVERY tool — keep light
-- **Blocking non-critical**: Use PostToolUse warnings instead
-- **Redundant injection**: Track injected files to avoid context bloat
-- **Direct state mutation**: Use `output.output +=` instead of replacing
+| Hook | Event | Purpose |
+|------|-------|---------|
+| categorySkillReminder | chat.message | Remind about category+skill delegation |
+| autoSlashCommand | chat.message | Auto-detect `/command` in user input |
+
+## KEY HOOKS (COMPLEX)
+
+### anthropic-context-window-limit-recovery (31 files, ~2232 LOC)
+Multi-strategy recovery when hitting context limits. Strategies: truncation, compaction, summarization.
+
+### atlas (17 files, ~1976 LOC)
+Master orchestrator for boulder sessions. Decision gates: session type → abort check → failure count → background tasks → agent match → plan completeness → cooldown (5s). Injects continuation prompts on session.idle.
+
+### ralph-loop (14 files, ~1687 LOC)
+Self-referential dev loop via `/ralph-loop` command. State persisted in `.sisyphus/ralph-loop.local.md`. Detects `<promise>DONE</promise>` in AI output. Max 100 iterations default.
+
+### todo-continuation-enforcer (13 files, ~2061 LOC)
+"Boulder" mechanism. Forces agent to continue when todos remain incomplete. 2s countdown toast → continuation injection. Exponential backoff: 30s base, ×2 per failure, max 5 consecutive failures then 5min pause.
+
+### keyword-detector (~1665 LOC)
+Detects modes from user input: ultrawork, search, analyze, prove-yourself. Injects mode-specific system prompts.
+
+### rules-injector (19 files, ~1604 LOC)
+Conditional rules injection from AGENTS.md, config, skill rules. Evaluates conditions to determine which rules apply.
+
+## STANDALONE HOOKS (in src/hooks/ root)
+
+| File | Purpose |
+|------|---------|
+| context-window-monitor.ts | Track context window percentage |
+| preemptive-compaction.ts | Trigger compaction before hard limit |
+| tool-output-truncator.ts | Truncate tool output by token count |
+| session-notification.ts + 4 helpers | OS notification on session completion |
+| empty-task-response-detector.ts | Detect empty/failed task responses |
+| session-todo-status.ts | Todo completion status tracking |
+
+## HOW TO ADD A HOOK
+
+1. Create `src/hooks/{name}/index.ts` with `createXXXHook(deps)` factory
+2. Register in appropriate tier file (`src/plugin/hooks/create-{tier}-hooks.ts`)
+3. Add hook name to `src/config/schema/hooks.ts` HookNameSchema
+4. Hook receives `(event, ctx)` — return value depends on event type

src/hooks/anthropic-context-window-limit-recovery/AGENTS.md

@@ -0,0 +1,49 @@
+# src/hooks/anthropic-context-window-limit-recovery/ — Multi-Strategy Context Recovery
+
+**Generated:** 2026-02-18
+
+## OVERVIEW
+
+31 files (~2232 LOC). Most complex hook. Recovers from context window limit errors via multiple strategies applied in sequence.
+
+## RECOVERY STRATEGIES (in priority order)
+
+| Strategy | File | Mechanism |
+|----------|------|-----------|
+| **Empty content recovery** | `empty-content-recovery.ts` | Handle empty/null content blocks in messages |
+| **Deduplication** | `deduplication-recovery.ts` | Remove duplicate tool results from context |
+| **Target-token truncation** | `target-token-truncation.ts` | Truncate largest tool outputs to fit target ratio |
+| **Aggressive truncation** | `aggressive-truncation-strategy.ts` | Last-resort truncation with minimal output preservation |
+| **Summarize retry** | `summarize-retry-strategy.ts` | Compaction + summarization then retry |
+
+## KEY FILES
+
+| File | Purpose |
+|------|---------|
+| `recovery-hook.ts` | Main hook entry — `session.error` handler, strategy orchestration |
+| `executor.ts` | Execute recovery strategies in sequence |
+| `parser.ts` | Parse Anthropic token limit error messages |
+| `state.ts` | `AutoCompactState` — per-session retry/truncation tracking |
+| `types.ts` | `ParsedTokenLimitError`, `RetryState`, `TruncateState`, config constants |
+| `storage.ts` | Persist tool results for later truncation |
+| `tool-result-storage.ts` | Store/retrieve individual tool call results |
+| `message-builder.ts` | Build retry messages after recovery |
+
+## RETRY CONFIG
+
+- Max attempts: 2
+- Initial delay: 2s, backoff ×2, max 30s
+- Max truncation attempts: 20
+- Target token ratio: 0.5 (truncate to 50% of limit)
+- Chars per token estimate: 4
+
+## PRUNING SYSTEM
+
+`pruning-*.ts` files handle intelligent output pruning:
+- `pruning-deduplication.ts` — Remove duplicate content across tool results
+- `pruning-tool-output-truncation.ts` — Truncate oversized tool outputs
+- `pruning-types.ts` — Pruning-specific type definitions
+
+## SDK VARIANTS
+
+`empty-content-recovery-sdk.ts` and `tool-result-storage-sdk.ts` provide SDK-based implementations for OpenCode client interactions.

src/hooks/claude-code-hooks/AGENTS.md

@@ -1,55 +1,41 @@
-# CLAUDE CODE HOOKS COMPATIBILITY
+# src/hooks/claude-code-hooks/ — Claude Code Compatibility
+
+**Generated:** 2026-02-17
 
 ## OVERVIEW
 
-Full Claude Code `settings.json` hook compatibility layer. Intercepts OpenCode events to execute external scripts/commands defined in settings.json.
+~2110 LOC across 19 files. Provides Claude Code settings.json compatibility layer. Parses CC permission rules and maps CC hooks (PreToolUse, PostToolUse) to OpenCode hooks.
 
-**Config Sources** (priority): `.claude/settings.local.json` > `.claude/settings.json` (project) > `~/.claude/settings.json` (global)
+## WHAT IT DOES
 
-## STRUCTURE
-```
-claude-code-hooks/
-├── index.ts              # Barrel export
-├── claude-code-hooks-hook.ts  # Main factory (22 lines)
-├── config.ts             # Claude settings.json loader (105 lines)
-├── config-loader.ts      # Extended plugin config (107 lines)
-├── pre-tool-use.ts       # PreToolUse hook executor (173 lines)
-├── post-tool-use.ts      # PostToolUse hook executor (200 lines)
-├── user-prompt-submit.ts # UserPromptSubmit executor (125 lines)
-├── stop.ts               # Stop hook executor (122 lines)
-├── pre-compact.ts        # PreCompact executor (110 lines)
-├── transcript.ts         # Tool use recording (235 lines)
-├── tool-input-cache.ts   # Pre→post input caching (51 lines)
-├── todo.ts               # Todo integration
-├── session-hook-state.ts # Active state tracking (11 lines)
-├── types.ts              # Hook & IO type definitions (204 lines)
-├── plugin-config.ts      # Default config constants (12 lines)
-└── handlers/             # Event handlers (5 files)
-    ├── pre-compact-handler.ts
-    ├── tool-execute-before-handler.ts
-    ├── tool-execute-after-handler.ts
-    ├── chat-message-handler.ts
-    └── session-event-handler.ts
+1. Parses Claude Code `settings.json` permission format
+2. Maps CC hook types to OpenCode event types
+3. Enforces CC permission rules (allow/deny per tool)
+4. Supports CC `.claude/settings.json` and `.claude/settings.local.json`
+
+## CC → OPENCODE HOOK MAPPING
+
+| CC Hook | OpenCode Event |
+|---------|---------------|
+| PreToolUse | tool.execute.before |
+| PostToolUse | tool.execute.after |
+| Notification | event (session.idle) |
+| Stop | event (session.idle) |
+
+## PERMISSION SYSTEM
+
+CC permissions format:
+```json
+{
+  "permissions": {
+    "allow": ["Edit", "Write"],
+    "deny": ["Bash(rm:*)"]
+  }
+}
 ```
 
-## HOOK LIFECYCLE
+Translated to OpenCode tool restrictions via permission-compat in shared/.
 
-| Event | Timing | Can Block | Context Provided |
-|-------|--------|-----------|------------------|
-| PreToolUse | Before exec | Yes (exit 2) | sessionId, toolName, toolInput, cwd |
-| PostToolUse | After exec | Warn (exit 1) | + toolOutput, transcriptPath |
-| UserPromptSubmit | On message | Yes (exit 2) | sessionId, prompt, parts, cwd |
-| Stop | Session end | Inject | sessionId, parentSessionId, cwd |
-| PreCompact | Before summarize | No | sessionId, cwd |
+## FILES
 
-## EXIT CODES
-
-- `0`: Pass (continue)
-- `1`: Warn (continue + system message)
-- `2`: Block (abort operation)
-
-## ANTI-PATTERNS
-
-- **Heavy PreToolUse**: Runs before EVERY tool — keep scripts fast
-- **Blocking non-critical**: Prefer PostToolUse warnings
-- **Ignoring exit codes**: Return `2` to block sensitive tools
+Key files: `settings-loader.ts` (parse CC settings), `hook-mapper.ts` (CC→OC mapping), `permission-handler.ts` (rule enforcement), `types.ts` (CC type definitions).

src/hooks/context-window-monitor.test.ts

@@ -1,6 +1,28 @@
-import { describe, it, expect, mock, beforeEach } from "bun:test"
+/// <reference types="bun-types" />
+
+import { describe, it, expect, mock, beforeEach, afterEach } from "bun:test"
 import { createContextWindowMonitorHook } from "./context-window-monitor"
 
+const ANTHROPIC_CONTEXT_ENV_KEY = "ANTHROPIC_1M_CONTEXT"
+const VERTEX_CONTEXT_ENV_KEY = "VERTEX_ANTHROPIC_1M_CONTEXT"
+
+const originalAnthropicContextEnv = process.env[ANTHROPIC_CONTEXT_ENV_KEY]
+const originalVertexContextEnv = process.env[VERTEX_CONTEXT_ENV_KEY]
+
+function resetContextLimitEnv(): void {
+  if (originalAnthropicContextEnv === undefined) {
+    delete process.env[ANTHROPIC_CONTEXT_ENV_KEY]
+  } else {
+    process.env[ANTHROPIC_CONTEXT_ENV_KEY] = originalAnthropicContextEnv
+  }
+
+  if (originalVertexContextEnv === undefined) {
+    delete process.env[VERTEX_CONTEXT_ENV_KEY]
+  } else {
+    process.env[VERTEX_CONTEXT_ENV_KEY] = originalVertexContextEnv
+  }
+}
+
 function createMockCtx() {
   return {
     client: {
@@ -17,6 +39,12 @@ describe("context-window-monitor", () => {
 
   beforeEach(() => {
     ctx = createMockCtx()
+    delete process.env[ANTHROPIC_CONTEXT_ENV_KEY]
+    delete process.env[VERTEX_CONTEXT_ENV_KEY]
+  })
+
+  afterEach(() => {
+    resetContextLimitEnv()
   })
 
   // #given event caches token info from message.updated
@@ -218,4 +246,81 @@ describe("context-window-monitor", () => {
     )
     expect(output.output).toBe("test")
   })
+
+  it("should use 1M limit when model cache flag is enabled", async () => {
+    //#given
+    const hook = createContextWindowMonitorHook(ctx as never, {
+      anthropicContext1MEnabled: true,
+    })
+    const sessionID = "ses_1m_flag"
+
+    await hook.event({
+      event: {
+        type: "message.updated",
+        properties: {
+          info: {
+            role: "assistant",
+            sessionID,
+            providerID: "anthropic",
+            finish: true,
+            tokens: {
+              input: 300000,
+              output: 1000,
+              reasoning: 0,
+              cache: { read: 0, write: 0 },
+            },
+          },
+        },
+      },
+    })
+
+    //#when
+    const output = { title: "", output: "original", metadata: null }
+    await hook["tool.execute.after"](
+      { tool: "bash", sessionID, callID: "call_1" },
+      output
+    )
+
+    //#then
+    expect(output.output).toBe("original")
+  })
+
+  it("should keep env var fallback when model cache flag is disabled", async () => {
+    //#given
+    process.env[ANTHROPIC_CONTEXT_ENV_KEY] = "true"
+    const hook = createContextWindowMonitorHook(ctx as never, {
+      anthropicContext1MEnabled: false,
+    })
+    const sessionID = "ses_env_fallback"
+
+    await hook.event({
+      event: {
+        type: "message.updated",
+        properties: {
+          info: {
+            role: "assistant",
+            sessionID,
+            providerID: "anthropic",
+            finish: true,
+            tokens: {
+              input: 300000,
+              output: 1000,
+              reasoning: 0,
+              cache: { read: 0, write: 0 },
+            },
+          },
+        },
+      },
+    })
+
+    //#when
+    const output = { title: "", output: "original", metadata: null }
+    await hook["tool.execute.after"](
+      { tool: "bash", sessionID, callID: "call_1" },
+      output
+    )
+
+    //#then
+    expect(output.output).toBe("original")
+  })
 })

src/hooks/context-window-monitor.ts

@@ -2,13 +2,21 @@ import type { PluginInput } from "@opencode-ai/plugin"
 import { createSystemDirective, SystemDirectiveTypes } from "../shared/system-directive"
 
 const ANTHROPIC_DISPLAY_LIMIT = 1_000_000
-const ANTHROPIC_ACTUAL_LIMIT =
-  process.env.ANTHROPIC_1M_CONTEXT === "true" ||
-  process.env.VERTEX_ANTHROPIC_1M_CONTEXT === "true"
-    ? 1_000_000
-    : 200_000
+const DEFAULT_ANTHROPIC_ACTUAL_LIMIT = 200_000
 const CONTEXT_WARNING_THRESHOLD = 0.70
 
+type ModelCacheStateLike = {
+  anthropicContext1MEnabled: boolean
+}
+
+function getAnthropicActualLimit(modelCacheState?: ModelCacheStateLike): number {
+  return (modelCacheState?.anthropicContext1MEnabled ?? false) ||
+    process.env.ANTHROPIC_1M_CONTEXT === "true" ||
+    process.env.VERTEX_ANTHROPIC_1M_CONTEXT === "true"
+    ? 1_000_000
+    : DEFAULT_ANTHROPIC_ACTUAL_LIMIT
+}
+
 const CONTEXT_REMINDER = `${createSystemDirective(SystemDirectiveTypes.CONTEXT_WINDOW_MONITOR)}
 
 You are using Anthropic Claude with 1M context window.
@@ -31,7 +39,10 @@ function isAnthropicProvider(providerID: string): boolean {
   return providerID === "anthropic" || providerID === "google-vertex-anthropic"
 }
 
-export function createContextWindowMonitorHook(_ctx: PluginInput) {
+export function createContextWindowMonitorHook(
+  _ctx: PluginInput,
+  modelCacheState?: ModelCacheStateLike,
+) {
   const remindedSessions = new Set<string>()
   const tokenCache = new Map<string, CachedTokenState>()
 
@@ -51,7 +62,8 @@ export function createContextWindowMonitorHook(_ctx: PluginInput) {
     const lastTokens = cached.tokens
     const totalInputTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0)
 
-    const actualUsagePercentage = totalInputTokens / ANTHROPIC_ACTUAL_LIMIT
+    const actualUsagePercentage =
+      totalInputTokens / getAnthropicActualLimit(modelCacheState)
 
     if (actualUsagePercentage < CONTEXT_WARNING_THRESHOLD) return
 

src/hooks/directory-agents-injector/hook.ts

@@ -27,9 +27,12 @@ interface EventInput {
   };
 }
 
-export function createDirectoryAgentsInjectorHook(ctx: PluginInput) {
+export function createDirectoryAgentsInjectorHook(
+  ctx: PluginInput,
+  modelCacheState?: { anthropicContext1MEnabled: boolean },
+) {
   const sessionCaches = new Map<string, Set<string>>();
-  const truncator = createDynamicTruncator(ctx);
+  const truncator = createDynamicTruncator(ctx, modelCacheState);
 
   const toolExecuteAfter = async (input: ToolExecuteInput, output: ToolExecuteOutput) => {
     const toolName = input.tool.toLowerCase();