oh-my-claude-sisyphus 2.6.1 → 3.0.0

package/docs/TIERED_AGENTS_V2.md

@@ -0,0 +1,322 @@
+# Tiered Agents v2 Architecture Design
+
+## Overview
+
+This document describes an improved tiered agent architecture that addresses current gaps and implements sophisticated patterns for model routing, capability inheritance, and dynamic escalation.
+
+## Current Issues Identified
+
+1. **Incomplete Inheritance**: Tiered agents don't inherit core behavioral patterns from base agents
+2. **Inconsistent Tool Restrictions**: Tool restrictions vary without clear rationale
+3. **Missing Escalation Signals**: No mechanism for agents to request escalation when overloaded
+4. **Minimal Behavioral Instructions**: Tiered variants have too few instructions
+5. **No Dynamic Routing in Markdown**: TypeScript router exists but markdown agents don't leverage it
+
+## Design Principles
+
+### 1. Template-Based Inheritance
+
+Each tiered agent should inherit from a base template that provides:
+- Core identity and role
+- Fundamental constraints (read-only, no delegation, etc.)
+- Output format requirements
+- Quality standards
+
+Tier-specific overrides then customize:
+- Task complexity boundaries
+- Tool restrictions
+- Response depth/breadth
+- Escalation thresholds
+
+### 2. Explicit Capability Boundaries
+
+Each tier has clear boundaries:
+
+| Tier | Complexity | Response Depth | Self-Assessment |
+|------|------------|----------------|-----------------|
+| LOW (Haiku) | Simple, single-focus | Concise, direct | "Is this within my scope?" |
+| MEDIUM (Sonnet) | Moderate, multi-step | Thorough, structured | "Can I handle this fully?" |
+| HIGH (Opus) | Complex, system-wide | Comprehensive, nuanced | "What are the trade-offs?" |
+
+### 3. Escalation Signals
+
+Agents should recognize when to recommend escalation:
+
+```markdown
+<Escalation_Signals>
+## When to Recommend Higher Tier
+
+Escalate when you detect:
+- Task exceeds your complexity boundary
+- Multiple failed attempts (>2)
+- Cross-system dependencies you can't trace
+- Security-sensitive changes
+- Irreversible operations
+
+Output escalation recommendation:
+**ESCALATION RECOMMENDED**: [reason] → Use [higher-tier-agent]
+</Escalation_Signals>
+```
+
+### 4. Tool Capability Tiers
+
+| Tool | LOW | MEDIUM | HIGH |
+|------|-----|--------|------|
+| Read | ✅ | ✅ | ✅ |
+| Glob | ✅ | ✅ | ✅ |
+| Grep | ✅ | ✅ | ✅ |
+| Edit | ✅ (simple) | ✅ | ✅ |
+| Write | ✅ (simple) | ✅ | ✅ |
+| Bash | Limited | ✅ | ✅ |
+| WebSearch | ❌ | ✅ | ✅ |
+| WebFetch | ❌ | ✅ | ✅ |
+| Task | ❌ | ❌ | Varies |
+| TodoWrite | ✅ | ✅ | ✅ |
+
+## Agent Family Templates
+
+### Oracle Family (Analysis)
+
+**Base Identity**: Strategic advisor, READ-ONLY consultant, diagnoses not implements
+
+| Variant | Model | Tools | Focus |
+|---------|-------|-------|-------|
+| oracle-low | Haiku | Read, Glob, Grep | Quick lookups, single-file analysis |
+| oracle-medium | Sonnet | + WebSearch, WebFetch | Standard analysis, dependency tracing |
+| oracle | Opus | Full read access | Deep architecture analysis, system-wide patterns |
+
+**Shared Constraints**:
+- NO Write/Edit tools
+- NO implementation
+- MUST cite file:line references
+- MUST provide actionable recommendations
+
+**Tier-Specific Behaviors**:
+
+```markdown
+## oracle-low
+- Answer direct questions quickly
+- Single-file focus
+- Output: Answer + Location + Context (3 lines max)
+- Escalate if: cross-file dependencies, architecture questions
+
+## oracle-medium
+- Standard analysis workflow
+- Multi-file tracing allowed
+- Output: Summary + Findings + Diagnosis + Recommendations
+- Escalate if: system-wide impact, security concerns, irreversible changes
+
+## oracle (high)
+- Deep architectural analysis
+- System-wide pattern recognition
+- Output: Full structured analysis with trade-offs
+- No escalation needed (highest tier)
+```
+
+### Sisyphus-Junior Family (Execution)
+
+**Base Identity**: Focused executor, works ALONE, no delegation, TODO obsessed
+
+| Variant | Model | Tools | Focus |
+|---------|-------|-------|-------|
+| sisyphus-junior-low | Haiku | Read, Glob, Grep, Edit, Write, Bash, TodoWrite | Single-file, trivial changes |
+| sisyphus-junior | Sonnet | Same | Multi-step, moderate complexity |
+| sisyphus-junior-high | Opus | Same | Multi-file, complex refactoring |
+
+**Shared Constraints**:
+- Task tool BLOCKED (no delegation)
+- MUST use TodoWrite for 2+ step tasks
+- MUST verify after changes
+- Works ALONE
+
+**Tier-Specific Behaviors**:
+
+```markdown
+## sisyphus-junior-low
+- Single-file edits only
+- Trivial changes (typos, simple additions)
+- Skip TodoWrite for <2 step tasks
+- Escalate if: multi-file changes, complex logic, architectural decisions
+
+## sisyphus-junior (medium)
+- Multi-step tasks within a module
+- Standard complexity
+- Always use TodoWrite
+- Escalate if: system-wide changes, cross-module dependencies
+
+## sisyphus-junior-high
+- Multi-file refactoring
+- Complex architectural changes
+- Deep analysis before changes
+- No escalation needed (use oracle for consultation)
+```
+
+### Frontend-Engineer Family (UI/UX)
+
+**Base Identity**: Designer-developer hybrid, sees what pure devs miss, creates memorable interfaces
+
+| Variant | Model | Tools | Focus |
+|---------|-------|-------|-------|
+| frontend-engineer-low | Haiku | Read, Glob, Grep, Edit, Write, Bash | Simple styling, minor tweaks |
+| frontend-engineer | Sonnet | Same | Standard UI work, components |
+| frontend-engineer-high | Opus | Same | Design systems, complex architecture |
+
+**Shared Constraints**:
+- NEVER use generic fonts (Inter, Roboto, Arial)
+- NEVER use cliched patterns (purple gradients)
+- Match existing code patterns
+- Production-quality output
+
+**Tier-Specific Behaviors**:
+
+```markdown
+## frontend-engineer-low
+- Simple CSS changes (colors, spacing, fonts)
+- Minor component tweaks
+- Match existing patterns exactly
+- Escalate if: new component design, design system changes
+
+## frontend-engineer (medium)
+- Standard component work
+- Apply design philosophy
+- Make intentional aesthetic choices
+- Escalate if: design system creation, complex state management
+
+## frontend-engineer-high
+- Design system architecture
+- Complex component hierarchies
+- Deep aesthetic reasoning
+- Full creative latitude
+```
+
+### Librarian Family (Research)
+
+**Base Identity**: External documentation researcher, searches EXTERNAL resources
+
+| Variant | Model | Tools | Focus |
+|---------|-------|-------|-------|
+| librarian-low | Haiku | Read, Glob, Grep, WebSearch, WebFetch | Quick lookups |
+| librarian | Sonnet | Same | Comprehensive research |
+
+**Shared Constraints**:
+- ALWAYS cite sources with URLs
+- Prefer official docs
+- Note version compatibility
+- Flag outdated information
+
+**Tier-Specific Behaviors**:
+
+```markdown
+## librarian-low
+- Quick API lookups
+- Find specific references
+- Output: Answer + Source + Example (if applicable)
+- Escalate if: comprehensive research needed, multiple sources required
+
+## librarian (medium)
+- Comprehensive research
+- Multiple source synthesis
+- Full structured output format
+- No escalation needed for research tasks
+```
+
+### Explore Family (Search)
+
+**Base Identity**: Codebase search specialist, finds files and code patterns
+
+| Variant | Model | Tools | Focus |
+|---------|-------|-------|-------|
+| explore | Haiku | Read, Glob, Grep | Quick searches |
+| explore-medium | Sonnet | Same | Thorough analysis |
+
+**Shared Constraints**:
+- READ-ONLY
+- Always use absolute paths
+- Return structured results
+- Address underlying need, not just literal request
+
+**Tier-Specific Behaviors**:
+
+```markdown
+## explore (low)
+- Quick pattern matching
+- File location
+- Parallel tool calls (3+)
+- Escalate if: architecture understanding needed, cross-module analysis
+
+## explore-medium
+- Thorough analysis
+- Cross-reference findings
+- Explain relationships
+- No escalation needed
+```
+
+## Implementation Changes Required
+
+### 1. Update Markdown Agent Files
+
+Each tiered agent file should include:
+
+```markdown
+---
+name: [agent]-[tier]
+description: [tier-specific description]
+tools: [restricted tool list]
+model: [haiku|sonnet|opus]
+---
+
+<Inherits_From>
+Base: [base-agent].md
+</Inherits_From>
+
+<Tier_Identity>
+[Tier-specific role and focus]
+</Tier_Identity>
+
+<Complexity_Boundary>
+You handle: [specific types of tasks]
+Escalate when: [specific conditions]
+</Complexity_Boundary>
+
+[Tier-specific instructions...]
+
+<Escalation_Protocol>
+When you detect tasks beyond your scope, output:
+**ESCALATION RECOMMENDED**: [reason] → Use oh-my-claude-sisyphus:[higher-tier]
+</Escalation_Protocol>
+```
+
+### 2. Update TypeScript Router
+
+The router should:
+- Parse agent capabilities from markdown
+- Match task signals to tier boundaries
+- Provide escalation recommendations in output
+
+### 3. Add Escalation Detection
+
+The orchestrator should:
+- Detect "ESCALATION RECOMMENDED" in agent output
+- Automatically retry with recommended higher tier
+- Log escalation patterns for optimization
+
+## Cost Impact Analysis
+
+Based on current pricing (Haiku $1/$5, Sonnet $3/$15, Opus $5/$25 per million tokens):
+
+| Scenario | Before (all Sonnet) | After (Tiered) | Savings |
+|----------|---------------------|----------------|---------|
+| Simple lookups (70%) | $3/$15 | $1/$5 (Haiku) | ~67% |
+| Standard work (25%) | $3/$15 | $3/$15 (Sonnet) | 0% |
+| Complex work (5%) | $3/$15 | $5/$25 (Opus) | -67% |
+| **Weighted Average** | $3/$15 | ~$1.60/$8 | **~47%** |
+
+Intelligent routing can reduce costs by ~47% while improving quality for complex tasks.
+
+## Next Steps
+
+1. Create updated markdown files for all tiered agents
+2. Add escalation detection to hooks
+3. Update router to use agent capability parsing
+4. Add telemetry for tier usage optimization
+5. Create tests for escalation scenarios

