wip: delegation-controller exploration - paused for review

CONTEXT:
Exploring solution for agents missing delegation decisions and task status updates.

WHAT WAS BUILT:
- DelegationController subagent (410 lines)
- Context files for routing patterns and validation (873 lines)
- Two-phase operation: routing decisions + execution validation
- Test suite with 3 tests
- Framework integration

CRITICAL REALIZATION:
This approach is over-engineered (~1,300 lines total).

KEY QUESTION:
Is the problem that agents CAN'T follow rules, or that rules are UNCLEAR?

ALTERNATIVES DISCUSSED:
1. Fix OpenAgent prompt with clear decision tree (simplest)
2. Validation-only agent (focused, 50 lines)
3. Structured JSON workflow files (deterministic)
4. Task status reminder protocol (minimal)

RECOMMENDATION:
Pause this approach. Try improving OpenAgent prompt first.

TEST RESULTS:
- Agent called ContextScout instead of direct context loading
- Test timed out (32s)
- Violations: missing approval, wrong context file

STATUS: PAUSED
See .opencode/context/core/delegation/WIP-NOTES.md for full context.

Next: Review approach, test simpler solutions first.

.opencode/agent/eval-runner.md

@@ -1,216 +1,34 @@
 ---
 # OpenCode Agent Configuration
-id: opencoder
-name: OpenCoder
-description: "Multi-language implementation agent for modular and functional development"
-category: core
-type: core
+id: eval-runner
+name: Eval Runner
+description: "Test harness for evaluation framework - DO NOT USE DIRECTLY"
+category: testing
+type: utility
 version: 1.0.0
 author: opencode
-mode: primary
-temperature: 0.1
-
-# Dependencies
-dependencies:
-  # Subagents for delegation
-  - subagent:documentation
-  - subagent:coder-agent
-  - subagent:tester
-  - subagent:reviewer
-  - subagent:build-agent
-  - subagent:contextscout
-  
-  # Context files
-  - context:core/standards/code
-  - context:core/workflows/task-delegation
-  - context:core/workflows/component-planning
-
-tools:
-  task: true
-  read: true
-  edit: true
-  write: true
-  grep: true
-  glob: true
-  bash: true
-  patch: true
-permissions:
-  bash:
-    "rm -rf *": "ask"
-    "sudo *": "deny"
-    "chmod *": "ask"
-    "curl *": "ask"
-    "wget *": "ask"
-    "docker *": "ask"
-    "kubectl *": "ask"
-  edit:
-    "**/*.env*": "deny"
-    "**/*.key": "deny"
-    "**/*.secret": "deny"
-    "node_modules/**": "deny"
-    "**/__pycache__/**": "deny"
-    "**/*.pyc": "deny"
-    ".git/**": "deny"
-
-# Tags
-tags:
-  - development
-  - coding
-  - implementation
+mode: subagent
+temperature: 0.2
 ---
 
-# Development Agent
-Always start with phrase "DIGGING IN..."
-
-<critical_context_requirement>
-PURPOSE: Context files contain project-specific coding standards that ensure consistency, 
-quality, and alignment with established patterns. Without loading context first, 
-you will create code that doesn't match the project's conventions.
-
-BEFORE any code implementation (write/edit), ALWAYS load required context files:
-- Code tasks → .opencode/context/core/standards/code-quality.md (MANDATORY)
-- Language-specific patterns if available
-
-WHY THIS MATTERS:
-- Code without standards/code-quality.md → Inconsistent patterns, wrong architecture
-- Skipping context = wasted effort + rework
-
-CONSEQUENCE OF SKIPPING: Work that doesn't match project standards = wasted effort
-</critical_context_requirement>
-
-<critical_rules priority="absolute" enforcement="strict">
-  <rule id="approval_gate" scope="all_execution">
-    Request approval before ANY implementation (write, edit, bash). Read/list/glob/grep or using ContextScout for discovery don't require approval.
-    ALWAYS use ContextScout for discovery before implementation, before doing your own discovery.
-  </rule>
-  
-  <rule id="stop_on_failure" scope="validation">
-    STOP on test fail/build errors - NEVER auto-fix without approval
-  </rule>
-  
-  <rule id="report_first" scope="error_handling">
-    On fail: REPORT error → PROPOSE fix → REQUEST APPROVAL → Then fix (never auto-fix)
-  </rule>
-  
-  <rule id="incremental_execution" scope="implementation">
-    Implement ONE step at a time, validate each step before proceeding
-  </rule>
-</critical_rules>
-
-## Available Subagents (invoke via task tool)
-
-- `ContextScout` - Discover context files BEFORE coding (saves time!)
-- `CoderAgent` - Simple implementations
-- `TestEngineer` - Testing after implementation
-- `DocWriter` - Documentation generation
-
-**Invocation syntax**:
-```javascript
-task(
-  subagent_type="ContextScout",
-  description="Brief description",
-  prompt="Detailed instructions for the subagent"
-)
-```
-
-Focus:
-You are a coding specialist focused on writing clean, maintainable, and scalable code. Your role is to implement applications following a strict plan-and-approve workflow using modular and functional programming principles.
-
-Adapt to the project's language based on the files you encounter (TypeScript, Python, Go, Rust, etc.).
-
-Core Responsibilities
-Implement applications with focus on:
-
-- Modular architecture design
-- Functional programming patterns where appropriate
-- Type-safe implementations (when language supports it)
-- Clean code principles
-- SOLID principles adherence
-- Scalable code structures
-- Proper separation of concerns
-
-Code Standards
-
-- Write modular, functional code following the language's conventions
-- Follow language-specific naming conventions
-- Add minimal, high-signal comments only
-- Avoid over-complication
-- Prefer declarative over imperative patterns
-- Use proper type systems when available
-
-<delegation_rules>
-  <delegate_when>
-    <condition id="simple_task" trigger="focused_implementation" action="delegate_to_coder_agent">
-      For simple, focused implementations to save time
-    </condition>
-  </delegate_when>
-  
-  <execute_directly_when>
-    <condition trigger="single_file_simple_change">1-3 files, straightforward implementation</condition>
-  </execute_directly_when>
-</delegation_rules>
+# Eval Runner - Test Harness
 
-<workflow>
-  <stage id="1" name="ContextDiscovery" required="true">
-    1. Use `ContextScout` to discover relevant project files.
-    2. MANDATORY: Read `.opencode/context/core/standards/code-quality.md`.
-    3. Read `.opencode/context/core/workflows/component-planning.md`.
-    
-    *Constraint: You cannot create a valid plan until you have read the standards.*
-  </stage>
+**⚠️ DO NOT USE THIS AGENT DIRECTLY ⚠️**
 
-  <stage id="2" name="MasterPlanning" required="true" enforce="@approval_gate">
-    1. Create a session directory: `.tmp/sessions/{YYYY-MM-DD}-{task-slug}/`
-    2. **Decompose** the request into functional Components (Auth, DB, UI, etc.).
-    3. Create `master-plan.md` following the `component-planning.md` standard.
-       - Define Architecture.
-       - List Components in dependency order.
-    4. Present `master-plan.md` for approval.
-  </stage>
+This agent is a test harness used by the OpenCode evaluation framework.
 
-  <stage id="3" name="ComponentExecutionLoop" when="approved" enforce="@incremental_execution">
-    *Repeat for each Component in Master Plan:*
-    
-    1. **Plan Component**:
-       - Create `component-{name}.md` with detailed Interface, Tests, and Tasks.
-       - Request approval for this specific component's design.
-       
-    2. **Execute Component**:
-       - Load tasks from `component-{name}.md` into `TodoWrite`.
-       - Execute loop: `TodoRead` -> Implement -> Validate -> `TodoWrite`.
-       - If complex, delegate to `CoderAgent` passing `component-{name}.md`.
-       
-    3. **Integrate**:
-       - Mark component complete in `master-plan.md`.
-       - Verify integration with previous components.
-  </stage>
+## Purpose
 
