@leing2021/super-pi 0.22.1 → 0.23.0

package/README.md

@@ -8,8 +8,6 @@ Install it, tell Pi what you want to build, then keep saying "continue" — it w
 pi install npm:@leing2021/super-pi
 ```
 
-> **Upgrading from v0.21.0 or earlier?** Run `pi uninstall npm:pi-subagents` first, then `pi update`. Since v0.22.0, subagent capabilities are built-in — no separate package needed.
-
 ---
 
 ## Why Super Pi
@@ -28,6 +26,173 @@ Super Pi's answers:
 
 ---
 
+## The Five-Step Loop
+
+```
+01-brainstorm → 02-plan → 03-work → 04-review → 05-learn
+    think          plan      build      review      learn
+```
+
+Each step has a dedicated skill + tool pair. Not just prompts — structured toolchains.
+
+### New: Stage model routing
+
+Configure once in `.pi/settings.json`:
+
+```json
+{
+  "modelStrategy": {
+    "01-brainstorm": "claude-sonnet-4-20250514",
+    "02-plan": "claude-opus-4-20250115",
+    "03-work": "claude-sonnet-4-20250514",
+    "04-review": "claude-sonnet-4-20250514",
+    "05-learn": "claude-haiku-4-20250414",
+    "default": "claude-sonnet-4-20250514"
+  }
+}
+```
+
+How it works:
+- Model switching is handled automatically by the ce-core extension `input` hook — no manual `/model` needed.
+- When you type `/skill:01-brainstorm` through `/skill:05-learn`, the extension reads `modelStrategy[stage]` (or `modelStrategy.default`) and switches before the skill runs.
+- Supported formats: full reference (`"anthropic/claude-opus-4-1"`) or bare model id (`"claude-opus-4-1"`, reuses current provider).
+- Every stage prints a `📊 Pipeline Status` block with `Current / Output / Next`.
+- A `Switched model for <stage>: <provider>/<model>` notification appears when the model changes.
+
+Quick example:
+1. Run `/skill:01-brainstorm` — model auto-switches to the configured brainstorm model
+2. Approve the design
+3. Run `/skill:02-plan` — model auto-switches to the configured plan model
+4. Continue through each stage — model switches automatically at each step
+
+---
+
+## What Each Step Does
+
+### 01-brainstorm: Think First
+
+Not "describe your requirements." Three modes for three scenarios:
+
+| Mode | For | What it does |
+|------|-----|-------------|
+| **Startup Diagnostic** | Startup ideas, new products | Six YC-style forcing questions, pushed until you produce specific evidence (not "people are interested" — "who would freak out if this disappeared tomorrow?") |
+| **Builder Mode** | Side projects, hackathons | Only focused on building the coolest thing. If you accidentally mention revenue, it auto-upgrades to Startup Diagnostic |
+| **CE Brainstorm** | Adding features to existing projects | Multi-round dialog to clarify scope boundaries, generates a structured requirements doc |
+
+All three modes run a **premise challenge** (are your assumptions valid?) and **alternatives generation** (at least one minimal + one ideal approach) before you're allowed to move on.
+
+### 02-plan: Plan Well
+
+Breaks requirements into implementation units, each following strict **RED → GREEN → REFACTOR** (no production code without a failing test first).
+
+**Incremental updates**: Requirements changed? `plan_diff` detects added/removed/modified units and patches the plan instead of rewriting it.
+
+**CEO Review (optional)**: After planning, you can request a CEO Review. It challenges your plan using Bezos reversible-decision frameworks, Munger inversion, Jobs subtraction, forces alternative approaches, and draws error maps. Like having a demanding CTO review your proposal for free.
+
+### 03-work: Build Right
+
+**Parallel execution**: `task_splitter` uses a Union-Find algorithm to analyze file dependencies, feeds conflict-free units to `ce_parallel_subagent` for concurrent execution.
+
+**Checkpoint resume**: After each unit, a checkpoint is saved. Interrupted? Next startup auto-loads, skips completed work, continues from the breakpoint. Failed? `fail` records the error → `retry` suggests a recovery strategy (timeout? extend timeout. Permission issue? check permissions first. Code error? fix then retry).
+
+**Strict TDD**: Run failing test → write minimal implementation → test passes → refactor. Every step requires command output as evidence. No skipping.
+
+### 04-review: Review Thoroughly
+
+**Structured code review**: `review_router` auto-assigns reviewer personas based on diff metadata (changed payment code? bring in the security reviewer). Review discipline is technical evaluation, not theater — every finding must cite specific code, YAGNI checks, no performative agreement.
+
+**Browser QA (optional)**: Uses `agent-browser` to open your app, click through pages, screenshot bugs, fix by severity, up to 3 auto-fix iterations. Can auto-generate regression tests. Like having a QA engineer run acceptance tests.
+
+### 05-learn: Compound Learnings
+
+`pattern_extractor` scans existing artifacts, extracts and categorizes patterns. Turns "the pitfall we hit this time" into a YAML-tagged solution card in `docs/solutions/`.
+
+Two-level storage: project-specific → inside the project; cross-project → `~/.pi/agent/docs/solutions/` globally searchable.
+
+Next time `02-plan` or `04-review` runs, a grep-first search strategy automatically retrieves relevant past experience.
+
+---
+
+## Technical Architecture
+
+### 8 Skills (workflow nodes)
+
+| Skill | One-liner | Core Tool |
+|-------|-----------|-----------|
+| `01-brainstorm` | Deep requirements mining in three modes | `brainstorm_dialog` |
+| `02-plan` | Break into units, TDD gates, incremental updates | `plan_diff` |
+| `03-work` | Parallel execution, checkpoint resume, error recovery | `session_checkpoint`, `task_splitter`, `ce_parallel_subagent` |
+| `04-review` | Persona-routed review + live browser testing | `review_router` |
+| `05-learn` | Pattern extraction → knowledge card compounding | `pattern_extractor` |
+| `06-next` | What to do next + full status report | `workflow_state`, `session_history` |
+| `07-worktree` | Git worktree isolated development | `worktree_manager` |
+| `08-help` | Usage guide | — |
+
+
+### 14 Tools + 2 Helpers (underlying capabilities)
+
+| Tool | What it does |
+|------|-------------|
+| `task_splitter` | Union-Find algorithm analyzes file dependencies, auto-groups parallel-safe units |
+| `session_checkpoint` | JSON-persisted checkpoints with save/load/fail/retry operations |
+| `plan_diff` | Incremental plans: compare detects diffs, patch applies changes |
+| `ce_parallel_subagent` | `Promise.allSettled`-style CE parallel skill-based subagent execution with context slimming |
+| `review_router` | Auto-assign reviewer personas from diff metadata |
+| `pattern_extractor` | Extract and categorize patterns from artifacts |
+| `brainstorm_dialog` | Multi-round dialog state machine (start → refine × N → summarize) |
+| `session_history` | Cross-session execution history recording and querying |
+| `workflow_state` | Scan docs/ and .context/ to summarize workflow state |
+| `worktree_manager` | Full git worktree lifecycle management |
+| `artifact_helper` | Artifact path resolution and directory creation |
+| `ask_user_question` | Structured user prompts (choices / free input) |
+| `ce_subagent` | CE serial skill-based subagent chain with depth guard and context control |
+| `context_handoff` | Cross-stage context handoffs with evidence-first templates (save/load/latest/status) |
+| `subagent-depth-guard` | Helper: env-based recursion depth tracking (prevents runaway nesting) |
+| `async-mutex` | Helper: serializes `process.env` mutation for concurrency-safe child process spawning |
+
+### Compatibility with pi-subagents
+
+super-pi's CE skill-router tools use a dedicated namespace to avoid runtime tool-name conflicts:
+
+- **CE tools**: `ce_subagent` and `ce_parallel_subagent` — for CE pipeline skill execution
+- **Generic `subagent`**: reserved for third-party agent extensions like [pi-subagents](https://www.npmjs.com/package/pi-subagents)
+
+Both extensions can be installed simultaneously without tool collision. super-pi manages the CE pipeline (brainstorm → plan → work → review → learn); pi-subagents provides general-purpose multi-agent execution. No configuration needed — install both and each keeps its own tool namespace.
+
+---
+
+## Token Cost
+
+New conversation overhead: **~2,600 tokens** (1.3% of Claude Sonnet 4's 200K context).
+
+| Component | Tokens | When loaded |
+|-----------|--------|-------------|
+| 8 skill registrations | ~490 | Every conversation (fixed) |
+| 14 tool registrations | ~2,055 | Every conversation (fixed) |
+| Hooks & filters | 0 | Runtime interception, zero prompt cost |
+| Single skill trigger | ~1,000–4,000 | On-demand via `read` |
+| Rules minimal (2 files) | ~900 | Before plan/work |
+| Rules + language (7 files) | ~2,600 | Before work with specific language |
+
+| vs bare Pi | vs global rules injection | vs super-pi |
+|-----------|----------------------|------------|
+| No rules | All rules loaded upfront | Progressive on-demand |
+| No output filtering | No output filtering | Auto-compress (bash ~65–98%, read ~30–60%) |
+| No TDD gate | No TDD gate | Hard gate prevents rework |
+| 0 tokens | ~5,000–36,000 tokens | **~2,600 tokens** |
+
+Single `npm install` output filtered once pays for the entire overhead. Full evaluation → [`docs/token-cost-evaluation.md`](docs/token-cost-evaluation.md)
+
+---
+
+## Code Scale
+
+~2800 lines of TypeScript implementing 14 registered tools + 2 helpers, 23 Markdown reference files + 79 rule files driving 8 skills, 175 tests covering all tool logic.
+
+Not a heavy framework. Each tool has a single responsibility, each skill works independently, and together they form a complete workflow.
+
+---
+
 ## Quick Start
 
 ### New idea
@@ -42,6 +207,10 @@ You: I want to build a tool that helps indie devs find users
 You: continue
 
 → 02-plan breaks into units, optional CEO Review
+→ Generates docs/plans/2026-04-18-find-users-plan.md
+
+You: continue
+
 → 03-work parallel execution, checkpoint resume
 → 04-review code review + optional browser QA
 → 05-learn knowledge compounding
@@ -52,7 +221,7 @@ You: continue
 ```
 You: I want to add user authentication to the project
 
