playbook-ai 1.5.2 → 1.6.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable updates to Playbook are documented here. Only impactful changes are listed — new commands, upgraded behavior, and things that make your workflow better. Cosmetic fixes and internal housekeeping are omitted.
 
+## [1.6.0] — 2026-05-31
+
+### Strategy
+- **The council** — `/plan`, `/chess`, and `/future` now convene a contextual council of real-world advisors before committing to a direction. Claude picks 4 relevant figures based on the specific topic — negotiation experts for a deal, product thinkers for a build decision, operators for a scaling question. Each gives their honest take; they disagree where they would. `/chess` runs it before intake (frames the strategic posture going into the move tree). `/plan` runs it when there are meaningful tradeoffs between approaches (before recommending a direction). `/future` runs it after the Opus subagent returns (council reacts to the 3 load-bearing decisions).
+- **Command routing** — all three strategic commands now open with a routing check so you land in the right one. Each points to the other two. Simple rule: `/plan` fights bad execution, `/chess` fights an opponent, `/future` fights uncertainty.
+- **Progress tracking** — complex `/plan` runs (multi-file, subagent path) now write the implementation steps as a markdown checkbox list to WORK_LOG.md when execution begins. Steps tick off as they complete — progress survives context compression.
+
+### Docs
+- **README** — `/chess` and `/future` now appear in the What's Included table and the Commands section. Added the primary enemy framing: each strategic command has a distinct enemy it's designed to defeat.
+
+## [1.5.3] — 2026-05-29
+
+### Commands
+- **Model routing documented** — `/debug`, `/end`, `/quick`, and `/new-project` now explicitly state they run inline on Sonnet with no subagents. Prevents future drift when commands are extended.
+
 ## [1.5.2] — 2026-05-28
 
 ### Architecture

package/README.md

@@ -12,6 +12,8 @@ Most Claude Code configs are built for developers. This one is built for operato
 | `commands/start.md` | `/start` — session kickoff with project briefing |
 | `commands/end.md` | `/end` — session closeout with handoff documentation |
 | `commands/plan.md` | `/plan` — brainstorm + plan in one command (auto-detects complexity) |
+| `commands/chess.md` | `/chess` — adversarial strategy (Human Mode: opponent-modeled; System Mode: failure-traced) |
+| `commands/future.md` | `/future` — scenario planning via three futures, surfaces the decisions that matter most |
 | `commands/debug.md` | `/debug` — 4-step systematic debugging |
 | `commands/quick.md` | `/quick` — lightweight mode for small fixes |
 | `commands/new-project.md` | `/new-project` — full project setup with guided interview |
@@ -119,11 +121,18 @@ Every session follows a consistent pattern:
 
 ### Commands
 - **`/plan`** — Before complex work. Claude assesses whether brainstorming is needed (multiple approaches? tradeoffs?) and either explores options first or jumps straight to an implementation plan. Always waits for your approval.
+- **`/chess`** — For decisions with a real adversary (negotiation, partnerships, competitive moves) or a system you need to break before it breaks you. Human Mode traces move branches against an opponent; System Mode attacks a technical plan for failure points. Always thorough — never a quick check.
+- **`/future`** — Scenario planning via three futures (The Win, The Unraveling, The Headwind). Rewinds each path to today, surfaces the 3 decisions that matter most, and gives you one specific action this week.
 - **`/debug`** — When something is broken. Follows: reproduce, isolate root cause, fix, verify. No guessing.
 - **`/quick`** — For small fixes that don't need the full session ceremony.
 - **`/new-project`** — Sets up a new project from scratch. Claude interviews you — what's the project about, do you have an existing repo or need a new one, do you want to connect a PM tool? Then it creates the repo, wires your terminal shortcut, and generates a comprehensive CLAUDE.md (the rules file) based on what it learned about your project and how you want to work. One command, everything ready.
 - **`/handoff`** — Claude uses this (not you) when a task should run in a separate terminal with fresh context.
 
+**Each strategic command has a primary enemy:**
+- `/plan` fights **bad execution** — wrong approach, missed dependencies, unverified assumptions
+- `/chess` fights **an opponent** — a counterparty, or a system that will fail in ways you haven't anticipated
+- `/future` fights **uncertainty** — which decisions matter across scenarios you can't control
+
 ### Context management
 Claude proactively manages session quality:
 - Saves state incrementally during long sessions (not just at the end)

package/VERSION

@@ -1 +1 @@
-1.5.2
+1.6.0

package/commands/chess.md

@@ -14,12 +14,28 @@ Three routes. Assess before doing anything else.
 
 **Route 3 — /plan:** No adversary, no system to stress-test. This is a pure tradeoffs decision or planning question. → Tell the user: *"/plan is the right tool here — this is a tradeoffs decision, not a strategic scenario."* Offer to invoke /plan instead.
 
+**Route 4 — /future:** No adversary, no system to stress-test. The question spans a longer horizon — which futures are possible, which decisions matter most across scenarios you can't fully control. → Tell the user: *"/future is the right tool here — this is scenario planning, not adversarial analysis."* Offer to invoke /future instead.
+
 **Borderline:** Name what makes it ambiguous. Ask the user to confirm before proceeding.
 
 ---
 
 ## Human Mode
 
+### Council pre-flight (Sonnet, inline)
+
+Before intake, frame the strategic posture with the council.
+
+Pick 4 contextually relevant advisors — real people whose documented thinking and experience apply directly to this type of situation. Name them, one sentence each on why they're on this panel.
+
+Have each give their honest read on the strategic posture in 3-4 sentences — not their general philosophy, but their take on *this type of situation*. Let them disagree where they would.
+
+Synthesize in 2-3 sentences: what the council collectively surfaces that should shape how to approach intake and the move tree.
+
+Present the council output in chat, then proceed to intake.
+
+---
+
 ### Intake
 
 Run in the main session on Sonnet. Ask conversationally — not as a numbered list. Group related questions naturally. Use follow-ups where the answer is thin.