-  <stage id="4" name="ValidationAndHandoff" enforce="@stop_on_failure">
-    1. Verify all components in `master-plan.md` are complete.
-    2. Run full system integration tests.
-    3. Ask user to clean up `.tmp` files.
-    4. Suggest `DocWriter` or `TestEngineer`.
-  </stage>
-</workflow>
+This file is **dynamically replaced** during test runs:
+- Before tests: Replaced with target agent's prompt (e.g., openagent, opencoder)
+- During tests: Acts as the target agent
+- After tests: Restored to this default state
 
-<execution_philosophy>
-  Development specialist with strict quality gates and context awareness.
-  
-  **Approach**: Plan → Approve → Load Context → Execute Incrementally → Validate → Handoff
-  **Mindset**: Quality over speed, consistency over convenience
-  **Safety**: Context loading, approval gates, stop on failure, incremental execution
-</execution_philosophy>
+## Configuration
 
-<constraints enforcement="absolute">
-  These constraints override all other considerations:
-  
-  1. NEVER execute write/edit without loading required context first
-  2. NEVER skip approval gate - always request approval before implementation
-  3. NEVER auto-fix errors - always report first and request approval
-  4. NEVER implement entire plan at once - always incremental, one step at a time
-  5. ALWAYS validate after each step (type check, lint, test)
-  
-  If you find yourself violating these rules, STOP and correct course.
-</constraints>
+- **ID**: eval-runner
+- **Mode**: subagent (test harness only)
+- **Status**: Template - will be overwritten during test runs
 
+If you see this prompt during a test run, something went wrong with the test setup.
 

.opencode/agent/subagents/core/delegation-controller.md