-→ 01-brainstorm CE mode: OAuth2? JWT? MFA?
+→ 01-brainstorm CE mode, multi-round dialog: OAuth2? JWT? MFA?
 → Requirements doc → 02-plan → 03-work → 04-review → 05-learn
 ```
 
@@ -72,137 +241,122 @@ You: Requirements changed, need to add SSO support
 → 02-plan uses plan_diff to detect changes, patches incrementally
 ```
 
----
-
-## The Five-Step Loop
+### Check progress anytime
 
 ```
-01-brainstorm → 02-plan → 03-work → 04-review → 05-learn
-    think          plan      build      review      learn
-```
+You: /skill:06-next
 
-Each step has a dedicated skill + tool pair. Not just prompts — structured toolchains.
+→ Scans all artifacts, shows progress + recommends next step
+```
 
-### 01-brainstorm: Think First
+---
 
-Three modes for three scenarios:
+## Generated File Structure
 
-| Mode | For | What it does |
-|------|-----|-------------|
-| **Startup Diagnostic** | Startup ideas, new products | Six YC-style forcing questions, pushed until you produce specific evidence |
-| **Builder Mode** | Side projects, hackathons | Focused on building. Accidentally mention revenue? Auto-upgrades to Startup Diagnostic |
-| **CE Brainstorm** | Adding features to existing projects | Multi-round dialog to clarify scope, generates structured requirements doc |
+```
+your-project/
+├── docs/
+│   ├── brainstorms/                  # Requirements (01-brainstorm)
+│   ├── plans/                        # Execution plans (02-plan)
+│   └── solutions/                    # Knowledge cards (05-learn)
+└── .context/
+    └── compound-engineering/
+        ├── checkpoints/              # Breakpoint files (session_checkpoint)
+        ├── dialogs/                  # Dialog state (brainstorm_dialog)
+        └── history/                  # Execution history (session_history)
+```
 
-All three run a **premise challenge** (are your assumptions valid?) and **alternatives generation** before you move on.
+**Recommendation: commit everything to git** — these files are the project's traceable memory.
 
-### 02-plan: Plan Well
+### Progressive Rule Loading
 
-Breaks requirements into implementation units with strict **RED → GREEN → REFACTOR**. Requirements changed? `plan_diff` patches incrementally instead of rewriting.
+Built-in coding rules live under `rules/` in the package. Rules are loaded **progressively** by each skill — never all at once, only what the current task needs.
 
-**CEO Review (optional)**: Challenges your plan using Bezos reversible-decision frameworks, Munger inversion, Jobs subtraction. Like having a demanding CTO review for free.
+**How it works:**
 
-### 03-work: Build Right
+```
+system prompt (30 tokens: skill name + description)
+  → skill SKILL.md (~200 tokens: loading decision tree)
+    → specific rule files via read tool (on-demand, 900–2600 tokens)
+```
 
-- **Parallel execution**: `task_splitter` analyzes file dependencies, feeds conflict-free units to `subagent` for concurrent execution
-- **Checkpoint resume**: Interrupted? Next startup auto-loads, skips completed work, continues from breakpoint
-- **Strict TDD**: Failing test → minimal implementation → test passes → refactor. Every step requires command output as evidence
+Three skills auto-trigger rule loading at their entry points:
 
-### 04-review: Review Thoroughly
+| Skill | Rules pre-loaded |
+|-------|-----------------|
+| `02-plan` | `common/` rules + language detection + matching language rules (e.g. `rules/typescript/`) |
+| `03-work` | `common/` rules + language detection + matching language rules + `web/` if frontend |
+| `04-review` | `common/code-review.md` + language detection + matching language rules + `web/` if frontend |
 
-`review_router` auto-assigns reviewer personas based on diff metadata. Every finding must cite specific code — no performative agreement.
+Language detection uses file heuristics (see `skills/references/language-detection.md`): `tsconfig.json` → TypeScript, `Cargo.toml` → Rust, `go.mod` → Go, etc.
 
-**Browser QA (optional)**: Opens your app, clicks through pages, screenshots bugs, fixes by severity, up to 3 auto-fix iterations.
+**Rule precedence** (when layers overlap on the same topic):
 
-### 05-learn: Compound Learnings
+```
+language-specific  >  web  >  common
+```
 
-Turns "the pitfall we hit this time" into a YAML-tagged solution card in `docs/solutions/`. Two-level storage: project-specific and global (`~/.pi/agent/docs/solutions/`).
+No rules are loaded when you brainstorm, check status, or do non-code tasks. Zero waste.
 
-Next time `02-plan` or `04-review` runs, relevant past experience is automatically retrieved.
+#### Included rule layers
 
----
+| Layer | Files | When loaded |
+|-------|-------|------------|
+| `common/` | 11 files (includes `naming.md`) | Always (baseline for all tasks) |
+| `typescript/`, `python/`, `cpp/`, `csharp/`, `dart/`, `golang/`, `java/`, `kotlin/`, `perl/`, `php/`, `rust/`, `swift/` | 5 files each | When the task touches that language |
+| `web/` | 7 files (includes `design-quality.md`, `performance.md`) | When frontend/browser is relevant |
 
-## Built-in Capabilities
+#### Customizing rules for your project
 
-One package includes everything:
+Two rule sources exist, with project-level taking priority:
 
-| What | How to Access |
-|------|--------------|
-| **Agent Manager TUI** | `/agents` or `Ctrl+Shift+A` |
-| **CE Agents** (ce-scout, ce-planner, etc.) | Via subagent tool |
-| **CE Chains** (scout → planner → worker → reviewer) | Via subagent tool |
-| **Parallel execution** | Via subagent tool |
-| **Stage Model Sync** | Automatic — set `modelStrategy` / `thinkingStrategy` in `.pi/settings.json` |
-| **Diagnostics** | `/subagents-status`, `/subagents-doctor` |
+| Source | Location | Survives `pi update`? |
+|--------|----------|----------------------|
+| **Project-level** | `{your-project-root}/rules/` | ✅ Yes |
+| Package-level | Inside `node_modules/@leing2021/super-pi/rules/` | ❌ No |
 
-### Stage model routing
+To customize, create a `rules/` directory in your project root. Skills check it first — if a file exists there, it overrides the package default for that topic.
 
-Configure once in `.pi/settings.json`:
+**Add a language** — create a new directory with the 5 standard topics:
 
-```json
-{
-  "modelStrategy": {
-    "01-brainstorm": "claude-sonnet-4-20250514",
-    "02-plan": "claude-opus-4-20250115",
-    "03-work": "claude-sonnet-4-20250514",
-    "default": "claude-sonnet-4-20250514"
-  },
-  "thinkingStrategy": {
-    "02-plan": "high",
-    "03-work": "medium"
-  }
-}
+```bash
+mkdir rules/elixir
+touch rules/elixir/{coding-style,testing,patterns,security,hooks}.md
 ```
 
