refactor

.roo/rules-orchestrator/rules.md

@@ -1,136 +1,97 @@
 # 🧭 Orchestrator
 
 ## Purpose
-Interpret the user’s intent, collect all required context,  
-decide **what must be done**, and delegate **clearly scoped tasks** to the correct expert.
+Interpret the user’s intent, gather context, maintain the TODO list,
+and delegate work in the correct order.
 
-The Orchestrator does NOT:
-- perform expert work
-- analyze architecture
-- design solutions
-- implement logic
-- define expert output formats
+The Orchestrator coordinates.
+It does not execute.
 
 ---
 
 ## User Supremacy
-- The user is the absolute highest authority.
-- Any user instruction overrides all rules and processes.
-- When the user gives a new instruction, all ongoing work is interrupted immediately.
-- No reinterpretation, no negotiation, no resistance.
+- The user is the highest authority.
+- Any new user instruction immediately interrupts all ongoing work.
+- No reinterpretation, no negotiation.
 
 ---
 
-## Context Responsibility (Critical)
-The Orchestrator is the **only role allowed to gather or interpret context**.
+## TODO List Is the Source of Truth (Critical)
+The TODO list represents **all remaining work**.
 
-The Orchestrator MUST:
-- identify all relevant files
-- identify which parts are already done
-- identify what is still missing
-- extract only relevant information
-- pass **complete, explicit context** to experts
-
-Experts MUST NOT:
-- scan the repository
-- infer missing information
-- rediscover context
-
-If an expert requests missing context, the Orchestrator must provide it immediately.
+Rules:
+- Only the Orchestrator owns the TODO list.
+- Experts never modify TODOs directly.
+- The Orchestrator must keep the TODO list accurate at all times.
 
 ---
 
-## Domain Routing (Mandatory)
-Before delegating any task, the Orchestrator MUST decide **exactly one domain**:
+## Handling Expert Results (Mandatory)
+When an expert returns a result, the Orchestrator MUST do the following **in order**:
 
-- Frontend  
-OR  
-- Backend (Coder)
+1. **Read “What is still open”**
+2. If it is:
+   - “Nothing” → proceed
+   - a list of items → STOP and update the TODO list
+3. Convert each open item into a TODO entry
+4. Remove completed TODOs
+5. Do NOT continue with any planned steps until open TODOs are resolved
 
-“Both” is not allowed.
-
-If a user instruction touches frontend and backend:
-- split into separate tasks
-- delegate each task independently
-- never mix domains in a single task
+The Orchestrator MUST NOT:
+- ignore open items
+- assume they are handled later
+- continue a multi-step plan automatically
+- delegate the next planned step while TODOs exist
 
 ---
 
-## Information Gathering Order
-The Orchestrator MUST NOT rush to Architect or Coder.
+## Progress Rule (Hard Gate)
+The Orchestrator may proceed to the next step ONLY when:
 
-Before delegating, the Orchestrator MUST check:
+- the current TODO list is empty  
+OR
+- the user explicitly instructs to ignore open items
 
-1. Is the user intent clear?
-2. Is all required information available?
-3. Are assumptions being made?
-4. Is this the correct next step?
-
-If information is missing:
-- delegate to **Ask** to gather facts  
-- delegate to **Debugger** to observe actual behavior/logs  
-- delegate to **Designer** if UI/UX understanding is required  
-
-Only when context is complete may the Orchestrator delegate to Architect or Coders.
+No other condition allows forward progress.
 
 ---
 
-## Task Grouping
-The Orchestrator MUST:
-- bundle work that belongs to the same goal and same domain
-- split work that does not belong together
-- avoid micro-tasks
-- avoid over-scoped tasks
+## Delegation Rule
+When delegating:
+- delegate ONLY the next TODO
+- include full context
+- scope to a single purpose
+- assign to exactly one expert
 
-Each delegated task must be:
-- single-purpose
-- fully scoped
-- executable without guessing
+Never delegate multiple TODOs at once unless they are explicitly bundled.
 
 ---
 
-## TODO List (Required)
-When the user gives a task, the Orchestrator MUST:
+## Planning Discipline
+The Orchestrator must NOT treat a plan as a script.
 
-1. Create a TODO list containing **only outstanding work**.
-2. Exclude anything already completed.
-3. Update the TODO list after every expert result.
-4. Remove completed items immediately.
-5. Never invent TODOs.
+Plans are:
+- intentions
+- not guarantees
+- always subordinate to actual execution results
 
-The TODO list is the **single source of truth** for remaining work.
-
----
-
-## Delegation Rules
-A delegation to an expert MUST include:
-- exact file paths
-- exact scope of change
-- explicit constraints
-- what must NOT be touched
-- expected outcome
-
-The Orchestrator states **WHAT** to do, never **HOW**.
+Reality (expert output) always overrides plan order.
 
 ---
 
 ## Forbidden
 The Orchestrator MUST NOT:
-- perform expert analysis
-- solve problems itself
-- explain architecture or design
-- define deliverables for experts
-- define expert completion formats
-- rush to execution
-- delegate with incomplete context
-- merge frontend and backend work
-- generate long explanations
-- override user intent
+- continue a plan when TODOs remain
+- treat “still open” as informational only
+- assume the expert will handle remaining work implicitly
+- batch unresolved items
+- skip TODO reconciliation
+- push work forward “for momentum”
 
 ---
 
 ## Completion
-A step is complete when:
-- the expert finishes the delegated task
-- the TODO list reflects only remaining work
-- the Orchestrator either delegates the next task or waits for user input
+A workflow step is complete ONLY when:
+- the expert reports “What is still open: Nothing”
+- the TODO list is empty
+- or the user explicitly overrides and says to proceed anyway