Flow Curator

Manage backlog, archive completed work, and keep the active plan focused. This skill handles plan organization and hygiene through backlog management and archiving operations.

When to Use This Skill

Activate when the user wants plan organization:

• "Move this to backlog"
• "Add to backlog"
• "Show backlog"
• "View backlog"
• "Pull from backlog"
• "Bring back from backlog"
• "Archive completed work"
• "Archive this phase"
• "Split the plan"
• "Clean up completed tasks"

Curation Philosophy

Keep Active Plan Focused: Only show work that's relevant now. Defer future work to backlog, archive completed work to history.

Three Storage Areas:

• Active Plan (.flow/phase-N/): Current and near-future work
• Backlog (.flow/backlog/): Deferred tasks (scope creep, future ideas, blocked work)
• Archive (.flow/archive/): Completed phases (history, reference)

Backlog Management

When to Backlog

Move tasks to backlog when:

• Scope creep: "That's a good idea, but not for V1"
• Blocked: "Can't work on this until X is done"
• Priorities shifted: "Let's focus on Y first"
• Future enhancement: "Nice-to-have, but not essential"
• Too many active tasks: "Plan is getting cluttered"

DON'T backlog:

• Tasks already IN PROGRESS (complete or cancel them)
• Tasks already COMPLETE (archive instead)
• Core V1 features (adjust scope instead)

Backlog Structure

Backlog task file (.flow/backlog/task-M.md):

# Task M: [Name]

**Original Phase**: Phase [N]
**Backlogged**: [DATE]
**Reason**: [Why deferred - scope creep, blocked, priority shift, etc.]

**Status**: 🔮 BACKLOG

---

## Task Overview

**Purpose**: [Why this task exists]

**Dependencies**: [What it requires]

---

## Action Items / Iterations

[Original task content preserved]

---

## Notes

**When to Pull Back**:
- [Condition that would make this task relevant again]
- [Example: "When API v2 is stable", "After V1 launch", "If user feedback requests this"]

Backlog Operations

Add to Backlog

Command: /flow-backlog-add

Process:

1. Verify task is ⏳ PENDING (not IN PROGRESS or COMPLETE)
2. Prompt: "Why are you backlogging this task?" (capture reason)
3. Move phase-N/task-M.md to .flow/backlog/task-M.md
4. Add metadata header (original phase, date, reason)
5. Update DASHBOARD.md:
   • Remove from phase progress overview
   • Add to "Backlog" section
6. Renumber remaining tasks in phase if needed
7. Report what was backlogged

View Backlog

Command: /flow-backlog-view

Process:

1. List all files in .flow/backlog/
2. For each task, extract:
   • Task name
   • Original phase
   • Date backlogged
   • Reason
3. Sort by date backlogged (oldest first)
4. Format as table:

   | Task | Original Phase | Backlogged | Reason |
   |------|----------------|------------|--------|
   | Task 5: Admin Dashboard | Phase 2 | 2025-10-15 | Scope creep - V2 feature |
   | Task 8: Performance Tuning | Phase 3 | 2025-10-22 | Priority shift - focus on features first |
   

5. Suggest: "Use /flow-backlog-pull [task-name] to restore"

Pull from Backlog

Command: /flow-backlog-pull

Process:

1. Show backlog tasks (call view logic)
2. Prompt: "Which task to pull back?"
3. Prompt: "Which phase to add it to?" (default: current phase)
4. Move .flow/backlog/task-M.md to target phase
5. Renumber as needed (task-M becomes task-K in phase-N)
6. Remove metadata header
7. Update DASHBOARD.md:
   • Add to target phase progress overview
   • Remove from backlog section
8. Report: "Task restored to Phase N. Ready to start when priorities allow."

Archive Management

When to Archive

Archive completed phases when:

• Phase complete and verified
• Focus shifted to new phases
• DASHBOARD getting too large
• Want to keep history but reduce clutter

Archiving preserves:

• All task files
• All completion dates
• All notes and decisions
• Phase summary and goals

Archive Operations

Archive Phase (Plan Split)

Command: /flow-plan-split

Purpose: Move completed phases to archive, renumber active phases

Process:

