flow-cc 0.5.7 → 0.6.0

package/skills/flow-status.md

@@ -1,95 +1,104 @@
----
-name: flow:status
-description: Quick orientation — shows current milestone, phase progress, and next actions
-user_invocable: true
----
-
-# /flow:status — Quick Orientation
-
-You are executing the `/flow:status` skill. This is a READ-ONLY operation. Do NOT modify any files.
-
-**Skill boundary:** You are inside the `/flow:*` workflow. NEVER invoke, suggest, or reference skills from other workflow systems (`/lisa:*`, `/gsd:*`, `/superpowers:*`, etc.). Only suggest `/flow:*` commands as next steps. Do NOT use the Skill tool to call any non-flow skill.
-
-## Step 1 — Read Context Files
-
-Read ALL of the following in parallel:
-- `.planning/STATE.md`
-- `.planning/ROADMAP.md`
-- List `.planning/prds/` directory for all PRD files (if directory exists)
-- Also check for legacy `PRD.md` at project root (backward compat)
-- Read the active PRD (from STATE.md "Active PRD" field) to get phase details
-- Count lessons in `tasks/lessons.md` (if exists)
-
-IF both STATE.md AND ROADMAP.md are missing:
-- Print: "No flow project found. Run `/flow:setup` to set up, or `/flow:task` for a quick standalone fix."
-- STOP here.
-
-IF only one file exists, continue with what's available.
-
-## Step 2 — Analyze Phase Status
-
-Parse ROADMAP.md to determine phase progress:
-- Count total phases
-- Count phases marked "Complete", "Done", or containing a completion date (e.g., `✓`, `[x]`, `completed`)
-- Count phases marked "Pending", "In Progress", or not yet started
-- Identify the FIRST phase that is NOT complete — this is the **next phase**
-
-RULE: Determine the next action from ROADMAP.md phase statuses, NOT from STATE.md "Next Actions" text. STATE.md may be stale from a previous session. ROADMAP.md is the source of truth for phase progress.
-
-## Step 3 — Determine Routing
-
-Use this explicit decision tree:
-
-**IF pending phases exist in ROADMAP AND a PRD exists for the current milestone (in `.planning/prds/` or legacy root):**
-→ Primary: `/flow:go` to execute Phase [N]: [name]
-→ Alt: `/flow:done` if wrapping up the session
-→ Alt: `/flow:task` for quick fixes or cleanup (no PRD needed)
-
-**IF pending phases exist in ROADMAP BUT no PRD exists for the current milestone:**
-→ `/flow:spec` — select a milestone and build its execution plan
-→ `/flow:task` — for quick fixes or cleanup (no PRD needed)
-
-**IF all phases are complete AND a next milestone with status "Planned" exists in ROADMAP.md:**
-→ Primary: `/flow:done` to finalize this milestone (will auto-transition to next milestone)
-→ Alt: `/flow:task` for quick fixes or cleanup (no PRD needed)
-
-**IF all phases are complete AND no next milestone exists:**
-→ Primary: `/flow:done` to finalize this milestone
-→ Then: `/flow:milestone` to add the next milestone
-→ Alt: `/flow:task` for quick fixes or cleanup (no PRD needed)
-
-**IF no phases exist in ROADMAP (milestone defined but not planned):**
-→ `/flow:spec` — select a milestone and build its execution plan
-→ `/flow:task` — for quick fixes or cleanup (no PRD needed)
-
-**CRITICAL — `/flow:spec` suggestion format:** When printing routing recommendations, output EXACTLY this text for /flow:spec suggestions:
-```
-→ /flow:spec — select a milestone and build its execution plan
-```
-Do NOT append a milestone name, do NOT say "for v16" or "to plan v16" or any variation. The milestone picker inside /flow:spec handles selection. Adding a name here confuses users who may have multiple milestones in flight across terminals. Print the line EXACTLY as shown above — no modifications.
-
-## Step 4 — Print Status Block
-
-```
-Milestone: [name] ([X/Y] phases complete)
-Last session: [date] — [what was built]
-Next: Phase [N] — [name] ([short description])
-Lessons: [N]/10 active
-
-PRDs:
-  * {slug}.md (active — current milestone)
-  [For each additional PRD in .planning/prds/:]
-  * {slug}.md (ready — future milestone)
-  [If legacy PRD.md at root:]
-  * PRD.md (legacy — at project root)
-
-[routing recommendations from Step 3]
-```
-
-The PRDs section shows all PRD files found. Mark the one matching STATE.md's "Active PRD" as "(active — current milestone)". Mark others as "(ready — future milestone)". If a legacy root `PRD.md` exists, show it as "(legacy — at project root)". Omit the PRDs section entirely if no PRD files exist anywhere.
-
-Adapt the block based on available information. If STATE.md is missing, omit "Last session". If ROADMAP.md is missing, omit phase counts and say "Run /flow:setup to set up tracking."
-
-## Step 5 — No File Writes
-
-This is purely informational. Do not modify any files.
+---
+name: flow:status
+description: Quick orientation — shows current milestone, phase progress, and next actions
+user_invocable: true
+---
+
+# /flow:status — Quick Orientation
+
+You are executing the `/flow:status` skill. This is a READ-ONLY operation. Do NOT modify any files.
+
+**Skill boundary:** You are inside the `/flow:*` workflow. NEVER invoke, suggest, or reference skills from other workflow systems (`/lisa:*`, `/gsd:*`, `/superpowers:*`, etc.). Only suggest `/flow:*` commands as next steps. Do NOT use the Skill tool to call any non-flow skill.
+
+## Step 1 — Read Context Files
+
+Read ALL of the following in parallel:
+- `.planning/STATE.md`
+- `.planning/ROADMAP.md`
+- List `.planning/prds/` directory for all PRD files (if directory exists)
+- Also check for legacy `PRD.md` at project root (backward compat)
+- Read the active PRD (from STATE.md "Active PRD" field) to get phase details
+- Count lessons in `tasks/lessons.md` (if exists)
+- `.claude/memory/session.md` (if exists) — personal session state
+- Run `git config user.name` to get developer identity
+
+IF both STATE.md AND ROADMAP.md are missing:
+- Print: "No flow project found. Run `/flow:setup` to set up, or `/flow:task` for a quick standalone fix."
+- STOP here.
+
+IF only one file exists, continue with what's available.
+
+## Step 2 — Analyze Phase Status
+
+Parse ROADMAP.md to determine phase progress:
+- Count total phases
+- Count phases marked "Complete", "Done", or containing a completion date (e.g., `✓`, `[x]`, `completed`)
+- Count phases marked "Pending", "In Progress", or not yet started
+- Identify the FIRST phase that is NOT complete — this is the **next phase**
+
+RULE: Determine the next action from ROADMAP.md phase statuses, NOT from STATE.md "Next Actions" text. STATE.md may be stale from a previous session. ROADMAP.md is the source of truth for phase progress.
+
+## Step 3 — Determine Routing
+
+Use this explicit decision tree:
+
+**IF pending phases exist in ROADMAP AND a PRD exists for the current milestone (in `.planning/prds/` or legacy root):**
+→ Primary: `/flow:go` to execute Phase [N]: [name]
+→ Alt: `/flow:done` if wrapping up the session
+→ Alt: `/flow:task` for quick fixes or cleanup (no PRD needed)
+
+**IF pending phases exist in ROADMAP BUT no PRD exists for the current milestone:**
+→ `/flow:spec` — select a milestone and build its execution plan
+→ `/flow:task` — for quick fixes or cleanup (no PRD needed)
+
+**IF all phases are complete AND a next milestone with status "Planned" exists in ROADMAP.md:**
+→ Primary: `/flow:done` to finalize this milestone (will auto-transition to next milestone)
+→ Alt: `/flow:task` for quick fixes or cleanup (no PRD needed)
+
+**IF all phases are complete AND no next milestone exists:**
+→ Primary: `/flow:done` to finalize this milestone
+→ Then: `/flow:milestone` to add the next milestone
+→ Alt: `/flow:task` for quick fixes or cleanup (no PRD needed)
+
+**IF no phases exist in ROADMAP (milestone defined but not planned):**
+→ `/flow:spec` — select a milestone and build its execution plan
+→ `/flow:task` — for quick fixes or cleanup (no PRD needed)
+
+**CRITICAL — `/flow:spec` suggestion format:** When printing routing recommendations, output EXACTLY this text for /flow:spec suggestions:
+```
+→ /flow:spec — select a milestone and build its execution plan
+```
+Do NOT append a milestone name, do NOT say "for v16" or "to plan v16" or any variation. The milestone picker inside /flow:spec handles selection. Adding a name here confuses users who may have multiple milestones in flight across terminals. Print the line EXACTLY as shown above — no modifications.
+
+## Step 4 — Print Status Block
+
+```
+Milestone: [name] ([X/Y] phases complete)
+Developer: [git config user.name]
+Session: [session.md "Working On" field if session.md exists, or "No active session"]
+Last session: [date] — [what was built]
+Next: Phase [N] — [name] ([short description])
+Lessons: [N]/10 active
+
+PRDs:
+  * {slug}.md (active — current milestone)
+  [For each additional PRD in .planning/prds/:]
+  * {slug}.md (ready — future milestone)
+  [If legacy PRD.md at root:]
+  * PRD.md (legacy — at project root)
+
+[routing recommendations from Step 3]
+```
+
+The PRDs section shows all PRD files found. Mark the one matching STATE.md's "Active PRD" as "(active — current milestone)". Mark others as "(ready — future milestone)". If a legacy root `PRD.md` exists, show it as "(legacy — at project root)". Omit the PRDs section entirely if no PRD files exist anywhere.
+
+When listing PRDs, if a PRD has `**Assigned To:**` fields in its phase sections, show assignment status in the PRD listing, e.g.:
+```
+  * {slug}.md (active — Phase 3 assigned to Matt, Phase 4 unassigned)
+```
+
+Adapt the block based on available information. If STATE.md is missing, omit "Last session". If ROADMAP.md is missing, omit phase counts and say "Run /flow:setup to set up tracking."
+
+## Step 5 — No File Writes
+
+This is purely informational. Do not modify any files.

