flow-cc 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flow-cc",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Structured workflow system for Claude Code — spec interviews, agent-team execution, session handoffs, compounding knowledge",
   "author": "Troy Hoffman",
   "license": "MIT",

package/skills/flow-done.md

@@ -41,7 +41,7 @@ Structure:
 # [Project Name] — Project State
 
 ## Current Position
-- **Milestone:** [name] (vX)
+- **Milestone:** [name]
 - **Phase:** [current phase status]
 - **Branch:** [current branch]
 - **Active PRD:** [path to active PRD, or "None" if milestone complete]
@@ -98,9 +98,9 @@ Write `.claude/memory/session.md` with the following content:
 - **Archive check:** If the current milestone is fully complete:
   - If `.planning/` does not exist, skip archiving entirely — there's nothing to archive
   - Create `.planning/archive/` if it doesn't already exist (use `mkdir -p` or equivalent)
-  - Move milestone phase details to `.planning/archive/milestones-vX.md`
+  - Move milestone phase details to `.planning/archive/milestones-{slug}.md`
   - Keep only the summary row in the ROADMAP milestone table
-  - Archive the milestone's PRD: move `.planning/prds/{slug}.md` to `.planning/archive/PRD-{slug}.md`. If using legacy root `PRD.md`, move it to `.planning/archive/PRD-vX.md` instead.
+  - Archive the milestone's PRD: move `.planning/prds/{slug}.md` to `.planning/archive/PRD-{slug}.md`. If using legacy root `PRD.md`, move it to `.planning/archive/PRD-{slug}.md` instead.
   - Clear STATE.md "Active PRD" field (set to "None")
   - Mark the milestone as "Complete" in the ROADMAP table
   - **Milestone transition:** Check ROADMAP.md for the NEXT milestone with status "Planned":
@@ -163,11 +163,11 @@ Determine the next action and generate a copyable handoff prompt. Include the de
   ```
 - If milestone is complete AND a next milestone was transitioned to (from Step 3):
   ```
-  [Developer Name] — Milestone [name] complete. Next: v[X] [next milestone name]. Run /flow:spec to plan it.
+  [Developer Name] — Milestone [name] complete. Next: [next milestone name]. Run /flow:spec to plan it.
   ```
 - If milestone is complete AND no next milestone exists:
   ```