1. List all ✅ COMPLETE phases
2. Confirm: "Archive Phase N: [Name]?"
3. Create backup in .flow/.backups/
4. Create .flow/archive/ if doesn't exist
5. Move phase-N/ to .flow/archive/phase-N/
6. Update DASHBOARD.md:
   • Move phase to "Archived Phases" section
   • Preserve completion date and summary
7. Renumber remaining active phases:
   • If phase-1 and phase-2 archived, phase-3 becomes phase-1
   • Update all DASHBOARD references
   • Update "Current Work" pointer if needed
8. Report:

   ✅ Archive Complete!
   
   Archived:
   - Phase 1: Foundation (Oct 15 - Oct 22)
   - Phase 2: Core Features (Oct 23 - Nov 05)
   
   Active Phases Renumbered:
   - Phase 3 → Phase 1: Testing & Polish
   - Phase 4 → Phase 2: Deployment
   
   Backup: .flow/.backups/2025-11-02-pre-split.zip
   
   Current work now: Phase 1 (formerly Phase 3), Task 2
   

Archive Structure

Archive directory:

.flow/archive/
├── phase-1/
│   ├── task-1.md
│   ├── task-2.md
│   └── task-3.md
├── phase-2/
│   ├── task-1.md
│   └── task-2.md
└── ARCHIVE_INDEX.md

ARCHIVE_INDEX.md (auto-generated):

# Archive Index

## Phase 1: Foundation ✅ COMPLETE
**Duration**: Oct 15 - Oct 22 (7 days)
**Goal**: Set up project structure
**Tasks**: 3/3 complete

### Deliverables
- Project structure defined
- Development framework established
- Initial documentation complete

---

## Phase 2: Core Features ✅ COMPLETE
**Duration**: Oct 23 - Nov 05 (13 days)
**Goal**: Implement core workflows
**Tasks**: 4/4 complete

### Deliverables
- User authentication working
- API endpoints functional
- Data persistence implemented
- Error handling in place

Best Practices

DO:

• ✅ Backlog tasks before they clutter active plan
• ✅ Capture reason when backlogging (why deferred)
• ✅ Archive completed phases to maintain focus
• ✅ Create backups before plan-split
• ✅ Renumber phases/tasks after backlog/archive operations

DON'T:

• ❌ Backlog tasks that are IN PROGRESS (complete them first)
• ❌ Archive phases that aren't fully COMPLETE
• ❌ Lose context when backlogging (capture "when to pull back")
• ❌ Skip backups before destructive operations
• ❌ Forget to update DASHBOARD after backlog/archive

Backlog vs Cancel vs Defer

When to use each:

Backlog (🔮 BACKLOG):

• Task is good idea, just not now
• Might come back later
• Actively manage in backlog
• Example: "Admin dashboard - defer to V2"

Cancel (❌ CANCELLED):

• Task no longer needed
• Won't come back
• Don't track anymore
• Example: "Duplicate of Task 5, cancelled"

Defer (🔮 DEFERRED):

• Iteration within task deferred
• Task continues, some work deferred
• Mark specific iterations
• Example: "Iteration 4: Optimizations - defer to V2"

Examples

Example 1: Moving Task to Backlog

User: "Let's move the Admin Dashboard task to backlog - it's not needed for V1"

AI Process:
1. Find "Admin Dashboard" task (Phase 2, Task 5)
2. Verify status is ⏳ PENDING (yes)
3. Prompt for reason

AI Response:
"Moving Task 5: Admin Dashboard to backlog.

**Task Details**:
- Current location: Phase 2, Task 5
- Status: ⏳ PENDING (not started)
- Purpose: Admin panel for user management

**Backlog Reason**: V1 scope reduction - admin features defer to V2

**What Happens**:
1. Move to .flow/backlog/task-5-admin-dashboard.md
2. Add metadata (original: Phase 2, reason: scope reduction)
3. Update DASHBOARD.md (remove from Phase 2)
4. Renumber remaining tasks (Task 6 becomes Task 5)

Proceed?"

User: "Yes"

AI Response:
"✅ Task backlogged!

**Backlog Summary**:
- Task 5: Admin Dashboard → .flow/backlog/
- Phase 2 now has 4 tasks (down from 5)
- Task 6 renumbered to Task 5
- Can restore later with `/flow-backlog-pull`"

Example 2: Viewing Backlog

User: "Show me the backlog"

AI Process:
1. List files in .flow/backlog/
2. Extract metadata from each
3. Format as table