package/commands/debug.md

@@ -1,4 +1,4 @@
-Follow this systematic debugging process:
+Follow this systematic debugging process. Runs inline on Sonnet. No subagents.
 
 0. **Check connectivity (only if the session is slow)** — If responses are taking unusually long, run `speedtest` (if installed) to check for high latency, packet loss, or low bandwidth. If the connection is poor (>500ms latency, >5% packet loss, or <1 Mbps upload), flag it and suggest deferring to a better connection before debugging code.
 1. **Reproduce** — Confirm the bug exists. Get the exact error, query, or behavior. Don't guess.

package/commands/end.md

@@ -1,4 +1,4 @@
-Session closeout. Do everything needed so the user can walk away without taking notes or remembering anything. The next `/start` must pick up seamlessly.
+Session closeout. Do everything needed so the user can walk away without taking notes or remembering anything. The next `/start` must pick up seamlessly. Runs inline on Sonnet. No subagents.
 
 ## Steps
 

package/commands/future.md

@@ -4,6 +4,16 @@ Scenario planning via three futures. Rewinds each path month by month to today,
 
 ---
 
+## Routing check
+
+Before starting, confirm this is the right command:
+- **Real adversary with competing interests?** → `/chess` (Human Mode)
+- **System or plan to stress-test?** → `/chess` (System Mode)
+- **Specific task to execute with steps?** → `/plan`
+- **Uncertain future with multiple possible outcomes?** → You're in the right place.
+
+---
+
 ## Pre-flight (Sonnet, inline)
 
 Silently read the following before doing anything else:
@@ -220,6 +230,18 @@ When the subagent returns, present the one-screen primary output (thesis → 3 d
 
 ---
 
+## Council reaction (Sonnet, inline)
+
+After presenting the primary output, run the council.
+
+Pick 4 contextually relevant advisors for this domain and project type — real people whose thinking applies to the specific situation. Name them, one sentence each on why they're on this panel.
+
+Have each react to the 3 load-bearing decisions in 2-3 sentences. Let them disagree where they would.
+
+Present the council reactions in chat. No synthesis needed — the reactions are the output. Then proceed to the /chess bridge evaluation below.
+
+---
+
 ## /chess bridge (after results return)
 
 After presenting the primary output, evaluate the chess candidates the subagent identified. For each ⚠️ swing-state decision that involves a real counterparty:

package/commands/new-project.md

@@ -1,4 +1,4 @@
-Set up a new project for Claude Code — clone or create a repo, wire all local config, and get ready for `/start`.
+Set up a new project for Claude Code — clone or create a repo, wire all local config, and get ready for `/start`. Runs inline on Sonnet. No subagents.
 
 ## Gather Info
 

package/commands/plan.md

@@ -4,13 +4,24 @@ Before making any changes, assess the task and create a structured plan.
 
 ---
 
+## Routing check
+
+Before starting, confirm this is the right command:
+- **Real adversary with competing interests?** → `/chess` (Human Mode)
+- **System or plan you need to stress-test before building?** → `/chess` (System Mode)
+- **Multiple possible futures you're navigating?** → `/future`
+- **Task to execute or decision to plan?** → You're in the right place.
+
+---
+
 ## Phase 1: Assess Complexity (Sonnet, inline)
 
 Read all relevant files first. Then determine:
 - **Is this straightforward?** (One obvious approach, clear requirements) → proceed directly to Phase 2 inline.
 - **Are there meaningful tradeoffs?** (Multiple approaches, architectural choices, unclear requirements) → Brainstorm first:
   - Present 2-3 approaches with pros/cons in short, scannable sections
-  - Flag which approach you'd recommend and why
+  - Run the council inline on Sonnet: pick 4 contextually relevant advisors — real people whose thinking applies to this type of decision. Name them, one sentence each on why they're relevant. Have each weigh in on the approaches in 2-3 sentences. Let them disagree. Synthesize what the council surfaces before making your recommendation.
+  - Flag which approach you'd recommend and why (incorporating council input)
   - Wait for approval of a direction before proceeding
   - Save the decision to `docs/decisions/YYYY-MM-DD-<topic>.md` if it's non-trivial
 
@@ -63,4 +74,7 @@ Direction is hardened. Write the execution plan once, correctly.
 3. **Dependencies** — What must happen in order vs. can be parallelized.
 
 Present the hardened plan and WAIT for approval before making any changes.
+
+**For complex plans (subagent path):** When the user approves and execution begins, write the implementation steps as a markdown checkbox list under `## Active Plan: [task name]` in WORK_LOG.md. Tick off each step as it completes — this persists progress across turns and context compression.
+
 Keep it concise — bullet points, not essays.

package/commands/quick.md

@@ -1,4 +1,4 @@
-Quick mode — for bug fixes, small changes, and one-off tasks that don't need full session ceremony.
+Quick mode — for bug fixes, small changes, and one-off tasks that don't need full session ceremony. Runs inline on Sonnet. No subagents.
 
 Skip the full /start briefing. Instead:
 1. Read CLAUDE.md (for rules) and the last WORK_LOG.md entry (for context) — don't present a briefing.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playbook-ai",
-  "version": "1.5.2",
+  "version": "1.6.0",
   "description": "Operating playbook for non-technical founders working with Claude Code",
   "bin": {
     "playbook-ai": "bin/cli.js"