package/skills/flow-task.md

@@ -1,128 +1,150 @@
----
-name: flow:task
-description: Lightweight task execution — bug fixes, cleanup, and small features without a PRD
-user_invocable: true
----
-
-# /flow:task — Lightweight Task Execution
-
-You are executing the `/flow:task` skill. This is for small, focused work — bug fixes, cleanup, one-off features — that doesn't warrant a full PRD. Understand the task, execute it, verify it works, commit it, and document it.
-
-**Skill boundary:** You are inside the `/flow:*` workflow. NEVER invoke, suggest, or reference skills from other workflow systems (`/lisa:*`, `/gsd:*`, `/superpowers:*`, etc.). Only suggest `/flow:*` commands as next steps. Do NOT use the Skill tool to call any non-flow skill.
-
-RULES:
-- NO AGENT TEAMS. NO PRD. Single execution context.
-- Exception: ONE Task agent for an isolated subtask to prevent context bloat.
-- This skill MUST work without `/flow:setup`. Missing planning files are fine.
-
-## Step 1 — Context Load
-
-Read ALL of the following in parallel. If any file is missing, skip it gracefully:
-- `.planning/STATE.md`
-- `.planning/ROADMAP.md`
-- `CLAUDE.md`
-- `tasks/lessons.md`
-- Active PRD from `.planning/prds/` (if STATE.md "Active PRD" field exists, use that path; else check for legacy `PRD.md` at root)
-
-If no `.planning/` directory exists, print:
-> No `.planning/` directory found — running standalone. Task will still be executed, verified, and committed.
-
-Then continue.
-
-## Step 2 — Task Understanding
-
-Parse the user's argument (text provided after `/flow:task`).
-
-IF no argument was provided:
-- Use AskUserQuestion: "What needs to be done?"
-- Provide 2-4 example options based on common task types (fix, cleanup, add, update)
-
-Run a quick codebase scan (Grep/Glob) for files relevant to the task description.
-
-## Step 3 — Quick Clarification
-
-Ask 0-3 clarifying questions maximum.
-
-RULES:
-- NEVER MORE THAN 3 QUESTIONS.
-- USE AskUserQuestion with 2-4 CONCRETE OPTIONS derived from codebase exploration.
-- IF THE TASK IS UNAMBIGUOUS, ASK ZERO QUESTIONS. Proceed directly.
-
-Decision gate: Can you identify WHAT to change, WHERE to change it, and the EXPECTED OUTCOME? If yes, skip to Step 4.
-
-## Step 4 — Scope Guard
-
-Estimate:
-- Number of files affected
-- Number of architectural layers touched (e.g., UI, API, DB, config)
-
-IF 5+ files OR 3+ architectural layers:
-- Use AskUserQuestion to recommend `/flow:spec` instead:
-  - Option 1: "Switch to /flow:spec (Recommended)" — "This touches [N] files across [N] layers. A PRD will keep it organized."
-  - Option 2: "Continue with /flow:task" — "I understand the scope. Execute it here."
-
-The user can always override. Do not block.
-
-## Step 5 — Execute
-
-Do the work directly in the current context.
-
-RULES:
-- NO AGENT TEAMS. NO PRD. Direct execution.
-- Exception: ONE Task agent is allowed for a single isolated subtask if it prevents context bloat.
-- Follow existing code patterns and conventions found in CLAUDE.md and the codebase.
-
-## Step 6 — Verify (MANDATORY)
-
-RULE: NEVER SILENTLY SKIP VERIFICATION.
-
-1. Check CLAUDE.md for project-specific verification commands (build, test, lint).
-2. If no CLAUDE.md commands: check `package.json` scripts, `Makefile`, `pyproject.toml`, or similar for standard commands.
-3. If verification commands are found: run them.
-4. If NO verification commands exist anywhere: print a warning and continue.
-   > ⚠ No verification commands found. Skipping automated verification.
-5. If verification fails: fix the issue and re-verify. Up to 2 fix cycles.
-6. If still failing after 2 cycles: report the failure clearly with the error output. Do not silently move on.
-
-## Step 7 — Commit
-
-- Stage ONLY the files you changed (never `git add .` or `git add -A`)
-- Commit message format: `fix:` / `feat:` / `refactor:` / `chore:` followed by a concise description
-- Do NOT push
-
-## Step 8 — Update Docs
-
-IF `.planning/STATE.md` exists:
-- Append to the "What Was Built" section (or create it if missing):
-  ```
-  - /flow:task — [description] ([N] files, commit [short SHA])
-  ```
-
-RULES:
-- DO NOT update ROADMAP.md — tasks are not milestone phases.
-- DO NOT update any PRD files in `.planning/prds/` — tasks are not part of the spec.
-- DO NOT create `.planning/` if it doesn't exist.
-
-Quick lessons prompt via AskUserQuestion:
-- "Any lessons from this task worth capturing?"
-  - Option 1: "No, nothing new" — Skip lessons.
-  - Option 2: "Yes, let me describe it" — Capture to `tasks/lessons.md` as a one-liner: `- **[topic]** The rule`
-
-If `tasks/lessons.md` doesn't exist, skip the lessons prompt.
-If lessons.md already has 10 items, promote the most battle-tested to `CLAUDE.md ## Learned Rules` before adding the new one.
-
-## Step 9 — Summary
-
-Print a compact completion block:
-
-```
-✓ /flow:task complete
-  [description of what was done]
-  Files: [N] changed | Commit: [short SHA]
-  Verified: [pass/fail/skipped]
-
-Next:
-  → /flow:task [description] for another quick fix
-  → /flow:go to continue milestone phases
-  → /flow:done to wrap up the session
-```
+---
+name: flow:task
+description: Lightweight task execution — bug fixes, cleanup, and small features without a PRD
+user_invocable: true
+---
+
+# /flow:task — Lightweight Task Execution
+
+You are executing the `/flow:task` skill. This is for small, focused work — bug fixes, cleanup, one-off features — that doesn't warrant a full PRD. Understand the task, execute it, verify it works, commit it, and document it.
+
+**Skill boundary:** You are inside the `/flow:*` workflow. NEVER invoke, suggest, or reference skills from other workflow systems (`/lisa:*`, `/gsd:*`, `/superpowers:*`, etc.). Only suggest `/flow:*` commands as next steps. Do NOT use the Skill tool to call any non-flow skill.
+
+RULES:
+- NO AGENT TEAMS. NO PRD. Single execution context.
+- Exception: ONE Task agent for an isolated subtask to prevent context bloat.
+- This skill MUST work without `/flow:setup`. Missing planning files are fine.
+
+## Step 1 — Context Load
+
+Read ALL of the following in parallel. If any file is missing, skip it gracefully:
+- `.planning/STATE.md`
+- `.planning/ROADMAP.md`
+- `CLAUDE.md`
+- `tasks/lessons.md`
+- Active PRD from `.planning/prds/` (if STATE.md "Active PRD" field exists, use that path; else check for legacy `PRD.md` at root)
+- `.claude/memory/session.md` (if exists) — personal session state
+
+Run `git config user.name` to get developer identity.
+
+If no `.planning/` directory exists, print:
+> No `.planning/` directory found — running standalone. Task will still be executed, verified, and committed.
+
+Then continue.
+
+## Step 2 — Task Understanding
+
+Parse the user's argument (text provided after `/flow:task`).
+
+IF no argument was provided:
+- Use AskUserQuestion: "What needs to be done?"
+- Provide 2-4 example options based on common task types (fix, cleanup, add, update)
+
+Run a quick codebase scan (Grep/Glob) for files relevant to the task description.
+
+## Step 3 — Quick Clarification
+
+Ask 0-3 clarifying questions maximum.
+
+RULES:
+- NEVER MORE THAN 3 QUESTIONS.
+- USE AskUserQuestion with 2-4 CONCRETE OPTIONS derived from codebase exploration.
+- IF THE TASK IS UNAMBIGUOUS, ASK ZERO QUESTIONS. Proceed directly.
+
+Decision gate: Can you identify WHAT to change, WHERE to change it, and the EXPECTED OUTCOME? If yes, skip to Step 4.
+
+## Step 4 — Scope Guard
+
+Estimate:
+- Number of files affected
+- Number of architectural layers touched (e.g., UI, API, DB, config)
+
+IF 5+ files OR 3+ architectural layers:
+- Use AskUserQuestion to recommend `/flow:spec` instead:
+  - Option 1: "Switch to /flow:spec (Recommended)" — "This touches [N] files across [N] layers. A PRD will keep it organized."
+  - Option 2: "Continue with /flow:task" — "I understand the scope. Execute it here."
+
+The user can always override. Do not block.
+
+## Step 5 — Execute
+
+Do the work directly in the current context.
+
+RULES:
+- NO AGENT TEAMS. NO PRD. Direct execution.
+- Exception: ONE Task agent is allowed for a single isolated subtask if it prevents context bloat.
+- Follow existing code patterns and conventions found in CLAUDE.md and the codebase.
+
+## Step 6 — Verify (MANDATORY)
+
+RULE: NEVER SILENTLY SKIP VERIFICATION.
+
+1. Check CLAUDE.md for project-specific verification commands (build, test, lint).
+2. If no CLAUDE.md commands: check `package.json` scripts, `Makefile`, `pyproject.toml`, or similar for standard commands.
+3. If verification commands are found: run them.
+4. If NO verification commands exist anywhere: print a warning and continue.
+   > ⚠ No verification commands found. Skipping automated verification.
+5. If verification fails: fix the issue and re-verify. Up to 2 fix cycles.
+6. If still failing after 2 cycles: report the failure clearly with the error output. Do not silently move on.
+
+## Step 7 — Commit
+
+- Stage ONLY the files you changed (never `git add .` or `git add -A`)
+- Commit message format: `fix:` / `feat:` / `refactor:` / `chore:` followed by a concise description
+- Do NOT push
+
+## Step 8 — Update Docs
+
+IF `.planning/STATE.md` exists:
+- Append to the "What Was Built" section (or create it if missing):
+  ```
+  - /flow:task — [description] ([N] files, commit [short SHA])
+  ```
+
+RULES:
+- DO NOT update ROADMAP.md — tasks are not milestone phases.
+- DO NOT update any PRD files in `.planning/prds/` — tasks are not part of the spec.
+- DO NOT create `.planning/` if it doesn't exist.
+
+**Session state:** Write `.claude/memory/session.md` (create `.claude/memory/` directory if needed):
+```
+# Session State
+**Date:** [today]
+**Developer:** [git config user.name]
+**Branch:** [current branch]
+**Working On:** /flow:task — [task description]
+**Status:** Task complete: [brief description]
+**Next:** [suggest next action]
+**Blockers:** None
+```
+
+Quick lessons prompt via AskUserQuestion:
+- "Any lessons from this task worth capturing?"
+  - Option 1: "No, nothing new" — Skip lessons.
+  - Option 2: "Yes, let me describe it" — Capture to `tasks/lessons.md` as a one-liner: `- **[topic]** The rule`
+
+If `tasks/lessons.md` doesn't exist, skip the lessons prompt.
+If lessons.md already has 10 items, promote the most battle-tested to `CLAUDE.md ## Learned Rules` before adding the new one.
+
+## Step 9 — Summary
+
+Print a compact completion block:
+
+```
+✓ /flow:task complete
+  [description of what was done]
+  Files: [N] changed | Commit: [short SHA]
+  Verified: [pass/fail/skipped]
+
+Next:
+  → /flow:task [description] for another quick fix
+  → /flow:go to continue milestone phases
+  → /flow:done to wrap up the session
+```
+
+**Linear comment (if applicable):** Check if the current branch name contains a Linear issue identifier pattern (e.g., `msig-45` in `feat/msig-45-rate-modeling`). If found:
+- Try `mcp__linear__list_issues` with a query matching the identifier
+- If Linear MCP is available AND an issue is found: post a progress comment via `mcp__linear__create_comment` with the task summary from the completion block above
+- If Linear MCP is not available or no matching issue is found: skip silently
+
+If no Linear identifier is found in the branch name: skip silently.