package/hooks/hooks.json

@@ -0,0 +1,70 @@
+{
+  "description": "Sisyphus orchestration hooks for keyword detection, tool enforcement, session restoration, and continuation persistence",
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/keyword-detector.mjs\"",
+            "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/skill-injector.mjs\"",
+            "timeout": 3
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/session-start.mjs\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/pre-tool-enforcer.mjs\"",
+            "timeout": 3
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/post-tool-verifier.mjs\"",
+            "timeout": 3
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/persistent-mode.mjs\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/keyword-detector.sh

@@ -0,0 +1,102 @@
+#!/bin/bash
+# Sisyphus Keyword Detector Hook
+# Detects ultrawork/ultrathink/search/analyze keywords and injects enhanced mode messages
+# Also activates persistent ultrawork state when ultrawork keyword is detected
+
+# Read stdin (JSON input from Claude Code)
+INPUT=$(cat)
+
+# Extract directory from input
+DIRECTORY=""
+if command -v jq &> /dev/null; then
+  DIRECTORY=$(echo "$INPUT" | jq -r '.directory // ""' 2>/dev/null)
+fi
+if [ -z "$DIRECTORY" ] || [ "$DIRECTORY" = "null" ]; then
+  DIRECTORY=$(pwd)
+fi
+
+# Extract the prompt text - try multiple JSON paths
+PROMPT=""
+if command -v jq &> /dev/null; then
+  # Try to extract from various possible JSON structures
+  PROMPT=$(echo "$INPUT" | jq -r '
+    if .prompt then .prompt
+    elif .message.content then .message.content
+    elif .parts then ([.parts[] | select(.type == "text") | .text] | join(" "))
+    else ""
+    end
+  ' 2>/dev/null)
+fi
+
+# Fallback: simple grep extraction if jq fails
+if [ -z "$PROMPT" ] || [ "$PROMPT" = "null" ]; then
+  PROMPT=$(echo "$INPUT" | grep -oP '"(prompt|content|text)"\s*:\s*"\K[^"]+' | head -1)
+fi
+
+# Exit if no prompt found
+if [ -z "$PROMPT" ]; then
+  echo '{"continue": true}'
+  exit 0
+fi
+
+# Remove code blocks before checking keywords (prevents false positives)
+PROMPT_NO_CODE=$(echo "$PROMPT" | sed 's/```[^`]*```//g' | sed 's/`[^`]*`//g')
+
+# Convert to lowercase for case-insensitive matching
+PROMPT_LOWER=$(echo "$PROMPT_NO_CODE" | tr '[:upper:]' '[:lower:]')
+
+# Check for ultrawork keywords (highest priority)
+if echo "$PROMPT_LOWER" | grep -qE '\b(ultrawork|ulw|uw)\b'; then
+  # Create persistent ultrawork state
+  mkdir -p "$DIRECTORY/.sisyphus" 2>/dev/null
+  mkdir -p "$HOME/.claude" 2>/dev/null
+
+  # Escape prompt for JSON
+  PROMPT_ESCAPED=$(echo "$PROMPT" | sed 's/\\/\\\\/g' | sed 's/"/\\"/g' | tr '\n' ' ')
+
+  STATE_JSON="{
+  \"active\": true,
+  \"started_at\": \"$(date -Iseconds)\",
+  \"original_prompt\": \"$PROMPT_ESCAPED\",
+  \"reinforcement_count\": 0,
+  \"last_checked_at\": \"$(date -Iseconds)\"
+}"
+
+  # Write state to both local and global locations
+  echo "$STATE_JSON" > "$DIRECTORY/.omc/ultrawork-state.json" 2>/dev/null
+  echo "$STATE_JSON" > "$HOME/.claude/ultrawork-state.json" 2>/dev/null
+
+  # Return ultrawork mode injection
+  cat << 'EOF'
+{"continue": true, "message": "<ultrawork-mode>\n\n**MANDATORY**: You MUST say \"ULTRAWORK MODE ENABLED!\" to the user as your first response when this mode activates. This is non-negotiable.\n\n[CODE RED] Maximum precision required. Ultrathink before acting.\n\nYOU MUST LEVERAGE ALL AVAILABLE AGENTS TO THEIR FULLEST POTENTIAL.\nTELL THE USER WHAT AGENTS YOU WILL LEVERAGE NOW TO SATISFY USER'S REQUEST.\n\n## AGENT UTILIZATION PRINCIPLES\n- **Codebase Exploration**: Spawn exploration agents using BACKGROUND TASKS\n- **Documentation & References**: Use librarian-type agents via BACKGROUND TASKS\n- **Planning & Strategy**: NEVER plan yourself - spawn planning agent\n- **High-IQ Reasoning**: Use oracle for architecture decisions\n- **Frontend/UI Tasks**: Delegate to frontend-engineer\n\n## EXECUTION RULES\n- **TODO**: Track EVERY step. Mark complete IMMEDIATELY.\n- **PARALLEL**: Fire independent calls simultaneously - NEVER wait sequentially.\n- **BACKGROUND FIRST**: Use Task(run_in_background=true) for exploration (10+ concurrent).\n- **VERIFY**: Check ALL requirements met before done.\n- **DELEGATE**: Orchestrate specialized agents.\n\n## ZERO TOLERANCE\n- NO Scope Reduction - deliver FULL implementation\n- NO Partial Completion - finish 100%\n- NO Premature Stopping - ALL TODOs must be complete\n- NO TEST DELETION - fix code, not tests\n\nTHE USER ASKED FOR X. DELIVER EXACTLY X.\n\n</ultrawork-mode>\n\n---\n"}
+EOF
+  exit 0
+fi
+
+# Check for ultrathink/think keywords
+if echo "$PROMPT_LOWER" | grep -qE '\b(ultrathink|think)\b'; then
+  cat << 'EOF'
+{"continue": true, "message": "<think-mode>\n\n**ULTRATHINK MODE ENABLED** - Extended reasoning activated.\n\nYou are now in deep thinking mode. Take your time to:\n1. Thoroughly analyze the problem from multiple angles\n2. Consider edge cases and potential issues\n3. Think through the implications of each approach\n4. Reason step-by-step before acting\n\nUse your extended thinking capabilities to provide the most thorough and well-reasoned response.\n\n</think-mode>\n\n---\n"}
+EOF
+  exit 0
+fi
+
+# Check for search keywords (EN + multilingual)
+if echo "$PROMPT_LOWER" | grep -qE '\b(search|find|locate|lookup|explore|discover|scan|grep|query|browse|detect|trace|seek|track|pinpoint|hunt)\b|where\s+is|show\s+me|list\s+all'; then
+  cat << 'EOF'
+{"continue": true, "message": "<search-mode>\nMAXIMIZE SEARCH EFFORT. Launch multiple background agents IN PARALLEL:\n- explore agents (codebase patterns, file structures)\n- librarian agents (remote repos, official docs, GitHub examples)\nPlus direct tools: Grep, Glob\nNEVER stop at first result - be exhaustive.\n</search-mode>\n\n---\n"}
+EOF
+  exit 0
+fi
+
+# Check for analyze keywords
+if echo "$PROMPT_LOWER" | grep -qE '\b(analyze|analyse|investigate|examine|research|study|deep.?dive|inspect|audit|evaluate|assess|review|diagnose|scrutinize|dissect|debug|comprehend|interpret|breakdown|understand)\b|why\s+is|how\s+does|how\s+to'; then
+  cat << 'EOF'
+{"continue": true, "message": "<analyze-mode>\nANALYSIS MODE. Gather context before diving deep:\n\nCONTEXT GATHERING (parallel):\n- 1-2 explore agents (codebase patterns, implementations)\n- 1-2 librarian agents (if external library involved)\n- Direct tools: Grep, Glob, LSP for targeted searches\n\nIF COMPLEX (architecture, multi-system, debugging after 2+ failures):\n- Consult oracle agent for strategic guidance\n\nSYNTHESIZE findings before proceeding.\n</analyze-mode>\n\n---\n"}
+EOF
+  exit 0
+fi
+
+# No keywords detected - continue without modification
+echo '{"continue": true}'
+exit 0

package/hooks/persistent-mode.sh

@@ -0,0 +1,172 @@
+#!/bin/bash
+# Sisyphus Persistent Mode Hook
+# Unified handler for ultrawork, ralph-loop, and todo continuation
+# Prevents stopping when work remains incomplete
+
+# Read stdin
+INPUT=$(cat)
+
+# Get session ID and directory
+SESSION_ID=""
+DIRECTORY=""
+if command -v jq &> /dev/null; then
+  SESSION_ID=$(echo "$INPUT" | jq -r '.sessionId // .session_id // ""' 2>/dev/null)
+  DIRECTORY=$(echo "$INPUT" | jq -r '.directory // ""' 2>/dev/null)
+fi
+
+# Default to current directory
+if [ -z "$DIRECTORY" ]; then
+  DIRECTORY=$(pwd)
+fi
+
+# Check for active ultrawork state
+ULTRAWORK_STATE=""
+if [ -f "$DIRECTORY/.omc/ultrawork-state.json" ]; then
+  ULTRAWORK_STATE=$(cat "$DIRECTORY/.omc/ultrawork-state.json" 2>/dev/null)
+elif [ -f "$HOME/.claude/ultrawork-state.json" ]; then
+  ULTRAWORK_STATE=$(cat "$HOME/.claude/ultrawork-state.json" 2>/dev/null)
+fi
+
+# Check for active ralph loop
+RALPH_STATE=""
+if [ -f "$DIRECTORY/.omc/ralph-state.json" ]; then
+  RALPH_STATE=$(cat "$DIRECTORY/.omc/ralph-state.json" 2>/dev/null)
+fi
+
+# Check for verification state (oracle verification)
+VERIFICATION_STATE=""
+if [ -f "$DIRECTORY/.omc/ralph-verification.json" ]; then
+  VERIFICATION_STATE=$(cat "$DIRECTORY/.omc/ralph-verification.json" 2>/dev/null)
+fi
+
+# Check for incomplete todos
+INCOMPLETE_COUNT=0
+TODOS_DIR="$HOME/.claude/todos"
+if [ -d "$TODOS_DIR" ]; then
+  for todo_file in "$TODOS_DIR"/*.json; do
+    if [ -f "$todo_file" ]; then
+      if command -v jq &> /dev/null; then
+        COUNT=$(jq '[.[] | select(.status != "completed" and .status != "cancelled")] | length' "$todo_file" 2>/dev/null || echo "0")
+        INCOMPLETE_COUNT=$((INCOMPLETE_COUNT + COUNT))
+      else
+        # Fallback: count "pending" or "in_progress" occurrences
+        COUNT=$(grep -c '"status"[[:space:]]*:[[:space:]]*"pending\|in_progress"' "$todo_file" 2>/dev/null) || COUNT=0
+        INCOMPLETE_COUNT=$((INCOMPLETE_COUNT + COUNT))
+      fi
+    fi
+  done
+fi
+
+# Check project todos as well
+for todo_path in "$DIRECTORY/.omc/todos.json" "$DIRECTORY/.claude/todos.json"; do
+  if [ -f "$todo_path" ]; then
+    if command -v jq &> /dev/null; then
+      COUNT=$(jq 'if type == "array" then [.[] | select(.status != "completed" and .status != "cancelled")] | length else 0 end' "$todo_path" 2>/dev/null || echo "0")
+      INCOMPLETE_COUNT=$((INCOMPLETE_COUNT + COUNT))
+    else
+      # Fallback: count "pending" or "in_progress" occurrences
+      COUNT=$(grep -c '"status"[[:space:]]*:[[:space:]]*"pending\|in_progress"' "$todo_path" 2>/dev/null) || COUNT=0
+      INCOMPLETE_COUNT=$((INCOMPLETE_COUNT + COUNT))
+    fi
+  fi
+done
+
+# Priority 1: Ralph Loop with Oracle Verification
+if [ -n "$RALPH_STATE" ]; then
+  IS_ACTIVE=$(echo "$RALPH_STATE" | jq -r '.active // false' 2>/dev/null)
+  if [ "$IS_ACTIVE" = "true" ]; then
+    ITERATION=$(echo "$RALPH_STATE" | jq -r '.iteration // 1' 2>/dev/null)
+    MAX_ITER=$(echo "$RALPH_STATE" | jq -r '.max_iterations // 10' 2>/dev/null)
+    PROMISE=$(echo "$RALPH_STATE" | jq -r '.completion_promise // "TASK_COMPLETE"' 2>/dev/null)
+    PROMPT=$(echo "$RALPH_STATE" | jq -r '.prompt // ""' 2>/dev/null)
+
+    # Check if oracle verification is pending
+    if [ -n "$VERIFICATION_STATE" ]; then
+      IS_PENDING=$(echo "$VERIFICATION_STATE" | jq -r '.pending // false' 2>/dev/null)
+      if [ "$IS_PENDING" = "true" ]; then
+        ATTEMPT=$(echo "$VERIFICATION_STATE" | jq -r '.verification_attempts // 0' 2>/dev/null)
+        MAX_ATTEMPTS=$(echo "$VERIFICATION_STATE" | jq -r '.max_verification_attempts // 3' 2>/dev/null)
+        ORIGINAL_TASK=$(echo "$VERIFICATION_STATE" | jq -r '.original_task // ""' 2>/dev/null)
+        COMPLETION_CLAIM=$(echo "$VERIFICATION_STATE" | jq -r '.completion_claim // ""' 2>/dev/null)
+        ORACLE_FEEDBACK=$(echo "$VERIFICATION_STATE" | jq -r '.oracle_feedback // ""' 2>/dev/null)
+        NEXT_ATTEMPT=$((ATTEMPT + 1))
+
+        FEEDBACK_SECTION=""
+        if [ -n "$ORACLE_FEEDBACK" ] && [ "$ORACLE_FEEDBACK" != "null" ]; then
+          FEEDBACK_SECTION="\n**Previous Oracle Feedback (rejected):**\n$ORACLE_FEEDBACK\n"
+        fi
+
+        cat << EOF
+{"continue": false, "reason": "<ralph-verification>\n\n[ORACLE VERIFICATION REQUIRED - Attempt $NEXT_ATTEMPT/$MAX_ATTEMPTS]\n\nThe agent claims the task is complete. Before accepting, YOU MUST verify with Oracle.\n\n**Original Task:**\n$ORIGINAL_TASK\n\n**Completion Claim:**\n$COMPLETION_CLAIM\n$FEEDBACK_SECTION\n## MANDATORY VERIFICATION STEPS\n\n1. **Spawn Oracle Agent** for verification:\n   \`\`\`\n   Task(subagent_type=\"oracle\", prompt=\"Verify this task completion claim...\")\n   \`\`\`\n\n2. **Oracle must check:**\n   - Are ALL requirements from the original task met?\n   - Is the implementation complete, not partial?\n   - Are there any obvious bugs or issues?\n   - Does the code compile/run without errors?\n   - Are tests passing (if applicable)?\n\n3. **Based on Oracle's response:**\n   - If APPROVED: Output \`<oracle-approved>VERIFIED_COMPLETE</oracle-approved>\`\n   - If REJECTED: Continue working on the identified issues\n\nDO NOT output the completion promise again until Oracle approves.\n\n</ralph-verification>\n\n---\n"}
+EOF
+        exit 0
+      fi
+    fi
+
+    if [ "$ITERATION" -lt "$MAX_ITER" ]; then
+      # Increment iteration
+      NEW_ITER=$((ITERATION + 1))
+      echo "$RALPH_STATE" | jq ".iteration = $NEW_ITER" > "$DIRECTORY/.omc/ralph-state.json" 2>/dev/null
+
+      cat << EOF
+{"continue": false, "reason": "<ralph-loop-continuation>\n\n[RALPH LOOP - ITERATION $NEW_ITER/$MAX_ITER]\n\nYour previous attempt did not output the completion promise. The work is NOT done yet.\n\nCRITICAL INSTRUCTIONS:\n1. Review your progress and the original task\n2. Check your todo list - are ALL items marked complete?\n3. Continue from where you left off\n4. When FULLY complete, output: <promise>$PROMISE</promise>\n5. Do NOT stop until the task is truly done\n\nOriginal task: $PROMPT\n\n</ralph-loop-continuation>\n\n---\n"}
+EOF
+      exit 0
+    fi
+  fi
+fi
+
+# Priority 2: Ultrawork Mode with incomplete todos
+if [ -n "$ULTRAWORK_STATE" ] && [ "$INCOMPLETE_COUNT" -gt 0 ]; then
+  # Check if active (with jq fallback)
+  IS_ACTIVE=""
+  if command -v jq &> /dev/null; then
+    IS_ACTIVE=$(echo "$ULTRAWORK_STATE" | jq -r '.active // false' 2>/dev/null)
+  else
+    # Fallback: grep for "active": true
+    if echo "$ULTRAWORK_STATE" | grep -q '"active"[[:space:]]*:[[:space:]]*true'; then
+      IS_ACTIVE="true"
+    fi
+  fi
+
+  if [ "$IS_ACTIVE" = "true" ]; then
+    # Get reinforcement count (with fallback)
+    REINFORCE_COUNT=0
+    if command -v jq &> /dev/null; then
+      REINFORCE_COUNT=$(echo "$ULTRAWORK_STATE" | jq -r '.reinforcement_count // 0' 2>/dev/null)
+    else
+      REINFORCE_COUNT=$(echo "$ULTRAWORK_STATE" | grep -oP '"reinforcement_count"[[:space:]]*:[[:space:]]*\K[0-9]+' 2>/dev/null) || REINFORCE_COUNT=0
+    fi
+    NEW_COUNT=$((REINFORCE_COUNT + 1))
+
+    # Get original prompt (with fallback)
+    ORIGINAL_PROMPT=""
+    if command -v jq &> /dev/null; then
+      ORIGINAL_PROMPT=$(echo "$ULTRAWORK_STATE" | jq -r '.original_prompt // ""' 2>/dev/null)
+    else
+      ORIGINAL_PROMPT=$(echo "$ULTRAWORK_STATE" | grep -oP '"original_prompt"[[:space:]]*:[[:space:]]*"\K[^"]+' 2>/dev/null) || ORIGINAL_PROMPT=""
+    fi
+
+    # Update state file (best effort)
+    if command -v jq &> /dev/null; then
+      echo "$ULTRAWORK_STATE" | jq ".reinforcement_count = $NEW_COUNT | .last_checked_at = \"$(date -Iseconds)\"" > "$DIRECTORY/.omc/ultrawork-state.json" 2>/dev/null
+    fi
+
+    cat << EOF
+{"continue": false, "reason": "<ultrawork-persistence>\n\n[ULTRAWORK MODE STILL ACTIVE - Reinforcement #$NEW_COUNT]\n\nYour ultrawork session is NOT complete. $INCOMPLETE_COUNT incomplete todos remain.\n\nREMEMBER THE ULTRAWORK RULES:\n- **PARALLEL**: Fire independent calls simultaneously - NEVER wait sequentially\n- **BACKGROUND FIRST**: Use Task(run_in_background=true) for exploration (10+ concurrent)\n- **TODO**: Track EVERY step. Mark complete IMMEDIATELY after each\n- **VERIFY**: Check ALL requirements met before done\n- **NO Premature Stopping**: ALL TODOs must be complete\n\nContinue working on the next pending task. DO NOT STOP until all tasks are marked complete.\n\nOriginal task: $ORIGINAL_PROMPT\n\n</ultrawork-persistence>\n\n---\n"}
+EOF
+    exit 0
+  fi
+fi
+
+# Priority 3: Todo Continuation (baseline)
+if [ "$INCOMPLETE_COUNT" -gt 0 ]; then
+  cat << EOF
+{"continue": false, "reason": "<todo-continuation>\n\n[SYSTEM REMINDER - TODO CONTINUATION]\n\nIncomplete tasks remain in your todo list ($INCOMPLETE_COUNT remaining). Continue working on the next pending task.\n\n- Proceed without asking for permission\n- Mark each task complete when finished\n- Do not stop until all tasks are done\n\n</todo-continuation>\n\n---\n"}
+EOF
+  exit 0
+fi
+
+# No blocking needed
+echo '{"continue": true}'
+exit 0