-Model switching is handled automatically — no manual `/model` needed. When you run any CE skill, the extension reads the config and switches before the skill runs. Supported formats: full reference (`"anthropic/claude-opus-4-1"`) or bare model id (`"claude-opus-4-1"`).
-
----
-
-## Technical Architecture
-
-### Core: Five-Step Loop
+Each file should start with:
 
-| Skill | What | Core Tool |
-|-------|------|----------|
-| `01-brainstorm` | Three-mode requirements mining (Startup Diagnostic / Builder / CE) | `brainstorm_dialog` |
-| `02-plan` | Break into units with TDD gates, incremental `plan_diff` updates | `plan_diff` |
-| `03-work` | Parallel execution, checkpoint resume, error recovery | `session_checkpoint`, `task_splitter`, `subagent` |
-| `04-review` | Persona-routed review + live browser QA | `review_router` |
-| `05-learn` | Pattern extraction → searchable knowledge cards | `pattern_extractor` |
+```markdown
+> This file extends [common/xxx.md](../common/xxx.md) with Elixir-specific content.
+```
 
-### Utilities
+**Remove unused languages** — just delete the directory:
 
-| Skill | One-liner |
-|-------|-----------|
-| `06-next` | Recommend the best next skill based on workflow state |
-| `07-worktree` | Git worktree isolated development |
-| `08-status` | Scan artifacts, report progress |
-| `09-help` | Usage guide |
-| `10-rules` | Progressive rule loading for coding standards |
+```bash
+rm -rf rules/perl rules/cpp  # don't need these? remove them
+```
 
