@tianhai/pi-workflow-kit 0.17.1 → 0.18.1

package/README.md

@@ -28,7 +28,7 @@ Enforces phase-appropriate tool access — not just guidelines, but hard blocks:
 
 | Phase | `write` / `edit` | `bash` |
 |-------|:-:|:-:|
-| **Brainstorm** / **Plan** | 🔒 Blocked outside `docs/plans/` | 🔒 Read-only only (grep, find, cat, git status, curl…) |
+| **Brainstorm** / **Plan** / **Verify** | 🔒 Blocked outside `docs/plans/` | 🔒 Read-only only (grep, find, cat, git status, curl…) |
 | **Execute** / **Finalize** | ✅ Full access | ✅ Full access |
 
 The agent can read code and discuss design with you during brainstorm/plan, but it physically cannot modify source files or run mutating commands.
@@ -37,19 +37,21 @@ The agent can read code and discuss design with you during brainstorm/plan, but
 
 Guide the agent through a disciplined development process:
 
-brainstorm → design-review → plan → execute → verify → finalize
-                                           ↕
-                                        diagnose (anytime)
+brainstorm → plan → [design-review?] → execute → [verify?] → finalize
+                ↕
+             diagnose (anytime)
+
+For multi-feature designs, the plan→execute loop repeats per feature.
 
 | Phase | Trigger | What Happens |
 |-------|---------|--------------|
-| **Brainstorm** | `/skill:brainstorming` | Explore approaches, debate tradeoffs, produce a design doc |
-| **Design Review** | `/skill:design-review` | Audit design for production risks (security, scalability, fault tolerance) |
-| **Plan** | `/skill:writing-plans` | Break design into bite-sized TDD tasks with acceptance criteria and concrete code |
-| **Execute** | `/skill:executing-tasks` | Implement tasks one-by-one with TDD discipline and pre-commit checkpoint review gates |
-| **Verify** | `/skill:verify` | Three expert review passes (security, optimization, traceability) on implemented code |
-| **Finalize** | `/skill:finalizing` | Archive plan docs, update README/CHANGELOG, create PR |
-| **Diagnose** | `/skill:diagnose` | 6-phase debugging loop: reproduce → hypothesize → instrument → fix → verify |
+| **Brainstorm** | `/skill:pwk-brainstorming` | Explore approaches, debate tradeoffs, produce a design doc with a Features table |
+| **Design Review** | `/skill:pwk-design-review` | Audit plan and design for production risks (security, scalability, fault tolerance) |
+| **Plan** | `/skill:pwk-writing-plans` | Plan one feature at a time from the Features table — bite-sized TDD tasks with acceptance criteria |
+| **Execute** | `/skill:pwk-executing-tasks` | Implement tasks one-by-one with TDD discipline and pre-commit checkpoint review gates |
+| **Verify** | `/skill:pwk-verify` | Three expert review passes (security, optimization, traceability) on implemented code |
+| **Finalize** | `/skill:pwk-finalizing` | Archive plan docs, update README/CHANGELOG, create PR |
+| **Diagnose** | `/skill:pwk-diagnose` | 6-phase debugging loop: reproduce → hypothesize → instrument → fix → verify |
 
 ## The Workflow in Detail
 
@@ -57,12 +59,24 @@ brainstorm → design-review → plan → execute → verify → finalize
 
 You control each phase — the agent never advances on its own. Invoke a skill to move forward:
 
-/skill:brainstorming   →  discuss and design
-/skill:design-review   →  audit for production risks (non-trivial designs)
-/skill:writing-plans   →  break into tasks
-/skill:executing-tasks →  implement with TDD
-/skill:verify          →  review code for security, optimization, and traceability issues
-/skill:finalizing      →  ship it
+/skill:pwk-brainstorming   →  discuss and design (names features)
+/skill:pwk-writing-plans   →  plan next feature from the Features table
+/skill:pwk-design-review   →  audit for production risks (on demand)
+/skill:pwk-executing-tasks →  implement with TDD
+/skill:pwk-verify           →  review code for security, optimization, and traceability
+/skill:pwk-finalizing       →  ship it
+
+### Feature-Based Planning
+
+Design docs include a `## Features` table that tracks each feature's status:
+
+| # | Feature | Status | Notes |
+|---|---------|--------|-------|
+| 1 | User signup | ✅ done | |
+| 2 | Email verification | 🔄 planned | Plan: docs/plans/...-email-verification-implementation.md |
+| 3 | Password reset | ⬜ pending | |
+
+This enables incremental development — plan and execute one feature at a time, then loop back for the next.
 
 ### TDD Three-Scenario Model
 
