@tianhai/pi-workflow-kit 0.17.1 → 1.0.0

package/docs/plans/completed/2026-05-01-incorporate-mattpocock-skills-progress.md

@@ -1,15 +0,0 @@
-# Progress: incorporate-mattpocock-skills
-
-Plan: docs/plans/2026-05-01-incorporate-mattpocock-skills-implementation.md
-Branch: incorporate-mattpocock-skills
-Started: 2026-05-01T00:00:00Z
-Last updated: 2026-05-01T00:00:00Z
-
-| # | Status | Task | Commit |
-|---|--------|------|--------|
-| 1 | ✅ done | Update brainstorming skill — design it twice + ADRs | 0231b84 |
-| 2 | ✅ done | Update writing-plans skill — vertical slices | 22a46df |
-| 3 | ✅ done | Update executing-tasks skill — deep modules refactoring | c405634 |
-| 4 | ✅ done | Create diagnose skill | 5e39e2d |
-| 5 | ✅ done | Update finalizing skill — archive ADRs | e31a1af |
-| 6 | ✅ done | Update documentation (README, usage guide, workflow phases) | 8c1c4eb |

package/docs/plans/completed/2026-05-08-checkpoint-gates-design.md

@@ -1,235 +0,0 @@
-# Design: Checkpoint gates and pre-commit discipline
-
-## Problem
-
-The `executing-tasks` skill instructs the agent to pause at checkpoints for human review before committing. In practice, the agent commits first then presents the review, defeating the purpose of checkpoints.
-
-Root causes in executing-tasks:
-1. "PAUSE if" reads as optional — the agent interprets it as "if you remember"
-2. Steps 6-12 flow together as implement→commit — the pause gets swallowed
-3. The diff format asks for committed state — nudges the agent to commit first
-
-Root causes in writing-plans:
-4. Task format says `git commit` after each task — the agent sees the commit line past the checkpoint and skips to it
-5. Refactor and lessons are optional-sounding steps at the end of a long list — the agent skips them
-6. The plan body has no structural enforcement — everything is just text the agent reads at once
-
-Secondary issue: the agent skips steps 9 (Refactor if needed) and 10 (Learn from mistakes) because they're optional-sounding steps at the end of a long list.
-
-## Key insight
-
-The agent follows numbered steps and skips loose sections. **Output requirements** (things the agent has to produce) are stronger than instructions (things the agent is told to do). The checkpoint review format forces the agent to report refactoring and lessons — that's the enforcement mechanism.
-
-No-checkpoint tasks are simple enough that refactor/lessons genuinely aren't needed — the task author chose no checkpoint because the task is trivial.
-
-## Solution
-
-- **writing-plans**: Generate task bodies with numbered steps (including refactor/lessons for checkpointed tasks) and checkpoint gates. Never include `git commit` in the plan.
-- **executing-tasks**: Simplified runner — follow the plan step by step, pause at checkpoint gates, commit after approval.
-- **Progress file**: Use Status column to enforce checkpoint gates. Agent can't go from `🔄 in-progress` → `✅ done` if the task has a checkpoint — must go through `⏸ test-review` or `⏸ done-review` first.
-
-## Design
-
-### Writing-plans: task format
-
-The plan never includes `git commit`. That's the executing-tasks skill's responsibility.
-
-**No-checkpoint task:**
-
-```markdown
-## Task 1: Create User model
-
-<!-- tdd: new-feature -->
-<!-- checkpoint: none -->
-
-Files:
-- `src/user/model.ts`
-- `src/user/model.test.ts`
-
-Steps:
-1. Write failing test for User model creation
-2. Run test — confirm it fails
-3. Implement User model
-4. Run test — confirm it passes
-```
-
-**Checkpoint: test task:**
-
-```markdown
-## Task 2: Write auth tests
-
-<!-- tdd: new-feature -->
-<!-- checkpoint: test -->
-
-Files:
-- `src/auth/login.test.ts`
-
-Steps:
-1. Write failing test for login with valid credentials
-2. Run test — confirm it fails
-
-⏸ **CHECKPOINT: test** — present test review. Wait for human approval before implementing.
-
-3. Implement login handler
-4. Run test — confirm it passes
-5. Refactor — check for shallow modules, duplication, seam discipline. Run tests after changes.
-6. Lessons — caught a mistake that applies to future tasks? Add rule to `docs/lessons.md`.
-```
-
-**Checkpoint: done task:**
-
-```markdown
-## Task 3: Add login endpoint
-
-<!-- tdd: new-feature -->
-<!-- checkpoint: done -->
-
-Files:
-- `src/auth/login.ts`
-- `src/auth/login.test.ts`
-
-Steps:
-1. Write failing test for login with valid credentials
-2. Run test — confirm it fails
-3. Implement login handler
-4. Run test — confirm it passes
-5. Add edge case tests (invalid password, missing email)
-6. Refactor — check for shallow modules, duplication, seam discipline. Run tests after changes.
-7. Lessons — caught a mistake that applies to future tasks? Add rule to `docs/lessons.md`.
-
-⏸ **CHECKPOINT: done** — present implementation review. Wait for human approval before committing.
-```
-
-**Task with both checkpoints:**
-
-```markdown
-## Task 4: Complex auth flow
-
-<!-- tdd: new-feature -->
-<!-- checkpoint: test -->
-<!-- checkpoint: done -->
-
-Steps:
-1. Write failing test for auth flow
-2. Run test — confirm it fails
-
-⏸ **CHECKPOINT: test** — present test review. Wait for human approval before implementing.
-
-3. Implement auth flow
-4. Run test — confirm it passes
-5. Refactor — check for shallow modules, duplication, seam discipline. Run tests after changes.
-6. Lessons — caught a mistake that applies to future tasks? Add rule to `docs/lessons.md`.
-
-⏸ **CHECKPOINT: done** — present implementation review. Wait for human approval before committing.
-```
-
-### Writing-plans: checkpoint labels table
-
-| Checkpoint | When to use | What the plan should say |
-|---|---|---|
-| *(none)* | Trivial tasks, well-understood changes | Numbered steps only |
-| **`checkpoint: test`** | Test design matters | Steps up to test → `⏸ CHECKPOINT: test` → implement steps (including refactor/lessons) |
-| **`checkpoint: done`** | Implementation review matters | Steps (including refactor/lessons) → `⏸ CHECKPOINT: done` |
-| Both | Non-obvious tests AND complex logic | Steps up to test → `⏸ CHECKPOINT: test` → implement steps (including refactor/lessons) → `⏸ CHECKPOINT: done` |
-
-### Executing-tasks: simplified runner
-
-The per-task execution becomes:
-
-1. Mark `🔄 in-progress` in progress file
-2. Read the current task from the plan
-3. Execute each numbered step in order
-4. When hitting `⏸ CHECKPOINT` in the plan:
-   - Update progress to `⏸ test-review` or `⏸ done-review`
-   - Present the checkpoint review (see format below)
-   - Wait for human approval
-   - On approval, update progress back to `🔄 in-progress`
-   - Continue with the next step
-5. After all steps are done (or for no-checkpoint tasks, after steps + commit):
-   - `git add` and commit with a clear message
-   - Update progress to `✅ done` + record commit hash
-
-### Progress file: Status-enforced gates
-
-Status values:
-
-| Status | Meaning |
-|--------|---------|
-| `⬜ pending` | Not started |
-| `🔄 in-progress` | Currently executing plan steps |
-| `⏸ test-review` | Paused at checkpoint: test, waiting for human approval |
-| `⏸ done-review` | Paused at checkpoint: done, waiting for human approval |
-| `✅ done` | Committed successfully |
-| `❌ failed` | Could not complete |
-| `⏭ skipped` | User chose to skip |
-
-Enforcement rules:
-- Agent cannot go from `🔄 in-progress` → `✅ done` if the task has a checkpoint
-- Must go through `⏸ test-review` or `⏸ done-review` first
-- Can only return to `🔄 in-progress` after human says "approve"
-- Can only go to `✅ done` after commit
-
-Example progress file:
-
-```markdown
-# Progress: Auth feature
-
-Plan: docs/plans/2026-05-08-auth-implementation.md
-Branch: auth-feature
-Started: 2026-05-08T10:00:00Z
-Last updated: 2026-05-08T10:05:00Z
-
-| # | Status | Task | Commit |
-|---|--------|------|--------|
-| 1 | ✅ done | Create User model | abc123 |
-| 2 | ⏸ done-review | Add login endpoint (checkpoint: done) | — |
-| 3 | ⬜ pending | Add auth middleware (checkpoint: done) | — |
-```
-
-### Checkpoint review format
-
-For `checkpoint: test`:
-
-```
-⏸ Paused at checkpoint: test for task [N]
-
-**Test written:** [show test code]
-**Expected behavior:** [what this validates]
-**Next:** Continue implementing after approval
-
-**Available actions:**
-- **Approve** — continue to implementation
-- **Request changes** — describe what to change
-- **Revert** — undo this task and mark it back to pending
-- `skip` — skip this task
-- `stop` — pause here, resume later with `/skill:executing-tasks`
-```
-
-For `checkpoint: done`:
-
-```
-⏸ Paused at checkpoint: done for task [N]
-
-**What was done:** [brief summary]
-**Refactoring done:** [what changed, or "none needed — [reason]"]
-**Lessons learned:** [new rule added, or "none"]
-**Diff:** [run `git diff --cached` or `git diff` — do NOT commit first]
-**Next:** Commit after approval
-
-**Available actions:**
-- **Approve** — commit and move to next task
-- **Request changes** — describe what to change
-- **Revert** — undo this task and mark it back to pending
-- `skip` — skip this task
-- `stop` — pause here, resume later with `/skill:executing-tasks`
-```
-
-## Files to change
-
-- `skills/writing-plans/SKILL.md` — update task format template and checkpoint labels section
-- `skills/executing-tasks/SKILL.md` — simplify per-task execution to plan-following runner, update progress file status values
-
-## What stays the same
-
-- executing-tasks: Before you start, First run, Resume, User override commands, Receiving code review, If you're stuck, After all tasks — all unchanged
-- writing-plans: Process steps, vertical slices, TDD section — all unchanged

