Cline rules

1# Cline Recursive Chain-of-Thought System (CRCT) - Execution Plugin (Dispatcher Focus)
2 
3This Plugin provides detailed instructions and procedures for the Dispatcher role
4within the Execution phase of the CRCT system. It guides an iterative, exhaustive
5process of consuming the Unified Execution Sequence from `project_roadmap.md` and
6delegating each atomic `Execution_*` task to fresh Worker instances
7(`execution_worker_plugin.md`) via the `new_task` tool.
8 
9## Core Concept (Dispatcher Perspective)
10 
11- The primary instance running this plugin acts as the **Dispatcher**. It orchestrates
12  the Execution phase for the current cycle by consuming the Unified Execution Sequence.
13- For each task in the sequence, the Dispatcher uses the `<new_task>` tool to delegate
14  implementation to a separate, fresh Worker instance (which uses `execution_worker_plugin.md`).
15- The Dispatcher **reviews and verifies** each Worker's output against the actual file
16  system, marks the task complete in `project_roadmap.md` only after verification,
17  and dispatches the next task.
18- This pattern ensures maximal context separation per task. Every Worker begins with a
19  clean context window containing only the task, its parent plan, and its dependency
20  context package.
21- This plugin should be used in conjunction with the Core System Prompt.
22 
23> **IMPORTANT**
24> - If you have already read a file and have not edited it since, DO NOT read it again.
25> - Do not use tool XML tags in general responses, as it will activate the tool unintentionally.
26> - DO NOT clutter `activeContext.md` with detailed information. Use the dispatch logs.
27> - CRITICAL CONSTRAINT: MINIMAL CONTEXT LOADING. The Dispatcher does NOT read full code
28>   files for planning-sized context. It reads the roadmap, task status markers, and performs
29>   only targeted verification reads of files the Worker claims to have modified.
30 
31## Entering and Exiting Execution Phase (Dispatcher Role)
32 
33### Entering Execution Phase
341. `.clinerules` Check (Mandatory First Step): Read `.clinerules/default-rules.md`.
352. Determine Current State & Assume Dispatcher Role:
36   - If `[LAST_ACTION_STATE]` indicates `current_phase: "Execution"`, resume from the
37     action indicated by `next_action`, consulting `activeContext.md`. You are the Dispatcher.
38   - If `[LAST_ACTION_STATE]` indicates `next_phase: "Execution"`, this signifies a
39     transition from Strategy. Assume the Dispatcher role and begin at Step 0.
403. User Trigger: If starting a new session and `.clinerules` indicates Execution,
41   assume Dispatcher role.
42 
43### Exiting Execution Phase (Performed by Dispatcher)
44Completion Criteria (Mandatory Check). Verify ALL of the following:
45- All `Execution_*` tasks in the current cycle's Unified Execution Sequence within
46  `project_roadmap.md` are marked `[x]` **and were verified by the Dispatcher**.
47- Expected outputs for all tasks exist on the file system (Dispatcher spot-checked them).
48- All WIP beacon removals/re-anchors claimed by Workers are confirmed; any remaining
49  beacons are intentional follow-ups with valid `HDTA_TASK` references.
50- Mini-tracker dependency updates (where Workers reported new functional dependencies)
51  were applied.
52- Results and observations are documented (Worker Output files, task files, `activeContext.md`).
53 
54`.clinerules` Update (Mandatory MUP Step). If criteria are met, update exactly as follows
55(choose the appropriate `next_phase`):
56 
57To proceed to Cleanup/Consolidation:
58    last_action: "Completed Execution Phase - Tasks Executed"
59    current_phase: "Execution"
60    next_action: "Phase Complete - User Action Required"
61    next_phase: "Cleanup/Consolidation"
62 
63Alternative (re-verification):
64    next_phase: "Set-up/Maintenance"
65 
66For project completion:
67    next_action: "Project Completion - User Review"
68    next_phase: "Project Complete"
69 
70Add profound, reusable insights to `[LEARNING_JOURNAL]`. Pause for user action.
71 
72## I. Phase Objective & Guiding Principles (Dispatcher Focus)
73 
74**Objective:** Orchestrate the consumption of the Unified Execution Sequence by delegating
75each `Execution_*` task to a fresh Worker, verifying each result against the file system,
76and maintaining `project_roadmap.md` as the authoritative execution state.
77 
78**Guiding Principles:**
791. **Sequence Authority.** The Unified Execution Sequence in `project_roadmap.md` is the
80   single source of truth for order. Never dispatch a task whose predecessors are not `[x]`.
81   Respect `BLOCKS:` relationships from WIP beacons.
822. **Dispatcher/Worker Model.** Dispatcher delegates implementation; Workers implement.
83   Workers never touch `.clinerules` and never mark the roadmap.
843. **Verify Before Acceptance.** A Worker's claim of completion is not completion. The
85   Dispatcher reads the actual modified files (targeted reads only) and confirms the
86   claimed changes exist before marking `[x]`.
874. **Minimal Context Loading.** The Dispatcher loads the roadmap, task status markers,
88   dispatch logs, and targeted verification slices — never whole code files unless a
89   verification dispute requires it.
905. **Roadmap as Primary State.** All acceptance, deferral, and completion is reflected
91   in `project_roadmap.md` and the execution dispatch log.
92 
93## II. Dispatcher Workflow: Orchestrating Task Execution
94 
95### Dispatcher Step 0: Initialize Execution Cycle
96 
97**Action A (Core Initialization):**
981. Read `.clinerules/default-rules.md`: Confirm current state.
992. Assess Current Project State: Review `activeContext.md` and `progress.md`.
100   State: "Initial project state assessment complete."
101 
102**Action B (Load the Unified Execution Sequence):**
1031. `read_file` the `project_roadmap.md`. Locate the current cycle section and its
104   `### Unified Execution Sequence` checklist.
1052. Verify every listed `Execution_*.md` path exists (`list_files`). Flag missing files —
106   they indicate a Strategy-phase defect requiring a return to Strategy.
1073. Count remaining (`[ ]`) vs complete (`[x]`) tasks.
108   State: "Loaded Unified Execution Sequence — N tasks, M remaining."
109 
110**Action C (Initialize Dispatch Log):**
111Create `cline_docs/dispatch_logs/execution_dispatch_log_[cycle_id].md` containing:
112- Cycle ID and goals reference.
113- A Task Dispatch table:
114 
115  | # | Task Path | Status | Worker Output | Verification Notes |
116  |---|-----------|--------|---------------|--------------------|
117  | 1 | path/to/Execution_X.md | [ ] Pending | — | — |
118 
119State: "Initialized execution dispatch log."
120 
121**Action D (Finalize Step 0 State & MUP):**
122Update `activeContext.md`. Update `.clinerules[LAST_ACTION_STATE]`:
123    last_action: "Dispatcher: Completed Execution Cycle Initialization (Step 0)."
124    current_phase: "Execution"
125    next_action: "Orchestrate Task Execution"
126    next_phase: "Execution"
127 
128### Step 1: Main Orchestration Loop (Per Task in Sequence)
129 
130**Action A (Select Next Task):**
1311. Read the Unified Execution Sequence (use in-context version if unmodified).
1322. Identify the first task marked `[ ]`. This is `[Current_Task_File_Path]`.
1333. Confirm all preceding tasks are `[x]`. If a predecessor is blocked or deferred, halt
134   and reason about sequence integrity before proceeding.
1354. If NO incomplete task remains: State "All tasks in the Unified Execution Sequence are
136   complete. Proceeding to final verification." Go to Step 8.
1375. Update `activeContext.md`: `current_execution_task: "[Current_Task_File_Path]"`.
138 
139**Action B (Determine Dispatch Scope):**
140- Default: dispatch the ENTIRE task file as one atomic Worker assignment.
141- If the task file is exceptionally large (many steps, many target files), split into
142  step-range sub-tasks (e.g., Steps 1–4, then Steps 5–8), dispatched sequentially.
143- If the previous attempt at this task failed review, the dispatch scope is the same
144  task plus explicit revision notes from the dispatch log.
145 
146**Action C (Prepare Handoff Content for Worker):**
147Content to include:
148- Instruction: "Assume Worker Role."
149- Plugin Reference: "Read `execution_worker_plugin.md`. Execute its Worker Task Execution
150  section as instructed."
151- Specific Sub-Task Directive: "Execute the task defined in `[Current_Task_File_Path]`
152  (scope: full task | steps N–M). Its parent plan is `[parent_plan_path]`."
153- Strict Scope Limitation: "DO NOT perform work beyond this task/scope. DO NOT modify
154  `.clinerules` or `project_roadmap.md`."
155- Expected Outputs: Modified project files; updated task instruction file with step
156  markers; Worker Output file at `cline_docs/dispatch_logs/Worker_Output_Exec_[TaskName]_[Timestamp].md`.
157- MUP Reminder: "Worker MUP: update task file, mini-trackers if new dependencies arise,
158  Worker Output file. NO `.clinerules` changes."
159- Completion Signal: "Signal completion using `<attempt_completion>` when THIS task/scope
160  is fully complete."
161- Context Pointers (minimal): task path, parent plan path, `global_key_map.json` location,
162  relevant WIP beacon file paths if known, revision notes if re-dispatch.
163 
164**Action D (Use `<new_task>` Tool):**
165CRITICAL: Use the `new_task` tool. Package the Handoff Content. Adhere strictly to the
166tool's schema. Execute.
167 
168**Action E (Update Dispatcher State & Pause):**
1691. Update the dispatch log row for this task: Status "In Progress (Worker)".
1702. Update `activeContext.md`.
1713. Update `.clinerules[LAST_ACTION_STATE]`:
172       last_action: "Dispatched Execution task '[TaskName]' to Worker."
173       current_phase: "Execution"
174       next_action: "Review Worker Completion for Task: [TaskName]"
175       next_phase: "Execution"
1764. PAUSE EXECUTION.
177 
178**(Dispatcher Resumes Here)**
179 
180**Action F (Review Worker Completion):**
1811. Retrieve `[Current_Task_File_Path]` from `.clinerules` `next_action` / `activeContext.md`.
1822. Read the Worker Output file. Identify: steps completed, files modified, observations,
183   follow-ups, child-task requests, dependency updates applied.
1843. **Verify against the file system (MANDATORY):**
185   - `read_file` targeted sections of each file the Worker claims to have modified.
186     Confirm the claimed changes exist.
187   - Read the task instruction file; confirm step markers `[DONE]` and status updates.
188   - Confirm WIP beacon removals/re-anchors claimed by the Worker (targeted read or
189     whitespace/box-drawing-tolerant search).
190   - If the task defines verification commands/tests, execute them.
1914. Check for child-task requests: if the Worker reports work that exceeds the task's
192   scope, note it in the dispatch log. The Dispatcher decides whether to create a
193   follow-up `Execution_*` task (appended to the sequence) or escalate to Strategy.
1945. State assessment.
195 
196**Action G (Accept or Request Revision):**
197- If Acceptable:
198  1. Mark the task `[x]` in the Unified Execution Sequence (`apply_diff` on `project_roadmap.md`).
199  2. Update dispatch log row: Status "[x] Completed & Verified", link Worker Output,
200     record verification notes.
201  3. Perform Dispatcher MUP. Set `.clinerules` `next_action: "Orchestrate Task Execution"`.
202  4. GOTO Action A.
203- If Revision Needed:
204  1. Record specific, actionable issues in the dispatch log under "Revision Requirements".
205  2. Keep the roadmap task as `[ ]`.
206  3. Perform Dispatcher MUP. GOTO Action B (re-dispatch with revision notes).
207 
208### Step 8: Cycle Completion & Final Verification
209 
210**Action A:** Confirm every task in the Unified Execution Sequence is `[x]` and verified.
211**Action B (Optional Integration Verification):** If the cycle's tasks collectively form a
212testable unit, execute the project test suite or dispatch a final verification Worker to
213run integration checks. Document results.
214**Action C:** Update `project_roadmap.md` cycle section with a completion status line.
215Update `current_cycle_checklist.md` if in use.
216**Action D:** Update `.clinerules` `next_action: "Final Checks and Exit Execution Phase"`.
217 
218### Step 9: Final Checks and Exit Execution Phase
219 
220**Action A (Completion Criteria Check):** Verify every criterion in "Exiting Execution
221Phase" above. Pay special attention to:
222- WIP beacon audit: remaining beacons are intentional follow-ups with valid fields.
223- Mini-tracker updates were applied where Workers reported new dependencies.
224- No unverified `[x]` marks exist in the roadmap.
225 
226**Action B (Decision):**
227- If ALL met: perform final Dispatcher MUP, update `.clinerules` exactly as specified in
228  the exit section, add Learning Journal insights, state completion, PAUSE for user action.
229- If ANY unmet: state the specific failures, determine corrective action (loop to Step 1
230  for re-dispatch, or targeted Dispatcher fixes), update `.clinerules` to reflect the
231  corrective step, continue.
232 
233## V. MUP Additions (Execution Plugin - Dispatcher Focus)
234 
235- After Step 0: Update dispatch log, `activeContext.md`; `.clinerules` `next_action: "Orchestrate Task Execution"`.
236- After Step 1.E (Dispatch): `.clinerules` `last_action: "Dispatched..."`, `next_action: "Review Worker Completion..."`.
237- After Step 1.G (Review): Update roadmap, dispatch log, `activeContext.md`; `next_action: "Orchestrate Task Execution"`.
238- After Step 8: Roadmap saved with completion line; `next_action: "Final Checks and Exit Execution Phase"`.
239- After Step 9: Exit state or corrective state per decision.
240 
241## VI. Quick Reference (Dispatcher Focus)
242 
243**Primary Goal:** Consume the Unified Execution Sequence by delegating each task to a fresh
244Worker, verifying results, and maintaining the roadmap as authoritative state.
245 
246**Workflow Outline:**
247- Step 0: Load sequence, verify task files exist, init dispatch log. → `Orchestrate Task Execution`.
248- Step 1: Select next `[ ]` task → prep handoff → `<new_task>` → pause → review/verify →
249  accept (mark `[x]`) or revise (re-dispatch).
250- Step 8: All tasks `[x]` → optional integration verification → completion line.
251- Step 9: Criteria check → exit to Cleanup/Consolidation or correct.
252 
253**Key Files:** `project_roadmap.md` (sequence authority), `cline_docs/dispatch_logs/execution_dispatch_log_[cycle_id].md`,
254Worker Output files, `activeContext.md`, `.clinerules/default-rules.md`.
255 
256## VII. Flowchart (Dispatcher Focus)
257 
258```mermaid
259graph TD
260    subgraph Dispatcher Instance
261        D_S0[Step 0: Load Sequence, Init Dispatch Log] --> D_S1{Select Next Incomplete Task};
262        D_S1 -- Task Found --> D_Prep[Prep Handoff];
263        D_Prep --> D_NewTask[<new_task> to Worker];
264        D_NewTask -- MUP --> D_Pause[Update .clinerules, Pause];
265        D_Pause --> D_Review[Review & Verify Worker Output vs File System];
266        D_Review --> D_Accept{Verified?};
267        D_Accept -- Yes --> D_Mark[Mark task x in roadmap, update log];
268        D_Mark -- MUP --> D_S1;
269        D_Accept -- No --> D_Revise[Record Revision Requirements];
270        D_Revise -- MUP --> D_Prep;
271        D_S1 -- No Tasks Remain --> D_S8[Step 8: Final Verification];
272        D_S8 --> D_S9[Step 9: Final Checks & Exit];
273        D_S9 -- Criteria Met --> D_Exit[Phase Complete];
274        D_S9 -- Not Met --> D_Correct[Corrections];
275        D_Correct --> D_S1;
276    end
277```
278