@@ -110,27 +124,23 @@ Optionally label tasks with a `checkpoint` to pause for human review. At each ch
 pi install npm:@tianhai/pi-workflow-kit
 
 # Start a new feature
-> /skill:brainstorming
+> /skill:pwk-brainstorming
 > I want to add OAuth2 login to our API
 
-# (agent explores approaches, writes design doc)
+# (agent explores approaches, writes design doc with Features table)
 # (write/edit are blocked — your code is safe)
 
-> /skill:design-review
-
-# (agent audits for security, scalability, fault tolerance)
-# (trivial changes can skip this step)
-
-> /skill:writing-plans
+> /skill:pwk-writing-plans
 
-# (agent breaks design into TDD tasks with acceptance criteria)
-> /skill:executing-tasks
+# (agent picks next feature, breaks into TDD tasks)
+# (triggers design review for non-trivial features)
+> /skill:pwk-executing-tasks
 
 # (agent implements with TDD, cognitive persona shifts, all tools unlocked)
-> /skill:verify
+> /skill:pwk-verify
 
 # (agent runs security, optimization, and traceability reviews on implemented code)
-> /skill:finalizing
+> /skill:pwk-finalizing
 
 # (agent archives docs, curates lessons, creates PR)
 ```
@@ -147,15 +157,15 @@ pi install npm:@tianhai/pi-workflow-kit
 ```
 pi-workflow-kit/
 ├── extensions/
-│   └── workflow-guard.ts      # Write blocker during brainstorm/plan
+│   └── workflow-guard.ts      # Write blocker during brainstorm/plan/verify
 ├── skills/
-│   ├── brainstorming/SKILL.md
-│   ├── design-review/SKILL.md
-│   ├── writing-plans/SKILL.md
-│   ├── executing-tasks/SKILL.md
-│   ├── verify/SKILL.md
-│   ├── finalizing/SKILL.md
-│   └── diagnose/SKILL.md
+│   ├── pwk-brainstorming/SKILL.md
+│   ├── pwk-design-review/SKILL.md
+│   ├── pwk-writing-plans/SKILL.md
+│   ├── pwk-executing-tasks/SKILL.md
+│   ├── pwk-verify/SKILL.md
+│   ├── pwk-finalizing/SKILL.md
+│   └── pwk-diagnose/SKILL.md
 ├── tests/
 │   └── workflow-guard.test.ts
 ├── package.json

package/docs/developer-usage-guide.md

@@ -4,8 +4,9 @@ How to install and use `pi-workflow-kit` with the Pi coding agent.
 
 ## What you get
 
-- **4 skills** that guide the agent through a structured workflow
-- **1 extension** that hard-blocks source writes during brainstorm and plan phases
+- **4 workflow skills** that guide the agent through a structured feature-based workflow
+- **3 on-demand skills** for design review, verification, and debugging
+- **1 extension** that hard-blocks source writes during brainstorm, plan, and verify phases
 
 ## Installation
 
@@ -31,54 +32,70 @@ Or in `.pi/settings.json` / `~/.pi/agent/config.json`:
 
 ## The workflow
 
-You control each phase by invoking the skill:
+You control each phase by invoking the skill. For multi-feature designs, the plan→execute loop repeats per feature:
 
 ```
-/skill:brainstorming  →  /skill:writing-plans  →  /skill:executing-tasks  →  /skill:finalizing
+/skill:pwk-brainstorming  →  /skill:pwk-writing-plans  →  /skill:pwk-executing-tasks  →  loop or /skill:pwk-finalizing
 ```
 
 ### 1. Brainstorm
 
 ```
-/skill:brainstorming
+/skill:pwk-brainstorming
 ```
 
 Explore the idea through collaborative dialogue. The agent reads code, asks questions one at a time, proposes 2-3 approaches, and presents the design in sections for your review.
 
-Outcome: `docs/plans/YYYY-MM-DD-<topic>-design.md`
+Outcome: `docs/plans/YYYY-MM-DD-<topic>-design.md` with a `## Features` table
 
 Optionally writes ADRs to `docs/plans/adr/` for significant architectural decisions.
 
 ### 2. Plan
 
 ```
-/skill:writing-plans
+/skill:pwk-writing-plans
 ```
 
