Orchestration System

> "I detect [research / implementation / investigation / evaluation / fix] intent — [reason]. 
   My approach: [explore → answer / plan → delegate / clarify first / etc.]."

User: "How does authentication work in this app?"

Sisyphus: "I detect research intent — you're asking for understanding, not implementation.
My approach: launch explore to find auth files → synthesize findings → explain."

[Fires explore agent in background]

{
  description: string          // Brief task description
  prompt: string               // Full instructions to agent
  subagent_type: string        // Agent name (oracle, librarian, explore, etc.)
  run_in_background?: boolean  // Async execution (default: false)
  session_id?: string          // Resume existing session
}

call_omo_agent(
  description="Get architectural advice on state management",
  subagent_type="oracle",
  prompt="I need advice on state management architecture. Context: \n- React app with 20+ components\n- Currently using prop drilling\n- Considering Redux vs Context API\n\nWhat do you recommend?"
)

// Launch 3 research tasks in parallel
call_omo_agent(description="Explore auth patterns", subagent_type="explore", run_in_background=true, ...)
call_omo_agent(description="Research OAuth docs", subagent_type="librarian", run_in_background=true, ...)
call_omo_agent(description="Check security best practices", subagent_type="librarian", run_in_background=true, ...)

// Poll results later
background_output(task_id=1)
background_output(task_id=2)
background_output(task_id=3)

{
  description: string           // Brief task description
  prompt: string                // Full instructions
  category?: string             // Task category (visual-engineering, ultrabrain, quick, etc.)
  subagent_type?: string        // Explicit agent (alternative to category)
  load_skills?: string[]        // Skills to inject
  run_in_background?: boolean   // Async execution
  session_id?: string           // Resume session
  command?: string              // Auto-run bash command after
}

task(
  description="Implement responsive navbar",
  category="visual-engineering",
  load_skills=["playwright", "tailwind"],
  prompt="Create a responsive navbar with:\n- Logo on left\n- Nav links center\n- Mobile hamburger menu\n- Smooth transitions\n\nMatch existing design system."
)

task(
  description="Deep refactor of state management",
  subagent_type="hephaestus",
  prompt="GOAL: Refactor state management to use Zustand.\n\nExplore current implementation, migrate incrementally, maintain tests."
)

1. Is there a specialized agent that perfectly matches this request?
   YES → call_omo_agent(subagent_type="...")
   NO → Continue

2. Is there a category that best describes this task?
   YES → task(category="...", load_skills=[...])
   NO → Continue

3. Can I do it myself for the best result, FOR SURE?
   YES → Execute directly
   NO → Default to task(category="unspecified-low" or "unspecified-high")

**Default Bias: DELEGATE. Work yourself only when it's super simple.**

## Task Dependency Graph

| Task | Depends On | Reason |
|------|------------|--------|
| Task 1 | None | Starting point |
| Task 2 | Task 1 | Requires Task 1 output |
| Task 3 | Task 1 | Uses Task 1 foundation |
| Task 4 | Task 2, Task 3 | Integrates both |

## Parallel Execution Graph

Wave 1 (Start immediately):
├── Task 1: Setup database schema (no dependencies)
└── Task 5: Design UI mockups (no dependencies)

Wave 2 (After Wave 1 completes):
├── Task 2: Implement API endpoints (depends: Task 1)
├── Task 3: Write migrations (depends: Task 1)
└── Task 6: Build UI components (depends: Task 5)

Wave 3 (After Wave 2 completes):
└── Task 4: Integration tests (depends: Task 2, Task 3)

Critical Path: Task 1 → Task 2 → Task 4
Estimated Parallel Speedup: 40% faster than sequential

### Task 2: Implement API endpoints

**Delegation Recommendation:**
- Category: `ultrabrain` - Complex business logic, requires deep reasoning
- Skills: [`express-api`, `database-patterns`] - API framework + DB best practices

**Skills Evaluation:**
- INCLUDED `express-api`: Task uses Express, needs routing/middleware patterns
- INCLUDED `database-patterns`: Task involves ORM usage, transaction handling
- OMITTED `playwright`: No UI testing in this task

## TODO List (ADD THESE)

### Wave 1 (Start Immediately)

- [ ] **1. Setup database schema**
  - What: Create tables for users, posts, comments with proper indexes
  - Depends: None
  - Blocks: 2, 3
  - Category: `ultrabrain`
  - Skills: [`database-patterns`]
  - QA: Run `npm run migrate` and verify tables exist

### Wave 2 (After Wave 1)

- [ ] **2. Implement API endpoints**
  - What: Create CRUD routes for /api/users, /api/posts
  - Depends: 1
  - Blocks: 4
  - Category: `ultrabrain`
  - Skills: [`express-api`, `database-patterns`]
  - QA: `npm test -- api.test.ts` passes

function getAtlasPromptSource(model?: string): AtlasPromptSource {
  if (model && isGptModel(model)) return "gpt"
  if (model && isGeminiModel(model)) return "gemini"
  return "default"
}

// Launch 3 tasks in parallel
const explore_id = call_omo_agent(..., run_in_background=true)
const librarian_id = call_omo_agent(..., run_in_background=true)
const oracle_id = call_omo_agent(..., run_in_background=true)

// Continue other work while they run
read("src/auth.ts")
grep("OAuth", ".")

// Collect results
const explore_result = background_output(task_id=explore_id)
const librarian_result = background_output(task_id=librarian_id)
const oracle_result = background_output(task_id=oracle_id)

// Synthesize findings

// Need immediate architectural guidance before proceeding
const advice = call_omo_agent(
  subagent_type="oracle",
  run_in_background=false,  // Block until complete
  prompt="Should I use Redux or Context API?"
)

// Proceed based on advice
if (advice.includes("Redux")) {
  // Install Redux
} else {
  // Use Context API
}

---
name: playwright
description: Playwright browser automation patterns
---

# Playwright Skill

## Common Patterns

[Skill content here]

## Anti-Patterns

[What to avoid]

task(
  category="visual-engineering",
  load_skills=["playwright", "tailwind"],
  prompt="Write E2E test for login flow"
)

if (hasPendingTodos && isAgentIdle) {
  injectContinuationPrompt(
    "You have pending todos. Continue working until ALL are completed."
  )
}

- [ ] Setup database schema
- [ ] Implement API endpoints
- [ ] Write tests

TaskCreate(
  subject="Setup database schema",
  description="Create tables for users, posts, comments",
  blockedBy=[],
  blocks=["task-2", "task-3"],
  metadata={ category: "ultrabrain", skills: ["database-patterns"] }
)

// ❌ BAD
task(category="quick", prompt="Add a console.log statement to line 42")

// ✅ GOOD
edit(file="src/app.ts", oldString="function foo() {", newString="function foo() {\n  console.log('debug');")

// ❌ BAD
// Sisyphus tries to design UI itself

// ✅ GOOD
task(
  category="visual-engineering",
  load_skills=["design-system"],
  prompt="Design responsive card component matching existing patterns"
)

// ❌ BAD (serial, 30s total)
const explore = call_omo_agent(subagent_type="explore", ...)
const librarian = call_omo_agent(subagent_type="librarian", ...)

// ✅ GOOD (parallel, 10s total)
call_omo_agent(subagent_type="explore", run_in_background=true, ...)
call_omo_agent(subagent_type="librarian", run_in_background=true, ...)
background_output(task_id=1)
background_output(task_id=2)

// ❌ BAD
task(category="visual-engineering", prompt="Write Playwright test")

// ✅ GOOD
task(
  category="visual-engineering",
  load_skills=["playwright", "testing-patterns"],
  prompt="Write Playwright test"
)