Rules for ALL agents

Core Principles:

Accuracy Over Speed: If you are not sure about file content or codebase structure pertaining to the user’s request, use your tools (read_file, search_files, list_files) to gather the relevant information. DO NOT GUESS or make up an answer. Verify information before acting.
Plan and Reflect: You MUST plan extensively before each significant action or function call, and reflect thoroughly on the outcomes of previous function calls. DO NOT rely solely on function calls for the entire process; thoughtful planning and reflection are crucial for insightful problem-solving.
Context Management:
- Be mindful of the context window. Prefer reading specific sections of files over entire large files.
- Proactive Summarization: Regularly summarize key information, progress, and context from logs and detailed documents into higher-level status files (e.g., Conductor summarizes Performer logs into task sheet notes; Score summarizes Conductor reports into project status notes). This helps keep essential information readily available without rereading large files.
- Check context usage conceptually or via /check-context command (if user-initiated). If approaching limits (e.g., 80%), prioritize summarization and prepare for potential handoff if essential.

Communication and Delegation:

Automation Level Check: Before delegating (new_task) or initiating communication using another agent's user command, you MUST verify the current automation level specified in symphony-[project-slug]/core/symphony-core.md permits this action. Follow the automation level guidelines strictly.
Delegation Logging: Before delegating to another agent via new_task, update the relevant team log (symphony-[project-slug]/communication/[goal-id]/[goal-id]-team-log.md or symphony-[project-slug]/communication/agent-interactions.md if goal-specific log doesn't exist). For each delegation include:
```
----Begin Update----
# Goal: [Goal-ID or N/A]
# Task: [Task-ID or N/A] - [Brief Task Name]
Description: [brief description of delegated task]
Assigned to: [Agent-Slug]
Communicated on: [date and time]
----End Update----
```
Common Commands: Standard commands like /delegate-to, /request-review, /escalate should be used consistently as defined in each agent's command list, always respecting the current automation level. Delegation typically uses new_task internally, while /delegate-to might be reserved for specific user-like interactions when automation is high. /escalate always targets a higher coordinating role (Conductor -> Score, Score -> Composer).

Standard User Commands & Procedures:

Agents should recognize standard commands defined in their respective 03-user-commands.md files.
/continue Command Procedure: When an agent receives the /continue command, it MUST follow the standard handoff procedure:
1. Identify its own agent slug/type and current context (Goal/Task ID, mode).
2. Generate a comprehensive handoff markdown document in the symphony-[project-slug]/handoffs/ directory, following naming conventions (DDMMYYYYHHHH_[agent-slug]_[brief-topic].md). This document must summarize the current state, progress, issues, relevant code snippets (read_file), file references, and the objective for the next agent. Use write_to_file to create it and read_file to verify.
3. Check the current automation level in symphony-core.md using read_file.
4. If automation allows, delegate the task via new_task to another agent of the same type. The new_task message must state it's a continuation, reference the handoff document path, and specify the objective. Log the delegation using append_to_file append to agent-interactions.md.
5. If automation does not allow delegation, inform the user that the handoff document is created but the new_task delegation requires manual initiation.
6. Log all tool calls with rationale as per standard procedure.

File System Usage:

Reserved Directory: The symphony-[project-slug]/ folder structure is reserved EXCLUSIVELY for the following file types used by Symphony agents:
```
Markdown - .md
Text - .txt
```
No other file types (e.g., source code, binaries, general images) should be stored directly within this structure unless explicitly part of a required artifact (like a Mermaid diagram within a .md file). Source code belongs in the project's main directories, tests in tests/, etc.
Log Files: All log files (work logs, team logs, communication logs) MUST be updated using an append-only approach. DO NOT delete or overwrite previous entries. Always timestamp new entries.
Structured Data: Where appropriate (e.g., status files, registries), use structured data formats within Markdown files (like consistent key-value pairs, tables, or embedded JSON/YAML-like blocks) to facilitate easier parsing and targeted updates using apply_diff or careful write_to_file.
Verification: After critical file operations (write_to_file, apply_diff), consider using read_file on the relevant section or checking file metadata to verify the change was successful, especially if the change affects system state.
Visual Documentation: Where instructed (e.g., for architecture, plans, flows), generate diagrams using Mermaid syntax within Markdown files. Ensure diagrams are kept up-to-date with the state they represent.

Error Handling:

Tool Failures: If a tool like write_to_file or apply_diff fails, log the error and attempt the operation again using a safer method (e.g., switch from apply_diff to write_to_file for the whole file). If it still fails, escalate the issue.
Command Failures: If a command via execute_command fails:
1. Analyze the error output.
2. If the cause is clear (e.g., syntax error, missing dependency), attempt to fix it and retry the command once.
3. If the cause is unclear or the retry fails, log the command, the error, and escalate the issue to the appropriate role (e.g., Performer -> Conductor).
Conflicting Information: If you detect conflicting information between different state files, prioritize the source of truth defined by the system (e.g., symphony-core.md for automation levels, Conductor's task sheet for task status). Log the discrepancy and escalate if it impacts critical operations.