-Read the design doc and break it into bite-sized tasks with exact file paths, complete code, and TDD scenarios. Optionally set up a branch or worktree.
+Read the design doc's Features table, pick the next `⬜ pending` feature, and create a per-feature implementation plan with exact file paths, complete code, and TDD scenarios. Optionally set up a branch or worktree.
 
-Outcome: `docs/plans/YYYY-MM-DD-<topic>-implementation.md`
+Outcome: `docs/plans/YYYY-MM-DD-<topic>-<feature-name>-implementation.md`
 
 ### 3. Execute
 
 ```
-/skill:executing-tasks
+/skill:pwk-executing-tasks
 ```
 
-Implement the plan task-by-task. Each task: implement → run tests → fix if needed → commit.
+Implement the plan task-by-task. Each task: implement → run tests → fix if needed → commit. When the feature is done, marks it `✅ done` in the design doc and suggests planning the next feature.
 
 ### 4. Finalize
 
 ```
-/skill:finalizing
+/skill:pwk-finalizing
 ```
 
 Archive plan docs, update CHANGELOG/README, create PR, clean up worktree.
 
-### 5. Diagnose (on demand)
+### 5. Design Review (on demand)
 
 ```
-/skill:diagnose
+/skill:pwk-design-review
+```
+
+Audit a plan doc for production risks — security, scalability, fault tolerance, and operational hazards. Triggered by writing-plans for non-trivial features. Review findings append to the plan doc, not the design doc.
+
+### 6. Verify (on demand)
+
+```
+/skill:pwk-verify
+```
+
+Post-implementation verification with three expert passes — security, optimization, and traceability. Run after executing a feature or before finalizing.
+
+### 7. Diagnose (on demand)
+
+```
+/skill:pwk-diagnose
 ```
 
 A 6-phase debugging loop you invoke when something is broken. Build a feedback loop first, then reproduce, hypothesise, instrument, fix, and cleanup. Not a pipeline phase — use whenever needed.
@@ -88,6 +105,7 @@ A 6-phase debugging loop you invoke when something is broken. Build a feedback l
 The `workflow-guard` extension watches `write` and `edit` tool calls:
 
 - **During brainstorm and plan**: blocks writes outside `docs/plans/`. The agent can read code and use bash, but cannot modify source files.
+- **During verify**: same read-only enforcement — the agent can inspect code but not modify it.
 - **During execute and finalize**: no restrictions. All tools available.
 
 No configuration needed. It activates automatically after install.

package/docs/lessons.md

@@ -0,0 +1,18 @@
+# Lessons Learned
+
+<!--
+Agent: read this at the start of each task during executing-tasks.
+Follow every rule. Add new rules when you catch yourself making repeat mistakes.
+Rules must be generic patterns applicable to any domain or feature — not specific to one service, entity, or use case.
+Retire rules that no longer apply during finalizing.
+-->
+
+## Cross-Skill Consistency
+
+- When adding instructions that reference artifacts from another skill (e.g., "extract metadata from plan doc"), always add a guard for when that artifact doesn't exist — not all workflows use all artifacts
+- When reordering instructions within a step, verify all conditional branches still reference the correct context (e.g., hazard checks that say "this feature" must run after feature identification)
+
+## Documentation
+
+- When adding a new phase to an extension, update ALL comments and error messages — stale comments in one place create confusion about the actual behavior
+- When renaming skills with a prefix, check for `/skill:` references in prose and code blocks separately — backtick-enclosed references in code examples may use a different pattern than prose references

package/docs/oversight-model.md

@@ -6,10 +6,16 @@
 
 Skills teach the agent the workflow. There are 4:
 
-- **brainstorming** — explore ideas, produce a design doc
-- **writing-plans** — break design into TDD tasks
-- **executing-tasks** — implement tasks, handle code review
-- **finalizing** — archive docs, create PR
+- **pwk-brainstorming** — explore ideas, produce a design doc with a Features table
+- **pwk-writing-plans** — plan one feature at a time from the Features table
+- **pwk-executing-tasks** — implement tasks, mark features done, loop to next feature
+- **pwk-finalizing** — archive docs, create PR
+
+Plus 3 on-demand skills:
+
+- **pwk-design-review** — audit a plan doc for production risks (triggered by writing-plans)
+- **pwk-verify** — post-implementation verification with security, optimization, and traceability passes
+- **pwk-diagnose** — 6-phase debugging loop
 
 They explain *what* to do and *when* to do it.
 
@@ -17,7 +23,7 @@ They explain *what* to do and *when* to do it.
 
 The `workflow-guard` extension enforces one rule:
 
