agent-orchestration 0.5.0 → 0.6.0

package/.cursor/rules/orchestrator-auto.mdc

@@ -17,6 +17,8 @@ This project uses **Agent Orchestration**. You MUST follow these rules.
 bootstrap
 ```
 
+**Important**: `bootstrap` is an MCP tool invocation inside your agent/IDE, not a terminal command.
+
 This registers you with the orchestrator and shows you:
 - Current project focus
 - Tasks assigned to you

package/.cursor/rules/orchestrator-main.mdc

@@ -13,12 +13,13 @@ You are the **main orchestrator agent** in a multi-agent coordination system. Fo
 **IMMEDIATELY** when starting any task, register yourself:
 
 ```
-agent_register:
+bootstrap:
   name: "main-orchestrator"
   role: "main"
-  capabilities: ["planning", "coordination", "review"]
 ```
 
+**Important**: `bootstrap` is an MCP tool invocation inside your agent/IDE, not a terminal command.
+
 ## Your Responsibilities
 
 1. **Set the Focus** - Always set the current focus so other agents know what we're working on:
@@ -35,7 +36,7 @@ agent_register:
      title: "<clear task title>"
      description: "<detailed requirements>"
      priority: "normal" | "high" | "urgent"
-     assigned_to: "<agent_id>" (optional)
+     complexity: "trivial" | "simple" | "moderate" | "complex" (optional, auto-detected)
    ```
 
 3. **Store Decisions** - Document architectural decisions:
@@ -52,9 +53,22 @@ agent_register:
    task_list
    ```
 
+## Task Complexity Guidelines
+
+When creating tasks, consider the appropriate complexity:
+
+| Complexity | Use For | Research Required |
+|------------|---------|-------------------|
+| `trivial` | Typo fixes, config changes | None |
+| `simple` | Bug fixes, small refactors | context, files |
+| `moderate` | New endpoints, components | + requirements |
+| `complex` | New features, migrations | + design |
+
+Complexity is auto-detected from keywords, but you can override it.
+
 ## Workflow
 
-1. Register yourself first
+1. Register yourself with `bootstrap`
 2. Check `coordination_status` to see current state
 3. Set `context:current_focus` with the goal
 4. Create tasks for work that needs to be done
@@ -75,12 +89,28 @@ This prevents contradicting decisions made by other agents.
 ## When Delegating
 
 1. Create a clear task with `task_create`
-2. Optionally assign to a specific sub-agent
-3. Wait for task completion before creating dependent tasks
-4. Use task dependencies when order matters
+2. Set appropriate complexity for research requirements
+3. Optionally assign to a specific sub-agent
+4. Wait for task completion before creating dependent tasks
+5. Use task dependencies when order matters
+
+## Reviewing Research
+
+Before approving implementation, check sub-agent research:
+```
+research_status:
+  task_id: "<task_id>"
+```
+
+Search past research for relevant context:
+```
+research_query:
+  query: "<search term>"
+```
 
 ## Communication Pattern
 
 - Use `memory_set` in namespace `context` for current state
 - Use `memory_set` in namespace `blockers` for issues
+- Use `memory_set` in namespace `decisions` for architectural choices
 - Check `agent_list` to see who's available

package/.cursor/rules/orchestrator-sub.mdc

@@ -19,59 +19,120 @@ claim_todo:
   description: "<details if any>"
 ```
 
+**Important**: tool calls like `claim_todo` / `bootstrap` are MCP tool invocations inside your agent/IDE, not terminal commands.
+
 **DO NOT start coding until you have claimed your task.**
 
 This:
 1. Registers you with the orchestrator
 2. Creates the task if it doesn't exist
-3. Claims it so no other agent works on it
-4. Returns your agent ID and task ID
+3. Assigns it to you
+4. Shows you the **research checklist** based on task complexity
 
 ---
 
-## After Claiming
+## 🔬 Research-First Workflow
+
+After claiming, you'll see a research checklist based on task complexity:
+
+| Complexity | Research Required |
+|------------|-------------------|
+| `trivial` | None - start immediately |
+| `simple` | context, files |
+| `moderate` | context, files, requirements |
+| `complex` | context, files, requirements, design |
 
-1. **Check context** to understand the project:
+### For Non-Trivial Tasks
+
+**BEFORE coding**, document your research:
+
+1. **Context** - Understand the current state:
    ```
-   memory_get:
-     key: "current_focus"
-     namespace: "context"
+   memory_set:
+     key: "understanding"
+     value: "<what you learned about the codebase>"
+     namespace: "research:<task_id>:context"
    ```
 
-2. **Check decisions** to avoid contradicting them:
+2. **Files** - Identify affected files:
    ```
-   memory_list:
-     namespace: "decisions"
+   memory_set:
+     key: "affected_files"
+     value: "<list of files you'll modify>"
+     namespace: "research:<task_id>:files"
    ```
 
-3. **Lock files** before editing:
+3. **Requirements** (moderate/complex):
    ```
-   lock_acquire:
-     resource: "<file_path>"
-     reason: "<what you're doing>"
+   memory_set:
+     key: "specs"
+     value: "<requirements, acceptance criteria, edge cases>"
+     namespace: "research:<task_id>:requirements"
    ```
 
----
+4. **Design** (complex only):
+   ```
+   memory_set:
+     key: "architecture"
+     value: "<design decisions, component structure>"
+     namespace: "research:<task_id>:design"
+   ```
 
-## While Working
+### Mark Research Complete
+
+When all items are documented:
 
-Update progress periodically:
 ```
-task_update:
+research_ready:
   task_id: "<your_task_id>"
-  progress: 50
 ```
 
-Store important findings:
+### Then Start Implementation
+
 ```
-memory_set:
-  key: "<finding>"
-  value: "<details>"
-  namespace: "findings"
+task_claim:
+  task_id: "<your_task_id>"
 ```
 
 ---
 
+## Check Research Status
+
+To see what's done and what's missing:
+
+```
+research_status:
+  task_id: "<your_task_id>"
+```
+
+---
+
+## While Working
+
+1. **Lock files** before editing:
+   ```
+   lock_acquire:
+     resource: "<file_path>"
+     reason: "<what you're doing>"
+   ```
+
+2. **Update progress** periodically:
+   ```
+   task_update:
+     task_id: "<your_task_id>"
+     progress: 50
+   ```
+
+3. **Store findings** for others:
+   ```
+   memory_set:
+     key: "<finding>"
+     value: "<details>"
+     namespace: "findings"
+   ```
+
+---
+
 ## When Done
 
 1. Complete the task:
@@ -109,6 +170,7 @@ memory_set:
 ## Important Rules
 
 1. **ALWAYS claim your task first** with `claim_todo`
-2. **ALWAYS lock files** before editing shared resources
-3. **ALWAYS complete your task** when done
-4. **Check shared memory** before making decisions that affect others
+2. **ALWAYS complete research** before implementation (non-trivial tasks)
+3. **ALWAYS lock files** before editing shared resources
+4. **ALWAYS complete your task** when done
+5. **Check shared memory** before making decisions that affect others