EPCC Workflow - with Task-List workflow integration

epcc.mdc

# Protocol: Integrated EPCC Workflow (with Task List Management)

When a user presents a significant problem, a new feature request, or a complex task, guide them and yourself (the AI) through the following integrated EPCC workflow. This workflow combines high-level strategic planning (EPCC) with detailed task management using established protocols.

## Integrated EPCC Workflow Visualized

```mermaid
graph TD
    A[Start: User Problem/Feature Request] --> B{EXPLORE Phase};
    B -- "User provides context" --> B1["AI: Read Context (NO code)"];
    B1 --> B1_Note["(Optional: Use Subagents for complexity)"];
    B1_Note --> B1;
    B1 -- "Context Gathered" --> C{PLAN Phase};
    C -- "User requests plan" --> C1["AI: 'Think...' to Develop Plan"];
    C1 -- "Plan formulated" --> C2["AI: Document Overall Plan Approach"];
    C2 --> C2_Decision{Does this plan require detailed task breakdown or a new feature task list?};
    C2_Decision -- "Yes" --> C2_InvokeTaskCreate["Invoke 'Feature & Task Definition Protocol' (...) -> Create/Update Task List"];
    C2_InvokeTaskCreate -- "Task List Ready" --> C3[User Reviews Overall Plan & Detailed Task List];
    C2_Decision -- "No" --> C3;
    C3 -- "Plan NOT OK" --> B;
    C3 -- "Plan OK" --> D{CODE Phase};
    D -- "User approves & requests coding" --> D1["AI: Implement Solution"];
    D1 -- "Iteratively, as tasks are worked on" --> D1_InvokeTaskExecute["Invoke 'Task Execution & Update Protocol' (...) for each task"];
    D1_InvokeTaskExecute -- "Individual task updated" --> D1;
    D1 -- "Overall Code Implementation Complete" --> E{COMMIT & DOCUMENT Phase};
    E -- "User confirms code" --> E1["AI: Commit Changes"];
    E1 -- "(If applicable)" --> E2["AI: Create Pull Request"];
    E2 --> E3["AI: Final Documentation Updates"];
    E3 -- "Update Task List" --> E3_InvokeTaskExecuteFinal["Invoke 'Task Execution & Update Protocol' (...) for final task list wrap-up"];
    E3_InvokeTaskExecuteFinal -- "Task List Finalized" --> E3_UpdateProjectDocs["AI: Update general Project Docs (READMEs, Changelogs, etc.)"];
    E3_UpdateProjectDocs -- "Project Docs Updated" --> F[End: EPCC Cycle Complete];
```

## AI Instructions for Each Phase:

### A. Start: User Presents Problem/Feature Request
   - Acknowledge the request.
   - If complex, suggest: "This seems like a good fit for our integrated EPCC workflow, which helps us explore, plan in detail (including creating a task list if needed), code, and then commit with proper documentation. Shall we begin?"
   - If agreed, initiate the **EXPLORE Phase**.

### B. EXPLORE Phase (Node B, B1, B1_Note in diagram)
   - **Objective:** Gather comprehensive context.
   - **AI Action (B1):**
     - State: **"Let's start exploring. I won't write any code yet."**
     - Request relevant files, URLs, or codebase areas from the user.
     - Analyze provided context. Use subagents/internal processes for deep analysis if needed (B1_Note), informing the user.
     - Summarize understanding and clarify doubts.
   - **Transition:** Once context is clear, proceed to the **PLAN Phase**.

### C. PLAN Phase (Node C, C1, C2, C2_Decision, C2_InvokeTaskCreate, C3 in diagram)
   - **Objective:** Develop a strategic plan, and if necessary, a detailed task breakdown in a task list file.
   - **AI Action (C1):**
     - Prompt: "Let's create a plan. How deeply should I 'think' about this (think, think hard, ultrathink)?"
     - Formulate a high-level strategic plan.
   - **AI Action (C2):**
     - Document this overall strategic approach.
   - **Decision Point (C2_Decision):**
     - Assess with the user: "Does this plan warrant a detailed breakdown into a new or existing task list (e.g., for a new feature or multiple steps)?"
   - **If YES (Invoke Task Creation Protocol - C2_InvokeTaskCreate):**
     - State: "Okay, let's detail this out. I'll now use our 'Feature & Task Definition Protocol' (referencing `task-create-rule.mdc`) to create/update the specific task list with all the necessary tasks, sub-tasks, dependencies, and initial implementation notes."
     - **Execute the `task-create-rule.mdc` protocol fully.** This involves asking the user for the target task list file, defining tasks, handling dependencies, outlining the implementation plan *within that task list*, etc. The output is an updated/new `.md` task list file.
   - **User Review (C3):**
     - Present the overall plan. If a task list was created/updated, present that as the detailed part of the plan.
     - **If Plan NOT OK:** Return to **EXPLORE Phase (B)** or refine plan/task list.
     - **If Plan OK:** Proceed to **CODE Phase**.

### D. CODE Phase (Node D, D1, D1_InvokeTaskExecute in diagram)
   - **Objective:** Implement the solution based on the plan and the detailed task list (if one was created).
   - **AI Action (D1):**
     - State: "Great, the plan is approved. I'll proceed with the implementation, following the overall strategy and working through the tasks in `[TASK_LIST_FILE.MD]` if we created/updated one."
     - Begin coding.
   - **Iterative Task Execution (D1_InvokeTaskExecute):**
     - **As each significant task or sub-task from the task list is being worked on or completed:**
       - State: "I'm now focusing on/just completed task: '[Task Description from list]'. I'll use our 'Task Execution & Update Protocol' (referencing `task_execution_protocol.mdc`) to update its status and capture details."
       - **Execute the `task_execution_protocol.mdc` for THAT specific task.** This includes marking it complete, documenting decisions/challenges *for that task* in the task list's Implementation Plan, noting relevant files *for that task*, and identifying any new sub-tasks emerging from it.
   - **Transition:** When all planned coding and tasks from the list (for the current scope) are complete, inform the user and proceed to **COMMIT & DOCUMENT Phase**.

### E. COMMIT & DOCUMENT Phase (Node E, E1, E2, E3, E3_InvokeTaskExecuteFinal, E3_UpdateProjectDocs in diagram)
   - **Objective:** Finalize code, commit, and update all relevant documentation including the task list and broader project docs.
   - **AI Action (E1, E2):**
     - Confirm code with user. Ask to commit and, if applicable, create a PR.
   - **AI Action (E3):** Begin final documentation updates.
   - **Final Task List Update (E3_InvokeTaskExecuteFinal):**
     - State: "Let's do a final update on our task list `[TASK_LIST_FILE.MD]` using the 'Task Execution & Update Protocol'."
     - **Execute relevant parts of `task_execution_protocol.mdc` again.** This might involve linking the PR to completed tasks, ensuring all related tasks are marked `[x]`, adding overall summary notes to the feature task if applicable.
   - **Update General Project Docs (E3_UpdateProjectDocs):**
     - Prompt: "Now that the main work is committed and the task list is updated, do we need to update any general project documentation like READMEs or Changelogs based on this feature/fix?"
     - Assist or perform updates as instructed.
   - **Transition:** The cycle is complete.

### F. End: EPCC Cycle Complete (Node F in diagram)
   - Confirm with the user that the entire process for this problem/feature is satisfactorily complete.

This integrated protocol provides a robust framework, ensuring that strategic planning (EPCC) is seamlessly connected with granular task management. Remember to explicitly mention when you are switching to or referencing the sub-protocols (`task-create-rule.mdc` and `task_execution_protocol.mdc`).