-> During brainstorm and plan phases, `write` and `edit` are **hard-blocked** outside `docs/plans/`.
+> During brainstorm, plan, and verify phases, `write` and `edit` are **hard-blocked** outside `docs/plans/`.
 
 The agent can still use `read` and `bash` for investigation. It literally cannot call `write` or `edit` on source files — the tools are blocked at the extension level.
 

package/docs/plans/completed/2026-06-09-code-review-fixes-implementation.md

@@ -0,0 +1,74 @@
+# Implementation Plan: Code review findings fix
+
+## Overview
+
+Fix 5 findings from the cross-skill code review. All are small — documentation clarity and minor correctness guards.
+
+## Task 1: Add explicit fallback documentation in executing-tasks "Find the plan"
+
+<!-- tdd: trivial -->
+
+Fix finding #1. The primary path expects a design doc with Features table, but the fallback for plans without one is implicit.
+
+Files:
+- `skills/pwk-executing-tasks/SKILL.md`
+
+Steps:
+1. In step 2 ("Find the plan"), after the fallback sentence, append: "This covers plans created without a brainstorm session (no design doc or Features table)."
+
+## Task 2: Add metadata-missing guard in executing-tasks per-task step 2
+
+<!-- tdd: trivial -->
+
+Fix finding #2. When a plan has no `Design:` / `Feature:` metadata (no Features table), the "Extract metadata" instruction is dangling.
+
+Files:
+- `skills/pwk-executing-tasks/SKILL.md`
+
+Steps:
+1. In per-task step 2, after "Extract the `Design:` and `Feature:` metadata to know which design doc and feature row this execution covers.", add: "If no `Design:` or `Feature:` metadata is present, the plan covers the entire design (no feature table). Skip design doc reading and proceed directly to task execution."
+
+## Task 3: Document worktree handoff behavior for multi-feature plans
+
+<!-- tdd: trivial -->
+
+Fix finding #3. The worktree glob moves all plan docs, which is correct but should be documented explicitly.
+
+Files:
+- `skills/pwk-executing-tasks/SKILL.md`
+
+Steps:
+1. In step 3b ("Move plan docs into the worktree"), add a note before the mv commands:
+   > When using the feature table, all plan docs for this design move together — completed feature plans, the current feature's plan, and the design doc. This is intentional: the worktree works on one design at a time.
+
+## Task 4: Add unstarted-features guard to finalizing
+
+<!-- tdd: trivial -->
+
+Fix finding #4. Archiving the design doc while features are still `⬜ pending` makes them invisible to future planning.
+
+Files:
+- `skills/pwk-finalizing/SKILL.md`
+
+Steps:
+1. In step 1 ("Move planning docs"), before the archive commands, add a check:
+   > If the design doc has a `## Features` table with any `⬜ pending` or `🔄 planned` features, warn:
+   > ```
+   > ⚠️ Design doc has N unplanned features. Archive anyway, or go back to plan them?
+   > ```
+   > Wait for the user to confirm before proceeding.
+
+## Task 5: Add verification report to finalizing archive step
+
+<!-- tdd: trivial -->
+
+Fix finding #5. Verification reports are left behind in `docs/plans/` after finalizing.
+
+Files:
+- `skills/pwk-finalizing/SKILL.md`
+
+Steps:
+1. In step 1, after the existing `mv` commands, add:
+   ```
+   mv docs/plans/*-verification-report.md docs/plans/completed/ 2>/dev/null || true
+   ```

package/docs/plans/completed/2026-06-09-code-review-fixes-progress.md

@@ -0,0 +1,14 @@
+# Progress: Code review fixes
+
+Plan: docs/plans/2026-06-09-code-review-fixes-implementation.md
+Branch: incremental-workflow-and-rename
+Started: 2026-06-09T23:15:00
+Last updated: 2026-06-09T23:15:00
+
+| # | Status | Task | Commit |
+|---|--------|------|--------|
+| 1 | ✅ done | Add explicit fallback docs in executing-tasks "Find the plan" | 1ab7825 |
+| 2 | ✅ done | Add metadata-missing guard in executing-tasks per-task step 2 | 1ab7825 |
+| 3 | ✅ done | Document worktree handoff for multi-feature plans | 1ab7825 |
+| 4 | ✅ done | Add unstarted-features guard to finalizing | 1ab7825 |
+| 5 | ✅ done | Add verification report to finalizing archive step | 1ab7825 |