package/skills/flow-triage.md

@@ -0,0 +1,99 @@
+---
+name: flow:triage
+description: Sort brain dump into Linear issues, ROADMAP entries, lessons, or discard
+user_invocable: true
+---
+
+# /flow:triage — Brain Dump Triage
+
+You are executing the `/flow:triage` skill. This takes a brain dump (text blob, bullet list, or stream of consciousness) and sorts it into actionable categories: Linear issues, ROADMAP entries, lessons, or discard.
+
+**Skill boundary:** You are inside the `/flow:*` workflow. NEVER invoke, suggest, or reference skills from other workflow systems (`/lisa:*`, `/gsd:*`, `/superpowers:*`, etc.). Only suggest `/flow:*` commands as next steps. Do NOT use the Skill tool to call any non-flow skill.
+
+## Step 1 — Input
+
+Check if the user provided text after `/flow:triage`.
+
+IF argument provided: use it as the brain dump.
+IF no argument: use AskUserQuestion: "Paste your brain dump — bullet list, stream of consciousness, whatever format. I'll sort it."
+
+## Step 2 — Context Load
+
+Read in parallel (skip gracefully if missing):
+- `.planning/ROADMAP.md` — to understand existing milestones and avoid duplicates
+- `tasks/lessons.md` — to check for existing lessons and enforce cap
+- `CLAUDE.md` — project context
+
+Run `git config user.name` to identify the developer.
+
+## Step 3 — Categorize
+
+For each distinct item in the brain dump, classify into one of:
+- **Linear Issue** — actionable task, bug, or feature → will become a Linear issue
+- **ROADMAP Entry** — future milestone or phase idea → append to ROADMAP.md Future section
+- **Lesson** — learning, pattern, or rule → append to tasks/lessons.md
+- **Discard** — not actionable, already done, duplicate, or too vague to action
+
+## Step 4 — Present Plan
+
+Show the full categorization in a table:
+
+```
+| # | Item | Category | Details |
+|---|------|----------|---------|
+| 1 | "Rate modeling table" | Linear Issue | Project: v18 Student Leasing, Priority: Normal |
+| 2 | "Never use git add ." | Lesson | "Always stage specific files" |
+| 3 | "Maybe add dark mode" | ROADMAP | Future/Unscheduled |
+| 4 | "Had a thought about..." | Discard | Too vague to action |
+```
+
+Use AskUserQuestion: "Here's how I'd categorize your brain dump. Review and approve, or tell me what to change."
+- "Looks good — execute it"
+- "I want to make changes" (user provides corrections)
+
+If the user wants changes, update the categorization and present again.
+
+## Step 5 — Execute
+
+For approved items:
+
+**Linear Issues:**
+- Check if Linear MCP tools are available (try `mcp__linear__list_teams`)
+- If available: create issues with `mcp__linear__create_issue` (team: "Monument Square", default project: "Future / Backlog" unless a better match exists based on the item content and existing Linear projects)
+- If not available: print the issues as formatted text for manual creation:
+  ```
+  Linear issues to create manually:
+  - [Title] | Team: Monument Square | Project: [suggested] | Priority: [suggested]
+  ```
+
+**ROADMAP Entries:**
+- Append to `.planning/ROADMAP.md` under a "Future (Unscheduled)" section
+- If that section doesn't exist, create it at the bottom of the file
+- Format: `| [name] | Unscheduled | — |`
+
+**Lessons:**
+- Append to `tasks/lessons.md` as one-liners: `- **[topic]** The rule`
+- Enforce max 10 cap (promote most battle-tested to `CLAUDE.md ## Learned Rules` if full)
+- If `tasks/lessons.md` doesn't exist, create it
+
+**Discard:** No action needed.
+
+## Step 6 — Summary
+
+Print a compact completion block:
+
+```
+Triage complete:
+- [N] Linear issues created (in [project names])
+- [N] ROADMAP entries added
+- [N] lessons captured
+- [N] items discarded
+```
+
+Then suggest next actions:
+```
+Next:
+  → /flow:triage for another brain dump
+  → /flow:spec to plan a milestone from triaged items
+  → /flow:status to see current state
+```

package/templates/session.md.template

@@ -0,0 +1,9 @@
+# Session State
+
+**Date:** {{DATE}}
+**Developer:** (auto-detected from git config)
+**Branch:** (auto-detected)
+**Working On:** (set by /flow:go or /flow:task)
+**Status:** Session initialized
+**Next:** Check Linear for assignments or run /flow:status
+**Blockers:** None