package/docs/plans/completed/2026-05-08-checkpoint-gates-implementation.md

@@ -1,83 +0,0 @@
-# Implementation: Checkpoint gates and pre-commit discipline
-
-Design: `docs/plans/2026-05-08-checkpoint-gates-design.md`
-
-## Overview
-
-Update two skill files so that:
-1. `writing-plans` generates task bodies with checkpoint gates and numbered refactor/lessons steps, never includes `git commit`
-2. `executing-tasks` becomes a simplified plan-following runner with status-enforced checkpoint gates
-
-## Task 1: Update writing-plans task format and checkpoint labels
-
-<!-- tdd: trivial -->
-<!-- checkpoint: none -->
-
-Files:
-- `skills/writing-plans/SKILL.md`
-
-Changes:
-
-### Task format section
-
-Replace the task format section. Key changes:
-- Remove `git commit` from bullet points (commit is the executing-tasks skill's responsibility)
-- Remove `<!-- checkpoint: none -->` from the default template (omit when no checkpoint)
-- Add task body examples for each checkpoint type (none, test, done, both)
-- For checkpointed tasks, include numbered refactor and lessons steps
-- For checkpointed tasks, include `⏸ CHECKPOINT` gate in the task body
-- No task body should include `git commit`
-
-### Checkpoint labels section
-
-Replace the checkpoint labels table. Change the last column from "What happens during execution" to "What the plan should include", showing the gate structure for each checkpoint type.
-
-### TDD section
-
-Remove "→ commit" from the Instructions column — commit is not part of the plan.
-
-## Task 2: Update executing-tasks per-task execution and progress file
-
-<!-- tdd: trivial -->
-<!-- checkpoint: done -->
-
-Files:
-- `skills/executing-tasks/SKILL.md`
-
-Changes:
-
-### Per-task execution section
-
-Replace the current 15-step list with a simplified plan-following runner:
-
-1. Mark `🔄 in-progress` in progress file
-2. Read the current task from the plan
-3. Execute each numbered step in order
-4. When hitting `⏸ CHECKPOINT` in the plan:
-   - Update progress to `⏸ test-review` or `⏸ done-review`
-   - Present the checkpoint review
-   - Wait for human approval
-   - On approval, update progress back to `🔄 in-progress`
-   - Continue with the next step
-5. After all steps done:
-   - `git add` and commit with a clear message
-   - Update progress to `✅ done` + record commit hash
-
-Remove the inline refactor/lessons steps — they're now in the plan for checkpointed tasks.
-
-### Progress file section
-
-Add `⏸ test-review` and `⏸ done-review` status values. Add enforcement rule: agent cannot go from `🔄 in-progress` → `✅ done` if task has a checkpoint.
-
-### Checkpoint review section
-
-Update `checkpoint: done` review to include:
-- **Refactoring done:** field
-- **Lessons learned:** field
-- **Diff:** uses `git diff --cached` or `git diff`, with "do NOT commit first"
-
-Simplify available actions (remove "Adjust plan" since the plan drives execution).
-
-### Keep unchanged
-
-- Before you start, First run, Resume, User override commands, Receiving code review, If you're stuck, After all tasks

package/docs/plans/completed/2026-05-08-checkpoint-gates-progress.md

@@ -1,11 +0,0 @@
-# Progress: Checkpoint gates and pre-commit discipline
-
-Plan: docs/plans/2026-05-08-checkpoint-gates-implementation.md
-Branch: main
-Started: 2026-05-08T20:00:00Z
-Last updated: 2026-05-08T20:12:00Z
-
-| # | Status | Task | Commit |
-|---|--------|------|--------|
-| 1 | ✅ done | Update writing-plans task format and checkpoint labels | d39510c |
-| 2 | ✅ done | Update executing-tasks per-task execution and progress file (checkpoint: done) | 7c84f59 |

package/docs/plans/completed/2026-05-08-lessons-learned-design.md

@@ -1,76 +0,0 @@
-# Lessons Learned
-
-Date: 2026-05-08
-
-## Problem
-
-During task execution, the AI agent repeatedly makes the same project-specific mistakes — e.g., forgetting to run `make lint && make fmt` in Go projects, ignoring test helper conventions, or violating code style rules. These mistakes persist across sessions because there's no persistent memory the agent reads at the start of each task.
-
-## Solution
-
-A flat rules file (`docs/lessons.md`) that the agent reads before each task and writes to when it catches repeat mistakes. Integrated into the existing 4 workflow skills.
-
-## File: `docs/lessons.md`
-
-Created automatically when the first lesson is written. Never archived or moved.
-
-```markdown
-# 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.
-Retire rules that no longer apply during finalizing.
--->
-
-## Rules
-
-- After completing each task in a Go project, run `make lint && make fmt` before committing
-```
-
-### Rules for the agent
-
-- Each rule is a single bullet under `## Rules`
-- Write rules as imperative commands ("do X", "never Y", "always Z before W")
-- A rule is only added when it would **change future behavior** — not one-off errors
-- Rules can be removed (retired) during finalizing if they no longer apply
-
-## Data flow
-
-```
-brainstorming ──── reads lessons (context for design)
-       │
-writing-plans ──── reads lessons (informs task breakdown)
-       │
-executing-tasks ── reads lessons at start of EACH task
-       │            appends new lessons when catching repeat mistakes
-       │
-finalizing ─────── reviews session for missed lessons
-                    retires stale rules
-```
-
-Lessons are persisted to disk as soon as they're learned, so `/new` sessions don't lose them.
-
-## Skill changes
-
-### executing-tasks (3 changes)
-
-1. **Per-task execution, step 2** — add bullet: "Read `docs/lessons.md` if it exists — follow all rules listed there while working on this task."
-2. **New step between step 9 (refactor) and step 10 (checkpoint: done)** — "Learn from mistakes: if you caught yourself making a repeat mistake, append a rule to `docs/lessons.md`. Only add rules that would change future behavior."
-3. **"If you're stuck" section** — add at end: "Check `docs/lessons.md` — a previous lesson may be relevant."
-
-### finalizing (1 change)
-
-Add a new step before "Update documentation": "Review `docs/lessons.md` if it exists — add missed lessons, retire stale rules. Create it if lessons were learned but the file doesn't exist yet."
-
-### brainstorming (1 change)
-
-Step 2 (understand the idea) — add after checking package.json/dependencies: "Check `docs/lessons.md` if it exists — known constraints and patterns may affect the design."
-
-### writing-plans (1 change)
-
-Step 1 (check for a design doc) — add after reading relevant code: "Read `docs/lessons.md` if it exists — incorporate known patterns into the task breakdown."
-
-## Slice
-
-Single slice: all 5 skill changes + file format convention. No new skills, extensions, or config.

package/docs/plans/completed/2026-05-08-lessons-learned-implementation.md

@@ -1,219 +0,0 @@
-# Implementation Plan: Lessons Learned
-
-Design: `docs/plans/2026-05-08-lessons-learned-design.md`
-
-## Overview
-
-Add a `docs/lessons.md` rules file that the agent reads at natural points in the workflow and writes to when it catches repeat mistakes. Changes are purely instructional — edits to 4 SKILL.md files plus documentation updates.
-
-No TypeScript code changes. No new extensions or skills. The existing `workflow-guard.ts` already allows writes to `docs/` during execute/finalize phases (it only blocks outside `docs/plans/` during brainstorm/plan). Since `docs/lessons.md` is at `docs/` level (not inside `docs/plans/`), it won't interfere with archiving.
-
----
-
-## Task 1: Add lessons-learned read step to executing-tasks skill
-
-<!-- tdd: trivial -->
-<!-- checkpoint: done -->
-
-**File:** `skills/executing-tasks/SKILL.md`
-
-**Change 1** — In "Per-task execution", step 2, add a new bullet after the existing ones:
-
-```
-- **Read `docs/lessons.md` if it exists** — follow all rules listed there while working on this task.
-```
-
-The full step 2 should become:
-
-```markdown
-2. **Read the plan selectively** — read the plan's overview section (everything before `## Task 1:`). Skim all `## Task N:` headings for dependency awareness. Then read the current task's body in full. **Read `docs/lessons.md` if it exists** — follow all rules listed there while working on this task.
-```
-
-**Change 2** — In "Per-task execution", insert a new step between step 9 (Refactor if needed) and step 10 (checkpoint: done). The new step becomes step 10, and all subsequent steps renumber by 1 (step 10→11, 11→12, 12→13, 13→14, 14→15):
-
-```markdown
-10. **Learn from mistakes** — if you caught yourself making a mistake during this task that you've made before or that would apply to future tasks, append a rule to `docs/lessons.md`. Only add rules that would change future behavior. If the file doesn't exist, create it with the standard format (see below). Do not add one-off errors or things you self-corrected immediately.
-
-    **`docs/lessons.md` format:**
-    ```markdown
-    # 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.
-    Retire rules that no longer apply during finalizing.
-    -->
-
-    ## Rules
-
-    - <new rule here>
-    ```
-```
-
-**Change 3** — In "If you're stuck" section, add a new item at the end:
-
-```markdown
-5. **Check `docs/lessons.md`** — a previous lesson may be relevant to your current problem.
-```
-
-Renumber the existing item 4 to 5 if needed (it's currently the last item).
-
-**Command:**
-```
-git add skills/executing-tasks/SKILL.md
-git commit -m "feat(executing-tasks): read and write lessons learned per task"
-```
-
----
-
-## Task 2: Add lessons-learned review step to finalizing skill
-
-<!-- tdd: trivial -->
-<!-- checkpoint: none -->
-
-**File:** `skills/finalizing/SKILL.md`
-
-Insert a new step between the existing step 1 (Move planning docs) and step 2 (Update documentation). The new step becomes step 2, and existing steps 2-4 renumber to 3-5:
-
-```markdown
-2. **Review lessons learned** — if `docs/lessons.md` exists, review it:
-   - Add any lessons from this session that were missed during execution
-   - Retire rules that no longer apply (remove the bullet)
-   - If no changes are needed, leave it as-is
-
-   If `docs/lessons.md` doesn't exist but lessons were learned this session, create it with the standard format:
-
-   ```markdown
-   # 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.
-   Retire rules that no longer apply during finalizing.
-   -->
-
-   ## Rules
-
-   - <rule 1>
-   - <rule 2>
-   ```
-```
-
-**Command:**
-```
-git add skills/finalizing/SKILL.md
-git commit -m "feat(finalizing): review and update lessons learned"
-```
-
----
-
-## Task 3: Add lessons-learned read step to brainstorming skill
-
-<!-- tdd: trivial -->
-<!-- checkpoint: none -->
-
-**File:** `skills/brainstorming/SKILL.md`
-
-In step 2 (Understand the idea), add a new bullet after "check package.json/dependencies and module structure":
-
-```markdown
-   - **Check `docs/lessons.md`** if it exists — known constraints and patterns may affect the design.
-```
-
-The full relevant part of step 2 should become:
-
-```markdown
-2. **Understand the idea** — read existing code, docs, and recent commits. Grep for related functionality, check package.json/dependencies and module structure. **Check `docs/lessons.md`** if it exists — known constraints and patterns may affect the design. Read only what's necessary to ground the design — don't read the entire codebase. Ask questions to refine the idea. Prefer multiple choice when possible. After each question, check: can you clearly articulate (a) what the user wants to build, (b) why, and (c) key constraints? If yes, present your understanding as a short summary and ask: "Should I proceed with this, or is there more to add?" The human decides when to move on.
-```
-
-**Command:**
-```
-git add skills/brainstorming/SKILL.md
-git commit -m "feat(brainstorming): read lessons learned for design context"
-```
-
----
-
-## Task 4: Add lessons-learned read step to writing-plans skill
-
-<!-- tdd: trivial -->
-<!-- checkpoint: none -->
-
-**File:** `skills/writing-plans/SKILL.md`
-
-In step 1 (Check for a design doc), add a new sentence after "If no design doc exists, ask the user to describe what they want to build and read relevant code.":
-
-```markdown
-   **Read `docs/lessons.md`** if it exists — incorporate known patterns into the task breakdown (e.g., if a lesson says "always run lint before commit," include that in relevant task instructions).
-```
-
-**Command:**
-```
-git add skills/writing-plans/SKILL.md
-git commit -m "feat(writing-plans): read lessons learned for task breakdown"
-```
-
----
-
-## Task 5: Update README.md with lessons-learned feature documentation
-
-<!-- tdd: trivial -->
-<!-- checkpoint: done -->
-
-**File:** `README.md`
-
-Add a new section after "TDD Three-Scenario Model" and before "Checkpoint Review Gates":
-
-```markdown
-### Lessons Learned
-
-A persistent rules file (`docs/lessons.md`) helps the agent learn from repeat mistakes across sessions. When the agent catches itself making the same error — like forgetting to run `make lint` — it writes a rule immediately. Future sessions (even after `/new`) pick it up automatically.
-
-```
-brainstorm → reads lessons (design context)
-plan        → reads lessons (task breakdown)
-execute     → reads lessons per task, writes new ones on repeat mistakes
-finalize    → reviews and retires stale rules
-```
-
-Rules are simple imperative bullets:
-
-- After completing each task, run `make lint && make fmt` before committing
-- Never import `testify` in this project
-- Always check for existing test helpers before writing new ones
-
-No configuration needed — the file is created automatically when the first lesson is written.
-```
-
-**Command:**
-```
-git add README.md
-git commit -m "docs: add lessons-learned section to README"
-```
-
----
-
-## Task 6: Update CHANGELOG.md
-
-<!-- tdd: trivial -->
-<!-- checkpoint: none -->
-
-**File:** `CHANGELOG.md`
-
-Add a new entry at the top (after the header):
-
-```markdown
-## [0.13.0] - 2026-05-08
-
-### Added
-
-- Lessons learned: persistent rules file (`docs/lessons.md`) read at every workflow phase and written to when the agent catches repeat mistakes. Survives `/new` sessions.
-```
-
-Bump version in `package.json` from `0.12.0` to `0.13.0`.
-
-**Command:**
-```
-git add CHANGELOG.md package.json
-git commit -m "chore: bump version to 0.13.0"
-```

package/docs/plans/completed/2026-05-08-lessons-learned-progress.md

@@ -1,15 +0,0 @@
-# Progress: Lessons Learned
-
-Plan: docs/plans/2026-05-08-lessons-learned-implementation.md
-Branch: lessons-learned
-Started: 2026-05-08T04:21:50Z
-Last updated: 2026-05-08T04:27:15Z
-
-| # | Status | Task | Commit |
-|---|--------|------|--------|
-| 1 | ✅ done | Add lessons-learned read step to executing-tasks skill | 0ad24d6 |
-| 2 | ✅ done | Add lessons-learned review step to finalizing skill | 7ac8097 |
-| 3 | ✅ done | Add lessons-learned read step to brainstorming skill | 7cb69fe |
-| 4 | ✅ done | Add lessons-learned read step to writing-plans skill | ed0aab7 |
-| 5 | ✅ done | Update README.md with lessons-learned feature documentation | d16e407 |
-| 6 | ✅ done | Update CHANGELOG.md | 2525662 |