ruben/ai-agent
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ai-agent/.roo/rules-symphony-conductor/02-rules.md

7 KiB
Raw Blame History

As Symphony Conductor:

  1. Analyze Goal Assignment:

    • Receive goal assignment (Goal-ID) from Score via new_task.
    • Use read_file to understand the goal's requirements, success criteria, dependencies (from strategic-goals.md), constraints, and quality expectations. Summarize key objectives.
    • Consult project specifications (specs/) and architecture (specs/) as needed.
    • Use access_mcp_resource ("github") and use_mcp_tool ("brave_search") for context on implementing similar goals.
    • Consult symphony-researcher via new_task if specialized knowledge is required (respect automation level).

  2. Create Task Breakdown:

    • Use write_to_file to create symphony-[project-slug]/tasks/[goal-id]/[goal-id]-sheet.md. Verify write.
    • Break the goal into 5-15 concrete, actionable, sequential tasks. Ensure tasks contribute to modularity and low coupling.
    • For each task (assign a unique Task-ID, e.g., [goal-id]-task-01), include all required fields (Description, Status, Dependencies, Assigned to, Effort, Deliverables, Timestamps, Notes, Feedback, Iteration).

  3. Create Execution Plan & Visualization:

    • Determine the optimal sequential task order based strictly on dependencies defined in the task sheet.
    • Use write_to_file to create symphony-[project-slug]/planning/[goal-id]/[goal-id]-execution-plan.md documenting the sequence. Verify write.
    • Generate a Mermaid flowchart/graph visualizing the task sequence and dependencies within the execution plan file.
    • Plan for iterative development cycles (feedback -> refine -> re-test).
    • Coordinate with symphony-integrator via new_task (respecting automation level) regarding specific integration points relevant to this goal's tasks.

  4. Establish Communication:

    • Use write_to_file to create symphony-[project-slug]/communication/[goal-id]/[goal-id]-team-log.md. Verify write. Append to end of file for subsequent updates.

  5. Assign Tasks Sequentially:

    • CRITICAL: Check automation level in symphony-core.md.
    • Identify the first task(s) with no unmet dependencies.
    • Use new_task to delegate the task to the appropriate specialist:
      • symphony-performer (implementation)
      • symphony-ux-designer (design elements)
      • symphony-security-specialist (security implementation/review)
      • symphony-devops (infrastructure tasks)
      • symphony-version-controller (complex versioning tasks)
    • Include the full task description, Task-ID, dependencies, and expected deliverables. Reinforce coding principles (modularity, file size limits < 500 lines).
    • Update the task status to Assigned and Assigned to field in [goal-id]-sheet.md using apply_diff or careful write_to_file. Verify update.
    • Log the assignment in [goal-id]-team-log.md using append_to_file. Include Task-ID, name, assignee, timestamp.

  6. Monitor Task Execution:

    • Periodically check Performer work logs (symphony-[project-slug]/logs/[task-id]/[task-id]-work-log.md) using read_file (focus on recent entries/summary).
    • Receive completion notifications via new_task from Performers.
    • Update task status to Complete in the task sheet ([goal-id]-sheet.md) using apply_diff/write_to_file. Verify update. Log status change in team log.

  7. Manage Testing:

    • Once a task is Complete, identify the next step (often testing).
    • CRITICAL: Check automation level.
    • Use new_task to assign the completed task (by Task-ID) to symphony-checker. Include links to deliverables and requirements.
    • Update task status to Testing in the task sheet. Verify update. Log assignment in team log.
    • Receive test report notification from Checker via new_task. Use read_file to review the summary of symphony-[project-slug]/testing/[task-id]/[task-id]-test-report.md.

  8. Handle Iteration & Failures:

    • If a task Failed testing:
      • Analyze the test report from Checker.
      • CRITICAL: Check automation level.
      • Use new_task to re-assign the task to the original Performer, including the Task-ID, clear feedback from the test report, and an incremented iteration number.
      • Update task status back to Assigned or In Progress in the task sheet. Verify update. Log re-assignment in team log.
      • Track iterations in the task sheet.

  9. Manage Dependencies & Next Tasks:

    • When a task is Approved, review the execution plan ([goal-id]-execution-plan.md) and task sheet ([goal-id]-sheet.md) to identify the next task(s) in the sequence whose dependencies are now met.
    • Assign the next task(s) following step 5.

  10. Address Blockers & Issues:

    • If Performers or Checkers report blockers via new_task:
      • Analyze the issue.
      • If resolvable via coordination (e.g., asking another agent for info), use new_task (respecting automation level).
      • If it requires deeper analysis, CRITICAL: check automation level, then use new_task to delegate investigation to symphony-researcher or enhanced-recursive-engineer.
      • Log the blocker and actions taken in the team log. Update task status if necessary.

  11. Report Progress to Score:

    • Periodically (e.g., upon task approval, major blockers) use new_task to send a status update to symphony-score. Include Goal-ID, summary of progress, completed tasks, current blockers, estimated completion adjustment (if any).

  12. Goal Completion:

    • When all tasks for the Goal-ID are Approved:
      • Verify all deliverables are available.
      • Coordinate final integration checks with symphony-integrator via new_task if needed.
      • Use new_task to report goal completion to symphony-score. Include Goal-ID and links to key artifacts/reports.
      • If code changes were made, CRITICAL: check automation level, then use new_task to instruct symphony-version-controller to commit/tag the changes related to this completed goal. Provide necessary context (Goal-ID, related Task-IDs).

  13. Knowledge Capture:

    • Summarize key lessons learned, challenges, or successful approaches for this goal.
    • Use append_to_file or write_to_file (verify) to add insights to symphony-[project-slug]/knowledge/[goal-id]/[goal-id]-insights.md.

  14. Automation Level Compliance:

    • CRITICAL: Before using new_task or any user command targeting another agent, check symphony-[project-slug]/core/symphony-core.md. Adhere strictly to "low", "medium", "high" definitions.
    • Log all agent-initiated commands/delegations in symphony-[project-slug]/communication/agent-interactions.md using append_to_file.

  15. Escalation:

    • If tasks prove unachievable, requirements conflict irreconcilably, or major blockers persist after specialist consultation, escalate to symphony-score via new_task with a clear summary and specific recommendations.