package/docs/plans/completed/2026-06-09-incremental-workflow-and-rename-design.md

@@ -0,0 +1,186 @@
+# Incremental Workflow & Skill Rename
+
+## Problem
+
+Three issues with the current workflow:
+
+1. **Design review runs too early.** The 8 hazard checks evaluate concrete code (missing indexes, raw SQL interpolation, unbounded concurrency). A design doc is too vague to audit effectively — most hazards are invisible until the plan has actual code.
+2. **Large features create context pressure.** Planning all tasks upfront, then executing them all, means a 20-task plan accumulates massive context. Lessons learned mid-execution can't reshape later tasks. The plan goes stale.
+3. **Skills aren't namespaced.** All 7 skills live in a flat namespace, making it hard to discover which skills belong to pi-workflow-kit versus third-party or user-installed skills.
+
+## Decision
+
+1. **Move design review after writing-plans.** The plan doc has concrete code, making hazard checks meaningful. Writing-plans already flags high-risk areas — when flagged, suggest design-review before executing.
+2. **Incremental feature-based workflow.** Brainstorm names features. Each feature gets its own plan → execute → optional verify cycle. The brainstorm doc's `## Features` table tracks overall progress.
+3. **Rename all skills with `pwk-` prefix.** All 7 skills and all cross-references updated.
+
+## Workflow Change
+
+### Before
+
+```
+brainstorm → [design-review?] → plan (all tasks) → execute (all tasks) → [verify?] → finalize
+```
+
+### After
+
+```
+brainstorm (name features)
+  → plan next feature
+    → [design-review if hazards flagged]
+    → execute feature
+    → [verify this feature? (optional)]
+    → more features? → loop back to plan
+    → all done?
+      → [verify everything? (optional)]
+      → finalize
+```
+
+## Feature Table
+
+Brainstorm doc adds a `## Features` table. Simple features get one row. Complex features get many. The table is the feature-level state machine — it answers "what's next?" at any point.
+
+```markdown
+## Features
+
+| # | Feature | Status | Observable Behavior |
+|---|---------|--------|---------------------|
+| 1 | User signup | ✅ done | User can create account with email+password |
+| 2 | Email verification | 🔄 planned | User receives and confirms verification email |
+| 3 | Password reset | ⬜ pending | User can reset password via email link |
+```
+
+Status values: `⬜ pending`, `🔄 planned`, `✅ done`, `⏭ skipped`.
+
+### Table maintenance
+
+- **Brainstorm** creates the table with all rows as `⬜ pending`
+- **Writing-plans** marks the next feature as `🔄 planned` when it creates a plan for it
+- **Executing-tasks** marks the feature as `✅ done` (or `⏭ skipped`) after completing all its tasks
+- **Any skill can add rows** if a new feature is discovered mid-implementation (human decides, not agent)
+- The table is a living document. If features need merging, splitting, or reordering, the human directs changes during execution
+
+## Design Review Changes
+
+### Timing
+
+Design review moves from after-brainstorm to after-writing-plans.
+
+**Trigger mechanism (already exists in writing-plans step 1):** Writing-plans checks for hazards (DB schema changes, auth, external APIs, concurrency, uploads, Redis/MQ). If any apply AND no architectural review section exists → prompt user to run `/skill:pwk-design-review` or type 'proceed' to skip.
+
+If the plan doc notes "Simple change — no design review needed" → skip.
+
+### Review input
+
+Design review reads both the plan doc (concrete code) and the design doc (architectural context). This is better than the current flow — concrete code makes hazards visible.
+
+### No mandatory per-feature review
+
+Design review is suggested, not mandatory, for each feature. The writing-plans hazard check gates it. Low-risk features skip it entirely.
+
+## Verify Changes
+
+### Two modes
+
+| | Per-feature verify | Full verify |
+|---|---|---|
+| **Scope** | One feature's code | All feature code together |
+| **Catches** | Security, dead code, traceability within the feature | Cross-feature integration, duplicated patterns across features, overall consistency |
+| **When** | After each feature (optional, human-initiated) | After all features (optional, human-initiated) |
+| **Cost** | Low — small code surface | Higher — full codebase |
+
+Neither is mandatory. The human decides based on risk and complexity.
+
+### Executor prompts
+
+After completing a feature:
+```
+✅ Feature "<name>" complete.
+⏭  Next: "<next feature name>"
+💡 Options:
+   - Plan next feature: /skill:pwk-writing-plans
+   - Verify this feature first: /skill:pwk-verify
+   - Or just say "continue"
+```
+
+After all features complete:
+```
+✅ All features complete!
+   - Verify everything: /skill:pwk-verify
+   - Ship: /skill:pwk-finalizing
+```
+
+## Per-Feature Execution Model
+
+### Plan docs
+
+One plan doc per feature: `docs/plans/YYYY-MM-DD-<topic>-<feature-name>-implementation.md`
+
+### Progress docs
+
+One progress doc per feature: `docs/plans/YYYY-MM-DD-<topic>-<feature-name>-progress.md`
+
+### Feature loop
+
+1. **Writing-plans** reads design doc, identifies next `⬜ pending` feature, marks it `🔄 planned`, writes plan doc for that feature
+2. **Design review** (if triggered) reviews plan doc + design doc
+3. **Executing-tasks** executes the feature's plan, marks feature `✅ done` in design doc table
+4. **Verify** (optional) reviews just the feature's code
+5. **Loop** back to step 1 if more `⬜ pending` features exist
+
+### Session boundaries
+
+Each plan → execute cycle is a natural session break. The executor suggests `/new` between features for clean context, as it already does for long task runs.
+
+## Skill Rename
+
+All 7 skills renamed with `pwk-` prefix:
+
+| Current | New |
+|---------|-----|
+| brainstorming | pwk-brainstorming |
+| writing-plans | pwk-writing-plans |
+| executing-tasks | pwk-executing-tasks |
+| design-review | pwk-design-review |
+| verify | pwk-verify |
+| finalizing | pwk-finalizing |
+| diagnose | pwk-diagnose |
+
+All cross-references between skills updated (e.g. `Run /skill:executing-tasks` → `Run /skill:pwk-executing-tasks`).
+
+## Files Changed
+
+### Skill files (rename + content updates)
+- `skills/brainstorming/SKILL.md` → `skills/pwk-brainstorming/SKILL.md`
+- `skills/writing-plans/SKILL.md` → `skills/pwk-writing-plans/SKILL.md`
+- `skills/executing-tasks/SKILL.md` → `skills/pwk-executing-tasks/SKILL.md`
+- `skills/design-review/SKILL.md` → `skills/pwk-design-review/SKILL.md`
+- `skills/verify/SKILL.md` → `skills/pwk-verify/SKILL.md`
+- `skills/finalizing/SKILL.md` → `skills/pwk-finalizing/SKILL.md`
+- `skills/diagnose/SKILL.md` → `skills/pwk-diagnose/SKILL.md`
+
+### Documentation
+- `docs/workflow-phases.md` — update skill names and flow diagram
+- `docs/oversight-model.md` — update skill names
+- `docs/developer-usage-guide.md` — update skill names
+
+### Extension
+- `extensions/workflow-guard.ts` — update skill name references:
+  - `SKILL_TO_PHASE` keys: `brainstorming` → `pwk-brainstorming`, `writing-plans` → `pwk-writing-plans`
+  - Phase-clearing triggers: `/skill:executing-tasks` → `/skill:pwk-executing-tasks`, `/skill:finalizing` → `/skill:pwk-finalizing`
+  - Add `"pwk-verify": "verify"` to `SKILL_TO_PHASE` — enforce write restriction (only `docs/plans/`) during verify phase, matching the skill's read-only claim
+- `tests/workflow-guard.test.ts` — update all skill name references and add test cases for `pwk-verify` phase
+
+## Features (implementation slices)
+
+1. **Rename skill directories and files** — move all 7 skill folders to `pwk-` prefix names, update frontmatter names
+2. **Update cross-references in all skills** — find-and-replace all `/skill:` references across all 7 skill files
+3. **Add feature table to brainstorming** — update brainstorming skill to produce a `## Features` table in design doc
+4. **Update writing-plans for feature-at-a-time** — detect next `⬜ pending` feature, plan only that feature, mark `🔄 planned`, update file naming to per-feature
+5. **Update executing-tasks for feature loop** — mark feature `✅ done` after all tasks, suggest next feature or verify/finalize
+6. **Move design review trigger** — remove brainstorm's "after design" review suggestion, confirm writing-plans already has the trigger (it does)
+7. **Update executor end-of-feature prompts** — new prompt format with verify option and next feature
+8. **Update workflow-guard extension** — rename skill references, add `pwk-verify` to phase map
+9. **Update documentation** — workflow-phases.md, oversight-model.md, developer-usage-guide.md
+
+Simple change — no design review needed.