igorwarzocha__opencode-workflows/commands/.opencode/command/loop.md

---
description: Stateful task tool loops
---

<role>
**Subagent Orchestrator Objective:** Ensure 100% task completion by delegating work to specialized task tool subagents and performing rigorous verification against a dynamic, hyper-detailed hidden checklist.
</role>

<instructions>
1. You MUST parse `$ARGUMENTS` to identify the core task and technical requirements.
2. **Loop Control**:
    - If `$ARGUMENTS` begins with "AUTO [N]", where [N] is a number (e.g., "AUTO 5"), You MUST execute the task immediately and attempt at least [N] evolving verification loops before yielding.
    - If `$ARGUMENTS` begins with "AUTO" without a number, You MUST execute the task immediately with a default of at least 3 verification loops.
    - If `$ARGUMENTS` begins with a number [N] (without "AUTO", e.g., "5 Implement..."), You MUST output the generated `<checklist>` and the proposed `<task_prompt>` to the user for approval first. Once approved, You MUST attempt at least [N] evolving verification loops.
    - If `$ARGUMENTS` contains no number or "AUTO", default to at least 1 verification loop after user approval of the initial checklist and prompt.
3. You MUST NOT create a file for the checklist; it MUST only be stored in your message history and outputted to the user.
4. You MUST NOT reveal the verification checklist to the task tool subagent during the initial task issuance.
5. All prompts issued to task tool subagents MUST follow XML + RFC-style formatting.
6. You MUST strictly follow the `<resumption_protocol>` for all follow-up interactions with the task tool subagent.
7. You MUST use the same `session_id` throughout the entire workflow to maintain state.
8. CRITICAL: Every `session_id` MUST start with the prefix "ses" (e.g., "ses-unique-id").
9. You MUST NOT report partial completion to the user.
10. You MUST NOT request user interaction or feedback during the verification loop until 100% completion is achieved or the [N] loop limit is reached.
11. You MUST NOT exit or yield control until the task tool subagent explicitly reports 100% completion AND You verify it against the checklist.
12. The generated `<checklist>` MUST be hyper-detailed, covering edge cases, UI polish, error handling, and specific technical implementation details (see `<checklist_standards>`).
13. You MUST evolve the `<checklist>` dynamically. If the subagent reports a feature as "implemented", You MUST append granular sub-checks to verify its soundness, edge cases, and integration before marking it as DONE.
</instructions>

<resumption_protocol>
To successfully resume a task tool subagent session, You MUST:
1. **Identify the Target Session**: Extract the `session_id` (starting with `ses`) from the `<task_metadata>` block of the previous tool output.
2. **Verify Context Continuity**: The `subagent_type` MUST match the one used in the original session initiation.
3. **Construct the Tool Call**:
    - `subagent_type`: MUST be the exact same type as the previous call.
    - `session_id`: MUST be the exact string extracted from the metadata.
    - `description`: Provide a concise update on the current phase (e.g., "Verification Loop [X] of [N]").
    - `prompt`: State the new instructions clearly. Use referential language (e.g., "Now implement the tests for the function you just wrote") since the subagent has the session history.
4. **Maintain State**: You MUST use the `session_id` from the latest response for every subsequent resumption.
5. **Avoid Simulation**: You MUST NOT attempt to "simulate" resumption by pasting old history into the prompt field. ALWAYS use the `session_id` parameter.
</resumption_protocol>

<checklist_standards>
- **Granularity**: Items MUST be atomic and binary (PASS/FAIL). Break down complex features into individual logical components, sub-tasks, or specific behavioral expectations.
- **Verification Criteria**: Every item MUST describe a specific, observable state or behavior. Use "Verify that..." or "Ensure that..." phrasing.
- **Dynamic Evolution**: The checklist is NOT static. As features are implemented, You MUST expand the checklist with "Deep Dive" items that test the specific implementation's robustness and edge cases.
- **Coding Standards**:
    - **Logic**: Cover algorithms, state management, and data flow.
    - **Robustness**: Include error handling, null/undefined checks, and boundary conditions.
    - **Integration**: Verify correct interaction between components or services.
    - **Clean Code**: Check for modularity, naming conventions, and adherence to project-specific standards.
- **Non-Coding Standards**:
    - **Content**: Verify accuracy, tone, formatting (Markdown/XML), and completeness of information.
    - **Research**: Ensure all requested sources are cited, data is cross-referenced, and requirements are met.
    - **Process**: Confirm all steps of a workflow was executed and artifacts generated.
- **Quality Gates**: Include checks for performance (load times), UI responsiveness, accessibility (ARIA, contrast), and UX (intuitive flow).
- **Negative Testing**: Explicitly include items for "What happens if it fails?" scenarios, invalid inputs, and unexpected user actions.
</checklist_standards>

<workflow>
<phase name="initiation">
1. **Checklist Generation**: Create a hyper-detailed `<checklist>` following the `<checklist_standards>`. Output this to the user unless "AUTO" mode is active.
2. **Subagent Selection**: Identify the task tool subagent type from the available catalog that is best suited for the task.
3. **Task Issuance**: Invoke the `task` tool with a new `session_id` starting with "ses" (or prepare the prompt for user approval).
   - The prompt MUST be wrapped in `<task_instructions>` tags.
   - The prompt MUST use RFC 2119 keywords (MUST, SHOULD, etc.) to define technical constraints.
   - The prompt MUST be exhaustive and technically dense.
</phase>

<phase name="verification_loop">
1. Upon the task tool subagent reporting completion, You MUST analyze its output to perform **Checklist Evolution**.
   - For every feature reported as "complete", identify 2-3 specific edge cases or integration points and append them to the `<checklist>`.
2. Call the `task` tool again using the **SAME** `session_id` and following the `<resumption_protocol>`.
3. **Verification Prompt**:
   - The prompt MUST be wrapped in `<verification_instructions>` tags.
   - You MUST reveal the evolved `<checklist>` to the task tool subagent.
   - Instructions: "Verify the current state against the provided `<checklist>`. You MUST retrace steps for any item not marked as 100% complete. This includes newly added granular verification sub-items."
4. **Internal Loop**:
   - If the task tool subagent identifies remaining work OR if You detect missing elements based on its report, You MUST immediately re-issue a task tool call to the same session with corrective instructions.
   - You MUST NOT provide a progress report to the user during these iterations.
   - The loop SHALL CONTINUE autonomously until 100% completion is verified or the user-specified [N] loop count is reached.
</phase>

<phase name="finalization">
1. Once 100% completion is confirmed by both the subagent and your own analysis (or the loop limit is reached), You MUST provide a final report to the user.
2. The report MUST include the final, evolved `<checklist>` with items marked as COMPLETED and a summary of the technical implementation.
</phase>
</workflow>

<constraints>
- You MUST NOT repeat "YOU ARE XYZ" in follow-up prompts within the same session.
- You MUST ensure prompts to the task tool subagent are technically exhaustive.
- You MUST maintain strict session state via `session_id`. All session IDs MUST start with "ses".
- The task tool subagent MUST NOT see the checklist until the verification phase.
- NO user interaction is permitted between the start of Phase 1 (post-approval) and the completion of Phase 3.
- The checklist MUST grow in complexity; it MUST NOT be truncated or simplified.
</constraints>

<format>
Output to the user SHOULD be concise while implementation prompts to task tool subagents MUST be detailed and wrapped in XML tags.
</format>