flow-cc 0.8.0 → 0.8.1

package/skills/flow-task.md

@@ -6,145 +6,105 @@ 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.
+You are executing the `/flow:task` skill. For small, focused work — bug fixes, cleanup, one-off features — that doesn't need a PRD. Understand, execute, verify, commit, document.
 
-**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.
+**Skill boundary:** Only use `/flow:*` commands. Never invoke or suggest `/lisa:*`, `/gsd:*`, `/superpowers:*` or 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.
+- 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
+Read ALL in parallel (skip missing files gracefully):
+- `.planning/STATE.md`, `.planning/ROADMAP.md`, `CLAUDE.md`, `tasks/lessons.md`
+- Active PRD from `.planning/prds/` via STATE.md "Active PRD" field (or legacy root `PRD.md`)
+- `.claude/memory/session.md` (if exists)
 
-Run `git config user.name` to get developer identity.
+Run `git config user.name` for developer identity.
 
-If no `.planning/` directory exists, print:
-> No `.planning/` directory found — running standalone. Task will still be executed, verified, and committed.
-
-Then continue.
+If no `.planning/` directory: print "No `.planning/` found — running standalone." Then continue.
 
 ## Step 2 — Task Understanding
 
-Parse the user's argument (text provided after `/flow:task`).
+Parse the user's argument (text 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)
+If no argument: AskUserQuestion "What needs to be done?" with 2-4 example options (fix, cleanup, add, update).
 
-Run a quick codebase scan (Grep/Glob) for files relevant to the task description.
+Run a quick codebase scan (Grep/Glob) for files relevant to the task.
 
 ## Step 3 — Quick Clarification
 
-Ask 0-3 clarifying questions maximum.
+0-3 clarifying questions maximum. NEVER MORE THAN 3.
 
-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.
+Use AskUserQuestion with 2-4 concrete options derived from codebase exploration. If the task is unambiguous, ask zero questions and proceed.
 
-Decision gate: Can you identify WHAT to change, WHERE to change it, and the EXPECTED OUTCOME? If yes, skip to Step 4.
+Decision gate: Can you identify WHAT, WHERE, and 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)
+Estimate files affected and architectural layers touched.
 
-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."
+IF 5+ files OR 3+ layers:
+- AskUserQuestion: recommend `/flow:spec` instead:
+  - "Switch to /flow:spec (Recommended)" — touches [N] files across [N] layers, PRD keeps it organized
+  - "Continue with /flow:task" — understood, execute here
 
-The user can always override. Do not block.
+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.
+Do the work directly. NO AGENT TEAMS. NO PRD. Exception: ONE Task agent for isolated subtask if it prevents context bloat. Follow existing code patterns from CLAUDE.md and codebase.
 
 ## Step 6 — Verify (MANDATORY)
 
-RULE: NEVER SILENTLY SKIP VERIFICATION.
+NEVER SILENTLY SKIP.
 
-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.
+1. Check CLAUDE.md for verification commands (build, test, lint)
+2. If none: check `package.json`, `Makefile`, `pyproject.toml` for standard commands
+3. If found: run them
+4. If nothing found anywhere: warn and continue
+5. If verification fails: fix and re-verify. Up to 2 fix cycles.
+6. Still failing after 2 cycles: report failure clearly with 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
+- Stage ONLY changed files (never `git add .` or `git add -A`)
+- Message format: `fix:` / `feat:` / `refactor:` / `chore:` + 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 project milestones.
-- 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):
+IF `.planning/STATE.md` exists, append to "What Was Built":
 ```
-# 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
+- /flow:task — [description] ([N] files, commit [short SHA])
 ```
 
-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`
+RULES: Do NOT update ROADMAP.md, PRDs, or create `.planning/` if missing.
 
-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.
+**Session state:** Write `.claude/memory/session.md` (create dir if needed):
+`# Session State` with Date, Developer, Branch, Working On (`/flow:task — [desc]`), Status, Next, Blockers fields.
 
-## Step 9 — Summary
+Lessons prompt via AskUserQuestion: "Any lessons worth capturing?" — "No" / "Yes, let me describe it" → capture to `tasks/lessons.md` as one-liner. Skip if lessons.md doesn't exist. If at 10, promote most battle-tested to `CLAUDE.md ## Learned Rules` first.
 