-  [Developer Name] — All milestones complete! Run /flow:milestone to plan what's next, or enjoy the win.
+  [Developer Name] — All milestones complete! Run /flow:triage to plan what's next, or enjoy the win.
   ```
 
 Print the handoff prompt in a fenced code block so the user can copy it.

package/skills/flow-intro.md

@@ -1,104 +1,106 @@
----
-name: flow:intro
-description: Introduction to the Flow workflow system — shows all commands and how to use them
-user_invocable: true
----
-
-# /flow:intro — Welcome to Flow
-
-You are executing the `/flow:intro` skill. Print the following guide EXACTLY as written. Do NOT modify any files. This is purely informational.
-
-Print this:
-
----
-
-## Flow — Your Workflow System
-
-Flow is 6 commands that turn your specs into shipped code through agent teams. Each command feeds the next.
-
-### The Lifecycle
-
-```
-/flow:setup → /flow:spec → /flow:go (repeat) → /flow:done
-  (captures      ↑                                  |
-  full roadmap)  |     auto-transitions to          |
-                 +---- next planned milestone ------+
-
-/flow:spec ← can pre-spec future milestones (each gets its own PRD in .planning/prds/)
-
-/flow:milestone ← add milestones to roadmap anytime
-/flow:task      ← standalone path for bug fixes, cleanup, small features (no PRD needed)
-```
-
-### Command by Command
-
-**`/flow:setup`** — Run once per project
-- Asks you 4-5 questions (what is it, tech stack, verify commands, roadmap/milestones)
-- Captures your full roadmap upfront (paste a list or build one milestone at a time)
-- Creates the scaffolding: `CLAUDE.md`, `.planning/STATE.md`, `.planning/ROADMAP.md`, `tasks/lessons.md`
-- If project already set up, tells you to use `/flow:milestone` or `/flow:spec` instead
-
-**`/flow:milestone`** — Add milestones to the roadmap
-- Adds new milestones to the project roadmap (paste a list or one at a time)
-- Shows current roadmap status before adding
-- If no milestone is active, activates the first new one
-
-**`/flow:task`** — Run anytime for small work
-- Bug fixes, cleanup, one-off features — anything that doesn't need a full PRD
-- Works standalone without `/flow:setup` — lowest friction entry to Flow
-- Executes, verifies, commits, and logs to STATE.md (if it exists)
-- Scope guard recommends `/flow:spec` if the task grows beyond 5 files or 3 layers
-
-**`/flow:spec`** — Run once per milestone
-- Interviews you about scope, user stories, technical design, trade-offs, and phasing
-- You can say "done" or "that's enough" anytime to cut the interview short
-- Produces `.planning/prds/{milestone}.md` — the execution contract with wave-based phases, file lists, and acceptance criteria
-- Can pre-spec future milestones in parallel terminal windows (each milestone gets its own PRD file)
-- Updates ROADMAP and STATE to reflect the plan (for the current milestone; future milestone specs skip STATE updates)
-
-**`/flow:go`** — Run once per phase (this is where the work happens)
-- Reads the PRD, finds the next pending phase
-- Checks for staleness (did prior phases change things this phase references?)
-- Spawns agent teams per the wave structure in the PRD
-- Verifies after each wave, commits when done
-- Updates docs and prints "run `/flow:go` again for the next phase"
-
-**`/flow:done`** — Run at end of every session
-- Replaces STATE.md with current status
-- Updates ROADMAP.md with phase completions
-- Auto-transitions to the next planned milestone when the current one completes
-- Captures lessons as one-liners, enforces 10-item cap (promotes to CLAUDE.md when full)
-- Commits doc updates
-- Generates a handoff prompt you copy-paste to start the next session
-
-**`/flow:status`** — Run anytime, read-only
-- Quick "where am I?" — milestone, phase progress, next step, lesson count
-
-**`/flow:update`** — Run anytime to update Flow
-- Pulls latest changes from the flow-plugin repo and re-installs all skills
-- No need to remember where you cloned the repo — it finds it automatically
-
-### Typical Session
-
-```
-1. Paste the handoff prompt from last session (or /flow:status to orient)
-2. /flow:go          ← executes the next phase
-3. /flow:go          ← executes the phase after that (if time permits)
-4. /flow:done        ← wraps up, gives you the handoff prompt for tomorrow
-```
-
-**Quick fix mid-session?** Run `/flow:task fix the broken test` — no PRD, no ceremony. It executes, verifies, commits, and you're back to `/flow:go`.
-
-### Starting a Brand New Project
-
-```
-1. /flow:setup       ← scaffolds everything
-2. /flow:spec        ← interview → PRD
-3. /flow:go          ← phase 1
-4. /flow:done        ← wrap up
-```
-
-### Learn More
-
-- Full design doc: see `DESIGN.md` in the flow-plugin repo
-- Compatible with GSD: `/gsd:debug` and `/gsd:map-codebase` still work alongside Flow
+---
+name: flow:intro
+description: Introduction to the Flow workflow system — shows all commands and how to use them
+user_invocable: true
+---
+
+# /flow:intro — Welcome to Flow
+
+You are executing the `/flow:intro` skill. Print the following guide EXACTLY as written. Do NOT modify any files. This is purely informational.
+
+Print this:
+
+---
+
+## Flow — Your Workflow System
+
+Flow is a structured workflow for Claude Code. Four core commands that turn your specs into shipped code through agent teams.
+
+### The Lifecycle
+
+```
+/flow:triage → /flow:spec → /flow:go (repeat) → /flow:done
+  (intake)       (plan)       (build)              (wrap)
+                    ↑                                 |
+                    |     auto-transitions to          |
+                    +---- next planned milestone ------+
+
+/flow:spec ← can pre-spec future milestones (each gets its own PRD in .planning/prds/)
+
+/flow:task ← standalone path for bug fixes, cleanup, small features (no PRD needed)
+```
+
+### Command by Command
+
+**`/flow:setup`** — Run once per project
+- Asks you 4-5 questions (what is it, tech stack, verify commands, roadmap/milestones)
+- Captures your full roadmap upfront (paste a list or build one milestone at a time)
+- Creates the scaffolding: `CLAUDE.md`, `.planning/STATE.md`, `.planning/ROADMAP.md`, `tasks/lessons.md`
+- If project already set up, tells you to use `/flow:triage` or `/flow:spec` instead
+
+**`/flow:triage`** — Sort a brain dump into action
+- Takes unstructured text (bullets, stream of consciousness, whatever)
+- Categorizes each item: Linear Issue, ROADMAP Entry, Milestone, Lesson, or Discard
+- Milestones get added to ROADMAP.md with status "Planned"
+- Linear issues created automatically (if Linear MCP available)
+- This is the single intake command — use it to add milestones, capture ideas, or file bugs
+
+**`/flow:task`** — Run anytime for small work
+- Bug fixes, cleanup, one-off features — anything that doesn't need a full PRD
+- Works standalone without `/flow:setup` — lowest friction entry to Flow
+- Executes, verifies, commits, and logs to STATE.md (if it exists)
+- Scope guard recommends `/flow:spec` if the task grows beyond 5 files or 3 layers
+
+**`/flow:spec`** — Run once per milestone
+- Interviews you about scope, user stories, technical design, trade-offs, and phasing
+- You can say "done" or "that's enough" anytime to cut the interview short
+- Produces `.planning/prds/{milestone}.md` — the execution contract with wave-based phases, file lists, and acceptance criteria
+- Can pre-spec future milestones in parallel terminal windows (each milestone gets its own PRD file)
+- Updates ROADMAP and STATE to reflect the plan (for the current milestone; future milestone specs skip STATE updates)
+
+**`/flow:go`** — Run once per phase (this is where the work happens)
+- Reads the PRD, finds the next pending phase
+- Checks for staleness (did prior phases change things this phase references?)
+- Spawns agent teams per the wave structure in the PRD
+- Verifies after each wave, commits when done
+- Updates docs and prints "run `/flow:go` again for the next phase"
+
+**`/flow:done`** — Run at end of every session
+- Replaces STATE.md with current status
+- Updates ROADMAP.md with phase completions
+- Auto-transitions to the next planned milestone when the current one completes
+- Captures lessons as one-liners, enforces 10-item cap (promotes to CLAUDE.md when full)
+- Commits doc updates
+- Generates a handoff prompt you copy-paste to start the next session
+
+**`/flow:status`** — Run anytime, read-only
+- Quick "where am I?" — milestone, phase progress, next step, lesson count
+
+**`/flow:update`** — Run anytime to update Flow
+- Pulls latest changes from the flow-plugin repo and re-installs all skills
+- No need to remember where you cloned the repo — it finds it automatically
+
+### Typical Session
+
+```
+1. Paste the handoff prompt from last session (or /flow:status to orient)
+2. /flow:go          ← executes the next phase
+3. /flow:go          ← executes the phase after that (if time permits)
+4. /flow:done        ← wraps up, gives you the handoff prompt for tomorrow
+```
+
+**Quick fix mid-session?** Run `/flow:task fix the broken test` — no PRD, no ceremony. It executes, verifies, commits, and you're back to `/flow:go`.
+
+### Starting a Brand New Project
+
+```
+1. /flow:setup       ← scaffolds everything
+2. /flow:spec        ← interview → PRD
+3. /flow:go          ← phase 1
+4. /flow:done        ← wrap up
+```
+
+### Learn More
+
+- Full design doc: see `DESIGN.md` in the flow-plugin repo
+- Compatible with GSD: `/gsd:debug` and `/gsd:map-codebase` still work alongside Flow

package/skills/flow-setup.md

@@ -1,196 +1,196 @@
----
-name: flow:setup
-description: Set up a new project with Flow planning scaffolding
-user_invocable: true
----
-
-# /flow:setup — Set Up New Project
-
-You are executing the `/flow:setup` skill. This sets up the planning scaffolding for a new project.
-
-## Guard: Already Initialized
-
-Check if `.planning/STATE.md` already exists:
-- **If it exists** → Print: "This project is already set up. Run `/flow:milestone` to start a new milestone, or `/flow:spec` to spec the current one." and **STOP. Do not overwrite.**
-- **If it does NOT exist** → Continue with setup below.
-
----
-
-## Step 1: Ask Setup Questions
-
-Use AskUserQuestion to gather project info. Ask these questions (you may combine into 2-3 AskUserQuestion calls):
-
-**Question 1 — Project basics:**
-- "What is this project?" (one sentence description)
-
-**Question 2 — Tech stack:**
-- "What's the tech stack?" with options like:
-  - "Next.js + TypeScript + PostgreSQL"
-  - "Python + FastAPI + PostgreSQL"
-  - "React + Node.js + MongoDB"
-  - (Other — user types custom)
-
-**Question 3 — Verification commands:**
-- "What commands verify the build?" with options like:
-  - "npx tsc --noEmit && npx biome check"
-  - "pytest && mypy ."
-  - "cargo build && cargo test"
-  - (Other — user types custom)
-
-**Question 4 — Roadmap:**
-- "Do you already have a roadmap or list of milestones?" with options:
-  - "Yes — I'll paste or describe them"
-  - "No — let's figure it out together"
-
-**If user selects "Yes":**
-- Accept free text (bullet list, paragraph, pasted doc — any format)
-- Parse into milestones, each with a name + brief goal
-- Print back: "Here's what I got:" followed by the parsed list (e.g., "v1: Auth — user registration and login", "v2: Dashboard — analytics and settings")
-- Use AskUserQuestion to confirm: "Does this look right?" with options:
-  - "Yes — looks good"
-  - "Let me adjust" (user re-enters)
-
-**If user selects "No" (guided):**
-- Ask: "What's the first milestone?" (name + one-sentence goal)
-- Then: "Any more milestones you can see right now? List them, or skip to add them later with `/flow:milestone`." with options:
-  - "I have more to add" (user enters additional milestones)
-  - "That's it for now"
-
-**Question 5 — Brownfield scan:**
-- "Is this an existing codebase I should scan?" with options:
-  - "Yes — scan and catalog existing code"
-  - "No — greenfield project"
-
-## Step 2: Brownfield Scan (if requested)
-
-If the user said yes to scanning:
-1. Use Glob to find key directories: `src/`, `app/`, `lib/`, `components/`, `api/`, `pages/`, `utils/`, `types/`
-2. Use Grep to find patterns: exports, route definitions, database models, config files
-3. Build a brief catalog of what exists (key components, patterns, data layer)
-4. Include this in the CLAUDE.md Quick Context section
-
-## Step 3: Create Project Files
-
-Create these 5 files (create directories as needed):
-
-**`.planning/STATE.md`:**
-```
-# [Project Name] — Project State
-
-## Current Position
-- **Milestone:** [first milestone name] (v1)
-- **Phase:** Not started — run `/flow:spec` to build PRD
-- **Branch:** main
-- **Active PRD:** None — run `/flow:spec` to create
-- **Last Session:** [today's date]
-
-## Milestone Progress
-
-| Phase | Name | Status |
-|-------|------|--------|
-| — | Run `/flow:spec` to define phases | — |
-
-## What Was Built (This Session)
-- Project initialized with `/flow:setup`
-- Created: CLAUDE.md, STATE.md, ROADMAP.md, tasks/lessons.md
-
-## Key Decisions
-- (none yet)
-
-## Next Actions
-1. Run `/flow:spec` to interview and generate PRD for [first milestone]
-```
-
-**`.planning/ROADMAP.md`:**
-```
-# [Project Name] — Roadmap
-
-## Milestones
-
-| Version | Milestone | Status | Phases |
-|---------|-----------|--------|--------|
-| v1 | [first milestone] | Pending — needs `/flow:spec` | TBD |
-[For each additional milestone:]
-| v[N] | [milestone name] | Planned | TBD |
-
----
-
-## v1: [first milestone]
-
-**Goal:** [milestone goal from user]
-
-**Phases:** Run `/flow:spec` to define implementation phases.
-
-[For each additional milestone:]
-
-## v[N]: [milestone name]
-
-**Goal:** [milestone goal]
-
-**Phases:** Run `/flow:spec` when this milestone is active.
-```
-
-Note: The first milestone gets status "Pending — needs `/flow:spec`". All subsequent milestones get status "Planned". Each milestone gets its own section with its goal.
-
-**`CLAUDE.md`:**
-```
-# [Project Name] — Claude Code Instructions
-
-## Quick Context
-[Project description from user]
-
-**Tech Stack:** [tech stack from user]
-[If brownfield: brief catalog of existing code]
-
-### START (Every Session)
-1. Read this file (CLAUDE.md)
-2. Read `.planning/STATE.md` for current status
-3. Read `.planning/ROADMAP.md` for milestone progress
-4. Read active PRD from `.planning/prds/` for current milestone (if one exists)
-
-## Execution Rules
-- **Plan before building.** For non-trivial work, read the milestone's PRD in `.planning/prds/` before touching anything.
-- **Delegate immediately.** If a task touches 3+ files, spawn an agent team within your first 2 tool calls.
-- **Verify everything.** Run [verification commands from user] after agent work lands. Nothing is done until proven.
-
-## Git Workflow
-- All changes via PR. Never commit directly to main.
-- Branch naming: `fix/short-description` or `feat/short-description`
-
-## Session-End Docs (MANDATORY)
-1. `.planning/STATE.md` — replace session notes (don't append), keep <80 lines
-2. `.planning/ROADMAP.md` — update phase progress
-3. `tasks/lessons.md` — add new lessons, refine existing ones
-4. Commit doc updates to feature branch
-
-## Critical Rules
-- No assumptions — ask if requirements unclear
-- Fight entropy — leave code better than you found it
-```
-
-**`tasks/lessons.md`:**
-```
-# [Project Name] — Lessons (max 10 active)
-
-One-liner format: `- **[topic]** The rule`
-
-<!-- EXAMPLE: - **[agent context]** Always tell agents exactly which functions/lines to read — never "read file.ts", say "read file.ts lines 50-120" -->
-```
-
-**`.planning/prds/`** — Create this empty directory (use `mkdir -p` via Bash). PRDs are stored here per-milestone.
-
-**`.planning/archive/`** — Create this empty directory (use `mkdir -p` via Bash).
-
-## Step 4: Print Completion Message
-
-```
-Project initialized:
-- CLAUDE.md — project execution rules
-- .planning/STATE.md — session GPS
-- .planning/ROADMAP.md — milestone tracker
-- tasks/lessons.md — active lessons (max 10)
-- .planning/prds/ — per-milestone PRD specs
-- .planning/archive/ — for completed milestones
-
-Run `/flow:spec` to plan your first milestone.
-```
+---
+name: flow:setup
+description: Set up a new project with Flow planning scaffolding
+user_invocable: true
+---
+
+# /flow:setup — Set Up New Project
+
+You are executing the `/flow:setup` skill. This sets up the planning scaffolding for a new project.
+
+## Guard: Already Initialized
+
+Check if `.planning/STATE.md` already exists:
+- **If it exists** → Print: "This project is already set up. Run `/flow:triage` to add milestones, or `/flow:spec` to spec the current one." and **STOP. Do not overwrite.**
+- **If it does NOT exist** → Continue with setup below.
+
+---
+
+## Step 1: Ask Setup Questions
+
+Use AskUserQuestion to gather project info. Ask these questions (you may combine into 2-3 AskUserQuestion calls):
+
+**Question 1 — Project basics:**
+- "What is this project?" (one sentence description)
+
+**Question 2 — Tech stack:**
+- "What's the tech stack?" with options like:
+  - "Next.js + TypeScript + PostgreSQL"
+  - "Python + FastAPI + PostgreSQL"
+  - "React + Node.js + MongoDB"
+  - (Other — user types custom)
+
+**Question 3 — Verification commands:**
+- "What commands verify the build?" with options like:
+  - "npx tsc --noEmit && npx biome check"
+  - "pytest && mypy ."
+  - "cargo build && cargo test"
+  - (Other — user types custom)
+
+**Question 4 — Roadmap:**
+- "Do you already have a roadmap or list of milestones?" with options:
+  - "Yes — I'll paste or describe them"
+  - "No — let's figure it out together"
+
+**If user selects "Yes":**
+- Accept free text (bullet list, paragraph, pasted doc — any format)
+- Parse into milestones, each with a name + brief goal
+- Print back: "Here's what I got:" followed by the parsed list (e.g., "Auth — user registration and login", "Dashboard — analytics and settings")
+- Use AskUserQuestion to confirm: "Does this look right?" with options:
+  - "Yes — looks good"
+  - "Let me adjust" (user re-enters)
+
+**If user selects "No" (guided):**
+- Ask: "What's the first milestone?" (name + one-sentence goal)
+- Then: "Any more milestones you can see right now? List them, or skip to add them later with `/flow:triage`." with options:
+  - "I have more to add" (user enters additional milestones)
+  - "That's it for now"
+
+**Question 5 — Brownfield scan:**
+- "Is this an existing codebase I should scan?" with options:
+  - "Yes — scan and catalog existing code"
+  - "No — greenfield project"
+
+## Step 2: Brownfield Scan (if requested)
+
+If the user said yes to scanning:
+1. Use Glob to find key directories: `src/`, `app/`, `lib/`, `components/`, `api/`, `pages/`, `utils/`, `types/`
+2. Use Grep to find patterns: exports, route definitions, database models, config files
+3. Build a brief catalog of what exists (key components, patterns, data layer)
+4. Include this in the CLAUDE.md Quick Context section
+
+## Step 3: Create Project Files
+
+Create these 5 files (create directories as needed):
+
+**`.planning/STATE.md`:**
+```
+# [Project Name] — Project State
+
+## Current Position
+- **Milestone:** [first milestone name]
+- **Phase:** Not started — run `/flow:spec` to build PRD
+- **Branch:** main
+- **Active PRD:** None — run `/flow:spec` to create
+- **Last Session:** [today's date]
+
+## Milestone Progress
+
+| Phase | Name | Status |
+|-------|------|--------|
+| — | Run `/flow:spec` to define phases | — |
+
+## What Was Built (This Session)
+- Project initialized with `/flow:setup`
+- Created: CLAUDE.md, STATE.md, ROADMAP.md, tasks/lessons.md
+
+## Key Decisions
+- (none yet)
+
+## Next Actions
+1. Run `/flow:spec` to interview and generate PRD for [first milestone]
+```
+
+**`.planning/ROADMAP.md`:**
+```
+# [Project Name] — Roadmap
+
+## Milestones
+
+| Milestone | Status | Phases |
+|-----------|--------|--------|
+| [first milestone] | Pending — needs `/flow:spec` | TBD |
+[For each additional milestone:]
+| [milestone name] | Planned | TBD |
+
+---
+
+## [first milestone]
+
+**Goal:** [milestone goal from user]
+
+**Phases:** Run `/flow:spec` to define implementation phases.
+
+[For each additional milestone:]
+
+## [milestone name]
+
+**Goal:** [milestone goal]
+
+**Phases:** Run `/flow:spec` when this milestone is active.
+```
+
+Note: The first milestone gets status "Pending — needs `/flow:spec`". All subsequent milestones get status "Planned". Each milestone gets its own section with its goal.
+
+**`CLAUDE.md`:**
+```
+# [Project Name] — Claude Code Instructions
+
+## Quick Context
+[Project description from user]
+
+**Tech Stack:** [tech stack from user]
+[If brownfield: brief catalog of existing code]
+
+### START (Every Session)
+1. Read this file (CLAUDE.md)
+2. Read `.planning/STATE.md` for current status
+3. Read `.planning/ROADMAP.md` for milestone progress
+4. Read active PRD from `.planning/prds/` for current milestone (if one exists)
+
+## Execution Rules
+- **Plan before building.** For non-trivial work, read the milestone's PRD in `.planning/prds/` before touching anything.
+- **Delegate immediately.** If a task touches 3+ files, spawn an agent team within your first 2 tool calls.
+- **Verify everything.** Run [verification commands from user] after agent work lands. Nothing is done until proven.
+
+## Git Workflow
+- All changes via PR. Never commit directly to main.
+- Branch naming: `fix/short-description` or `feat/short-description`
+
+## Session-End Docs (MANDATORY)
+1. `.planning/STATE.md` — replace session notes (don't append), keep <80 lines
+2. `.planning/ROADMAP.md` — update phase progress
+3. `tasks/lessons.md` — add new lessons, refine existing ones
+4. Commit doc updates to feature branch
+
+## Critical Rules
+- No assumptions — ask if requirements unclear
+- Fight entropy — leave code better than you found it
+```
+
+**`tasks/lessons.md`:**
+```
+# [Project Name] — Lessons (max 10 active)
+
+One-liner format: `- **[topic]** The rule`
+
+<!-- EXAMPLE: - **[agent context]** Always tell agents exactly which functions/lines to read — never "read file.ts", say "read file.ts lines 50-120" -->
+```
+
+**`.planning/prds/`** — Create this empty directory (use `mkdir -p` via Bash). PRDs are stored here per-milestone.
+
+**`.planning/archive/`** — Create this empty directory (use `mkdir -p` via Bash).
+
+## Step 4: Print Completion Message
+
+```
+Project initialized:
+- CLAUDE.md — project execution rules
+- .planning/STATE.md — session GPS
+- .planning/ROADMAP.md — milestone tracker
+- tasks/lessons.md — active lessons (max 10)
+- .planning/prds/ — per-milestone PRD specs
+- .planning/archive/ — for completed milestones
+
+Run `/flow:spec` to plan your first milestone.
+```