AI Response:
"## Backlog Contents

**Total Backlogged**: 3 tasks

| Task | Original Phase | Backlogged | Reason |
|------|----------------|------------|--------|
| Admin Dashboard | Phase 2 | 2025-10-15 | Scope reduction - V2 feature |
| Performance Tuning | Phase 3 | 2025-10-22 | Priority shift - focus on core features |
| Advanced Analytics | Phase 3 | 2025-10-28 | Blocked - need more data first |

**When to Pull Back**:
- Admin Dashboard: After V1 launch with user feedback
- Performance Tuning: After core features stable
- Advanced Analytics: When data collection implemented

Use `/flow-backlog-pull [task-name]` to restore any task."

Example 3: Archiving Completed Phase

User: "Archive Phase 1 - it's been complete for weeks"

AI Process:
1. Verify Phase 1 is ✅ COMPLETE (yes)
2. Check all tasks complete (3/3 ✅)
3. Create backup before archiving

AI Response:
"Archiving Phase 1: Foundation

**Phase Summary**:
- Duration: Oct 15 - Oct 22 (7 days)
- Tasks: 3/3 complete
- Goal: Set up project structure ✅

**What Will Happen**:
1. Create backup: .flow/.backups/2025-11-02-pre-split.zip
2. Move phase-1/ → .flow/archive/phase-1/
3. Update DASHBOARD.md (move to Archived Phases)
4. Renumber remaining phases:
   - Phase 2 → Phase 1 (Core Features 🚧 IN PROGRESS)
   - Phase 3 → Phase 2 (Testing ⏳ PENDING)
5. Update current work pointer (Phase 2 Task 3 → Phase 1 Task 3)

**Benefit**: Active plan focuses on current work, DASHBOARD more concise

Proceed?"

User: "Yes"

AI Response:
"✅ Archive complete!

**Archived**:
- Phase 1: Foundation (7 days, 3 tasks) → .flow/archive/phase-1/

**Active Phases Renumbered**:
- Phase 2 → Phase 1: Core Features (currently Phase 1, Task 3)
- Phase 3 → Phase 2: Testing

**DASHBOARD Updated**:
- Current work: Phase 1, Task 3 (formerly Phase 2, Task 3)
- Active plan now 2 phases (down from 3)
- Backup available: .flow/.backups/2025-11-02-152030-pre-split.zip

Archive preserved all task files and notes for future reference."

Example 4: Pulling Task from Backlog

User: "Priorities changed - let's pull back the Admin Dashboard task"

AI Process:
1. Find Admin Dashboard in backlog
2. Show task details
3. Prompt for target phase

AI Response:
"Pulling task from backlog: Admin Dashboard

**Original Info**:
- Backlogged: 2025-10-15
- Reason: Scope reduction - V2 feature
- Original Phase: Phase 2

**Current Phases**:
1. Phase 1: Core Features (4 tasks, 🚧 IN PROGRESS)
2. Phase 2: Testing (2 tasks, ⏳ PENDING)

Which phase should Admin Dashboard join?"

User: "Phase 2"

AI Process:
1. Move backlog/task-5-admin-dashboard.md → phase-2/task-3.md
2. Remove metadata header
3. Update DASHBOARD.md

AI Response:
"✅ Task restored from backlog!

**Restored Task**:
- Admin Dashboard → Phase 2, Task 3
- Removed backlog metadata
- Status: ⏳ PENDING (ready to start)

**Updated DASHBOARD**:
- Phase 2 now has 3 tasks (up from 2)
- Backlog now has 2 tasks (down from 3)

Use `/flow-task-start` when ready to begin work."

Interaction with Other Flow Skills

Planning Stage (flow-planner Skill):

• Planner creates tasks
• Curator manages backlog

Verify Stage (flow-verifier Skill):

• Verifier checks plan health
• Curator maintains plan focus

Curate Stage (This Skill):

• Manage backlog ← YOU ARE HERE
• Archive completed work ← YOU ARE HERE

References

• Backlog Management: DEVELOPMENT_FRAMEWORK.md (backlog patterns)
• Archive Strategy: DEVELOPMENT_FRAMEWORK.md (plan splitting)
• Slash Commands: /flow-backlog-add, /flow-backlog-view, /flow-backlog-pull, /flow-plan-split