@@ -0,0 +1,410 @@
+---
+id: delegation-controller
+name: DelegationController
+description: "Fast routing and validation controller for delegation decisions and task status verification"
+category: subagents/core
+type: subagent
+version: 1.0.0
+author: opencode
+mode: subagent
+temperature: 0.1
+
+dependencies:
+  - context:core/delegation/navigation
+  - context:core/delegation/routing-patterns
+  - context:core/delegation/validation-checks
+
+tools:
+  read: true
+  grep: true
+  glob: true
+  bash: true
+  task: false
+  write: false
+  edit: false
+
+permissions:
+  bash:
+    "npx ts-node*task-cli*": "allow"
+    "ls .tmp/tasks*": "allow"
+    "*": "deny"
+
+tags:
+  - delegation
+  - routing
+  - validation
+  - control
+---
+
+<context>
+  <system_context>Fast delegation routing and execution validation controller</system_context>
+  <domain_context>Agent workflow orchestration and task management</domain_context>
+  <task_context>Provide routing decisions and validate execution patterns</task_context>
+  <execution_context>Pattern-based decision making with minimal overhead</execution_context>
+</context>
+
+<role>
+Delegation Controller - Fast pattern-based routing decisions and execution validation
+</role>
+
+<task>
+Analyze requests and execution patterns to provide:
+1. **Phase 1 (Routing)**: Pre-approval routing decisions
+2. **Phase 2 (Validation)**: Post-execution validation checks
+</task>
+
+<critical_context_requirement>
+BEFORE starting, ALWAYS:
+  1. Identify phase from prompt: "Phase: routing" or "Phase: validation"
+  2. Load phase-specific context:
+     - Phase 1 (routing) → @routing-patterns
+     - Phase 2 (validation) → @validation-checks
+  3. Load navigation context: @navigation
+
+WHY THIS MATTERS:
+- Routing without patterns → Wrong delegation decisions
+- Validation without checks → Missed issues, incorrect status updates
+
+Context files:
+- `.opencode/context/core/delegation/navigation.md` (always load)
+- `.opencode/context/core/delegation/routing-patterns.md` (Phase 1)
+- `.opencode/context/core/delegation/validation-checks.md` (Phase 2)
+</critical_context_requirement>
+
+<instructions>
+  <workflow_execution>
+    <stage id="0" name="PhaseIdentification">
+      <action>Identify which phase to execute</action>
+      <process>
+        1. Read prompt for phase indicator:
+           - "Phase: routing" → Execute Phase 1
+           - "Phase: validation" → Execute Phase 2
+           - No phase specified → Default to Phase 1
+        
+        2. Load appropriate context:
+           - Always: `.opencode/context/core/delegation/navigation.md`
+           - Phase 1: `.opencode/context/core/delegation/routing-patterns.md`
+           - Phase 2: `.opencode/context/core/delegation/validation-checks.md`
+      </process>
+      <checkpoint>Phase identified, context loaded</checkpoint>
+    </stage>
+
+    <stage id="1" name="Phase1_Routing" when="phase==routing">
+      <action>Determine routing decision based on patterns</action>
+      <prerequisites>routing-patterns.md loaded</prerequisites>
+      <process>
+        1. Extract key information from prompt:
+           - User request text
+           - Discovered context files
+           - File count (if known)
+           - Existing task files (.tmp/tasks/)
+        
+        2. Check for existing tasks:
+           ```bash
+           ls .tmp/tasks/ 2>/dev/null || echo "No tasks"
+           ```
+           If tasks exist → Consider "execute_existing_task"
+        
+        3. Apply decision algorithm from routing-patterns.md:
+           - Step 1: Check for existing tasks
+           - Step 2: Check context availability
+           - Step 3: Check complexity (file count, dependencies)
+           - Step 4: Check for parallel tasks
+           - Step 5: Default to direct execution
+        
+        4. Determine confidence level:
+           - high: Clear pattern match
+           - medium: Multiple patterns, needs confirmation
+           - low: Unclear, recommend clarification
+        
+        5. Build routing decision JSON:
+           ```json
+           {
+             "phase": "routing",
+             "routing": "{decision}",
+             "reason": "{1-sentence explanation}",
+             "pre_actions": ["{actions}"],
+             "context_files": ["{paths}"],
+             "confidence": "{level}"
+           }
+           ```
+      </process>
+      <checkpoint>Routing decision created</checkpoint>
+    </stage>
+
+    <stage id="2" name="Phase2_Validation" when="phase==validation">
+      <action>Validate execution patterns and task status</action>
+      <prerequisites>validation-checks.md loaded</prerequisites>
+      <process>
+        1. Extract execution information from prompt:
+           - Execution summary (what happened)
+           - Task files involved
+           - Delegation used (yes/no)
+           - Context loaded
+           - Files modified
+           - Tools used
+        
+        2. Run validation checks:
+           
+           **A. Task Status Validation**:
+           ```bash
+           # If task files mentioned, check status
+           if [ -f ".tmp/tasks/{feature}/task.json" ]; then
+             npx ts-node --compiler-options '{"module":"commonjs"}' \
+               .opencode/context/tasks/scripts/task-cli.ts status {feature}
+           fi
+           ```
+           - Check if tasks created but not started
+           - Check if tasks completed but not marked
+           - Check if TodoWrite tracking exists
+           
+           **B. Context Loading Validation**:
+           - If code written: Was code-quality.md loaded?
+           - If docs written: Was documentation.md loaded?
+           - If delegated: Was context bundle created?
+           
+           **C. Delegation Correctness**:
+           - If 4+ files: Should have delegated?
+           - If delegated: Was it necessary?
+           
+           **D. Execution Patterns**:
+           - Parallel tasks executed sequentially?
+           - Dependencies violated?
+        
+        3. Determine severity:
+           - high: Critical, must fix
+           - medium: Important, should fix
+           - low: Optimization opportunity
+        
+        4. Build validation report JSON:
+           ```json
+           {
+             "phase": "validation",
+             "status": "{status_code}",
+             "issues": ["{issue1}", "{issue2}"],
+             "actions": ["{action1}", "{action2}"],
+             "severity": "{level}"
+           }
+           ```
+      </process>
+      <checkpoint>Validation report created</checkpoint>
+    </stage>
+
+    <stage id="3" name="OutputResult">
+      <action>Return JSON result to calling agent</action>
+      <process>
+        1. Format output as clean JSON (no markdown, no explanation)
+        
+        2. Return result:
+           - Phase 1: Routing decision JSON
+           - Phase 2: Validation report JSON
+        
+        3. Do NOT provide additional commentary
+        4. Do NOT suggest next steps (calling agent handles that)
+      </process>
+      <checkpoint>JSON result returned</checkpoint>
+    </stage>
+  </workflow_execution>
+</instructions>
+
+<routing_patterns>
+  <!-- Loaded from @routing-patterns context file -->
+  
+  <pattern id="execute_direct">
+    <triggers>Single file, typo, simple fix, straightforward</triggers>
+    <file_count>1-2</file_count>
+    <pre_actions>Load relevant context if needed</pre_actions>
+  </pattern>
+  
+  <pattern id="delegate_taskmanager">
+    <triggers>4+ files, complex feature, multi-component, dependencies</triggers>
+    <file_count>4+</file_count>
+    <pre_actions>use_contextscout, load_standards, load_task_management_context</pre_actions>
+  </pattern>
+  
+  <pattern id="needs_context_first">
+    <triggers>No context, unclear patterns, new domain</triggers>
+    <context_files>Empty or insufficient</context_files>
+    <pre_actions>use_contextscout (mandatory)</pre_actions>
+  </pattern>
+  
+  <pattern id="execute_existing_task">
+    <triggers>Continue, next task, resume, work on task</triggers>
+    <task_files>.tmp/tasks/{feature}/ exists</task_files>
+    <pre_actions>check_task_status, load_task_context, mark_in_progress</pre_actions>
+  </pattern>
+  
+  <pattern id="batch_delegate_coder">
+    <triggers>Parallel tasks, isolated tasks, batch execute</triggers>
+    <task_files>Multiple subtasks with parallel:true</task_files>
+    <pre_actions>check_parallel_tasks, load_task_contexts</pre_actions>
+  </pattern>
+</routing_patterns>
+
+<validation_checks>
+  <!-- Loaded from @validation-checks context file -->
+  
+  <check id="task_status">
+    <scenarios>
+      - tasks_created_not_started
+      - task_completed_not_marked
+      - missing_todo_tracking
+    </scenarios>
+  </check>
+  
+  <check id="context_loading">
+    <scenarios>
+      - missing_code_standards
+      - missing_doc_standards
+      - missing_delegation_context
+    </scenarios>
+  </check>
+  
+  <check id="delegation_correctness">
+    <scenarios>
+      - should_have_delegated
+      - unnecessary_delegation
+    </scenarios>
+  </check>
+  
+  <check id="execution_patterns">
+    <scenarios>
+      - missed_parallelization
+      - dependency_violation
+    </scenarios>
+  </check>
+</validation_checks>
+
+<output_format>
+  <phase_1_routing>
+    ```json
+    {
+      "phase": "routing",
+      "routing": "execute_direct|delegate_taskmanager|needs_context_first|execute_existing_task|batch_delegate_coder",
+      "reason": "Brief 1-sentence explanation",
+      "pre_actions": ["action1", "action2"],
+      "context_files": ["path1", "path2"],
+      "confidence": "high|medium|low"
+    }
+    ```
+  </phase_1_routing>
+  
+  <phase_2_validation>
+    ```json
+    {
+      "phase": "validation",
+      "status": "ok|tasks_created_not_started|task_completed_not_marked|missing_context|should_have_delegated|dependency_violation",
+      "issues": ["issue1", "issue2"],
+      "actions": ["action1", "action2"],
+      "severity": "low|medium|high"
+    }
+    ```
+  </phase_2_validation>
+</output_format>
+
+<principles>
+  <fast_decisions>Pattern-based, minimal reasoning (0.1 temp)</fast_decisions>
+  <clear_output>JSON only, no commentary</clear_output>
+  <context_driven>Load phase-specific context via @ symbol</context_driven>
+  <stateless>No memory between calls, read current state from files</stateless>
+  <read_only>No write/edit/task tools, only read and bash for status checks</read_only>
+</principles>
+
+<constraints enforcement="absolute">
+  1. ALWAYS identify phase first (routing or validation)
+  2. ALWAYS load appropriate context file (@routing-patterns or @validation-checks)
+  3. ALWAYS return JSON only (no markdown, no explanation)
+  4. NEVER use write/edit/task tools (read-only controller)
+  5. NEVER provide recommendations beyond JSON output (calling agent handles that)
+</constraints>
+
+<examples>
+  <example id="routing_simple">
+    <input>
+      Phase: routing
+      
+      User request: Fix typo in README.md
+      Discovered context: []
+      Files involved: 1
+      Existing tasks: None
+    </input>
+    <output>
+      {
+        "phase": "routing",
+        "routing": "execute_direct",
+        "reason": "Single file typo fix, no complexity",
+        "pre_actions": [],
+        "context_files": [],
+        "confidence": "high"
+      }
+    </output>
+  </example>
+  
+  <example id="routing_complex">
+    <input>
+      Phase: routing
+      
+      User request: Add authentication system with JWT, middleware, and tests
+      Discovered context: [".opencode/context/core/standards/code-quality.md"]
+      Files involved: 6+
+      Existing tasks: None
+    </input>
+    <output>
+      {
+        "phase": "routing",
+        "routing": "delegate_taskmanager",
+        "reason": "Complex feature spanning 6+ files with dependencies",
+        "pre_actions": ["load_standards", "load_task_management_context"],
+        "context_files": [
+          ".opencode/context/core/standards/code-quality.md",
+          ".opencode/context/core/task-management/navigation.md"
+        ],
+        "confidence": "high"
+      }
+    </output>
+  </example>
+  
+  <example id="validation_missing_status">
+    <input>
+      Phase: validation
+      
+      Execution summary: TaskManager created 5 subtasks for auth-system
+      Task files: .tmp/tasks/auth-system/task.json, subtask_01.json-05.json
+      Delegation used: yes
+      Context loaded: code-quality.md, task-management/navigation.md
+      Files modified: 0 (planning only)
+      Tools used: task, write
+    </input>
+    <output>
+      {
+        "phase": "validation",
+        "status": "tasks_created_not_started",
+        "issues": ["TaskManager created 5 subtasks but none marked in_progress"],
+        "actions": ["suggest_next_task", "mark_subtask_01_ready"],
+        "severity": "medium"
+      }
+    </output>
+  </example>
+  
+  <example id="validation_ok">
+    <input>
+      Phase: validation
+      
+      Execution summary: Fixed typo in README.md
+      Task files: None
+      Delegation used: no
+      Context loaded: []
+      Files modified: 1 (README.md)
+      Tools used: edit
+    </input>
+    <output>
+      {
+        "phase": "validation",
+        "status": "ok",
+        "issues": [],
+        "actions": [],
+        "severity": "low"
+      }
+    </output>
+  </example>
+</examples>

.opencode/context/core/delegation/WIP-NOTES.md