-Print a compact completion block:
+## Step 9 — Summary
 
 ```
 ✓ /flow:task complete
-  [description of what was done]
+  [description]
   Files: [N] changed | Commit: [short SHA]
   Verified: [pass/fail/skipped]
 
 Next:
-  → /flow:task [description] for another quick fix
+  → /flow:task [desc] for another quick fix
   → /flow:go to continue project milestones
   → /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
+**Linear comment:** If branch name contains a Linear issue ID (e.g., `msig-45` in `feat/msig-45-rate-modeling`):
+- Try `mcp__linear__list_issues` matching the identifier
+- If Linear MCP available AND issue found: post progress comment via `mcp__linear__create_comment` with task summary
+- Otherwise: skip silently
 
-If no Linear identifier is found in the branch name: skip silently.
+No Linear ID in branch name: skip silently.

package/skills/flow-triage.md

@@ -6,9 +6,9 @@ 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.
+You are executing the `/flow:triage` skill. Takes a brain dump (text blob, bullets, or stream of consciousness) and sorts it into actionable categories.
 
-**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.
+**Skill boundary:** Only use `/flow:*` commands. Never invoke or suggest `/lisa:*`, `/gsd:*`, `/superpowers:*` or any non-flow skill.
 
 ## Step 1 — Input
 
@@ -20,40 +20,38 @@ IF no argument: use AskUserQuestion: "Paste your brain dump — bullet list, str
 ## Step 2 — Context Load
 
 Read in parallel (skip gracefully if missing):
-- `.planning/ROADMAP.md` — to understand existing projects and avoid duplicates
-- `tasks/lessons.md` — to check for existing lessons and enforce cap
+- `.planning/ROADMAP.md` — existing projects, avoid duplicates
+- `tasks/lessons.md` — existing lessons, 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
+For each distinct item, classify into one of:
+- **Linear Issue** — actionable task, bug, or feature → becomes a Linear issue
 - **ROADMAP Entry** — future project or milestone idea → append to ROADMAP.md Future section
 - **Lesson** — learning, pattern, or rule → append to tasks/lessons.md
-- **Project** — project-sized work item → add to ROADMAP.md as a planned project
-- **Discard** — not actionable, already done, duplicate, or too vague to action
+- **Project** — project-sized work → add to ROADMAP.md as planned project
+- **Discard** — not actionable, duplicate, or too vague
 
 ## Step 4 — Present Plan
 
-Show the full categorization in a table:
+Show 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 |
-| 5 | "Student leasing rate modeling" | Project | Add to ROADMAP as planned project |
+| 3 | "Student leasing rate modeling" | Project | Add to ROADMAP as planned project |
 ```
 
 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.
+If the user wants changes, update and present again.
 
 ## Step 5 — Execute
 
@@ -61,37 +59,34 @@ 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:
+- If available: create issues with `mcp__linear__create_issue` (team: "Monument Square", default project: "Future / Backlog" unless a better match exists)
+- If not available: print 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
+- Append to `.planning/ROADMAP.md` under "Future (Unscheduled)" section (create if missing)
 - Format: `| [name] | Unscheduled | — |`
 
 **Projects:**
-- Add to `.planning/ROADMAP.md` main project table with status "Planned"
-- Add a section with the project goal: `## [Project Name]\n\n**Goal:** [goal]\n\n**Milestones:** Run /flow:spec when this project is active.`
-- If no active project exists (all existing projects are "Complete" or none exist):
-  - Set the first new project's status to "Pending — needs `/flow:spec`"
-  - Update STATE.md to point to the new project as current
-- Optionally create a Linear project (if Linear MCP tools available via `mcp__linear__list_teams`)
+- Add to `.planning/ROADMAP.md` project table with status "Planned"
+- Add section: `## [Project Name]\n\n**Goal:** [goal]\n\n**Milestones:** Run /flow:spec when this project is active.`
+- If no active project exists (all "Complete" or none):
+  - Set first new project status to "Pending — needs `/flow:spec`"
+  - Update STATE.md to point to new project as current
+- Optionally create a Linear project (if MCP available)
 
 **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
+- Create `tasks/lessons.md` if it doesn't exist
 
 **Discard:** No action needed.
 
 ## Step 6 — Summary
 
-Print a compact completion block:
-
 ```
 Triage complete:
 - [N] Linear issues created (in [project names])
@@ -101,10 +96,9 @@ Triage complete:
 - [N] items discarded
 ```
 
-Then suggest next actions:
+Next actions:
 ```
-Next:
-  → /flow:triage for another brain dump
-  → /flow:spec to plan a project from triaged items
-  → /flow:status to see current state
+→ /flow:triage for another brain dump
+→ /flow:spec to plan a project from triaged items
+→ /flow:status to see current state
 ```