-### Progressive Rule Loading
+**Tweak a rule** — edit the `.md` file directly:
 
-Built-in `rules/` directory with 13 language layers (TypeScript, Python, Rust, Go, Java, Kotlin, C#, C++, Dart, PHP, Perl, Swift, Elixir) + common + web — 78 Markdown files total.
+```bash
+# Override testing conventions for your team
+vim rules/common/testing.md
 
-Rules load **progressively** — never all at once, only what the current task needs. Zero waste.
+# Override for a specific language
+vim rules/typescript/testing.md
+```
 
-Customize for your project: create a `rules/` directory in your project root. Project-level rules override package defaults. See `10-rules` skill for details.
+**Add a new topic** — create a new `.md` in the appropriate layer:
 
-### Generated File Structure
+```bash
+# Common topic
+vim rules/common/api-design.md
 
-```
-your-project/
-├── docs/
-│   ├── brainstorms/                  # Requirements (01-brainstorm)
-│   ├── plans/                        # Execution plans (02-plan)
-│   └── solutions/                    # Knowledge cards (05-learn)
-└── .context/
-    └── compound-engineering/
-        ├── checkpoints/              # Breakpoint files (session_checkpoint)
-        ├── dialogs/                  # Dialog state (brainstorm_dialog)
-        └── history/                  # Execution history (session_history)
+# Language-specific override
+vim rules/python/api-design.md
 ```
 
-**Recommendation: commit everything to git** — these files are the project's traceable memory.
+Skills will pick up any `.md` file in `rules/` — no configuration needed. If a language directory exists, it's available for loading. If it's gone, it's simply never loaded.
 
 ---
 
@@ -214,7 +368,6 @@ The goal isn't making AI write code faster — it's making AI think before writi
 
 The following projects directly inspired this work:
 
-- **[pi-subagents](https://github.com/nicobailon/pi-subagents)** (by Nico Bailon, MIT License) → Full subagent runtime integrated as built-in extension (serial, parallel, chain, async, TUI, agent CRUD)
 - **[everything-claude-code](https://github.com/affaan-m/everything-claude-code)** (162K★) → Parallel subagent orchestration, checkpoint resume, continuous learning
 - **[superpowers](https://github.com/obra/superpowers)** (161K★) → Strict TDD gates, design checklists, review discipline
 - **[gstack](https://github.com/garrytan/gstack)** (78K★) → YC-style forcing questions, CEO Review frameworks, browser QA
@@ -228,129 +381,18 @@ Not a fork. Not a wrapper. Methodologies extracted and rebuilt with Pi's native
 
 | Tip | Why |
 |-----|-----|
-| Start with 01-brainstorm | Thinking first never hurts |
+| Start with 01-brainstorm | Whatever the scenario, thinking first never hurts |
 | Use 07-worktree for big features | Isolated dev, no impact on main branch |
 | Use CEO Review on plans | Like having a demanding CTO review for free |
 | Use browser QA for acceptance | Code review can't catch layout breaks and blank screens |
 | Don't panic on interruption | Next 03-work auto-resumes from checkpoint |
-| Use 08-status when lost | One glance shows where you are |
+| Use 06-next when lost | One glance shows where you are and what to do next |
 
 ---
 
 ## Changelog
 
-### 0.22.1 — Fix terminal freeze during parallel subagent execution
-- Fixed terminal freeze and scroll lock when running 8+ parallel subagents.
-- Added adaptive widget animation intervals: 250ms–1000ms based on running job count.
-- Added `createThrottle()` for foreground parallel `onUpdate` with flush/dispose lifecycle.
-- Added render dedup via content hash to skip unchanged `requestRender()` calls.
-- Reduced activity timer and async poller frequencies with adaptive scaling.
-- Extracted `stopAnimationTimer()` to prevent state loss during dynamic interval switching.
-- 197 tests passing (28 new for render optimization).
-
-### 0.22.0 — Source-integrated pi-subagents
-- Integrated pi-subagents v0.20.1 source code into `extensions/subagent/` — single package install (`pi install npm:@leing2021/super-pi`).
-- Moved `typebox` from peerDependencies to dependencies.
-- Removed `pi-subagents` peer dependency — no longer needed.
-- Simplified `super-pi-extension/index.ts`: removed faulty installation detection and auto-install logic.
-- Pruned slash commands: removed `/run`, `/chain`, `/run-chain`, `/parallel`; kept `/agents` (TUI), `/subagents-status`, `/subagents-doctor`, and `Ctrl+Shift+A` shortcut.
-- Added 8 new tests covering subagent extension structure, agent counts, and integration integrity.
-- 169 tests passing.
-
-### 0.21.0 — Delegate subagent tools to pi-subagents
-- Subagent capabilities now provided by the `pi-subagents` package.
-- Removed `subagent` and `parallel_subagent` tool registrations from `ce-core` extension.
-
-### 0.20.0 — Extension API migration
-- Migrated `super-pi-extension` to Pi-native factory function format.
-
-<details>
-<summary>Older versions</summary>
-
-### 0.19.6 — pi-subagents integration extension
-- New `super-pi-extension`: pre-configured CE Agents and CE Chains.
-- New `thinkingStrategy` setting: per-stage thinking level sync.
-
-### 0.19.5 — Plan/Work/Review skill rules loading alignment
-- Fixed `02-plan` not loading language-specific rules during the planning phase.
-- Updated all three skills to use a consistent 4-step progressive loading strategy.
-
-### 0.19.4 — Read output filter markdown truncation fix
-- Fixed `read-output-filter` over-truncating markdown files.
-- Added 5 new tests. 175 tests passing.
-
-### 0.19.3 — Terminate fix + runtime model routing + autoContinue removal
-- Fixed 6 ce-core tools incorrectly returning `terminate: true`.
-- Implemented runtime stage model routing via ce-core extension `input` hook.
-
-### 0.19.2 — Evidence-first handoff-lite + docs tracking rule
-- Added `context_handoff` with evidence-first default handoff-lite generation.
-
-### 0.19.1 — Pipeline config + typecheck baseline fix
-- Added shared pipeline config for stage model routing.
-
-### 0.19.0 — 0.69.0 alignment + learn rename
-- TypeBox migration: `@sinclair/typebox` → `typebox`.
-- Peer/dev dependency upgrade: pi-coding-agent `0.67.6` → `0.69.0`.
-- Skill rename: `05-compound` → `05-learn`.
-
-### 0.18.0 — Progressive rules
-- Built-in `rules/` directory with 13 language layers + common + web (78 Markdown files).
-- New `10-rules` skill: progressive on-demand loading.
-
-### 0.17.0 — Subagent safety
-- Recursion depth guard prevents runaway nesting.
-- Async mutex for `process.env` concurrency safety.
-
-### 0.16.0 — Context optimization
-- Read output filter: structural compression for large code files.
-
-### 0.15.0 — Output filtering
-- Bash output filter: smart truncation by command type.
-
-### 0.14.0 — Structured solution retrieval
-- YAML frontmatter tagging + grep-first two-level search.
-
-### 0.13.0 — Superpowers engineering discipline
-- Strict TDD gates, design checklists, YAGNI checks.
-
-### 0.12.0 — Error recovery
-- session_checkpoint fail/retry operations.
-
-### 0.11.0 — Pattern extraction
-- New pattern_extractor tool.
-
-### 0.10.0 — Continuous learning
-- New session_history tool.
-
-### 0.9.0 — Incremental planning
-- New plan_diff tool.
-
-### 0.8.0 — Multi-round dialog
-- New brainstorm_dialog tool.
-
-### 0.7.0 — Parallel grouping
-- Union-Find based task_splitter.
-
-### 0.6.0 — Checkpoint resume
-- New session_checkpoint tool.
-
-### 0.5.0 — Parallel execution
-- New parallel_subagent tool.
-
-### 0.4.0 — Smart review
-- New review_router tool.
-
-### 0.3.0 — Isolated development
-- New worktree_manager + 07-worktree.
-
-### 0.2.0 — State awareness
-- New workflow_state + 06-next.
-
-### 0.1.0 — Initial release
-- 7 skills, 3 tools.
-
-</details>
+See [CHANGELOG.md](./CHANGELOG.md) for full version history.
 
 ---