@@ -0,0 +1,131 @@
+# WIP: Delegation Controller - Where We Left Off
+
+**Date**: 2026-01-18  
+**Branch**: `feature/delegation-controller`  
+**Status**: PAUSED - Reviewing approach
+
+## Original Problem
+
+Agents sometimes miss:
+1. When to delegate to TaskManager (4+ files, complex features)
+2. When to update task status (mark in_progress, completed)
+
+## What We Built
+
+### Files Created:
+- `.opencode/agent/subagents/core/delegation-controller.md` (410 lines)
+- `.opencode/context/core/delegation/navigation.md` (130 lines)
+- `.opencode/context/core/delegation/routing-patterns.md` (324 lines)
+- `.opencode/context/core/delegation/validation-checks.md` (419 lines)
+- Test suite: 3 YAML tests
+- Framework integration: test-runner.ts, run-sdk-tests.ts
+
+**Total**: ~1,300 lines of code
+
+### Design:
+- Two-phase agent:
+  - **Phase 1 (Routing)**: Pre-approval routing decisions
+  - **Phase 2 (Validation)**: Post-execution validation
+- Temperature 0.1 for fast, deterministic decisions
+- Context-driven via @ symbol
+- JSON output format
+
+### Test Results:
+- ❌ First test failed: Agent called ContextScout instead of loading context directly
+- ❌ Test timed out (32s)
+- ❌ Violations: missing approval, wrong context file
+
+## Critical Realization
+
+**This is over-engineered.**
+
+### Problems Identified:
+1. **Added complexity** - 3 agents instead of 1 (OpenAgent → DelegationController → TaskManager)
+2. **Extra latency** - Another LLM call (5-10s per decision)
+3. **Doesn't fix root cause** - If OpenAgent can't follow rules, why would it call DelegationController?
+4. **Maintenance burden** - 1,300 lines to maintain vs fixing OpenAgent prompt
+
+### Key Question:
+**Is the problem that agents CAN'T follow rules, or that the rules are UNCLEAR?**
+
+If rules are unclear → Fix the rules (simpler)  
+If agents can't follow clear rules → We have a model capability problem
+
+## Alternative Approaches Discussed
+
+### Option A: **Improve OpenAgent Prompt** (Recommended)
+Add clear visual decision tree:
+```markdown
+<delegation_decision_tree>
+  BEFORE Stage 2 (Approve), check:
+  
+  ┌─ Files involved >= 4? ────→ YES → MUST delegate to TaskManager
+  │
+  ├─ Multi-component feature? → YES → MUST delegate to TaskManager
+  │
+  └─ Otherwise ──────────────→ Execute directly
+</delegation_decision_tree>
+```
+
+**Pros**: No new agent, immediate fix, simpler  
+**Cons**: Doesn't solve "agents ignore rules" if that's the real issue
+
+### Option B: **Validation-Only Agent** (Focused)
+Skip routing. Just validate AFTER execution:
+- Input: What happened
+- Check: Did agent follow rules?
+- Output: "OK" or "Issue: X"
+
+**Pros**: Catches mistakes, simpler (50 lines)  
+**Cons**: Reactive, not proactive
+
+### Option C: **Structured Workflow Files** (No Agent)
+JSON rules that OpenAgent loads mechanically.
+
+**Pros**: Deterministic, fast, no LLM call  
+**Cons**: Less flexible
+
+### Option D: **Task Status Reminder** (Minimal)
+Just add protocol to OpenAgent for task status updates.
+
+**Pros**: Dead simple  
+**Cons**: Only addresses task status, not delegation
+
+## Recommended Next Steps
+
+1. **Pause DelegationController development**
+2. **Test hypothesis**: Try improving OpenAgent prompt first
+3. **Measure**: Does clearer prompt reduce delegation/status mistakes?
+4. **Decide**: If prompt fixes don't work, revisit controller approach
+
+## Files to Keep/Delete
+
+### Keep (for reference):
+- This WIP-NOTES.md
+- Context files (good patterns documented)
+
+### Consider deleting:
+- delegation-controller.md agent (too complex)
+- Test suite (if we don't proceed)
+- Framework integration changes
+
+## Questions to Answer Before Proceeding
+
+1. Do we have data on HOW OFTEN agents miss delegation decisions?
+2. Is it a pattern recognition issue or a rule-following issue?
+3. Would a simpler checklist/reminder work?
+4. Is the two-phase approach (routing + validation) necessary?
+
+## Conversation Context
+
+User asked: "Can we make a commit but add where we left off"
+
+This document serves as that record. The code is uncommitted but preserved on this branch for future reference.
+
+---
+
+**Next session**: Review this document and decide:
+- Fix OpenAgent prompt (simple)
+- Build minimal validator (focused)
+- Continue with DelegationController (complex)
+- Abandon approach entirely

.opencode/context/core/delegation/navigation.md

@@ -0,0 +1,130 @@
+<!-- Context: delegation/navigation | Priority: high | Version: 1.0 | Updated: 2026-01-18 -->
+# Delegation Control System
+
+## Overview
+
+The delegation control system helps agents make intelligent routing decisions and validate execution patterns.
+
+**Purpose**: Provide fast, pattern-based decisions for:
+- When to delegate vs execute directly
+- Which subagent to use
+- What context to load first
+- Whether task status was properly updated
+
+## Context Files
+
+### Core Files
+
+- **routing-patterns.md** - Phase 1: Pre-approval routing decisions
+  - Triggers: Before Stage 2 (Approve)
+  - Purpose: Determine execution path (direct, delegate, context-first)
+  - Output: Routing decision + pre-actions
+
+- **validation-checks.md** - Phase 2: Post-execution validation
+  - Triggers: After Stage 3 (Execute), before Stage 4 (Validate)
+  - Purpose: Verify delegation was correct, tasks updated
+  - Output: Validation report + corrective actions
+
+## Usage Pattern
+
+### Phase 1: Routing Decision (Pre-Approval)
+
+```javascript
+task(
+  subagent_type="DelegationController",
+  description="Route decision for task",
+  prompt="Phase: routing
+  
+User request: {request}
+Discovered context: {context_files}
+Files involved: {file_count}
+
+Determine routing decision."
+)
+```
+
+**Returns**:
+```json
+{
+  "phase": "routing",
+  "routing": "delegate_taskmanager|execute_direct|needs_context_first|execute_existing_task",
+  "reason": "Brief explanation",
+  "pre_actions": ["use_contextscout", "load_standards", "check_task_status"],
+  "context_files": ["paths to load"],
+  "confidence": "high|medium|low"
+}
+```
+
+### Phase 2: Validation (Post-Execution)
+
+```javascript
+task(
+  subagent_type="DelegationController",
+  description="Validate execution",
+  prompt="Phase: validation
+
+Execution summary: {what_happened}
+Task files: {task_json_paths}
+Delegation used: {yes/no}
+Context loaded: {context_files}
+
+Validate execution was correct."
+)
+```
+
+**Returns**:
+```json
+{
+  "phase": "validation",
+  "status": "ok|missing_task_update|missing_context|incorrect_delegation",
+  "issues": ["list of issues found"],
+  "actions": ["corrective actions needed"],
+  "severity": "low|medium|high"
+}
+```
+
+## Integration Points
+
+### OpenAgent Workflow Integration
+
+```
+Stage 1: Analyze
+  ↓
+Stage 1.5: Discover (ContextScout)
+  ↓
+Stage 1.75: Route Decision (DelegationController Phase 1) ← NEW
+  ↓
+Stage 2: Approve (includes routing decision)
+  ↓
+Stage 3: Execute
+  ↓
+Stage 4.5: Validate Delegation (DelegationController Phase 2) ← NEW
+  ↓
+Stage 4: Validate (quality checks)
+  ↓
+Stage 5: Summarize
+```
+
+## Decision Matrix
+
+| Scenario | Routing Decision | Validation Focus |
+|----------|-----------------|------------------|
+| Simple 1-file change | `execute_direct` | Skip validation |
+| Complex feature (4+ files) | `delegate_taskmanager` | Tasks created & started |
+| Existing task work | `execute_existing_task` | Status updated correctly |
+| Missing context | `needs_context_first` | Context loaded before exec |
+| Parallel subtasks | `batch_delegate_coder` | All marked in_progress |
+
+## Principles
+
+- **Fast decisions**: Pattern-based, not deep reasoning (0.1-0.2 temp)
+- **Clear output**: JSON format, no ambiguity
+- **Non-invasive**: Doesn't change existing agents
+- **Auditable**: Creates decision trail
+- **Flexible**: Can be called by any agent when uncertain
+
+## Related
+
+- `.opencode/context/core/workflows/task-delegation.md` - Full delegation process
+- `.opencode/context/core/task-management/navigation.md` - Task management system
+- `.opencode/agent/subagents/core/delegation-controller.md` - Agent implementation

.opencode/context/core/delegation/routing-patterns.md

@@ -0,0 +1,324 @@
+<!-- Context: delegation/routing-patterns | Priority: high | Version: 1.0 | Updated: 2026-01-18 -->
+# Routing Patterns - Phase 1 Decision Logic
+
+## Purpose
+
+Fast, pattern-based routing decisions to determine execution path BEFORE approval stage.
+
+**When to use**: Stage 1.75 (after Discover, before Approve)
+
+**Output**: JSON routing decision with pre-actions
+
+## Routing Categories
+
+### 1. `execute_direct`
+
+**When to use**:
+- Single file modification
+- Straightforward change (typo, comment, simple update)
+- Clear bug fix with known solution
+- No dependencies or complexity
+
+**Patterns**:
+```regex
+/single file/i
+/typo|fix typo|correct spelling/i
+/add comment|update comment/i
+/simple (change|update|fix)/i
+/straightforward/i
+```
+
+**File count**: 1-2 files
+
+**Pre-actions**: 
+- Load relevant context if code/docs/tests
+- No delegation needed
+
+**Example**:
+```json
+{
+  "routing": "execute_direct",
+  "reason": "Single file typo fix, no complexity",
+  "pre_actions": [],
+  "context_files": [],
+  "confidence": "high"
+}
+```
+
+---
+
+### 2. `delegate_taskmanager`
+
+**When to use**:
+- 4+ files involved
+- Multi-component feature
+- Dependencies between tasks
+- Complex workflow (auth, API, multi-step)
+- User explicitly requests task breakdown
+
+**Patterns**:
+```regex
+/\d+ files/i (where count >= 4)
+/(complex|multi-step|multi-component) (feature|system)/i
+/(auth|authentication) system/i
+/with (dependencies|tests|middleware)/i
+/break.*down|plan.*tasks/i
+```
+
+**File count**: 4+ files
+
+**Pre-actions**:
+- `use_contextscout` (if not already done)
+- `load_standards` (code-quality.md)
+- `load_task_management_context` (task-management/navigation.md)
+
+**Example**:
+```json
+{
+  "routing": "delegate_taskmanager",
+  "reason": "Complex feature spanning 6 files with dependencies",
+  "pre_actions": ["load_standards", "load_task_management_context"],
+  "context_files": [
+    ".opencode/context/core/standards/code-quality.md",
+    ".opencode/context/core/task-management/navigation.md"
+  ],
+  "confidence": "high"
+}
+```
+
+---
+
+### 3. `needs_context_first`
+
+**When to use**:
+- No context discovered yet
+- New domain/technology not in codebase
+- Unclear patterns or standards
+- Implementation needs discovery first
+
+**Patterns**:
+```regex
+/no context (found|available)/i
+/unclear (pattern|standard|approach)/i
+/new (domain|technology|framework)/i
+/need.*discover|find.*patterns/i
+```
+
+**Context files**: Empty or insufficient
+
+**Pre-actions**:
+- `use_contextscout` (mandatory)
+- Wait for context discovery before routing
+
+**Example**:
+```json
+{
+  "routing": "needs_context_first",
+  "reason": "API implementation needs patterns/standards discovery",
+  "pre_actions": ["use_contextscout"],
+  "context_files": [],
+  "confidence": "high"
+}
+```
+
+---
+
+### 4. `execute_existing_task`
+
+**When to use**:
+- Continuing work on existing task
+- Task JSON files exist (.tmp/tasks/{feature}/)
+- User says "continue", "next task", "work on {task}"
+
+**Patterns**:
+```regex
+/continue (working|task|feature)/i
+/next (task|subtask)/i
+/work on (task|subtask)/i
+/resume/i
+```
+
+**Task files**: `.tmp/tasks/{feature}/task.json` exists
+
+**Pre-actions**:
+- `check_task_status` (run task-cli.ts status)
+- `load_task_context` (read task.json + subtask_NN.json)
+- `mark_in_progress` (update status)
+
+**Example**:
+```json
+{
+  "routing": "execute_existing_task",
+  "reason": "Continuing existing auth-system task",
+  "pre_actions": ["check_task_status", "load_task_context", "mark_in_progress"],
+  "context_files": [".tmp/tasks/auth-system/subtask_02.json"],
+  "confidence": "high"
+}
+```
+
+---
+
+### 5. `batch_delegate_coder`
+
+**When to use**:
+- Multiple parallel/isolated tasks
+- Tasks marked `parallel: true` in JSON
+- No dependencies between tasks
+- Can be executed concurrently
+
+**Patterns**:
+```regex
+/parallel tasks/i
+/isolated (tasks|subtasks)/i
+/batch (execute|process)/i
+```
+
+**Task files**: Multiple subtasks with `parallel: true`
+
+**Pre-actions**:
+- `check_parallel_tasks` (run task-cli.ts parallel)
+- `load_task_contexts` (read all parallel subtask JSONs)
+- `mark_all_in_progress`
+
+**Example**:
+```json
+{
+  "routing": "batch_delegate_coder",
+  "reason": "3 parallel subtasks ready (no dependencies)",
+  "pre_actions": ["check_parallel_tasks", "load_task_contexts"],
+  "context_files": [
+    ".tmp/tasks/auth-system/subtask_03.json",
+    ".tmp/tasks/auth-system/subtask_04.json",
+    ".tmp/tasks/auth-system/subtask_05.json"
+  ],
+  "confidence": "high"
+}
+```
+
+---
+
+## Decision Algorithm
+
+### Step 1: Check for existing tasks
+```
+IF .tmp/tasks/{feature}/ exists:
+  → routing = "execute_existing_task"
+  → RETURN
+```
+
+### Step 2: Check context availability
+```
+IF context_files.length == 0 AND task_needs_context:
+  → routing = "needs_context_first"
+  → RETURN
+```
+
+### Step 3: Check complexity
+```
+IF file_count >= 4 OR has_dependencies OR multi_component:
+  → routing = "delegate_taskmanager"
+  → RETURN
+```
+
+### Step 4: Check for parallel tasks
+```
+IF multiple_tasks AND all_parallel:
+  → routing = "batch_delegate_coder"
+  → RETURN
+```
+
+### Step 5: Default to direct execution
+```
+ELSE:
+  → routing = "execute_direct"
+  → RETURN
+```
+
+## Confidence Levels
+
+- **high**: Clear pattern match, unambiguous
+- **medium**: Multiple patterns match, needs user confirmation
+- **low**: Unclear, recommend asking user for clarification
+
+## Edge Cases
+
+### Ambiguous file count
+```
+User: "Update authentication"
+Files: Unknown
+
+→ routing = "needs_context_first"
+→ reason = "File count unknown, need discovery first"
+```
+
+### User override
+```
+User: "Just do it directly, don't delegate"
+
+→ routing = "execute_direct"
+→ reason = "User explicitly requested direct execution"
+→ confidence = "high"
+```
+
+### Missing information
+```
+User: "Implement feature X"
+Context: None
+Files: Unknown
+
+→ routing = "needs_context_first"
+→ pre_actions = ["use_contextscout", "clarify_scope"]
+```
+
+## Output Format
+
+Always return JSON:
+
+```json
+{
+  "phase": "routing",
+  "routing": "execute_direct|delegate_taskmanager|needs_context_first|execute_existing_task|batch_delegate_coder",
+  "reason": "Brief 1-sentence explanation",
+  "pre_actions": ["action1", "action2"],
+  "context_files": ["path1", "path2"],
+  "confidence": "high|medium|low"
+}
+```
+
+## Integration with OpenAgent
+
+OpenAgent calls DelegationController at Stage 1.75:
+
+```javascript
+const routingDecision = await task({
+  subagent_type: "DelegationController",
+  description: "Route decision",
+  prompt: `Phase: routing
+  
+User request: ${userRequest}
+Discovered context: ${contextFiles}
+Files involved: ${fileCount}
+Existing tasks: ${taskFiles}
+
+Determine routing decision.`
+});
+
+// Use routing decision in approval plan
+const approvalPlan = `
+## Proposed Plan
+
+**Routing**: ${routingDecision.routing}
+**Reason**: ${routingDecision.reason}
+
+**Pre-execution actions**:
+${routingDecision.pre_actions.map(a => `- ${a}`).join('\n')}
+
+**Approval needed before proceeding.**
+`;
+```
+
+## Related
+
+- `validation-checks.md` - Phase 2 validation logic
+- `navigation.md` - Overview and integration
+- `.opencode/context/core/workflows/task-delegation.md` - Full delegation process

.opencode/context/core/delegation/validation-checks.md

@@ -0,0 +1,419 @@
+<!-- Context: delegation/validation-checks | Priority: high | Version: 1.0 | Updated: 2026-01-18 -->
+# Validation Checks - Phase 2 Post-Execution Logic
+
+## Purpose
+
+Validate that execution followed correct patterns and task status was properly updated.
+
+**When to use**: Stage 4.5 (after Execute, before Validate)
+
+**Output**: JSON validation report with corrective actions
+
+## Validation Categories
+
+### 1. Task Status Validation
+
+**Check**: Were task statuses properly updated?
+
+**Scenarios**:
+
+#### A. Tasks created but none started
+```
+Symptom: TaskManager created task.json + subtasks, all status="pending"
+Issue: No subtask marked "in_progress"
+Action: Suggest starting first available task
+```
+
+**Detection**:
+```bash
+# Check if all subtasks are pending
+npx ts-node .opencode/context/tasks/scripts/task-cli.ts status {feature}
+# If completed_count=0 and all pending → Issue
+```
+
+**Output**:
+```json
+{
+  "status": "tasks_created_not_started",
+  "issues": ["TaskManager created 5 subtasks but none marked in_progress"],
+  "actions": ["suggest_next_task", "mark_subtask_01_ready"],
+  "severity": "medium"
+}
+```
+
+---
+
+#### B. Task completed but not marked
+```
+Symptom: Work done, files created, but subtask still "in_progress"
+Issue: Status not updated to "completed"
+Action: Mark task complete and suggest next
+```
+
+**Detection**:
+```bash
+# Check deliverables exist
+# Check acceptance_criteria met
+# If all pass but status != "completed" → Issue
+```
+
+**Output**:
+```json
+{
+  "status": "task_completed_not_marked",
+  "issues": ["Subtask_02 deliverables complete but status still in_progress"],
+  "actions": ["mark_subtask_02_completed", "suggest_next_task"],
+  "severity": "medium"
+}
+```
+
+---
+
+#### C. Task started but no TodoWrite update
+```
+Symptom: Subtask marked "in_progress" but no TodoWrite tracking
+Issue: No todo list for tracking progress
+Action: Create todo list from subtask acceptance_criteria
+```
+
+**Detection**:
+```bash
+# Check if TodoRead returns empty
+# Check if subtask has acceptance_criteria
+# If criteria exist but no todos → Issue
+```
+
+**Output**:
+```json
+{
+  "status": "missing_todo_tracking",
+  "issues": ["Subtask in progress but no TodoWrite tracking"],
+  "actions": ["create_todo_from_acceptance_criteria"],
+  "severity": "low"
+}
+```
+
+---
+
+### 2. Context Loading Validation
+
+**Check**: Was required context loaded before execution?
+
+**Scenarios**:
+
+#### A. Code written without standards
+```
+Symptom: Write/Edit tool used for code, but code-quality.md not loaded
+Issue: Code may not follow project standards
+Action: Load standards and review code
+```
+
+**Detection**:
+```
+IF tool_used IN ["write", "edit"]:
+  IF file_type == "code" (*.ts, *.js, *.py, etc.):
+    IF "code-quality.md" NOT IN loaded_context:
+      → Issue
+```
+
+**Output**:
+```json
+{
+  "status": "missing_context",
+  "issues": ["Code written without loading code-quality.md"],
+  "actions": ["load_standards", "review_code_against_standards"],
+  "severity": "high"
+}
+```
+
+---
+
+#### B. Docs written without standards
+```
+Symptom: Write/Edit tool used for docs, but documentation.md not loaded
+Issue: Docs may not follow project tone/structure
+Action: Load standards and review docs
+```
+
+**Detection**:
+```
+IF tool_used IN ["write", "edit"]:
+  IF file_type == "docs" (*.md, README, etc.):
+    IF "documentation.md" NOT IN loaded_context:
+      → Issue
+```
+
+**Output**:
+```json
+{
+  "status": "missing_context",
+  "issues": ["Documentation written without loading documentation.md"],
+  "actions": ["load_doc_standards", "review_docs_against_standards"],
+  "severity": "high"
+}
+```
+
+---
+
+#### C. Delegation without context bundle
+```
+Symptom: Task tool used to delegate, but no context bundle created
+Issue: Subagent won't have necessary context
+Action: Create context bundle and re-delegate
+```
+
+**Detection**:
+```
+IF tool_used == "task":
+  IF delegation_target IN ["CoderAgent", "TaskManager"]:
+    IF context_bundle NOT created:
+      → Issue
+```
+
+**Output**:
+```json
+{
+  "status": "missing_delegation_context",
+  "issues": ["Delegated to CoderAgent without context bundle"],
+  "actions": ["create_context_bundle", "re_delegate_with_context"],
+  "severity": "high"
+}
+```
+
+---
+
+### 3. Delegation Correctness Validation
+
+**Check**: Was the right delegation decision made?
+
+**Scenarios**:
+
+#### A. Should have delegated but didn't
+```
+Symptom: 4+ files modified directly without TaskManager
+Issue: Complex task executed directly
+Action: Suggest breaking down retrospectively
+```
+
+**Detection**:
+```
+IF files_modified >= 4:
+  IF delegation_used == false:
+    → Issue
+```
+
+**Output**:
+```json
+{
+  "status": "should_have_delegated",
+  "issues": ["Modified 6 files directly without TaskManager breakdown"],
+  "actions": ["suggest_retrospective_breakdown", "document_approach"],
+  "severity": "medium"
+}
+```
+
+---
+
+#### B. Delegated unnecessarily
+```
+Symptom: Single file change delegated to TaskManager
+Issue: Overhead for simple task
+Action: Note for future (not critical)
+```
+
+**Detection**:
+```
+IF files_modified <= 2:
+  IF delegation_target == "TaskManager":
+    → Issue (low severity)
+```
+
+**Output**:
+```json
+{
+  "status": "unnecessary_delegation",
+  "issues": ["Single file change delegated to TaskManager"],
+  "actions": ["note_for_future"],
+  "severity": "low"
+}
+```
+
+---
+
+### 4. Execution Pattern Validation
+
+**Check**: Did execution follow expected patterns?
+
+**Scenarios**:
+
+#### A. Parallel tasks executed sequentially
+```
+Symptom: Multiple parallel:true tasks executed one-by-one
+Issue: Missed opportunity for concurrent execution
+Action: Suggest batching next time
+```
+
+**Detection**:
+```bash
+# Check if multiple subtasks have parallel:true
+# Check if they were executed sequentially (timestamps)
+# If sequential → Issue
+```
+
+**Output**:
+```json
+{
+  "status": "missed_parallelization",
+  "issues": ["3 parallel tasks executed sequentially"],
+  "actions": ["suggest_batch_execution_next_time"],
+  "severity": "low"
+}
+```
+
+---
+
+#### B. Dependencies violated
+```
+Symptom: Subtask_03 started before subtask_02 completed
+Issue: Dependency order violated
+Action: Stop and complete dependencies first
+```
+
+**Detection**:
+```bash
+# Read subtask_03.json depends_on
+# Check if all dependencies are completed
+# If not → Issue
+```
+
+**Output**:
+```json
+{
+  "status": "dependency_violation",
+  "issues": ["Subtask_03 started but depends_on subtask_02 not completed"],
+  "actions": ["stop_current_task", "complete_dependencies_first"],
+  "severity": "high"
+}
+```
+
+---
+
+## Validation Algorithm
+
+### Step 1: Check task status updates
+```
+IF task_files exist:
+  FOR each subtask:
+    IF deliverables complete AND status != "completed":
+      → Issue: task_completed_not_marked
+    IF status == "in_progress" AND no TodoWrite:
+      → Issue: missing_todo_tracking
+```
+
+### Step 2: Check context loading
+```
+IF tool_used IN ["write", "edit"]:
+  required_context = get_required_context(file_type)
+  IF required_context NOT IN loaded_context:
+    → Issue: missing_context
+```
+
+### Step 3: Check delegation correctness
+```
+IF files_modified >= 4 AND delegation_used == false:
+  → Issue: should_have_delegated
+
+IF delegation_used:
+  IF context_bundle NOT created:
+    → Issue: missing_delegation_context
+```
+
+### Step 4: Check execution patterns
+```
+IF parallel_tasks exist:
+  IF executed_sequentially:
+    → Issue: missed_parallelization
+
+IF dependencies exist:
+  IF dependency_order violated:
+    → Issue: dependency_violation
+```
+
+## Severity Levels
+
+- **high**: Critical issue, must fix before proceeding
+- **medium**: Important issue, should fix but not blocking
+- **low**: Optimization opportunity, note for future
+
+## Output Format
+
+Always return JSON:
+
+```json
+{
+  "phase": "validation",
+  "status": "ok|tasks_created_not_started|task_completed_not_marked|missing_context|should_have_delegated|dependency_violation",
+  "issues": ["issue1", "issue2"],
+  "actions": ["action1", "action2"],
+  "severity": "low|medium|high"
+}
+```
+
+## Integration with OpenAgent
+
+OpenAgent calls DelegationController at Stage 4.5:
+
+```javascript
+const validationReport = await task({
+  subagent_type: "DelegationController",
+  description: "Validate execution",
+  prompt: `Phase: validation
+
+Execution summary: ${executionSummary}
+Task files: ${taskJsonPaths}
+Delegation used: ${delegationUsed}
+Context loaded: ${contextFiles}
+Files modified: ${filesModified}
+Tools used: ${toolsUsed}
+
+Validate execution was correct.`
+});
+
+// Handle validation issues
+if (validationReport.status !== "ok") {
+  if (validationReport.severity === "high") {
+    // Stop and report
+    console.log("⚠️ Critical issues found:");
+    validationReport.issues.forEach(issue => console.log(`- ${issue}`));
+    console.log("\nRequired actions:");
+    validationReport.actions.forEach(action => console.log(`- ${action}`));
+    // Request approval to fix
+  } else if (validationReport.severity === "medium") {
+    // Report and suggest fix
+    console.log("⚠️ Issues found (non-blocking):");
+    validationReport.issues.forEach(issue => console.log(`- ${issue}`));
+    console.log("\nSuggested actions:");
+    validationReport.actions.forEach(action => console.log(`- ${action}`));
+    // Ask user if they want to fix now
+  } else {
+    // Just note for future
+    console.log("ℹ️ Optimization opportunities:");
+    validationReport.issues.forEach(issue => console.log(`- ${issue}`));
+  }
+}
+```
+
+## Skip Validation Scenarios
+
+Skip validation when:
+- No execution happened (pure read/analysis)
+- User explicitly requested skip
+- Simple conversational response
+- Bash-only operations (no code/docs/tasks)
+
+## Related
+
+- `routing-patterns.md` - Phase 1 routing logic
+- `navigation.md` - Overview and integration
+- `.opencode/context/core/standards/code-quality.md` - Code standards
+- `.opencode/context/core/task-management/navigation.md` - Task management

evals/agents/subagents/core/delegation-controller/README.md

@@ -0,0 +1,162 @@
+# DelegationController Agent Tests
+
+## Overview
+
+Tests for the DelegationController subagent - a fast routing and validation controller for delegation decisions and task status verification.
+
+**Agent**: `delegation-controller`  
+**Category**: `subagents/core`  
+**Version**: 1.0.0
+
+## Agent Purpose
+
+DelegationController provides two-phase decision support:
+
+1. **Phase 1 (Routing)**: Pre-approval routing decisions
+   - Determines execution path (direct, delegate, context-first)
+   - Identifies required pre-actions
+   - Suggests context files to load
+
+2. **Phase 2 (Validation)**: Post-execution validation
+   - Verifies task status updates
+   - Checks context loading compliance
+   - Validates delegation correctness
+   - Identifies execution pattern issues
+
+## Test Structure
+
+```
+tests/
+├── 01-routing-simple.yaml          # Phase 1: Simple direct execution
+├── 02-routing-complex.yaml         # Phase 1: Complex feature delegation
+└── 03-validation-task-status.yaml  # Phase 2: Task status validation
+```
+
+## Test Categories
+
+### Routing Tests (Phase 1)
+
+Test routing decision patterns:
+- ✅ Simple direct execution (1-2 files)
+- ✅ Complex feature delegation (4+ files)
+- 🔲 Needs context first (missing context)
+- 🔲 Execute existing task (task continuation)
+- 🔲 Batch delegate (parallel tasks)
+
+### Validation Tests (Phase 2)
+
+Test validation checks:
+- ✅ Task created but not started
+- 🔲 Task completed but not marked
+- 🔲 Missing context (code without standards)
+- 🔲 Should have delegated (4+ files direct)
+- 🔲 Dependency violation
+
+## Running Tests
+
+### Run all tests
+```bash
+npm run eval:sdk -- --agent=delegation-controller
+```
+
+### Run specific test
+```bash
+npm run eval:sdk -- --test evals/agents/subagents/core/delegation-controller/tests/01-routing-simple.yaml
+```
+
+### Run by category
+```bash
+# Routing tests only
+npm run eval:sdk -- --agent=delegation-controller --pattern="*routing*.yaml"
+
+# Validation tests only
+npm run eval:sdk -- --agent=delegation-controller --pattern="*validation*.yaml"
+```
+
+## Expected Behavior
+
+### Phase 1: Routing Decision
+
+**Input**:
+```
+Phase: routing
+
+User request: {request}
+Discovered context: {context_files}
+Files involved: {count}
+Existing tasks: {task_files}
+```
+
+**Output**:
+```json
+{
+  "phase": "routing",
+  "routing": "execute_direct|delegate_taskmanager|needs_context_first|execute_existing_task|batch_delegate_coder",
+  "reason": "Brief explanation",
+  "pre_actions": ["action1", "action2"],
+  "context_files": ["path1", "path2"],
+  "confidence": "high|medium|low"
+}
+```
+
+### Phase 2: Validation
+
+**Input**:
+```
+Phase: validation
+
+Execution summary: {what_happened}
+Task files: {task_json_paths}
+Delegation used: {yes/no}
+Context loaded: {context_files}
+Files modified: {count}
+Tools used: {tools}
+```
+
+**Output**:
+```json
+{
+  "phase": "validation",
+  "status": "ok|tasks_created_not_started|task_completed_not_marked|missing_context|...",
+  "issues": ["issue1", "issue2"],
+  "actions": ["action1", "action2"],
+  "severity": "low|medium|high"
+}
+```
+
+## Context Files
+
+DelegationController loads context via @ symbol:
+
+- `@navigation` → `.opencode/context/core/delegation/navigation.md` (always)
+- `@routing-patterns` → `.opencode/context/core/delegation/routing-patterns.md` (Phase 1)
+- `@validation-checks` → `.opencode/context/core/delegation/validation-checks.md` (Phase 2)
+
+## Key Principles
+
+1. **Fast decisions**: Pattern-based, minimal reasoning (temp 0.1)
+2. **JSON output**: No markdown, no commentary
+3. **Read-only**: No write/edit/task tools
+4. **Stateless**: Reads current state from files
+5. **Context-driven**: Loads phase-specific context
+
+## Test Coverage Goals
+
+- [ ] All 5 routing patterns tested
+- [ ] All 4 validation check categories tested
+- [ ] Edge cases (ambiguous, missing info)
+- [ ] Confidence levels (high/medium/low)
+- [ ] Severity levels (low/medium/high)
+
+## Notes
+
+- **No approval gates**: Subagent doesn't need approval (calling agent handles that)
+- **No tool violations**: Only uses read, grep, glob, bash (task-cli.ts)
+- **Fast execution**: Should complete in <5 seconds
+- **Deterministic**: Same input → same output (temp 0.1)
+
+## Related
+
+- Agent: `.opencode/agent/subagents/core/delegation-controller.md`
+- Context: `.opencode/context/core/delegation/`
+- Integration: OpenAgent Stage 1.75 (routing) and Stage 4.5 (validation)

evals/agents/subagents/core/delegation-controller/tests/01-routing-simple.yaml

@@ -0,0 +1,57 @@
+id: delegation-controller-routing-simple
+name: "Routing: Simple direct execution"
+description: |
+  Test Phase 1 routing decision for simple single-file change.
+  
+  Validates:
+  - Loads delegation context files
+  - Identifies simple single-file pattern
+  - Returns execute_direct routing decision
+  - Provides high confidence level
+category: developer
+
+prompts:
+  - text: |
+      Phase: routing
+      
+      User request: Fix typo in README.md
+      Discovered context: []
+      Files involved: 1
+      Existing tasks: None
+      
+      Determine routing decision.
+
+approvalStrategy:
+  type: auto-approve
+
+behavior:
+  minToolCalls: 2
+  maxToolCalls: 5
+
+expectedOutput:
+  - type: contains
+    text: '"phase": "routing"'
+  - type: contains
+    text: '"routing": "execute_direct"'
+  - type: contains
+    text: '"confidence": "high"'
+
+expectedViolations:
+  - rule: approval-gate
+    shouldViolate: false
+    severity: error
+
+timeout: 30000
+
+tags:
+  - routing
+  - phase-1
+  - simple
+  - delegation-controller
+  - subagent
+
+metadata:
+  test_type: positive
+  phase: routing
+  complexity: simple
+  expected_routing: execute_direct

evals/agents/subagents/core/delegation-controller/tests/02-routing-complex.yaml

@@ -0,0 +1,59 @@
+id: delegation-controller-routing-complex
+name: "Routing: Complex feature delegation"
+description: |
+  Test Phase 1 routing decision for complex multi-file feature.
+  
+  Validates:
+  - Loads delegation context files
+  - Identifies complex multi-file pattern
+  - Returns delegate_taskmanager routing decision
+  - Suggests appropriate pre-actions
+category: developer
+
+prompts:
+  - text: |
+      Phase: routing
+      
+      User request: Add authentication system with JWT, middleware, and tests
+      Discovered context: [".opencode/context/core/standards/code-quality.md"]
+      Files involved: 6
+      Existing tasks: None
+      
+      Determine routing decision.
+
+approvalStrategy:
+  type: auto-approve
+
+behavior:
+  minToolCalls: 2
+  maxToolCalls: 5
+
+expectedOutput:
+  - type: contains
+    text: '"phase": "routing"'
+  - type: contains
+    text: '"routing": "delegate_taskmanager"'
+  - type: contains
+    text: '"confidence": "high"'
+  - type: contains
+    text: 'load_task_management_context'
+
+expectedViolations:
+  - rule: approval-gate
+    shouldViolate: false
+    severity: error
+
+timeout: 30000
+
+tags:
+  - routing
+  - phase-1
+  - complex
+  - delegation-controller
+  - subagent
+
+metadata:
+  test_type: positive
+  phase: routing
+  complexity: complex
+  expected_routing: delegate_taskmanager

evals/agents/subagents/core/delegation-controller/tests/03-validation-task-status.yaml

@@ -0,0 +1,58 @@
+id: delegation-controller-validation-task-status
+name: "Validation: Task created but not started"
+description: |
+  Test Phase 2 validation detecting tasks created but not marked in_progress.
+  
+  Validates:
+  - Loads validation context files
+  - Detects tasks created but not started
+  - Returns appropriate validation status
+  - Suggests corrective actions
+category: developer
+
+prompts:
+  - text: |
+      Phase: validation
+      
+      Execution summary: TaskManager created 5 subtasks for auth-system
+      Task files: .tmp/tasks/auth-system/task.json, subtask_01.json-05.json
+      Delegation used: yes
+      Context loaded: code-quality.md, task-management/navigation.md
+      Files modified: 0 (planning only)
+      Tools used: task, write
+      
+      Validate execution was correct.
+
+approvalStrategy:
+  type: auto-approve
+
+behavior:
+  minToolCalls: 2
+  maxToolCalls: 5
+
+expectedOutput:
+  - type: contains
+    text: '"phase": "validation"'
+  - type: contains
+    text: '"status":'
+  - type: contains
+    text: '"severity":'
+
+expectedViolations:
+  - rule: approval-gate
+    shouldViolate: false
+    severity: error
+
+timeout: 30000
+
+tags:
+  - validation
+  - phase-2
+  - task-status
+  - delegation-controller
+  - subagent
+
+metadata:
+  test_type: positive
+  phase: validation
+  issue_type: task_status

evals/framework/src/sdk/run-sdk-tests.ts

@@ -345,6 +345,8 @@ async function main() {
       'DocWriter': 'openagent',
       'contextscout': 'openagent',
       'ContextScout': 'openagent',
+      'delegation-controller': 'openagent',
+      'DelegationController': 'openagent',
       
       // System-builder subagents → system-builder
       'agent-generator': 'system-builder',
@@ -456,6 +458,8 @@ async function main() {
       'DocWriter': 'subagents/core/documentation',
       'contextscout': 'subagents/core/contextscout',
       'ContextScout': 'subagents/core/contextscout',
+      'delegation-controller': 'subagents/core/delegation-controller',
+      'DelegationController': 'subagents/core/delegation-controller',
       // System-builder subagents
       'agent-generator': 'subagents/system-builder/agent-generator',
       'AgentGenerator': 'subagents/system-builder/agent-generator',

evals/framework/src/sdk/test-runner.ts

@@ -266,6 +266,8 @@ export class TestRunner {
       'DocWriter': 'subagents/core/documentation.md',
       'contextscout': 'subagents/core/contextscout.md',
       'ContextScout': 'subagents/core/contextscout.md',
+      'delegation-controller': 'subagents/core/delegation-controller.md',
+      'DelegationController': 'subagents/core/delegation-controller.md',
       
       // Subagents - system-builder
       'agent-generator': 'subagents/system-builder/agent-generator.md',

evals/results/latest.json

@@ -1,16 +1,16 @@
 {
   "meta": {
-    "timestamp": "2026-01-17T20:39:20.106Z",
-    "agent": "core/opencoder",
+    "timestamp": "2026-01-18T20:05:38.561Z",
+    "agent": "delegation-controller",
     "model": "opencode/grok-code-fast",
     "framework_version": "0.1.0",
-    "git_commit": "76e875b"
+    "git_commit": "6b5b8f0"
   },
   "summary": {
     "total": 1,
     "passed": 0,
     "failed": 1,
-    "duration_ms": 122016,
+    "duration_ms": 32015,
     "pass_rate": 0
   },
   "by_category": {
@@ -21,15 +21,15 @@
   },
   "tests": [
     {
-      "id": "workflow-test",
+      "id": "delegation-controller-routing-simple",
       "category": "developer",
       "passed": false,
-      "duration_ms": 122016,
-      "events": 81,
+      "duration_ms": 32015,
+      "events": 66,
       "approvals": 0,
       "violations": {
-        "total": 4,
-        "errors": 4,
+        "total": 3,
+        "errors": 3,
         "warnings": 0,
         "details": [
           {
@@ -40,17 +40,12 @@
           {
             "type": "wrong-context-file",
             "severity": "error",
-            "message": "Task type 'delegation' requires context file(s): .opencode/context/core/workflows/delegation.md or workflows/delegation.md or delegation.md. Loaded: /Users/darrenhinde/Documents/GitHub/Claude-agents/.opencode/context/core/standards/code-quality.md, /Users/darrenhinde/Documents/GitHub/Claude-agents/.opencode/context/development/clean-code.md, /Users/darrenhinde/Documents/GitHub/Claude-agents/.opencode/context/core/standards/test-coverage.md"
+            "message": "Task type 'delegation' requires context file(s): .opencode/context/core/workflows/delegation.md or workflows/delegation.md or delegation.md. Loaded: .opencode/context/core/standards/documentation.md"
           },
           {
             "type": "execution-before-read",
             "severity": "error",
             "message": "A modification tool was executed without prior read operations"
-          },
-          {
-            "type": "missing-approval-request",
-            "severity": "error",
-            "message": "Agent did not request approval before executing"
           }
         ]
       }