kiyoraka/project-ai-memorycore/work-plan-execution

Work — Plan Execution Skill

Plan lifecycle management with tracked execution and context recovery

Activation

Three commands, each with its own activation message:

Context Guard

Command Dispatch

Copy Plan

Step 1: Find Latest Plan

• [ ] Scan [PLAN_SOURCE_PATH] for plan files
• [ ] Sort by modification date, pick most recently modified
• [ ] If no plan files found: ask user to specify a plan file path or enter plan mode first

Step 2: Transform to Project Plan Format

• [ ] Convert plan steps/items into - [ ] checkbox todo items
• [ ] Preserve all architecture diagrams (ASCII, mermaid) from the original plan
• [ ] Add standard instructions header (see plan-format.md in plan location folder)
• [ ] Maintain logical phase/section grouping from the original plan
• [ ] No emoji in the plan file — clean, parseable markdown only

Step 3: Write Project Plan

• [ ] Check if [PLAN_LOCATION]/ folder exists — create if needed
• [ ] Write to [PLAN_LOCATION]/project-plan.md (overwrite if exists)
• [ ] Report: "Plan copied — [X] todo items ready for execution"

Step 4: Begin Execution

• [ ] Execute the Shared Execution Loop (see below)

Append Plan

Step 1: Find Latest Plan

• [ ] Same as Copy Plan Step 1

Step 2: Transform to Project Plan Format

• [ ] Same as Copy Plan Step 2

Step 3: Check Existing Plan + Line Limit

• [ ] Read current [PLAN_LOCATION]/project-plan.md
• [ ] Count total lines in the existing file
• [ ] If appending would NOT exceed [LINE_LIMIT] lines:
• Append new content with a date separator:

```

## Appended: [YYYY-MM-DD] ```

• Report: "Plan extended — [X] new items added, [Y] total items"
• [ ] If appending WOULD exceed [LINE_LIMIT] lines:
• Rename current file to project-plan-YYYYMMDD.md (archived)
• Create fresh project-plan.md with the new content only
• Report: "Previous plan archived as project-plan-[date].md, new plan created"

Step 4: Begin Execution

• [ ] Execute the Shared Execution Loop (see below)

Resume Plan

Step 1: Read Current Project Plan

• [ ] Read [PLAN_LOCATION]/project-plan.md
• [ ] If file not found: report "No plan found — use 'copy plan' to create one"

Step 2: Parse Progress

• [ ] Count [x] items (completed)
• [ ] Count [ ] items (pending)
• [ ] Count [~] items (blocked)
• [ ] Identify the next pending [ ] item as the resumption point
• [ ] Read the Architecture section to restore technical context

Step 3: Report Status

• [ ] Display progress summary:

`` Plan Status: [X] completed, [Y] pending, [Z] blocked Current Phase: [phase name] Next Task: [description of next pending item] ``

• [ ] Read architecture diagrams to restore technical understanding

Step 4: Resume Execution

• [ ] Execute the Shared Execution Loop from the next pending item

Recovery Context

After a context reset, the AI loses its working state. "resume plan" restores it entirely from the file:

• The plan file IS the recovery mechanism
• No user explanation needed — the AI reads the file and continues

Shared Execution Loop

The core cycle that all three commands use after setup:

For each [ ] todo item in order:
  1. Execute the task (write code, create files, make changes)
  2. If Auto-Commit is installed → trigger commit for this completed item
  3. Mark the item as [x] in the plan file
  4. Every 5 completed items → save/update the plan file (checkpoint)
  5. Move to the next [ ] item
  6. If item is [~] (blocked) → skip and continue to next

Key Behaviors

• Per-task commits — each completed todo gets its own commit (not batched)
• Checkpoint saves — plan file is updated every 5 items to prevent loss
• Skip blocked items — [~] items are flagged and skipped, not stalled on
• User can pause — if user says "stop" or "pause", halt at the current item

Without Auto-Commit

If the Auto-Commit System is not installed, the execution loop still works:

• Tasks are executed and marked [x] in the plan file
• Commits must be done manually by the user
• The plan file still serves as the recovery mechanism

Mandatory Rules

1. Commit chain per-todo — every completed todo item triggers a commit (if Auto-Commit is installed). Not at the end, not in batches — every single one.
2. Never commit plan files — project-plan*.md stays local as the AI's working reference. Only code changes are committed.
3. Preserve diagrams — all visual elements (ASCII art, mermaid diagrams) from the original plan must be carried over to the plan file.
4. No emoji in plan files — clean, parseable markdown only.
5. Line limit enforcement — if the plan file exceeds [LINE_LIMIT] lines during append, rotate (archive old, create fresh).
6. Recovery-first design — the plan file IS the recovery mechanism after any context reset. Everything needed to resume must be in the file.
7. Skip blocked items — if a task is blocked, mark it [~], flag it to the user, and continue to the next item.
8. Checkpoint discipline — update the plan file every 5 completed items, even mid-execution.

Edge Cases

Level History

• Lv.1 — Base: Three commands (copy/append/resume) + shared execution loop + per-todo commit chain + line rotation + recovery mechanism + checkpoint saves. (Origin: Production AI companion plan execution workflow)
• Lv.2 — Wave Execution: Dependency-aware wave grouping — independent tasks within a phase can be executed in parallel via sub-agents, with wave barriers enforcing order between dependent groups.