From 8ae19a94ffb2337523aba030286c6b59912418c7 Mon Sep 17 00:00:00 2001 From: Kyle Sexton <153232337+kyle-sexton@users.noreply.github.com> Date: Fri, 17 Jul 2026 12:37:43 -0400 Subject: [PATCH 1/3] refactor(planning): rename architect skill to plan BREAKING CHANGE: /planning:architect is now /planning:plan. The architect name was a pre-plugin shadow compromise; plugin namespacing made the accurate name available, and per the shadowed-skill-renames contract (docs/topics/shadowed-skill-renames/PLAN.md on PR #256) the rename ships as a clean break: skill directory + frontmatter name move together, every in-repo reference is updated atomically (cross-plugin docs, evals, marketplace tag, arbiter tags, plan-ready phrasing), the planning plugin bumps 0.12.0 -> 0.13.0 (0.x breaking-by-minor), and no marketplace renames-map entry is added. Built-in /plan (plan-mode toggle) is unaffected -- plugin skills have no bare command form. Historical CHANGELOG entries keep the old name as written. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01YVApnNGoKxYMJKNQx1QK8C --- .claude-plugin/marketplace.json | 2 +- .../topic-docs/examples/worked-slice.md | 4 +-- docs/topics/plugin-fleet-sync-skill/PLAN.md | 2 +- docs/topics/plugin-organization/PLAN.md | 4 +-- plugins/claude-ops/skills/changelog/SKILL.md | 8 ++--- .../skills/changelog/evals/evals.json | 2 +- .../skills/implement-dispatch/SKILL.md | 4 +-- .../implementation/skills/implement/SKILL.md | 8 ++--- .../skills/implement/evals/evals.json | 2 +- plugins/knowledge/skills/youtube/SKILL.md | 2 +- .../skills/youtube/context/quality-gates.md | 2 +- plugins/planning/.claude-plugin/plugin.json | 4 +-- plugins/planning/CHANGELOG.md | 14 ++++++++ plugins/planning/README.md | 6 ++-- plugins/planning/reference/topic-docs.md | 8 ++--- .../planning/skills/design-handoff/SKILL.md | 18 +++++----- .../skills/design-handoff/evals/evals.json | 10 +++--- plugins/planning/skills/design/SKILL.md | 24 ++++++------- .../planning/skills/design/evals/evals.json | 12 +++---- .../planning/skills/devils-advocate/SKILL.md | 2 +- plugins/planning/skills/interview/SKILL.md | 20 +++++------ .../planning/skills/interview/context/loop.md | 10 +++--- .../skills/interview/evals/evals.json | 6 ++-- .../skills/{architect => plan}/SKILL.md | 20 +++++------ .../context/plan-reviewer.md | 2 +- .../context/plan-template.md | 0 .../context/research-iterate.md | 0 .../context/stress-test-triggers.md | 0 .../context/tag-decisions.md | 10 +++--- .../{architect => plan}/evals/evals.json | 16 ++++----- .../templates/checklist.md | 4 +-- plugins/planning/skills/prd/SKILL.md | 36 +++++++++---------- .../planning/skills/prd/context/templates.md | 10 +++--- plugins/planning/skills/prd/evals/evals.json | 8 ++--- plugins/planning/skills/setup/SKILL.md | 2 +- plugins/planning/skills/wayfind/SKILL.md | 10 +++--- .../skills/wayfind/context/map-anatomy.md | 2 +- .../wayfind/context/tracker-mechanics.md | 2 +- .../planning/skills/wayfind/evals/evals.json | 2 +- plugins/prototype/context/discipline.md | 2 +- plugins/session-flow/skills/workflow/SKILL.md | 2 +- .../testing/skills/diagnose/context/loop.md | 2 +- plugins/work-items/reference/tracker-seam.md | 2 +- .../work-items/skills/work/evals/evals.json | 2 +- 44 files changed, 161 insertions(+), 147 deletions(-) rename plugins/planning/skills/{architect => plan}/SKILL.md (95%) rename plugins/planning/skills/{architect => plan}/context/plan-reviewer.md (95%) rename plugins/planning/skills/{architect => plan}/context/plan-template.md (100%) rename plugins/planning/skills/{architect => plan}/context/research-iterate.md (100%) rename plugins/planning/skills/{architect => plan}/context/stress-test-triggers.md (100%) rename plugins/planning/skills/{architect => plan}/context/tag-decisions.md (71%) rename plugins/planning/skills/{architect => plan}/evals/evals.json (75%) rename plugins/planning/skills/{architect => plan}/templates/checklist.md (91%) diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json index f4fd86fa3..404fefe76 100644 --- a/.claude-plugin/marketplace.json +++ b/.claude-plugin/marketplace.json @@ -191,7 +191,7 @@ "name": "planning", "source": "./plugins/planning", "category": "design", - "tags": ["planning", "wayfind", "decision-map", "brainstorm", "prd", "interview", "domain-modeling", "ubiquitous-language", "glossary", "design", "design-handoff", "devils-advocate", "architect", "stress-test", "skill"] + "tags": ["planning", "wayfind", "decision-map", "brainstorm", "prd", "interview", "domain-modeling", "ubiquitous-language", "glossary", "design", "design-handoff", "devils-advocate", "plan", "stress-test", "skill"] }, { "name": "review", diff --git a/docs/conventions/topic-docs/examples/worked-slice.md b/docs/conventions/topic-docs/examples/worked-slice.md index ead4bf8d1..b94dbe700 100644 --- a/docs/conventions/topic-docs/examples/worked-slice.md +++ b/docs/conventions/topic-docs/examples/worked-slice.md @@ -8,10 +8,10 @@ Topic: adding token-refresh to an auth module. Derived slug: ```text docs/topics/auth-token-refresh/ <- contract slice, committed on branch - PLAN.md interview writes Brief; architect appends Plan + PLAN.md interview writes Brief; plan appends Plan PRD.md prd (status: locked) design/ - design-threads.md all RESOLVED -> architect's gate passes + design-threads.md all RESOLVED -> plan's gate passes design-resolution.md verification/ 20260714T161500Z-outcomes.md distilled manifest, verified_at_sha-keyed diff --git a/docs/topics/plugin-fleet-sync-skill/PLAN.md b/docs/topics/plugin-fleet-sync-skill/PLAN.md index 7edeed8a2..f7b46a595 100644 --- a/docs/topics/plugin-fleet-sync-skill/PLAN.md +++ b/docs/topics/plugin-fleet-sync-skill/PLAN.md @@ -64,7 +64,7 @@ One command that guarantees, on any machine and from any directory, that the plu - **Does `plugin update -s project` avoid writing the repo's committed `.claude/settings.json`?** — RESOLVED, see Open questions VERIFIED line 1: hash-verified no write. Decision 4 stands, no re-approval needed. - **Is `/reload-plugins --force` required after sync, or is plain `/reload-plugins` sufficient?** — RESOLVED, see Open questions VERIFIED line 2: no `--force` flag exists; report recommends bare `/reload-plugins`. -- **`all`-marketplaces argument interaction with third-party marketplaces lacking renames maps / non-git sources** — RESOLVED by /architect: graceful degradation — `marketplace update` handles every source type; a marketplace without a `renames` map simply has no rename residue; failures per-marketplace are reported and do not abort the sweep. +- **`all`-marketplaces argument interaction with third-party marketplaces lacking renames maps / non-git sources** — RESOLVED by /planning:plan: graceful degradation — `marketplace update` handles every source type; a marketplace without a `renames` map simply has no rename residue; failures per-marketplace are reported and do not abort the sweep. ## Plan diff --git a/docs/topics/plugin-organization/PLAN.md b/docs/topics/plugin-organization/PLAN.md index 81ca4fa95..c2df63e85 100644 --- a/docs/topics/plugin-organization/PLAN.md +++ b/docs/topics/plugin-organization/PLAN.md @@ -81,9 +81,9 @@ history; grouping lives in marketplace metadata. ### Deferred questions -- Empirical check: typeahead prefix filtering on plugin-skill leaf names — `/architect`. +- Empirical check: typeahead prefix filtering on plugin-skill leaf names — `/planning:plan`. - session-flow category label `workflow` — judgment call (no marketplace precedent); revisit if a stronger authoritative label emerges. ## Plan -(unfilled — /architect) +(unfilled — /planning:plan) diff --git a/plugins/claude-ops/skills/changelog/SKILL.md b/plugins/claude-ops/skills/changelog/SKILL.md index 19ab956f9..da6c45b34 100644 --- a/plugins/claude-ops/skills/changelog/SKILL.md +++ b/plugins/claude-ops/skills/changelog/SKILL.md @@ -49,7 +49,7 @@ Parse `$ARGUMENTS` to extract the action (first token) and remaining arguments. | Action | Description | Detail | |--------|-------------|--------| -| `apply` | Full pipeline: ingest → explore → research → interview → architect → implement → verify → close issues | See "Action: apply" below | +| `apply` | Full pipeline: ingest → explore → research → interview → plan → implement → verify → close issues | See "Action: apply" below | | `fetch` | Fetch + display changelog for version(s). Read-only | See "Action: fetch" below | | `diff` | Fetch + orient on repo impact. Read-only analysis table | See "Action: diff" below | | `status` | Show applied versions, open issues, pending work | See "Action: status" below | @@ -69,7 +69,7 @@ If action is unknown, show action table. detects a new CC release in conversation, default to `fetch` or `diff` and offer `apply` — do not auto-start the pipeline. -The full pipeline runs explore → research → interview → architect → implement → verify as the phases below. If the consumer project ships its own stage skills for these, prefer them at each phase. +The full pipeline runs explore → research → interview → plan → implement → verify as the phases below. If the consumer project ships its own stage skills for these, prefer them at each phase. ### Phase 0 — Ingest @@ -127,7 +127,7 @@ User picks scope: "all P1+P2", "just P1", or specific items by number. Lock brief: confirmed scope becomes implementation contract. -### Phase 4 — Architect +### Phase 4 — Plan Plan concrete edits with cross-cutting awareness: @@ -140,7 +140,7 @@ Plan concrete edits with cross-cutting awareness: Execute plan: -1. Edit files per architect plan +1. Edit files per the approved plan 2. Run the consumer repo's markdown linter on every touched `.md` file (e.g. `npx markdownlint-cli2`), when one is configured 3. If hook scripts touched: run their tests with the consumer repo's test runner 4. If settings.json touched: `jq empty .claude/settings.json` diff --git a/plugins/claude-ops/skills/changelog/evals/evals.json b/plugins/claude-ops/skills/changelog/evals/evals.json index 0f1ea926b..4ae85ed9b 100644 --- a/plugins/claude-ops/skills/changelog/evals/evals.json +++ b/plugins/claude-ops/skills/changelog/evals/evals.json @@ -9,7 +9,7 @@ "files": [], "expectations": [ "The response presents changelog content and/or a repo-impact analysis without editing any file", - "The response does NOT run the apply pipeline (no interview/architect/implement phases executed) on a passive version mention", + "The response does NOT run the apply pipeline (no interview/plan/implement phases executed) on a passive version mention", "If integration is relevant, the response offers `apply` as an explicit opt-in step rather than starting it automatically" ] }, diff --git a/plugins/implementation/skills/implement-dispatch/SKILL.md b/plugins/implementation/skills/implement-dispatch/SKILL.md index 1bf8bf093..bfcfc3569 100644 --- a/plugins/implementation/skills/implement-dispatch/SKILL.md +++ b/plugins/implementation/skills/implement-dispatch/SKILL.md @@ -34,7 +34,7 @@ Run the `/implementation:implement` "Step 1: Prerequisite Check" preflight first 2. **Dispatch** the worker 3. **Verify the return against direct evidence before accepting edits** — worker returns are synthesis, not ground truth; promote their claims to direct evidence (diff read, grep, file Read) before building on them 4. **Build/test main-side** — invoke `/toolchain:build` from the main window when the `toolchain` plugin is installed, otherwise run the project's own build/test command main-side; never accept a worker's green claim as the build signal -5. **Route worker divergence reports into `/implementation:implement` "Step 3: Divergence Detection"** — a worker STOPping per the divergence-escalation clause is a divergence signal, severity-assessed the same way; the orchestrator revises the brief or routes back to the planning skill (`/planning:architect review` when installed) +5. **Route worker divergence reports into `/implementation:implement` "Step 3: Divergence Detection"** — a worker STOPping per the divergence-escalation clause is a divergence signal, severity-assessed the same way; the orchestrator revises the brief or routes back to the planning skill (`/planning:plan review` when installed) ## Divergence in non-interactive runs @@ -62,7 +62,7 @@ Any criterion fails → clear + resume from the emitted prompt. **The phase-boun |-----------|--------| | Phase is inline-routed (main-window), interactive mode | Hand back to `/implementation:implement` classic cadence | | Phase is inline-routed or routing table absent, autonomous mode | Synthesize a worker row and dispatch — the orchestrator never does volume edits | -| Worker divergence report | Severity-assess per `/implementation:implement` "Step 3: Divergence Detection"; Major → the planning skill (`/planning:architect review` when installed) | +| Worker divergence report | Severity-assess per `/implementation:implement` "Step 3: Divergence Detection"; Major → the planning skill (`/planning:plan review` when installed) | | Every worker return | Verify against direct evidence, then `/toolchain:build` main-side (when the `toolchain` plugin is installed; else the project's own build) | | Phase sanity check passes | `/implementation:implement` "Step 4" ritual (its item-1 verifier gate applies in every mode; orchestrated runs dispatch it — see Phase boundaries) | | All phases complete | `/implementation:implement` "Step 5: Completion and Handoff" | diff --git a/plugins/implementation/skills/implement/SKILL.md b/plugins/implementation/skills/implement/SKILL.md index 724eb3a96..40b35a35f 100644 --- a/plugins/implementation/skills/implement/SKILL.md +++ b/plugins/implementation/skills/implement/SKILL.md @@ -52,7 +52,7 @@ If `$ARGUMENTS` specifies a mode (`feature`, `fix`, `refactor`, `config`), use t Before writing code, verify the knowledge base: -- **Is there an approved plan?** If yes, use it as execution roadmap. If no plan exists and the task is non-trivial (3+ files, new project, cross-cutting change), suggest a planning pass first — `/planning:architect` when the planning plugin is installed, otherwise whatever plan skill the consuming setup provides (check what's actually available; never invent skill names). For trivial changes (single-file fix, small config edit), proceed without a formal plan +- **Is there an approved plan?** If yes, use it as execution roadmap. If no plan exists and the task is non-trivial (3+ files, new project, cross-cutting change), suggest a planning pass first — `/planning:plan` when the planning plugin is installed, otherwise whatever plan skill the consuming setup provides (check what's actually available; never invent skill names). For trivial changes (single-file fix, small config edit), proceed without a formal plan - **Is the branch correct?** Check pre-computed branch. If on the default branch (`main`/`master`) and the project's workflow expects feature branches, stop and create one (`git checkout -b /`, or `/source-control:worktree` when that plugin is installed) - **Are there uncommitted changes?** If dirty working tree with unrelated changes, flag it — don't mix concerns in one commit @@ -74,7 +74,7 @@ Core execution loop. Key discipline: **validate after each logical block, not ju - **Build fails** → fix immediately. Don't add more code on top of broken code - **Test fails unexpectedly** → investigate. An unexpected failure may signal a flawed approach, not just a bug -- **Scope creep** → if implementation reveals the task is bigger than planned, stop and replan — route back to the planning skill (`/planning:architect review` when installed) rather than expanding scope silently +- **Scope creep** → if implementation reveals the task is bigger than planned, stop and replan — route back to the planning skill (`/planning:plan review` when installed) rather than expanding scope silently - **Too-big-and-foggy (not just bigger)** → if implementation reveals the work is a sprawling set of still-undecided, not-yet-phrasable questions rather than a scoped change, stop building and name `/planning:wayfind` to the user — it charts the fog as a decision map upstream of the plan. Guide, never auto-switch ### Commit discipline @@ -108,7 +108,7 @@ Most important discipline in execution. Plans are hypotheses — implementation 3. **Assess severity:** - **Minor** (typo in plan, small API difference) → fix inline, note the deviation - **Moderate** (approach needs adjustment but direction is right) → adjust the plan, document what changed and why. Research alternatives before adjusting — don't settle for workarounds when a proper solution may exist - - **Major** (fundamental assumption was wrong) → run external research first to find alternative approaches (`/discovery:research` when the discovery plugin is installed, otherwise a disciplined multi-source lookup), THEN route back to the planning skill (`/planning:architect review` when installed) to re-plan. The user approved a plan that no longer works — they need to approve the new direction, informed by fresh research + - **Major** (fundamental assumption was wrong) → run external research first to find alternative approaches (`/discovery:research` when the discovery plugin is installed, otherwise a disciplined multi-source lookup), THEN route back to the planning skill (`/planning:plan review` when installed) to re-plan. The user approved a plan that no longer works — they need to approve the new direction, informed by fresh research 4. **For major divergence:** switch to plan mode for safe exploration while redesigning the approach. Exit plan mode only after the revised plan is clear **Non-interactive fork (autonomous runs only):** see `/implementation:implement-dispatch` "Divergence in non-interactive runs" — Moderate divergence takes the conservative option + a deviations log instead of deadlocking; Major still STOPS. Interactive sessions keep the escalation ladder above unchanged. @@ -190,7 +190,7 @@ When all planned work is done: | After each logical block | Invoke `/toolchain:build` via Skill tool (when the `toolchain` plugin is installed; else the project's own build) | | At every phase boundary | Run the Step 4 ritual (plan marks + handoff entry + status + commit + resume prompt) | | Worker-routed phase or autonomous orchestration | Invoke `/implementation:implement-dispatch` via Skill tool | -| Divergence detected (major) | Route back to the planning skill (`/planning:architect review` when installed) | +| Divergence detected (major) | Route back to the planning skill (`/planning:plan review` when installed) | | Technical question mid-implementation | `/discovery:research` (when installed), otherwise disciplined multi-source research | | HIGH/CRITICAL change at completion | Call the `advisor` tool — rubber-duck checkpoint before review | | All implementation complete, tests pass | `/verification:confirm` (when the `verification` plugin is installed; else self-verify against intent), then suggest the project's review/PR flow (`/review:quality-gate`, `/source-control:pull-request` when installed) | diff --git a/plugins/implementation/skills/implement/evals/evals.json b/plugins/implementation/skills/implement/evals/evals.json index 141379b15..c90c4d7be 100644 --- a/plugins/implementation/skills/implement/evals/evals.json +++ b/plugins/implementation/skills/implement/evals/evals.json @@ -30,7 +30,7 @@ "id": 3, "name": "major-divergence-routes-back-to-planning", "prompt": "/implementation:implement — I approved a plan that assumed the vendor SDK exposes a streaming API, but partway through it's clear the SDK only supports batch calls, so the whole approach doesn't fit. Keep going and make it work.", - "expected_output": "Recognizes this as major divergence (a fundamental plan assumption was wrong), STOPS writing code rather than forcing workarounds, runs external research for alternative approaches first, then routes back to the planning skill (/planning:architect review when installed) so the user can approve the new direction — it does not silently push through with hacks.", + "expected_output": "Recognizes this as major divergence (a fundamental plan assumption was wrong), STOPS writing code rather than forcing workarounds, runs external research for alternative approaches first, then routes back to the planning skill (/planning:plan review when installed) so the user can approve the new direction — it does not silently push through with hacks.", "files": [], "expectations": [ "Classifies the wrong SDK-capability assumption as major divergence, not a minor inline fixup", diff --git a/plugins/knowledge/skills/youtube/SKILL.md b/plugins/knowledge/skills/youtube/SKILL.md index b5cad2888..82169eda6 100644 --- a/plugins/knowledge/skills/youtube/SKILL.md +++ b/plugins/knowledge/skills/youtube/SKILL.md @@ -266,7 +266,7 @@ node "${CLAUDE_PLUGIN_ROOT}/skills/youtube/extraction/run.mjs" evals/check-resea - `recommendations/questions.md` — open questions for the user - Update `README.md` per `templates/readme-journey.md` - **Offer an HTML view** — optionally render a self-contained HTML dashboard of the prioritized recommendations menu (markdown stays the tracked record); follow your project's HTML-vs-markdown convention when one exists. - - **No auto-implement** — `/interview` → `/architect` → `/implement` + - **No auto-implement** — `/interview` → `/planning:plan` → `/implement` 2. **Interview handoff** — write `recommendations/interview.md` with menu + *"Should we go further?"*; suggest `/interview` for POC/full-slice items. diff --git a/plugins/knowledge/skills/youtube/context/quality-gates.md b/plugins/knowledge/skills/youtube/context/quality-gates.md index 26971b5c5..cff09d025 100644 --- a/plugins/knowledge/skills/youtube/context/quality-gates.md +++ b/plugins/knowledge/skills/youtube/context/quality-gates.md @@ -144,7 +144,7 @@ When `watch.json` / `selection.json` sets `highVolume: true`: | `recommendations/questions.md` | Yes | | `recommendations/interview.md` | Yes | | `README.md` updated | Yes — per `templates/readme-journey.md` | -| Auto-implement | **No** — `/interview` → `/architect` → `/implement` | +| Auto-implement | **No** — `/interview` → `/planning:plan` → `/implement` | ## Complete slice diff --git a/plugins/planning/.claude-plugin/plugin.json b/plugins/planning/.claude-plugin/plugin.json index 7c8ac8ac2..9c00808a8 100644 --- a/plugins/planning/.claude-plugin/plugin.json +++ b/plugins/planning/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "planning", - "version": "0.12.0", + "version": "0.13.0", "description": "Pre-implementation planning pipeline: chart a too-big, foggy effort as a decision map, diverge on candidate approaches, lock product intent and the engineering contract, actively maintain resolved domain language, explore the design space, stress-test adversarially, and produce a structured implementation plan with an approval gate.", "author": { "name": "Melodic Software", @@ -21,7 +21,7 @@ "design", "design-handoff", "devils-advocate", - "architect", + "plan", "stress-test", "implementation-plan", "skill" diff --git a/plugins/planning/CHANGELOG.md b/plugins/planning/CHANGELOG.md index 760cb09b6..e2298ec38 100644 --- a/plugins/planning/CHANGELOG.md +++ b/plugins/planning/CHANGELOG.md @@ -3,6 +3,20 @@ All notable changes to the `planning` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.13.0] + +### Changed + +- **BREAKING: `/planning:architect` is renamed `/planning:plan`** (skill directory, frontmatter + `name`, and every in-repo reference). The `architect` name was a pre-migration shadow-compromise: + before plugins, a flat local skill named `plan` would have collided with surfaces already using + that word, so the skill shipped under `architect`. Plugin namespacing removed that constraint — + `/planning:plan` is unambiguous and says what the skill produces. Claude Code's built-in `/plan` + (the plan-mode toggle) is unaffected: plugin skills have no bare command form, so the full + invocation is always `/planning:plan`. Consumers invoking `/planning:architect` must switch to + `/planning:plan`; no `renames`-map entry is provided (clean break while the marketplace settles). + "architect this" remains a trigger phrase in the skill description. + ## [0.12.0] ### Changed diff --git a/plugins/planning/README.md b/plugins/planning/README.md index 192f637f6..241c5325d 100644 --- a/plugins/planning/README.md +++ b/plugins/planning/README.md @@ -15,14 +15,14 @@ re-runnable `setup` action that settles where artifacts land in the consuming re | `/planning:interview` | Engineering contract | Locks a task contract (goal, constraints, acceptance criteria, named assumptions) into a PLAN.md Brief — synthesizing when intent is clear, running depth-first Q&A when it isn't, or interviewing relentlessly on request. | | `/planning:domain-modeling` | Domain language | Maintains the consuming project's active ubiquitous-language glossary: resolves ambiguous terms, records canonical language and rejected synonyms, and routes entries to already-known contexts without discovering boundaries. | | `/planning:design` | Design space | Explores types, contracts, module boundaries, and package topology through collaborative discussion rounds, producing capability-matrix / type-inventory / design-threads / topology artifacts; its `handoff` action delegates to `/planning:design-handoff`. | -| `/planning:design-handoff` | Design→plan gate | Gates a finished design for `/planning:architect` — a binary check that every `design-threads.md` thread is RESOLVED, directional, or TAGGED-DEFERRED — then packages the architect-ready summary and resume prompt, or FAILs and routes back to `/planning:design`. | +| `/planning:design-handoff` | Design→plan gate | Gates a finished design for `/planning:plan` — a binary check that every `design-threads.md` thread is RESOLVED, directional, or TAGGED-DEFERRED — then packages the plan-ready summary and resume prompt, or FAILs and routes back to `/planning:design`. | | `/planning:devils-advocate` | Adversarial review | Stress-tests plans via assumption extraction, evidence checks, failure scenarios, and operational-gotcha sweeps — every finding evidence-backed, never generic warnings. | -| `/planning:architect` | Implementation plan | Produces a structured plan (goal, approach, test strategy, blast radius, parallelism analysis, tagged unilateral decisions) with a mandatory fresh-context stress-test and a user approval gate, persisted to PLAN.md. | +| `/planning:plan` | Implementation plan | Produces a structured plan (goal, approach, test strategy, blast radius, parallelism analysis, tagged unilateral decisions) with a mandatory fresh-context stress-test and a user approval gate, persisted to PLAN.md. | | `/planning:setup` | Configuration | Interviews the consumer and persists the tracked `.claude/topic-docs.yaml` concern file that governs where every pipeline skill writes its per-topic artifacts (idempotent — re-run to reconfigure). | The pipeline composes end-to-end — `wayfind` charts the fog upstream when an effort is too big to hold at once, then `brainstorm → prd → interview → design → -design-handoff → architect` with `devils-advocate` attacking the plan before +design-handoff → plan` with `devils-advocate` attacking the plan before approval — while `domain-modeling` is invoked whenever those workflows resolve vocabulary. Every skill also works standalone. diff --git a/plugins/planning/reference/topic-docs.md b/plugins/planning/reference/topic-docs.md index ebc698862..f993ecfe5 100644 --- a/plugins/planning/reference/topic-docs.md +++ b/plugins/planning/reference/topic-docs.md @@ -17,10 +17,10 @@ behavior; this binding and topic-docs remain authoritative for their placement. | Artifact (writer) | Tier | Location (default) | |---|---|---| | `PRD.md` (`/planning:prd`) | Contract | `docs/topics//`, committed on the task branch | -| `PLAN.md` — Brief (`/planning:interview`), Plan (`/planning:architect`) | Contract | same slice | +| `PLAN.md` — Brief (`/planning:interview`), Plan (`/planning:plan`) | Contract | same slice | | `design/` — ALL design artifacts, including the `design-threads.md` / `design-resolution.md` gate files (`/planning:design`, gated by `/planning:design-handoff`; gate files must travel with the branch) | Contract | `docs/topics//design/` | -| `interview-checklist.md`, `architect-checklist.md` | Memory | `.work//` — never committed | -| `baselines/` — machine-bound captures from the architect's baseline step | Memory | `.work//baselines/` | +| `interview-checklist.md`, `plan-checklist.md` | Memory | `.work//` — never committed | +| `baselines/` — machine-bound captures from the plan skill's baseline step | Memory | `.work//baselines/` | | Opt-in `brainstorm.md` (`/planning:brainstorm` — never a default write) | Memory | `.work//` | `contract_tier: local` moves the contract rows into the memory slice with an identical layout — @@ -29,7 +29,7 @@ the contract's solo/offline mode. Roots are configurable via the concern file's ## Close-out — the vault seam -`/planning:architect` owns describing the contract-slice close-out. Its promotion step resolves +`/planning:plan` owns describing the contract-slice close-out. Its promotion step resolves the concern file's `vault_backend`: `docs` (default) → a guarded, history-preserving `git mv` into `docs/adr/` / `docs/specs/`; an enabled non-`docs` value → the backend the consuming repo documents, degrading to `docs` when that backend's tools are absent. diff --git a/plugins/planning/skills/design-handoff/SKILL.md b/plugins/planning/skills/design-handoff/SKILL.md index e5804cb78..733ff33c0 100644 --- a/plugins/planning/skills/design-handoff/SKILL.md +++ b/plugins/planning/skills/design-handoff/SKILL.md @@ -1,6 +1,6 @@ --- name: design-handoff -description: "Gate and package a finished design for /planning:architect: binary check that every thread in design-threads.md is RESOLVED, directional, or TAGGED-DEFERRED, then emit the architect-ready summary and resume prompt. Use when: 'design handoff', 'hand off the design', 'is the design ready', 'architect-ready summary', 'design gate', /planning:design discussion rounds stop surfacing gaps, or entering /planning:architect from a completed design session. FAILs on any thread that is unresolved AND untagged — names it and routes back to /planning:design. Skip when: still exploring the design space — use /planning:design; mid-session save-point to clear and resume later — use a session-handoff capability." +description: "Gate and package a finished design for /planning:plan: binary check that every thread in design-threads.md is RESOLVED, directional, or TAGGED-DEFERRED, then emit the plan-ready summary and resume prompt. Use when: 'design handoff', 'hand off the design', 'is the design ready', 'plan-ready summary', 'design gate', /planning:design discussion rounds stop surfacing gaps, or entering /planning:plan from a completed design session. FAILs on any thread that is unresolved AND untagged — names it and routes back to /planning:design. Skip when: still exploring the design space — use /planning:design; mid-session save-point to clear and resume later — use a session-handoff capability." argument-hint: "(no args — reads the design-threads artifact in the topic's contract slice)" user-invocable: true disable-model-invocation: false @@ -12,9 +12,9 @@ Current branch: !`git branch --show-current 2>/dev/null || echo "unknown"` ## Purpose -The seam between design and planning. `/planning:architect`'s prerequisite check blocks on design-gate evidence; this skill produces that evidence honestly — a binary check read off the artifact, then a handoff summary sourced from the artifacts rather than recalled from conversation memory. +The seam between design and planning. `/planning:plan`'s prerequisite check blocks on design-gate evidence; this skill produces that evidence honestly — a binary check read off the artifact, then a handoff summary sourced from the artifacts rather than recalled from conversation memory. -Design artifacts live in `//design/` (default `docs/topics/`) — the topic's contract slice on the task branch, joining the memory slice under `contract_tier: local`; roots, tier, and precedence resolve per the topic-docs binding [`${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md`](${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md). Derive `` from the task or branch name (kebab-case, ≤40 chars; shared with `/planning:design` and `/planning:architect`). +Design artifacts live in `//design/` (default `docs/topics/`) — the topic's contract slice on the task branch, joining the memory slice under `contract_tier: local`; roots, tier, and precedence resolve per the topic-docs binding [`${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md`](${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md). Derive `` from the task or branch name (kebab-case, ≤40 chars; shared with `/planning:design` and `/planning:plan`). ## Binary gate — check the artifact, not your memory @@ -30,26 +30,26 @@ If `design-threads.md` does not exist, check for `design-resolution.md` at the s ## Handoff summary (gate passed) -Hand off to `/planning:architect` — sourced from the artifacts, not recalled from memory: +Hand off to `/planning:plan` — sourced from the artifacts, not recalled from memory: - Resolved decisions with their recorded rationale (from `design-threads.md`) - Deferred research items with tags - Design artifacts produced - Dependency order for implementation (which decisions block others) -- Extension / config / observability threads **RESOLVED** or **TAGGED-DEFERRED** — `/planning:architect` next walks its design-default checklist against the plan -- **Review-routing notes** — when the consuming project declares review checklists (architecture, code-design, security, multi-tenancy, messaging, and the like), list which apply to this slice so `/planning:architect` and the implementation stage inherit proactive review targets +- Extension / config / observability threads **RESOLVED** or **TAGGED-DEFERRED** — `/planning:plan` next walks its design-default checklist against the plan +- **Review-routing notes** — when the consuming project declares review checklists (architecture, code-design, security, multi-tenancy, messaging, and the like), list which apply to this slice so `/planning:plan` and the implementation stage inherit proactive review targets - **Mechanization notes** (optional) — when the project distinguishes deterministic mechanization from human judgment, mark per capability whether a sub-step is script-, hook-, agent-, or human-owned; a trivial early-exit records "no deterministic sub-steps" -Emit a resume prompt so a fresh cleared session can pick up at `/planning:architect` reading only the persisted artifacts. +Emit a resume prompt so a fresh cleared session can pick up at `/planning:plan` reading only the persisted artifacts. ## What this skill does NOT do - **Design exploration or thread resolution** — that's `/planning:design` (a FAILed gate routes there; this skill never resolves threads itself) -- **Implementation planning** — that's `/planning:architect` (this skill packages its input) +- **Implementation planning** — that's `/planning:plan` (this skill packages its input) - **Mid-session save-point** — that's a session-handoff capability (a journal entry plus status for a later clear-and-resume). This skill is the design→plan stage seam, not a pause-point ## Gotchas -- A thread marked "decided" without recorded rationale is NOT RESOLVED — the rationale must be in the artifact, or `/planning:architect` inherits an unexplainable decision. FAIL it back to `/planning:design` to record the why +- A thread marked "decided" without recorded rationale is NOT RESOLVED — the rationale must be in the artifact, or `/planning:plan` inherits an unexplainable decision. FAIL it back to `/planning:design` to record the why - Do not soften a FAIL into a warning because the offending thread "feels minor" — silent gaps are exactly what the binary gate exists to catch - `/planning:design`'s `handoff` action is an in-session shortcut that delegates here — this skill is the single canonical gate implementation, so criteria changes land here only diff --git a/plugins/planning/skills/design-handoff/evals/evals.json b/plugins/planning/skills/design-handoff/evals/evals.json index 2d1cdd604..d85f3d479 100644 --- a/plugins/planning/skills/design-handoff/evals/evals.json +++ b/plugins/planning/skills/design-handoff/evals/evals.json @@ -4,14 +4,14 @@ { "id": 1, "name": "gate-passes-all-threads-accounted", - "prompt": "/planning:design-handoff — treat evals/fixtures/design-threads-all-resolved.md (relative to the skill directory) as the topic's design-threads.md. Run the gate and, if it passes, hand off to /planning:architect.", - "expected_output": "The binary gate confirms every thread is RESOLVED (with recorded rationale), directional (agreed + research tag), or TAGGED-DEFERRED, so it PASSES and emits the architect-ready handoff summary sourced from the artifact — resolved decisions with rationale, deferred research tags, and dependency order.", + "prompt": "/planning:design-handoff — treat evals/fixtures/design-threads-all-resolved.md (relative to the skill directory) as the topic's design-threads.md. Run the gate and, if it passes, hand off to /planning:plan.", + "expected_output": "The binary gate confirms every thread is RESOLVED (with recorded rationale), directional (agreed + research tag), or TAGGED-DEFERRED, so it PASSES and emits the plan-ready handoff summary sourced from the artifact — resolved decisions with rationale, deferred research tags, and dependency order.", "files": ["evals/fixtures/design-threads-all-resolved.md"], "expectations": [ "Output evaluates each thread against the artifact and reports a PASS", - "Output emits an /architect-ready handoff summary sourced from the artifact (resolved decisions with rationale, deferred research tags)", + "Output emits a plan-ready handoff summary sourced from the artifact (resolved decisions with rationale, deferred research tags)", "The summary is drawn from the artifact content, not recalled from conversation memory", - "Output emits a resume prompt so a fresh session can pick up at /planning:architect" + "Output emits a resume prompt so a fresh session can pick up at /planning:plan" ] }, { @@ -24,7 +24,7 @@ "Output reports a FAIL rather than handing off", "Output names the specific offending thread that is unresolved AND untagged (the stop-word / stemming thread)", "Output routes back to /planning:design to resolve or tag the gap", - "Output does NOT emit an /architect-ready handoff summary" + "Output does NOT emit a plan-ready handoff summary" ] }, { diff --git a/plugins/planning/skills/design/SKILL.md b/plugins/planning/skills/design/SKILL.md index 3789a2bd6..c5d938494 100644 --- a/plugins/planning/skills/design/SKILL.md +++ b/plugins/planning/skills/design/SKILL.md @@ -1,6 +1,6 @@ --- name: design -description: "Explore and resolve design decisions — types, contracts, package topology, module boundaries — through collaborative discussion rounds before /architect plans implementation, producing capability-matrix / type-inventory / design-threads / topology artifacts. Use for 'design this', 'type modeling', 'figure out the abstractions', 'model this domain', or entering /architect without exploring the design space first; scales from a single-file early-exit to a multi-session design effort." +description: "Explore and resolve design decisions — types, contracts, package topology, module boundaries — through collaborative discussion rounds before /planning:plan plans implementation, producing capability-matrix / type-inventory / design-threads / topology artifacts. Use for 'design this', 'type modeling', 'figure out the abstractions', 'model this domain', or entering /planning:plan without exploring the design space first; scales from a single-file early-exit to a multi-session design effort." argument-hint: "[scope] [action] (e.g., /planning:design library, /planning:design module, /planning:design status, /planning:design discuss, /planning:design handoff)" user-invocable: true disable-model-invocation: false @@ -16,17 +16,17 @@ Arguments: `$ARGUMENTS` ## Purpose -Design exploration answers WHAT before `/architect` answers HOW. Without it, implementation plans are built on unexamined assumptions — the wrong types, wrong boundaries, wrong package topology. This skill structures the exploratory work so that every `/architect` plan starts from a design the user has validated through iterative discussion. +Design exploration answers WHAT before `/planning:plan` answers HOW. Without it, implementation plans are built on unexamined assumptions — the wrong types, wrong boundaries, wrong package topology. This skill structures the exploratory work so that every `/planning:plan` plan starts from a design the user has validated through iterative discussion. -This is the step between research and planning: exploration maps existing code, research gathers external facts, this skill synthesizes both into a concrete design, and `/architect` plans implementation of that design. Upstream: when the PROBLEM itself is still rough — no chosen approach to design — diverge first via `/brainstorm` (cheapest→most-ambitious candidates, user reacts), then design the direction that resonated. +This is the step between research and planning: exploration maps existing code, research gathers external facts, this skill synthesizes both into a concrete design, and `/planning:plan` plans implementation of that design. Upstream: when the PROBLEM itself is still rough — no chosen approach to design — diverge first via `/brainstorm` (cheapest→most-ambitious candidates, user reacts), then design the direction that resonated. The depth of design exploration scales to the work: -- Single-file fix → early-exit: write `design-resolution.md` with `outcome: early-exit`, tier `C`, and reason — then proceed to `/architect` +- Single-file fix → early-exit: write `design-resolution.md` with `outcome: early-exit`, tier `C`, and reason — then proceed to `/planning:plan` - New module → light-form (1-2 discussion rounds, basic type sketch) - Large library or system → full-form (multiple sessions, all phases, all artifact types) -Early-exit is diagnostic, not failure. The stage always runs; depth scales to signal. **Gate artifact:** Tier C and light Tier B early-exits MUST produce `design-resolution.md` in the topic's design slice (`//design/`, default `docs/topics/`; the memory slice under `contract_tier: local`) so `/architect`'s prerequisite check can verify the gate without relying on conversation memory. +Early-exit is diagnostic, not failure. The stage always runs; depth scales to signal. **Gate artifact:** Tier C and light Tier B early-exits MUST produce `design-resolution.md` in the topic's design slice (`//design/`, default `docs/topics/`; the memory slice under `contract_tier: local`) so `/planning:plan`'s prerequisite check can verify the gate without relying on conversation memory. ### design-resolution.md (early-exit artifact) @@ -64,7 +64,7 @@ Parse `$ARGUMENTS` for scope and action: Design exploration is iterative, not strictly sequential. Phases may interleave. Track which phases have produced artifacts and which have outstanding questions. -All artifacts live in `//design/` (default `docs/topics/`) — the topic's contract slice, committed on the task branch (under `contract_tier: local` it joins the memory slice): the gate files (`design-threads.md`, `design-resolution.md`) and the working design exploration docs travel together, because `/architect`'s gate and any fresh worktree or clone must see them. Roots, tier, and precedence resolve per the topic-docs binding [`${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md`](${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md). Derive `` from the task or branch name (kebab-case, ≤40 chars; shared with `/interview` and `/architect`). Skip artifact creation for read-only actions (`status`). +All artifacts live in `//design/` (default `docs/topics/`) — the topic's contract slice, committed on the task branch (under `contract_tier: local` it joins the memory slice): the gate files (`design-threads.md`, `design-resolution.md`) and the working design exploration docs travel together, because `/planning:plan`'s gate and any fresh worktree or clone must see them. Roots, tier, and precedence resolve per the topic-docs binding [`${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md`](${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md). Derive `` from the task or branch name (kebab-case, ≤40 chars; shared with `/interview` and `/planning:plan`). Skip artifact creation for read-only actions (`status`). ### Phase 1: Problem Space Decomposition @@ -134,7 +134,7 @@ Systematic gap-finding. For each round: 3. Present findings to user for discussion 4. When discussion surfaces project-wide principles, suggest codifying them immediately in the project's own rules -Continue rounds until no new gaps surface — then run the `handoff` action to delegate to `/planning:design-handoff` for the binary gate and /architect-ready summary. +Continue rounds until no new gaps surface — then run the `handoff` action to delegate to `/planning:design-handoff` for the binary gate and plan-ready summary. ## Terminology pass (`terminology` action) @@ -149,7 +149,7 @@ A cross-cutting naming review of the full type inventory, run once type modeling ## Handoff gate (`handoff` action) -The in-session shortcut to the design→plan gate. Delegate to `/planning:design-handoff` — the single canonical gate implementation: it applies the binary check against `design-threads.md` (or the `design-resolution.md` early-exit artifact), and on PASS emits the /architect-ready summary and resume prompt. This skill carries no gate criteria of its own; criteria changes land in `/planning:design-handoff` only. +The in-session shortcut to the design→plan gate. Delegate to `/planning:design-handoff` — the single canonical gate implementation: it applies the binary check against `design-threads.md` (or the `design-resolution.md` early-exit artifact), and on PASS emits the plan-ready summary and resume prompt. This skill carries no gate criteria of its own; criteria changes land in `/planning:design-handoff` only. ## Scope-specific artifacts @@ -169,14 +169,14 @@ The in-session shortcut to the design→plan gate. Delegate to `/planning:design - **Track resolution status.** Every question and thread gets a status: resolved / directional / deferred. Deferred items carry a research tag describing what external investigation is needed - **Codify rules when discovered.** When discussion surfaces a principle that applies project-wide, suggest codifying it immediately in the project's own rules files - **Incremental artifacts.** Don't produce all artifacts at once. Build them as discussion progresses. Update existing artifacts as decisions evolve. Multi-turn shared artifacts (`design-threads.md` and peers): re-read from disk before every write — another turn or agent may have modified them — and prefer appending or refining over wholesale rewrites -- **Dependency order awareness.** Note which decisions block others. Surface these dependencies to the user so `/architect` can sequence phases correctly +- **Dependency order awareness.** Note which decisions block others. Surface these dependencies to the user so `/planning:plan` can sequence phases correctly - **Resume from prior state.** When design artifacts exist in the topic's design directory, resume from them. Read artifacts, summarize current state, identify remaining gaps - **Suggest adjacent skills.** When a domain-event workshop fits better for domain modeling, suggest it if available. When external research is needed for a deferred item, suggest the research capability (`/discovery:research` if installed). When the session tail is reached, suggest the `terminology` then `handoff` actions - **Design defaults (non-trivial scopes only).** For `library`, `module`, `data`, `integration`, and `system` scopes — when discussion touches configurability, extension points, observability, or testability, open a design thread for it. Skip on early-exit, `status`, or trivial single-file work ## What this skill does NOT do -- **Implementation planning** — that's `/architect` (phases, sanity checks, file-level work items) +- **Implementation planning** — that's `/planning:plan` (phases, sanity checks, file-level work items) - **Code writing** — that's the implementation stage - **External research** — that's the research capability (this skill synthesizes research results into design decisions) - **UI/UX design** — use dedicated frontend design and UI/UX tooling @@ -192,5 +192,5 @@ The in-session shortcut to the design→plan gate. Delegate to `/planning:design | `/planning:domain-modeling` | **During.** Owns active project-glossary updates whenever design resolves domain language; it does not own type or boundary design | | `/discovery:explore` (if installed) | **Before.** Exploration maps existing code. `/design` creates what SHOULD exist | | `/discovery:research` (if installed) | **Before + parallel.** Research gathers external facts. `/design` synthesizes them. Deferred research items can run in parallel | -| `/design-handoff` | **The gate.** Owns the design→plan gate criteria and the /architect-ready summary; this skill's `handoff` action delegates to it | -| `/architect` | **After the handoff gate.** `/design` produces WHAT. `/architect` produces HOW (implementation plan with phases). When design artifacts exist, `/architect` consumes them instead of re-deriving design inline | +| `/design-handoff` | **The gate.** Owns the design→plan gate criteria and the plan-ready summary; this skill's `handoff` action delegates to it | +| `/planning:plan` | **After the handoff gate.** `/design` produces WHAT. `/planning:plan` produces HOW (implementation plan with phases). When design artifacts exist, `/planning:plan` consumes them instead of re-deriving design inline | diff --git a/plugins/planning/skills/design/evals/evals.json b/plugins/planning/skills/design/evals/evals.json index 0bd8d51a4..e41ef8d4a 100644 --- a/plugins/planning/skills/design/evals/evals.json +++ b/plugins/planning/skills/design/evals/evals.json @@ -29,36 +29,36 @@ "id": 3, "name": "early-exit-writes-resolution-artifact", "prompt": "/planning:design this is a single-file bug fix in paginate.js — there's no real design work here.", - "expected_output": "The skill takes the early-exit path and writes design-resolution.md with outcome: early-exit, tier C, and a one-line reason — so /architect's prerequisite check can verify the gate from the artifact — then points onward to /architect.", + "expected_output": "The skill takes the early-exit path and writes design-resolution.md with outcome: early-exit, tier C, and a one-line reason — so /planning:plan's prerequisite check can verify the gate from the artifact — then points onward to /planning:plan.", "files": [], "expectations": [ "Output treats this as an early-exit (diagnostic, not failure) rather than forcing full design exploration", "Output writes a design-resolution.md artifact recording outcome: early-exit, a tier, and a reason", - "Output routes onward to /architect after the early-exit" + "Output routes onward to /planning:plan after the early-exit" ] }, { "id": 4, "name": "handoff-delegates-to-gate", - "prompt": "/planning:design handoff — I think the design threads are all resolved, hand it off to architect.", + "prompt": "/planning:design handoff — I think the design threads are all resolved, hand it off to the plan skill.", "expected_output": "The handoff action delegates to /planning:design-handoff (the single canonical gate) to run the binary check against design-threads.md; the design skill does not apply its own gate criteria inline.", "files": [], "expectations": [ "Output delegates the handoff gate to /planning:design-handoff rather than applying gate criteria itself", "Output does not invent its own separate pass/fail gate logic", - "The handoff is framed as producing an /architect-ready summary sourced from the artifacts" + "The handoff is framed as producing a plan-ready summary sourced from the artifacts" ] }, { "id": 5, "name": "does-not-plan-implementation", "prompt": "/planning:design system for an event-driven order pipeline — and give me the implementation phases and file-level work items while you're at it.", - "expected_output": "The skill produces design artifacts (component map, communication patterns, design threads) but declines to produce implementation phases or file-level work items, deferring that to /architect.", + "expected_output": "The skill produces design artifacts (component map, communication patterns, design threads) but declines to produce implementation phases or file-level work items, deferring that to /planning:plan.", "files": [], "expectations": [ "Output produces design-level artifacts (components, communication patterns, threads), not an implementation plan", "Output does NOT emit implementation phases or file-level work items", - "Output defers implementation planning to /architect" + "Output defers implementation planning to /planning:plan" ] }, { diff --git a/plugins/planning/skills/devils-advocate/SKILL.md b/plugins/planning/skills/devils-advocate/SKILL.md index eab7297f4..e0258e59d 100644 --- a/plugins/planning/skills/devils-advocate/SKILL.md +++ b/plugins/planning/skills/devils-advocate/SKILL.md @@ -175,6 +175,6 @@ Based on findings, suggest relevant follow-up actions: ## Workflow position -Runs as the stress-test step between `/architect`'s plan formulation and user approval: ... → `/architect` → **stress-test (this skill)** → targeted research iteration if needed → user approval → execute. +Runs as the stress-test step between `/planning:plan`'s plan formulation and user approval: ... → `/planning:plan` → **stress-test (this skill)** → targeted research iteration if needed → user approval → execute. For plans that don't warrant a full stress-test (single-file edits, simple config changes with well-understood behavior), prior research validation is sufficient. Use judgment — the trigger is complexity and blast radius, not every plan. diff --git a/plugins/planning/skills/interview/SKILL.md b/plugins/planning/skills/interview/SKILL.md index 331097ae9..28d62f8db 100644 --- a/plugins/planning/skills/interview/SKILL.md +++ b/plugins/planning/skills/interview/SKILL.md @@ -20,11 +20,11 @@ Arguments: `$ARGUMENTS` Most rework comes from acting on assumptions the user never made and the agent never surfaced. `/interview` prevents it: a structured pass driving every load-bearing unknown to a decision OR capturing it as a named, explicit assumption — before exploration, planning, or execution start. -The **pre-clarity** stage — upstream of exploration, research, and `/architect`. `/architect` presupposes a coherent task; `/interview` produces one out of fuzzy intent. The contract it writes is the target every later stage aims at. +The **pre-clarity** stage — upstream of exploration, research, and `/planning:plan`. `/planning:plan` presupposes a coherent task; `/interview` produces one out of fuzzy intent. The contract it writes is the target every later stage aims at. **Supportive, not adversarial.** `/devils-advocate` attacks an existing artifact after the fact. `/interview` walks alongside the user to extract a clear contract from the start. -**Domain-routed.** The interview loop is universal — it grills any plan, decision, or idea. What the session *produces* depends on context: an engineering task in a code repo locks a PLAN.md Brief and can hand off to `/architect`; a general decision drives to a shared understanding and ends there. The domain is inferred from the task's build surface — the problem itself decides, with repo and working directory as context that never suffices alone — never asked, and it is orthogonal to the `me`/`auto`/`lock` action. Engineering machinery — codebase grounding, the Brief, ADR/glossary outputs, pipeline handoff — engages only when the context is engineering; the universal loop runs either way. A user can override the inference in prose ("this isn't a code task", "grill me on this decision"). +**Domain-routed.** The interview loop is universal — it grills any plan, decision, or idea. What the session *produces* depends on context: an engineering task in a code repo locks a PLAN.md Brief and can hand off to `/planning:plan`; a general decision drives to a shared understanding and ends there. The domain is inferred from the task's build surface — the problem itself decides, with repo and working directory as context that never suffices alone — never asked, and it is orthogonal to the `me`/`auto`/`lock` action. Engineering machinery — codebase grounding, the Brief, ADR/glossary outputs, pipeline handoff — engages only when the context is engineering; the universal loop runs either way. A user can override the inference in prose ("this isn't a code task", "grill me on this decision"). **Two invocation modes, one schema.** When intent is fuzzy, `/interview` runs the depth-first Q&A loop. When intent is already clear from conversation, `/interview` synthesizes directly without asking (front-loaded brief). Both write the same output for the session's domain — a PLAN.md Brief for an engineering task, a shared-understanding summary otherwise. The default action **auto-detects** which mode fits and routes accordingly. @@ -163,7 +163,7 @@ Stop when every load-bearing unknown is resolved OR captured as named assumption ### Step 4 — Persist the contract -Derive `` from the task or current branch name (kebab-case, ≤40 chars — shared with `/prd`, `/design`, `/architect`). The contract lands in the topic's contract slice `//` (default `docs/topics/`); working ledgers land in the memory slice `//` (default `.work/`) — roots, tier, and precedence resolve per the topic-docs binding [`${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md`](${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md). *What* gets persisted follows the Step 1 domain classification. +Derive `` from the task or current branch name (kebab-case, ≤40 chars — shared with `/prd`, `/design`, `/planning:plan`). The contract lands in the topic's contract slice `//` (default `docs/topics/`); working ledgers land in the memory slice `//` (default `.work/`) — roots, tier, and precedence resolve per the topic-docs binding [`${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md`](${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md). *What* gets persisted follows the Step 1 domain classification. **General (non-engineering) sessions** persist a shared-understanding summary — the decisions reached and their rationale — to the memory slice (nothing downstream enforces against it), or inline when the user wants no artifact. NEVER create or edit a PLAN.md Brief for a general decision: the `## Brief`/`## Plan` structure is the engineering shape. In `me` mode, the incremental-persistence and context-pressure-flush discipline below still applies, with the summary standing in for the Brief. @@ -171,11 +171,11 @@ Derive `` from the task or current branch name (kebab-case, ≤40 ch **`me` mode persists incrementally, not just at the end.** Lock each answer into the decision-tree ledger (`interview-checklist.md`) + the relevant PLAN.md Brief section the moment it resolves — so a crash, context clear, or overflow never loses resolved branches. **Context-pressure flush:** if the conversation is getting heavy, force-flush the current ledger + partial Brief to disk and offer a handoff (`/session-flow:handoff` if installed, otherwise write a resume note in the topic's memory slice) before continuing. Target the light V1-spec Brief shape (scope / schema / code-surface bullets) — keep it terse. -PLAN.md holds `## Brief` + `## Plan` sections. `/interview` writes only the Brief section; the Plan section stays empty until `/architect` fills it. +PLAN.md holds `## Brief` + `## Plan` sections. `/interview` writes only the Brief section; the Plan section stays empty until `/planning:plan` fills it. If a PLAN.md Brief exists and user chose **revise**, edit the Brief in-place. If **start fresh**, append a dated scope-change note to the top of the Brief capturing why before rewriting — never silently overwrite — and let the commit message carry the pivot rationale. -Section schema: write the literal `## Brief` template — TLDR / Goal / Constraints / Acceptance criteria / Captured assumptions / Out-of-scope / Deferred questions — per [`context/loop.md`](context/loop.md) "Brief template (the literal shape)". Each **Deferred question** carries an **arbiter tag** (`/architect` default, or `USER-RESERVED` when its resolution could change acceptance criteria / out-of-scope / constraints) — load-bearing; loop.md covers when to use which. +Section schema: write the literal `## Brief` template — TLDR / Goal / Constraints / Acceptance criteria / Captured assumptions / Out-of-scope / Deferred questions — per [`context/loop.md`](context/loop.md) "Brief template (the literal shape)". Each **Deferred question** carries an **arbiter tag** (`/planning:plan` default, or `USER-RESERVED` when its resolution could change acceptance criteria / out-of-scope / constraints) — load-bearing; loop.md covers when to use which. ### Step 5 — Hand off @@ -183,7 +183,7 @@ Route the handoff by what the session produced. **A general (non-engineering) se - **Code change with unknowns about the codebase** → clear context, then codebase exploration (`/discovery:explore` if installed — it reads the Brief as scope) - **Code change relying on external libs/APIs/best-practices** → external research (`/discovery:research` if installed) -- **Already understand the codebase and the externals** → `/architect` +- **Already understand the codebase and the externals** → `/planning:plan` - **Task is small and the contract IS the plan** → proceed directly to implementation - **Interview outgrew one session (many branches, context filling)** → handoff now (`/session-flow:handoff` if installed, otherwise write a resume note), clear, resume — the ledger + Brief survive; resume continues from the first open branch @@ -194,7 +194,7 @@ Do NOT auto-clear or auto-invoke. Recommend; let the user pull the trigger. - `context/gotchas.md` — failure patterns from real sessions - **Does not deep-dive the codebase** — Step 1 is a fast survey; the codebase gate in Step 2 is a lightweight per-question check (Grep/Read/Glob). Neither is exploration-depth work. If exploration grows beyond quick lookups, stop and recommend the exploration capability -- **Does not plan implementation** — the Brief says *what* and *what we are assuming*; `/architect` says *how*. Resist drafting an approach mid-interview +- **Does not plan implementation** — the Brief says *what* and *what we are assuming*; `/planning:plan` says *how*. Resist drafting an approach mid-interview - **Does not write code or run tests** — discovery skill. In an engineering session it DOES write domain docs outside the topic's slices when the project keeps them: domain-vocabulary updates (inline, between questions) and ADRs are first-class interview outputs alongside the Brief (a general session writes none) - **Does not adversarially attack the user's idea** — that is `/devils-advocate`. Domain scenario exploration (probing concept boundaries through invented edge cases) discovers domain semantics — it is not plan-attacking. If you find yourself wanting to push back on the goal itself, surface once, capture response, continue - **Does not gate truly mechanical work** — typo, lint-only, whitespace, comment, single-line non-behavioral fix, and routine dependency bumps skip `/interview`. Everything that creates or changes behavior, contracts, structure, or design is **interview-first by default** — auto-detect keeps that cheap (synthesize-on-clear, relentless-Q&A-on-fuzzy). The bar is behavior-change, not fuzziness @@ -208,10 +208,10 @@ Do NOT auto-clear or auto-invoke. Recommend; let the user pull the trigger. | Product intent fuzzy (whose problem, what success) | `/prd` | Upstream of `/interview`; PRD answers *what for whom and why* | | Need codebase grounding | `/discovery:explore` (if installed) | Reads PLAN.md Brief as scope | | Need external evidence | `/discovery:research` (if installed) | Reads PLAN.md Brief as scope | -| Plan the implementation | `/architect` | Reads PLAN.md Brief + explore + research findings | -| Stress-test the plan | `/devils-advocate` | Adversarial pass on `/architect` output | +| Plan the implementation | `/planning:plan` | Reads PLAN.md Brief + explore + research findings | +| Stress-test the plan | `/devils-advocate` | Adversarial pass on `/planning:plan` output | | Pause and resume later | `/session-flow:handoff` (if installed) | Captures session state, distinct from the Brief (mid-task pause vs pre-execution intent) | **Mid-interview composition (`me` mode):** research, exploration, and handoff are not only downstream — invoke them *during* the interview when a recommendation needs external/codebase grounding or when branches outgrow the session. Return to the open branch after. -`/interview` is sister to `/architect`: one resolves *what*, the other resolves *how*. They share the topic slug, share the directory, feed each other. +`/interview` is sister to `/planning:plan`: one resolves *what*, the other resolves *how*. They share the topic slug, share the directory, feed each other. diff --git a/plugins/planning/skills/interview/context/loop.md b/plugins/planning/skills/interview/context/loop.md index 15c2f5d60..0529e8ac4 100644 --- a/plugins/planning/skills/interview/context/loop.md +++ b/plugins/planning/skills/interview/context/loop.md @@ -171,7 +171,7 @@ Each section in the PLAN.md Brief captures a specific shape. Keep tight. - ✅ "`GET /api/users/me` returns 401 when the session token is missing" (testable) - ❌ "Authentication works correctly" (fuzzy) -**Captured assumptions** — what was deferred-with-assumption. Each captures the assumption AND the trigger forcing a revisit. The load-bearing innovation: what would otherwise be silent becomes explicit, and `/devils-advocate` and `/architect` can attack it later. +**Captured assumptions** — what was deferred-with-assumption. Each captures the assumption AND the trigger forcing a revisit. The load-bearing innovation: what would otherwise be silent becomes explicit, and `/devils-advocate` and `/planning:plan` can attack it later. **Out-of-scope** — things raised during the interview and explicitly excluded. Distinct from non-goals (constraints up-front); these surfaced in conversation. @@ -179,7 +179,7 @@ Each section in the PLAN.md Brief captures a specific shape. Keep tight. ### Brief template (the literal shape) -Write this into `//PLAN.md` (default `docs/topics/`; the topic's contract slice, joining the memory slice under `contract_tier: local`). `/interview` writes only `## Brief` and leaves `## Plan` empty for `/architect`. +Write this into `//PLAN.md` (default `docs/topics/`; the topic's contract slice, joining the memory slice under `contract_tier: local`). `/interview` writes only `## Brief` and leaves `## Plan` empty for `/planning:plan`. ```markdown ## Brief @@ -203,10 +203,10 @@ Write this into `//PLAN.md` (default `docs/topics/`; t - ### Deferred questions -- — defer until ; **arbiter: /architect** (default — /architect resolves unilaterally during planning) OR **arbiter: USER-RESERVED** (user must re-confirm at /architect approval gate; /architect proposes, user resolves) +- — defer until ; **arbiter: /planning:plan** (default — /planning:plan resolves unilaterally during planning) OR **arbiter: USER-RESERVED** (user must re-confirm at /planning:plan approval gate; /planning:plan proposes, user resolves) ## Plan - + ``` -**Arbiter tag is load-bearing.** Default `/architect` is fine for execution-shape decisions (orchestration shape, agent rosters, phase nesting) within already-approved scope. Use `USER-RESERVED` for any deferred question whose resolution could change the brief's acceptance criteria, out-of-scope list, or constraints. When in doubt, mark `USER-RESERVED` and let `/architect` surface it at approval time. +**Arbiter tag is load-bearing.** Default `/planning:plan` is fine for execution-shape decisions (orchestration shape, agent rosters, phase nesting) within already-approved scope. Use `USER-RESERVED` for any deferred question whose resolution could change the brief's acceptance criteria, out-of-scope list, or constraints. When in doubt, mark `USER-RESERVED` and let `/planning:plan` surface it at approval time. diff --git a/plugins/planning/skills/interview/evals/evals.json b/plugins/planning/skills/interview/evals/evals.json index 7ca3a42c5..b6448215d 100644 --- a/plugins/planning/skills/interview/evals/evals.json +++ b/plugins/planning/skills/interview/evals/evals.json @@ -42,12 +42,12 @@ "id": 4, "name": "brief-persisted-not-plan", "prompt": "/planning:interview lock a brief for adding a CSV export endpoint to the reports service.", - "expected_output": "The skill writes the Brief section (TLDR / Goal / Constraints / Acceptance criteria / Captured assumptions / Out-of-scope / Deferred questions) into PLAN.md and leaves the Plan section for /architect — it produces the WHAT contract, not an implementation approach.", + "expected_output": "The skill writes the Brief section (TLDR / Goal / Constraints / Acceptance criteria / Captured assumptions / Out-of-scope / Deferred questions) into PLAN.md and leaves the Plan section for /planning:plan — it produces the WHAT contract, not an implementation approach.", "files": [], "expectations": [ "Output writes a Brief with goal, constraints, and testable acceptance criteria", - "Output does NOT draft an implementation plan / approach (that is /architect's job)", - "Output recommends a next step (explore, research, or /architect) rather than starting to code" + "Output does NOT draft an implementation plan / approach (that is /planning:plan's job)", + "Output recommends a next step (explore, research, or /planning:plan) rather than starting to code" ] }, { diff --git a/plugins/planning/skills/architect/SKILL.md b/plugins/planning/skills/plan/SKILL.md similarity index 95% rename from plugins/planning/skills/architect/SKILL.md rename to plugins/planning/skills/plan/SKILL.md index 9d33408e1..d3104810a 100644 --- a/plugins/planning/skills/architect/SKILL.md +++ b/plugins/planning/skills/plan/SKILL.md @@ -1,7 +1,7 @@ --- -name: architect +name: plan description: "Produce structured implementation plans with goal, approach, test strategy, blast-radius assessment, parallelism analysis, and a user approval gate before any code is written — persisting PLAN.md for fresh-session handoff. Use for 'plan this', 'architect this', 'how should we implement', 'implementation plan', proactively before executing without a formalized plan, or 'review this plan' to audit an existing plan's completeness." -argument-hint: "[task description, 'review', or 'close-out'] (e.g., /planning:architect add caching to query handlers, /planning:architect review, /planning:architect close-out)" +argument-hint: "[task description, 'review', or 'close-out'] (e.g., /planning:plan add caching to query handlers, /planning:plan review, /planning:plan close-out)" user-invocable: true disable-model-invocation: false --- @@ -28,7 +28,7 @@ This skill takes the outputs of the earlier stages — exploration (local unders ## Emit checklist -For multi-step planning sessions (almost always — Steps 1-5 of this skill), copy `templates/checklist.md` into the topic's memory slice as `//architect-checklist.md` (default `.work/`). Tick each `- [ ]` as the corresponding step completes. Step 3 (Plan stress-test via fresh-context sub-agent) and Step 5 (Present for approval) are non-negotiable ticks — stress-test before presenting, always. +For multi-step planning sessions (almost always — Steps 1-5 of this skill), copy `templates/checklist.md` into the topic's memory slice as `//plan-checklist.md` (default `.work/`). Tick each `- [ ]` as the corresponding step completes. Step 3 (Plan stress-test via fresh-context sub-agent) and Step 5 (Present for approval) are non-negotiable ticks — stress-test before presenting, always. **Skip when:** mid-flight `review` replan only — append a dated scope-change note and revise the PLAN phases instead; do not spawn a second checklist file. @@ -53,7 +53,7 @@ Before the prerequisite checklist runs, apply a pre-planning discipline checklis Before planning, verify the knowledge base is ready: -- **Is the effort coherent enough to plan?** — If the work is too big to hold at once AND still too foggy to phrase as sharp decisions (missing questions you can't yet state, not just unanswered ones), `/architect` is premature — a plan needs a coherent target. Guide the user to `/planning:wayfind` first (it charts the fog as a decision map and works it down until a destination coheres); recommend, never auto-switch. Skip when the effort is already scoped and the open items are answerable questions +- **Is the effort coherent enough to plan?** — If the work is too big to hold at once AND still too foggy to phrase as sharp decisions (missing questions you can't yet state, not just unanswered ones), `/planning:plan` is premature — a plan needs a coherent target. Guide the user to `/planning:wayfind` first (it charts the fog as a decision map and works it down until a destination coheres); recommend, never auto-switch. Skip when the effort is already scoped and the open items are answerable questions - **Is product intent clear?** — For product-driven feature work (new user-facing surface, business-driven change, cross-team initiative), check that the topic's contract slice holds `PRD.md` (`//PRD.md`, default `docs/topics/`; the memory slice under `contract_tier: local`) OR that problem/users/success-metrics are already crisp in conversation. If fuzzy, suggest running `/prd` first. Skip this check for engineering-internal work (refactors, infra, hooks, conventions, bug fixes) — `/prd` does not apply - **Has exploration been done?** — Check if the conversation contains exploration findings for the relevant area. If not, suggest running the exploration capability first (`/discovery:explore` if installed). Don't plan in the dark - **Has research been done?** — Check if external research has been completed for technical claims the plan will rely on. If not, suggest running the research capability first (`/discovery:research` if installed). Plans built on assumptions instead of evidence lead to rework @@ -65,7 +65,7 @@ Before planning, verify the knowledge base is ready: | **B — light design** | 2–5 files, one new type, localized contract tweak | **Blocking:** minimal `type-inventory.md` OR `design/design-resolution.md` documenting early-exit with type sketch | | **C — no design** | Single-file bugfix, config/doc/markdown, rename, hook text, pure test addition | **Blocking:** `design/design-resolution.md` with `outcome: early-exit` + reason (gate always evaluated) | -Check the topic's contract slice `//design/` (default `docs/topics/`; the memory slice under `contract_tier: local`) for design artifacts OR `design-resolution.md` at that path. If Tier A/B requirements are unmet, **stop** — offer `/design` or document the early-exit artifact. The user may override via `AskUserQuestion` only when they explicitly accept skipping design exploration. `/architect` consumes design artifacts — do not re-derive design inline when design-significant. +Check the topic's contract slice `//design/` (default `docs/topics/`; the memory slice under `contract_tier: local`) for design artifacts OR `design-resolution.md` at that path. If Tier A/B requirements are unmet, **stop** — offer `/design` or document the early-exit artifact. The user may override via `AskUserQuestion` only when they explicitly accept skipping design exploration. `/planning:plan` consumes design artifacts — do not re-derive design inline when design-significant. - **Is the scope clear?** — If the task is ambiguous, ask clarifying questions before planning. A plan for "improve performance" is useless; a plan for "add a cache to the GetOrderById query handler" is actionable. When 2–4 discrete options exist (e.g. cache scope, eviction policy, key derivation), use `AskUserQuestion`; for open-ended ambiguity use prose, one question at a time - **Open Decisions surfaced BEFORE plan body** — scan the resume prompt + conversation context + Brief for unresolved decisions (scope cuts, technique choices, ordering, exclusions) that the downstream plan body would otherwise lock inline. Surface them as a numbered "Open Decisions" block with research-backed recommendations + trade-offs per decision; resolve via `AskUserQuestion` (≤4 decisions) or single-prompt prose (≥5). Resolving once up front is cheaper than iterating during Step 5 approval @@ -203,7 +203,7 @@ Present the final plan to the user. The plan is a proposal, not a commitment — 3. Stress-test summary (from Step 4, if run) — or "Skipped: blast radius LOW, no triggers matched" 4. **Execution shape** (from Step 4.5) — parallelism shape AND per-phase routing table. Skipped for single-phase plans 5. **Decisions made (gate-passed)** (from Step 4.6) — TABLE per [context/tag-decisions.md](context/tag-decisions.md) "Presentation contract": `Decision | What it changes in the plan | Basis (evidence)`, one row per gate-passed `[EXEC-SHAPE]` / `[FALLBACK]` tag, written for a cold reader (no session shorthand). Below-bar decisions never appear here — they were interviewed before the plan locked. An empty section ("no unilateral decisions — every PLAN item traces to brief") is also valid output -6. **Explicit approval request**: "Approve this plan to proceed to execution, or provide feedback to revise. Anything tagged `[EXEC-SHAPE]` or `[FALLBACK]` above is /architect's discretion — flag any you want changed." +6. **Explicit approval request**: "Approve this plan to proceed to execution, or provide feedback to revise. Anything tagged `[EXEC-SHAPE]` or `[FALLBACK]` above is /planning:plan's discretion — flag any you want changed." **Presentation order — tweak-likelihood first.** Order the presentation by what the user is most likely to change on review: data-model/schema choices, type interfaces and public contracts, and user-facing surfaces LEAD (flag close calls with their alternatives); mechanical refactoring and low-judgment work sits at the bottom. Presentation order only — phase EXECUTION order stays integration-first per Step 2. Optionally offer a self-contained HTML plan view (decisions-first layout, flagged choices with toggleable alternatives); PLAN.md stays the tracked record. @@ -221,7 +221,7 @@ Before handing off to implementation, verify the branch name matches the approve Derive the conventional type from plan content: new capability → `feat/`, bug fix → `fix/`, restructuring → `refactor/`, tooling/maintenance → `chore/`, docs-only → `docs/`, tests-only → `test/`, build config → `build/`, performance → `perf/`. -**After approval:** the plan feeds into implementation. Suggest the consuming environment's implementation workflow (an `/implement`-style skill if it ships one, otherwise structured inline execution reading PLAN.md). If implementation diverges from the plan, chain back to `/architect review` to re-plan rather than pushing through a broken approach. +**After approval:** the plan feeds into implementation. Suggest the consuming environment's implementation workflow (an `/implement`-style skill if it ships one, otherwise structured inline execution reading PLAN.md). If implementation diverges from the plan, chain back to `/planning:plan review` to re-plan rather than pushing through a broken approach. ## Plan Mode Integration @@ -283,7 +283,7 @@ After the user approves the plan in Step 5, update the draft `/ ### Execution shape ([EXEC-SHAPE] tagged) - + ### Mechanical work @@ -295,7 +295,7 @@ PLAN.md is a multi-turn shared artifact: re-read it from disk before every write Write the plan even for small changes — future you or a fresh-session agent will thank you. -**Close-out (PR time).** The contract slice is branch-lived; `/architect` owns describing its close-out — invoke with the `close-out` argument once the plan is approved: +**Close-out (PR time).** The contract slice is branch-lived; `/planning:plan` owns describing its close-out — invoke with the `close-out` argument once the plan is approved: 1. Paste the approved PLAN.md into the PR description inside a `
` block — the review-surface publication (PR bodies cap near 64 KB; paste the contract, reference the rest). 2. Graduate durable outcomes through the knowledge-vault seam — resolve the concern file's `vault_backend`: `docs` (default) → a history-preserving `git mv` of the promoted doc into `docs/adr/` or `docs/specs/` (guard the command — create the target directory first); `gitbook` → report that writes are deferred and use the `docs` path without invoking GitBook API/MCP or Git Sync; any other enabled value → the backend the consuming repo documents, degrading to `docs` when its tools are absent (binding: [`${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md`](${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md)). Actionable follow-ups go through the work-item tracker seam. @@ -323,7 +323,7 @@ Lifecycle detail and the redaction bar for committed evidence: [`${CLAUDE_PLUGIN - **NEVER skip Step 3 plan stress-test.** Dispatch the fresh-context plan-reviewer sub-agent every time — the producing planner must not self-critique inline. If the user finds a gap in 5 seconds that the reviewer missed, tighten the reviewer brief. MANDATORY regardless of blast radius - **Don't skip the prerequisite check.** Plans built without exploration miss existing patterns. Plans without research repeat mistakes others have solved. The prerequisite check is 30 seconds; the rework is 30 minutes - **Scale the plan to the task.** A 50-line plan for a typo fix is over-engineering. A 3-bullet plan for a cross-cutting refactor is under-engineering. Match depth to blast radius -- **Don't confuse this skill with built-in plan mode.** Plan mode is a read-only permission mode. `/architect` is a planning discipline. If a user types "plan this", they want the discipline, not the permission mode +- **Don't confuse this skill with built-in plan mode.** Plan mode is a read-only permission mode. `/planning:plan` is a planning discipline. If a user types "plan this", they want the discipline, not the permission mode - **Research-iterate has a ceiling.** 3 iterations max before escalating to the user. Infinite loops waste context on diminishing returns. If 3 rounds can't resolve it, the approach may need to change, not just the evidence - **The plan is a proposal.** Never start executing without user approval. The approval gate is the point — it's where human judgment enters the loop - **Step 4.5 (Execution shape) is default ON for ≥2-phase plans.** Skip explicitly only for single-phase plans or trivial fixes — skipped = all-main-session execution, stated in one line diff --git a/plugins/planning/skills/architect/context/plan-reviewer.md b/plugins/planning/skills/plan/context/plan-reviewer.md similarity index 95% rename from plugins/planning/skills/architect/context/plan-reviewer.md rename to plugins/planning/skills/plan/context/plan-reviewer.md index 265900aef..2b3da6a57 100644 --- a/plugins/planning/skills/architect/context/plan-reviewer.md +++ b/plugins/planning/skills/plan/context/plan-reviewer.md @@ -1,6 +1,6 @@ # Plan Reviewer — Sub-Agent Dispatch -Fresh-context plan stress-test for `/architect` Step 3. The producing planner MUST NOT run this checklist inline. +Fresh-context plan stress-test for `/planning:plan` Step 3. The producing planner MUST NOT run this checklist inline. ## Orchestrator inputs diff --git a/plugins/planning/skills/architect/context/plan-template.md b/plugins/planning/skills/plan/context/plan-template.md similarity index 100% rename from plugins/planning/skills/architect/context/plan-template.md rename to plugins/planning/skills/plan/context/plan-template.md diff --git a/plugins/planning/skills/architect/context/research-iterate.md b/plugins/planning/skills/plan/context/research-iterate.md similarity index 100% rename from plugins/planning/skills/architect/context/research-iterate.md rename to plugins/planning/skills/plan/context/research-iterate.md diff --git a/plugins/planning/skills/architect/context/stress-test-triggers.md b/plugins/planning/skills/plan/context/stress-test-triggers.md similarity index 100% rename from plugins/planning/skills/architect/context/stress-test-triggers.md rename to plugins/planning/skills/plan/context/stress-test-triggers.md diff --git a/plugins/planning/skills/architect/context/tag-decisions.md b/plugins/planning/skills/plan/context/tag-decisions.md similarity index 71% rename from plugins/planning/skills/architect/context/tag-decisions.md rename to plugins/planning/skills/plan/context/tag-decisions.md index 7888119d5..ba24f57f6 100644 --- a/plugins/planning/skills/architect/context/tag-decisions.md +++ b/plugins/planning/skills/plan/context/tag-decisions.md @@ -1,12 +1,12 @@ # Tag unilateral decisions (Step 4.6) -Full taxonomy for `/architect` Step 4.6. Before Step 5 approval, walk the PLAN body + Handoff section and classify every decision NOT explicit in the brief. Three categories: +Full taxonomy for `/planning:plan` Step 4.6. Before Step 5 approval, walk the PLAN body + Handoff section and classify every decision NOT explicit in the brief. Three categories: | Category | Definition | Tag | |---|---|---| -| **Briefed** | The Brief / interview locked this decision (acceptance criteria, constraints, out-of-scope items, deferred questions with `arbiter: /architect`) | (no tag — assumed approved) | -| **Execution-shape** | /architect's discretion within briefed scope — orchestration shape (parallel/sequential), sub-topic promotion, technique selection, per-phase ordering, sanity-check criteria | **Tag: `[EXEC-SHAPE]`** in the PLAN body | -| **Fallback-for-edge-case** | An /architect-invented contingency for scenarios the brief did NOT anticipate — follow-up work items, alignment-check protocols between parallel agents, retry mechanisms, mid-flight pivot defaults | **Tag: `[FALLBACK — confirm or override]`** in the PLAN body | +| **Briefed** | The Brief / interview locked this decision (acceptance criteria, constraints, out-of-scope items, deferred questions with `arbiter: /planning:plan`) | (no tag — assumed approved) | +| **Execution-shape** | /planning:plan's discretion within briefed scope — orchestration shape (parallel/sequential), sub-topic promotion, technique selection, per-phase ordering, sanity-check criteria | **Tag: `[EXEC-SHAPE]`** in the PLAN body | +| **Fallback-for-edge-case** | A /planning:plan-invented contingency for scenarios the brief did NOT anticipate — follow-up work items, alignment-check protocols between parallel agents, retry mechanisms, mid-flight pivot defaults | **Tag: `[FALLBACK — confirm or override]`** in the PLAN body | ## Confidence gate (decide vs interview) @@ -29,4 +29,4 @@ Surface every decided tag at Step 5 in a "Decisions made (gate-passed)" subsecti The what-it-changes column is mandatory — a label without its plan impact is unreviewable. Write for a cold reader dropping in mid-session: no session-internal shorthand; the row must make sense without scrollback. Interviewed decisions do NOT appear here — they were resolved by the user and are briefed by the time of presentation. -Anti-pattern: bundling unilateral decisions deep in the Handoff section so they read as part of an approved plan. The reviewer must distinguish "user approved this" from "/architect added this" without reading every line. +Anti-pattern: bundling unilateral decisions deep in the Handoff section so they read as part of an approved plan. The reviewer must distinguish "user approved this" from "/planning:plan added this" without reading every line. diff --git a/plugins/planning/skills/architect/evals/evals.json b/plugins/planning/skills/plan/evals/evals.json similarity index 75% rename from plugins/planning/skills/architect/evals/evals.json rename to plugins/planning/skills/plan/evals/evals.json index 2c0aba8da..002aaa1ab 100644 --- a/plugins/planning/skills/architect/evals/evals.json +++ b/plugins/planning/skills/plan/evals/evals.json @@ -1,10 +1,10 @@ { - "skill_name": "architect", + "skill_name": "plan", "evals": [ { "id": 1, "name": "full-plan-happy-path", - "prompt": "/planning:architect add a cache to the GetOrderById query handler. Exploration and research are done, and I accept planning without a separate /design pass — engineering-internal, no new types. Produce the plan.", + "prompt": "/planning:plan add a cache to the GetOrderById query handler. Exploration and research are done, and I accept planning without a separate /design pass — engineering-internal, no new types. Produce the plan.", "expected_output": "The design gate is satisfied by the explicit override, so planning proceeds to a structured implementation plan covering goal, approach (ordered steps), test strategy, files affected, alternatives considered, and risks — persisted to PLAN.md. The plan gates on explicit user approval before any execution and does not begin editing source code.", "files": [], "expectations": [ @@ -17,7 +17,7 @@ { "id": 2, "name": "mandatory-fresh-context-stress-test", - "prompt": "/planning:architect exploration and research are done, and I explicitly accept planning without a separate /design pass (no new types or modules). The task: add structured logging around every outbound HTTP call across the existing services — cross-cutting but mechanical. Formulate the plan and get it ready to present.", + "prompt": "/planning:plan exploration and research are done, and I explicitly accept planning without a separate /design pass (no new types or modules). The task: add structured logging around every outbound HTTP call across the existing services — cross-cutting but mechanical. Formulate the plan and get it ready to present.", "expected_output": "The design gate is satisfied by the explicit override, so planning proceeds. Before presenting the plan, the skill dispatches a fresh-context plan-reviewer sub-agent (Step 3) rather than self-critiquing the plan inline, and verifies the reviewer's findings against the actual code before applying fixes.", "files": [], "expectations": [ @@ -29,7 +29,7 @@ { "id": 3, "name": "does-not-write-code", - "prompt": "/planning:architect add retry-with-backoff to the outbound webhook sender — exploration and research are done and I accept planning without a separate /design pass (no new types). And go ahead and just implement it while you're at it.", + "prompt": "/planning:plan add retry-with-backoff to the outbound webhook sender — exploration and research are done and I accept planning without a separate /design pass (no new types). And go ahead and just implement it while you're at it.", "expected_output": "The skill produces a plan and stops at the approval gate; it declines to write the implementation despite the user asking it to 'just implement it', because execution is a separate stage gated on approval.", "files": [], "expectations": [ @@ -41,7 +41,7 @@ { "id": 4, "name": "sanity-checks-mechanically-verifiable", - "prompt": "/planning:architect exploration and research are done and I accept planning without a separate /design pass — this adds a null-guard and an error return to the existing parseInvoice function at its 3 call sites (no new types). Write the plan with per-phase sanity checks.", + "prompt": "/planning:plan exploration and research are done and I accept planning without a separate /design pass — this adds a null-guard and an error return to the existing parseInvoice function at its 3 call sites (no new types). Write the plan with per-phase sanity checks.", "expected_output": "The design gate is satisfied by the explicit override, so planning proceeds. Each phase ends with at least one Sanity Check that is mechanically verifiable — a specific grep, file-Read assertion, or build/test exit code — never vague language like 'documented appropriately' or 'behaves as expected'.", "files": [], "expectations": [ @@ -53,7 +53,7 @@ { "id": 5, "name": "design-gate-blocks-without-artifact", - "prompt": "/planning:architect design and add a new Notifications module with its own types, contracts, and package topology. No /design has been run and there is no design artifact in the topic's contract slice yet.", + "prompt": "/planning:plan design and add a new Notifications module with its own types, contracts, and package topology. No /design has been run and there is no design artifact in the topic's contract slice yet.", "expected_output": "The prerequisite check classifies this as design-significant (Tier A), finds no design artifact, and STOPS before planning — offering to run /design or to document an early-exit design-resolution.md — instead of re-deriving the design inline.", "files": [], "expectations": [ @@ -65,7 +65,7 @@ { "id": 6, "name": "review-action-critiques-existing-plan", - "prompt": "/planning:architect review — here is the plan to review: 'Phase 1: add a Redis cache to the GetOrderById query handler. Phase 2: wire cache invalidation on order update.' That's the whole plan. Critique it.", + "prompt": "/planning:plan review — here is the plan to review: 'Phase 1: add a Redis cache to the GetOrderById query handler. Phase 2: wire cache invalidation on order update.' That's the whole plan. Critique it.", "expected_output": "In review mode the skill critiques the provided plan against the plan template and the project's conventions — flagging that it has no test strategy, no alternatives-considered, no risks, and no blast-radius assessment, and that neither phase carries a mechanically verifiable sanity check — rather than authoring a new plan or writing code.", "files": [], "expectations": [ @@ -77,7 +77,7 @@ { "id": 7, "name": "gitbook-backend-degrades-to-docs-without-writing", - "prompt": "/planning:architect close-out\n\nThe approved plan is complete. This repo's .claude/topic-docs.yaml says vault_backend: gitbook. Graduate the durable decision now.", + "prompt": "/planning:plan close-out\n\nThe approved plan is complete. This repo's .claude/topic-docs.yaml says vault_backend: gitbook. Graduate the durable decision now.", "expected_output": "Reports that GitBook is a deferred, non-writable backend and follows the documented docs fallback: it promotes the durable decision with a guarded, history-preserving git mv into docs/adr or docs/specs. It does not invoke or configure a GitBook API, MCP operation, or Git Sync writer.", "files": [], "expectations": [ diff --git a/plugins/planning/skills/architect/templates/checklist.md b/plugins/planning/skills/plan/templates/checklist.md similarity index 91% rename from plugins/planning/skills/architect/templates/checklist.md rename to plugins/planning/skills/plan/templates/checklist.md index 3f1f5fc71..9bf79a1f7 100644 --- a/plugins/planning/skills/architect/templates/checklist.md +++ b/plugins/planning/skills/plan/templates/checklist.md @@ -1,6 +1,6 @@ -# /architect Checklist +# /planning:plan Checklist -Copy into `//architect-checklist.md` (default `.work/`; the topic's memory slice). Tick as each step completes. +Copy into `//plan-checklist.md` (default `.work/`; the topic's memory slice). Tick as each step completes. ## Steps diff --git a/plugins/planning/skills/prd/SKILL.md b/plugins/planning/skills/prd/SKILL.md index e76a3fc0d..f58d1e465 100644 --- a/plugins/planning/skills/prd/SKILL.md +++ b/plugins/planning/skills/prd/SKILL.md @@ -1,6 +1,6 @@ --- name: prd -description: "Produce a Product Requirements Document that locks product intent — problem, users, success metrics — before any engineering plan, with tiers (one-pager / consumer-feature / b2b-internal), a synthesize path, and a review mode. Use for 'write a PRD', 'spec out a feature', 'product brief', or any user-facing business-driven change needing written alignment; skip for refactors, infra, bug fixes, and engineering-internal work (route to /interview or /architect)." +description: "Produce a Product Requirements Document that locks product intent — problem, users, success metrics — before any engineering plan, with tiers (one-pager / consumer-feature / b2b-internal), a synthesize path, and a review mode. Use for 'write a PRD', 'spec out a feature', 'product brief', or any user-facing business-driven change needing written alignment; skip for refactors, infra, bug fixes, and engineering-internal work (route to /interview or /planning:plan)." argument-hint: "[tier] [task description] (e.g., /planning:prd, /planning:prd one-pager add gig calendar, /planning:prd review)" user-invocable: true disable-model-invocation: false @@ -20,13 +20,13 @@ Arguments: `$ARGUMENTS` Most product-feature rework comes from skipping the *what for whom and why* layer and jumping straight to *how*. `/prd` produces the lockable product intent contract — what we are building, for which users, against what measurable success — before any engineering plan, exploration, or research begins. -This is the **product-intent** stage. **Upstream of exploration**, **upstream of `/architect`**, and may run **before or alongside `/interview`** depending on task shape: +This is the **product-intent** stage. **Upstream of exploration**, **upstream of `/planning:plan`**, and may run **before or alongside `/interview`** depending on task shape: - `/prd` — answers *what should we build, for whom, and why*. Outcome-focused. Required for new user-facing features, business-driven changes, cross-team initiatives - `/interview` — answers *what is the engineering contract for this task*. Constraint and acceptance-criteria focused. Required whenever intent is fuzzy, regardless of source -- Complementary, not redundant. A product feature usually wants both: `/prd` (product intent) → `/interview` (engineering contract) → exploration → research → `/design` → `/architect`. Engineering-internal work skips `/prd` entirely +- Complementary, not redundant. A product feature usually wants both: `/prd` (product intent) → `/interview` (engineering contract) → exploration → research → `/design` → `/planning:plan`. Engineering-internal work skips `/prd` entirely -The PRD is **never an implementation plan**. Boundaries: problem, users, success — yes. Architecture, files, tests, code shapes — no. That is `/architect`'s job. If the user pulls toward implementation mid-PRD, anchor back to *what for whom* and let `/architect` pick up after. +The PRD is **never an implementation plan**. Boundaries: problem, users, success — yes. Architecture, files, tests, code shapes — no. That is `/planning:plan`'s job. If the user pulls toward implementation mid-PRD, anchor back to *what for whom* and let `/planning:plan` pick up after. **Cost framing**: locking product intent up-front is the cheapest version of the conversation. Every later session that runs against a written PRD costs less than one that infers product goals from a half-formed thought. @@ -40,7 +40,7 @@ Invoke `/prd` when ALL of these are true: ## Skip conditions — when to NOT invoke `/prd` -If ANY of these hold, do NOT write a PRD. Tell the user explicitly: *"This is engineering-internal — no PRD. Recommend `/interview` (if intent is fuzzy) or `/architect` (if it's clear)."* +If ANY of these hold, do NOT write a PRD. Tell the user explicitly: *"This is engineering-internal — no PRD. Recommend `/interview` (if intent is fuzzy) or `/planning:plan` (if it's clear)."* - **Refactors** (no behaviour change) - **Infrastructure** (build, CI, hooks, config, dependency bumps, lockfiles) @@ -74,7 +74,7 @@ Tier choice rationale lives in [`context/templates.md`](context/templates.md). W Before any other work, validate the request matches the trigger conditions. If it matches the skip conditions, STOP and tell the user: -> *"This looks engineering-internal (``). PRDs add cost without value here. Recommend: `/interview` for fuzzy intent OR `/architect` directly if scope is clear."* +> *"This looks engineering-internal (``). PRDs add cost without value here. Recommend: `/interview` for fuzzy intent OR `/planning:plan` directly if scope is clear."* Do not proceed unless the user explicitly overrides ("write the PRD anyway") OR clarifies the user-facing/business framing. @@ -113,7 +113,7 @@ When invoked with `synthesize`, skip Step 4 Q&A entirely. Produce the PRD from e Use when conversation already contains rich product context and re-asking would waste time. The user is signaling "I've told you enough — write it." Respect that signal. -If after the survey (Step 2) a required section has NO answerable content in the conversation, note it as an open question rather than forcing Q&A. The PRD with open questions is still useful — `/interview` or `/architect` picks them up downstream. +If after the survey (Step 2) a required section has NO answerable content in the conversation, note it as an open question rather than forcing Q&A. The PRD with open questions is still useful — `/interview` or `/planning:plan` picks them up downstream. ### Step 4 — Drive depth-first Q&A @@ -132,13 +132,13 @@ Question shapes that recur, in priority order: | User stories | "Pick the one most-important journey: as a `` I want to `` so that ``." | | Success metrics | "How will we know it worked? Name the metric and the threshold — adoption %, conversion %, time saved, error rate." | | Dependencies / risks | "What outside this team must exist or change for this to ship? What's the biggest risk?" | -| Open questions | "What is genuinely undecided that the architect needs an answer to?" | +| Open questions | "What is genuinely undecided that `/planning:plan` needs an answer to?" | Stop asking once every required section has either a resolved answer or an explicit "open question with revisit trigger". ### Step 5 — Persist the PRD -Derive `` from the task description or current branch name (kebab-case, ≤40 chars) — the same slug `/interview`, `/design`, and `/architect` will use for this topic. Write to `//PRD.md` (default `docs/topics/`) — the topic's contract slice, committed on the task branch as it locks; under `contract_tier: local` it joins the memory slice instead. Roots, tier, and precedence resolve per the topic-docs binding [`${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md`](${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md). PRD.md lives alongside `PLAN.md` (architect's output) and the topic's design artifacts. +Derive `` from the task description or current branch name (kebab-case, ≤40 chars) — the same slug `/interview`, `/design`, and `/planning:plan` will use for this topic. Write to `//PRD.md` (default `docs/topics/`) — the topic's contract slice, committed on the task branch as it locks; under `contract_tier: local` it joins the memory slice instead. Roots, tier, and precedence resolve per the topic-docs binding [`${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md`](${CLAUDE_PLUGIN_ROOT}/reference/topic-docs.md). PRD.md lives alongside `PLAN.md` (the plan skill's output) and the topic's design artifacts. Frontmatter: @@ -159,7 +159,7 @@ Required sections (every tier — verbosity varies): 4. **Users** — primary persona(s) + 1-2 user stories in `as a , I want , so that ` form 5. **Success metrics** — named metric + threshold + measurement window 6. **Dependencies / risks** — outside-team dependencies + top 1-3 risks with mitigations -7. **Open questions** — anything genuinely undecided that `/architect` needs answered +7. **Open questions** — anything genuinely undecided that `/planning:plan` needs answered Tier-3 (B2B) adds: **Stakeholders**, **Rollout**, **Compliance / integration**. @@ -180,7 +180,7 @@ After writing the PRD, recommend the next step. The recommendation depends on re - **Engineering scope still fuzzy** (constraints, untouchable areas, perf budget unclear) → clear context, then `/interview` (it will read the topic's `PRD.md` as scope) - **Engineering scope is clear, codebase grounding needed** → `/discovery:explore` if installed, otherwise whatever codebase-exploration capability the environment provides - **Need external research (libs, APIs, comparables)** → `/discovery:research` if installed, otherwise the strongest research capability available -- **Engineering scope clear and externals understood** → `/architect` +- **Engineering scope clear and externals understood** → `/planning:plan` Do NOT auto-clear or auto-invoke. Recommend; let the user pull the trigger. @@ -195,11 +195,11 @@ When invoked with `review`: 5. Check success metrics have a *measurement window* and *threshold*, not vague language 6. Present findings: what's strong, what's missing, what to revise -Complementary to `/devils-advocate` — review checks structure and convention; stress-test (run later against `/architect`'s plan, not the PRD) checks failure modes. +Complementary to `/devils-advocate` — review checks structure and convention; stress-test (run later against `/planning:plan`'s plan, not the PRD) checks failure modes. ## What this skill does NOT do -- **Does not plan implementation** — the PRD is *what for whom and why*. Architecture, files, tests, code is `/architect`'s job. If you find yourself writing "we'll add `XHandler` to module Y", stop and move that to the open-questions section as an architecture decision for later +- **Does not plan implementation** — the PRD is *what for whom and why*. Architecture, files, tests, code is `/planning:plan`'s job. If you find yourself writing "we'll add `XHandler` to module Y", stop and move that to the open-questions section as an architecture decision for later - **Does not run exploration or research** — Step 2's survey is a *fast grounding pass*, not deep work. If product framing requires deep external research (competitive analysis, market data), pause the PRD and recommend the research capability first - **Does not gate other skills** — engineering-internal tasks skip `/prd` entirely. Even product features can skip if intent is already locked elsewhere (existing roadmap doc, recent ADR, prior PRD) - **Does not adversarially attack the user's product idea** — not the PRD's role. If the proposed feature has obvious product risk, surface it once in the *risks* section and continue. Pushback belongs in product review, not PRD authoring @@ -214,11 +214,11 @@ Complementary to `/devils-advocate` — review checks structure and convention; | Pre-task: any fuzzy task — including post-PRD constraint discovery | `/interview` | Produces the Brief in `PLAN.md` (reads PRD if present) | | Need codebase grounding | `/discovery:explore` (if installed) | Reads PRD + PLAN as scope | | Need external evidence | `/discovery:research` (if installed) | Reads PRD + PLAN as scope | -| Need design exploration (types, contracts, topology) | `/design` | Reads PRD + PLAN; produces design artifacts that `/architect` consumes | -| Plan the implementation | `/architect` | Reads PRD + PLAN + explore + research findings | -| Stress-test the plan | `/devils-advocate` | Adversarial pass on `/architect` output (not the PRD) | +| Need design exploration (types, contracts, topology) | `/design` | Reads PRD + PLAN; produces design artifacts that `/planning:plan` consumes | +| Plan the implementation | `/planning:plan` | Reads PRD + PLAN + explore + research findings | +| Stress-test the plan | `/devils-advocate` | Adversarial pass on `/planning:plan` output (not the PRD) | -`/prd` is sister to `/architect`: one resolves *what for whom and why*; the other resolves *how*. They share the topic slug, share the contract slice, and feed each other. +`/prd` is sister to `/planning:plan`: one resolves *what for whom and why*; the other resolves *how*. They share the topic slug, share the contract slice, and feed each other. ## Gotchas @@ -226,5 +226,5 @@ Complementary to `/devils-advocate` — review checks structure and convention; - **Success metrics need a window.** "Increase engagement" is not a metric; "DAU/MAU rises from X to Y over 30 days post-launch" is. If a metric has no number and no window, it can't validate the feature - **Don't write a PRD for engineering-internal work.** Skip-condition check is mandatory. PRDs for refactors, hooks, lint rules waste cycles and dilute the convention - **Tier governs verbosity, not which sections exist.** All three tiers have the same seven required sections. Tier-1 is one line per section; tier-3 is a full paragraph. Don't drop sections to "save time" — drop words -- **The PRD is never an architecture document.** When discussion drifts to implementation, anchor back to *what for whom*. Capture architecture questions in the **open questions** section for `/architect` to resolve +- **The PRD is never an architecture document.** When discussion drifts to implementation, anchor back to *what for whom*. Capture architecture questions in the **open questions** section for `/planning:plan` to resolve - **Resume vs revise vs start-fresh on prior PRDs.** Never silently overwrite. If scope shifted, append a dated restart note capturing why before rewriting diff --git a/plugins/planning/skills/prd/context/templates.md b/plugins/planning/skills/prd/context/templates.md index 778695611..68ff103ee 100644 --- a/plugins/planning/skills/prd/context/templates.md +++ b/plugins/planning/skills/prd/context/templates.md @@ -2,7 +2,7 @@ All three tiers cover the same seven required sections. Tier governs verbosity, not section presence. Loaded on demand by `/prd` once tier is chosen. -**Prototype snippet exception:** if a logic prototype (e.g. `/prototype:logic`, if installed) produced a snippet that encodes a design decision more precisely than prose (state machine, reducer, schema, type shape), inline the decision-rich parts in the Open questions section and note it came from a prototype. The PRD defers implementation details to `/architect`, but prototype-validated design constraints are product-level — they belong here. +**Prototype snippet exception:** if a logic prototype (e.g. `/prototype:logic`, if installed) produced a snippet that encodes a design decision more precisely than prose (state machine, reducer, schema, type shape), inline the decision-rich parts in the Open questions section and note it came from a prototype. The PRD defers implementation details to `/planning:plan`, but prototype-validated design constraints are product-level — they belong here. --- @@ -44,7 +44,7 @@ updated: - — ## Open questions -- +- ``` ### Example — "Add gig calendar to dashboard" @@ -84,7 +84,7 @@ Solo and band artists who play 2+ gigs/month. - Risk: overlapping with planned rehearsal-scheduling feature → coordinate with that PRD ## Open questions -- Show full month or rolling 14-day window? (architect to evaluate based on data density) +- Show full month or rolling 14-day window? (/planning:plan to evaluate based on data density) ``` --- @@ -142,7 +142,7 @@ Each metric must have a measurement window and a numeric or qualitative threshol - **Risk**: — ## Open questions -- +- - ``` @@ -231,7 +231,7 @@ Each metric named with owner — "who watches the dashboard" matters in tier-3. - **Communication**: ## Open questions -- +- - - ``` diff --git a/plugins/planning/skills/prd/evals/evals.json b/plugins/planning/skills/prd/evals/evals.json index 7940fec34..0cc8592fa 100644 --- a/plugins/planning/skills/prd/evals/evals.json +++ b/plugins/planning/skills/prd/evals/evals.json @@ -17,12 +17,12 @@ "id": 2, "name": "skip-condition-refuses-engineering-internal", "prompt": "/planning:prd refactor the payment module to remove the static DateTime.Now calls and inject TimeProvider instead.", - "expected_output": "The mandatory skip-condition check identifies this as engineering-internal (a refactor with no user-facing surface), declines to write a PRD, and recommends /interview (fuzzy intent) or /architect (clear scope) instead.", + "expected_output": "The mandatory skip-condition check identifies this as engineering-internal (a refactor with no user-facing surface), declines to write a PRD, and recommends /interview (fuzzy intent) or /planning:plan (clear scope) instead.", "files": [], "expectations": [ "Output identifies the task as engineering-internal (refactor, no user-facing surface)", "Output does NOT produce a PRD", - "Output recommends /interview or /architect instead of writing a PRD" + "Output recommends /interview or /planning:plan instead of writing a PRD" ] }, { @@ -53,12 +53,12 @@ "id": 5, "name": "does-not-drift-into-implementation", "prompt": "/planning:prd consumer add group playlists to the music app. While you're at it, tell me which handler classes and database tables we'll need.", - "expected_output": "The skill anchors back to what-for-whom-and-why and declines to specify handler classes or database tables in the PRD, capturing those as architecture open questions for /architect instead.", + "expected_output": "The skill anchors back to what-for-whom-and-why and declines to specify handler classes or database tables in the PRD, capturing those as architecture open questions for /planning:plan instead.", "files": [], "expectations": [ "Output does not enumerate handler classes, database tables, or other implementation structures in the PRD", "Output anchors the discussion back to problem / users / success (product intent)", - "Output defers the architecture questions to the open-questions section (for /architect) rather than answering them" + "Output defers the architecture questions to the open-questions section (for /planning:plan) rather than answering them" ] }, { diff --git a/plugins/planning/skills/setup/SKILL.md b/plugins/planning/skills/setup/SKILL.md index f01b5a090..fe742bcb0 100644 --- a/plugins/planning/skills/setup/SKILL.md +++ b/plugins/planning/skills/setup/SKILL.md @@ -65,7 +65,7 @@ values, the conflict-check result, and how to re-run this setup to reconfigure. - Run a planning stage — that is the pipeline skills (`/planning:brainstorm`, `/planning:prd`, `/planning:interview`, `/planning:design`, `/planning:design-handoff`, - `/planning:devils-advocate`, `/planning:architect`). + `/planning:devils-advocate`, `/planning:plan`). - Edit the consumer's root `.gitignore` or any ignore file — the conflict check surfaces rules; the user resolves them. (The memory root's own self-ignoring `.gitignore` is created by the first memory-tier write, announced — not by setup.) diff --git a/plugins/planning/skills/wayfind/SKILL.md b/plugins/planning/skills/wayfind/SKILL.md index 747e4edec..a0c9cfd92 100644 --- a/plugins/planning/skills/wayfind/SKILL.md +++ b/plugins/planning/skills/wayfind/SKILL.md @@ -24,14 +24,14 @@ Arguments: `$ARGUMENTS` Some efforts are **too big to hold at once AND too foggy to ticket** — you can't yet phrase half the questions, let alone answer them. `/interview` needs a coherent task; -`/architect` needs a coherent plan; both presuppose you already know what you're deciding. +`/planning:plan` needs a coherent plan; both presuppose you already know what you're deciding. `/wayfind` sits **upstream of all of them**: it turns a too-big-foggy effort into a shared **decision map** on the work-item tracker, then works that map's frontier one decision at a time until the fog burns off and a real destination (Brief / PRD / PLAN) can be handed onward. **Plan, don't do.** A map holds *decisions*, not build work. Each decision item, once resolved, either sharpens the map or graduates to the destination. The moment the destination -is coherent, the map closes and the normal pipeline (`/interview → /design → /architect → +is coherent, the map closes and the normal pipeline (`/interview → /design → /planning:plan → /implement`) takes over. Fog-of-war framing adapted from Matt Pocock's wayfinder — this skill diverges by persisting the map as native tracker primitives, routing each decision to a first-party skill, and keeping execution artifacts in `//` (default @@ -123,13 +123,13 @@ an interactive session — do not fabricate a map. sharpened previously-foggy uncertainty, chart the new sharp items now. 6. **Map closure → destination handoff.** When the frontier is empty and every decision item is closed, the destination is coherent: close the map issue and hand the destination - onward (`/planning:interview` or `/planning:prd` for a Brief/PRD; `/planning:architect` + onward (`/planning:interview` or `/planning:prd` for a Brief/PRD; `/planning:plan` for a PLAN). A map's job ends where the pipeline's begins. ## Escalation — pull the user back to charting at choke points `/wayfind`'s description carries the proactive trigger. The sibling skills carry **pull-back -lines**: when `/interview`, `/architect`, or `/implement` hits a task that is clearly +lines**: when `/interview`, `/planning:plan`, or `/implement` hits a task that is clearly too-big-AND-foggy for their stage, they name `/planning:wayfind` as the better entry — **guiding the user, never auto-switching**. Wording lives in each of those skills; this skill owns the trigger's meaning (too-big + fog, both, not either alone). @@ -144,7 +144,7 @@ owns the trigger's meaning (too-big + fog, both, not either alone). | Design-space item | `/planning:design`, `/event-storming:*` | `design`-typed items route here | | Feasibility / UX unknown | `/prototype:logic`, `/prototype:ui` | `prototype`-typed items route here | | External-evidence item | `/discovery:research` | `research`-typed items route here (autonomous) | -| The plan itself | `/planning:architect` | Graduation target when the destination is a PLAN | +| The plan itself | `/planning:plan` | Graduation target when the destination is a PLAN | ## What this skill does NOT do diff --git a/plugins/planning/skills/wayfind/context/map-anatomy.md b/plugins/planning/skills/wayfind/context/map-anatomy.md index 9005821c4..7e70388a9 100644 --- a/plugins/planning/skills/wayfind/context/map-anatomy.md +++ b/plugins/planning/skills/wayfind/context/map-anatomy.md @@ -73,5 +73,5 @@ Mode is materialized as the `needs-human` label (present = HITL). Extension poli the map for `/work-items`. - **Closure (whole map):** frontier empty ∧ every decision item closed ⟹ the destination is coherent. Close the map and hand the destination to the pipeline entry that fits it - (`/planning:interview` or `/planning:prd` → Brief/PRD; `/planning:architect` → PLAN). The + (`/planning:interview` or `/planning:prd` → Brief/PRD; `/planning:plan` → PLAN). The map's lifecycle ends exactly where the normal planning pipeline's begins. diff --git a/plugins/planning/skills/wayfind/context/tracker-mechanics.md b/plugins/planning/skills/wayfind/context/tracker-mechanics.md index f26e0f660..d64c5d327 100644 --- a/plugins/planning/skills/wayfind/context/tracker-mechanics.md +++ b/plugins/planning/skills/wayfind/context/tracker-mechanics.md @@ -137,5 +137,5 @@ gh issue close --reason completed ```shell gh issue close --reason completed \ - --comment "Destination coherent — handed to <\/planning:interview | \/planning:prd | \/planning:architect>." + --comment "Destination coherent — handed to <\/planning:interview | \/planning:prd | \/planning:plan>." ``` diff --git a/plugins/planning/skills/wayfind/evals/evals.json b/plugins/planning/skills/wayfind/evals/evals.json index 5391e527c..c02631e53 100644 --- a/plugins/planning/skills/wayfind/evals/evals.json +++ b/plugins/planning/skills/wayfind/evals/evals.json @@ -10,7 +10,7 @@ "expectations": [ "Output recognizes the effort as too-big-and-foggy and enters chart mode rather than work mode, since no open map exists yet for this topic", "Output applies the fog test to sort uncertainties into sharp candidate decision items versus foggy Not-yet-specified prose, instead of trying to answer every uncertainty itself", - "Output does not skip straight to /planning:interview or /planning:architect without first charting the fog" + "Output does not skip straight to /planning:interview or /planning:plan without first charting the fog" ] }, { diff --git a/plugins/prototype/context/discipline.md b/plugins/prototype/context/discipline.md index 7e18d81b7..bea1f5ce1 100644 --- a/plugins/prototype/context/discipline.md +++ b/plugins/prototype/context/discipline.md @@ -53,5 +53,5 @@ prototype so the answer gets filled in before deletion. Then delete the throwawa |------|-------|-----------------| | Product intent locked | `/planning:prd` (when installed) | PRD says "users need X" — prototype proves X works | | Architecture discovery surfaced a design question | `/architecture:improve` (when installed) | Improvement pass surfaces the opportunity → prototype validates the approach | -| Prototype answered the question | `/planning:architect` (when installed) | Validated decision feeds the plan | +| Prototype answered the question | `/planning:plan` (when installed) | Validated decision feeds the plan | | Logic module worth keeping | `/implementation:implement` (when installed) | Lift the pure module into production; delete the TUI shell | diff --git a/plugins/session-flow/skills/workflow/SKILL.md b/plugins/session-flow/skills/workflow/SKILL.md index efc88c23a..36d7acb34 100644 --- a/plugins/session-flow/skills/workflow/SKILL.md +++ b/plugins/session-flow/skills/workflow/SKILL.md @@ -29,7 +29,7 @@ map — it defines the stages, detects the current position, and suggests what c This skill adapts to the consuming repo rather than imposing structure: - **Stage execution.** When the consuming repo defines a skill for a stage (its skill listing or - `CLAUDE.md` names one — e.g. an explore, research, plan/architect, or implement skill), suggest + `CLAUDE.md` names one — e.g. an explore, research, plan, or implement skill), suggest invoking that skill. Otherwise execute the stage inline following its definition in `context/steps.md`. Never invent skill names — check what actually exists. - **Artifact location.** When persisting stage outputs or checklists, honor the consuming repo's diff --git a/plugins/testing/skills/diagnose/context/loop.md b/plugins/testing/skills/diagnose/context/loop.md index d796247c9..3e39e416d 100644 --- a/plugins/testing/skills/diagnose/context/loop.md +++ b/plugins/testing/skills/diagnose/context/loop.md @@ -91,7 +91,7 @@ After fixing one instance, ask: is this a pattern? Could the same bug exist in s If after 3 iterations the fix keeps breaking other things: - The code may need redesign, not a patch -- Route back to the planning skill (`/planning:architect review` when installed) for a broader replanning +- Route back to the planning skill (`/planning:plan review` when installed) for a broader replanning - Don't push through — that's how technical debt compounds ## Integration with /implementation:implement diff --git a/plugins/work-items/reference/tracker-seam.md b/plugins/work-items/reference/tracker-seam.md index 72b96d391..5fd43325f 100644 --- a/plugins/work-items/reference/tracker-seam.md +++ b/plugins/work-items/reference/tracker-seam.md @@ -43,7 +43,7 @@ Do NOT reflexively suggest `/work-items:track add` or `/work-items:scan` for sma discovered while working. Boy Scout scope (cosmetic, stale counts, broken links, single-line corrections, one-paragraph clarifications) belongs in the current change, not the tracker. File NEW items only when the work is genuinely orthogonal to the current session, large enough to need its -own `/architect` plan, or needs research the current session isn't positioned to do. Auto-suggesting +own `/planning:plan` pass, or needs research the current session isn't positioned to do. Auto-suggesting `add` for fixable scope is the failure mode this rule prevents. When in doubt, fix in-place and surface what was fixed in the commit message / PR description. diff --git a/plugins/work-items/skills/work/evals/evals.json b/plugins/work-items/skills/work/evals/evals.json index 6f7392f2f..2ba2a8fa6 100644 --- a/plugins/work-items/skills/work/evals/evals.json +++ b/plugins/work-items/skills/work/evals/evals.json @@ -13,7 +13,7 @@ "Selects from the frontier via `work-item-tracker.sh list-frontier` (open, `blocked_by_count == 0`, unassigned); `--autonomous` additionally excludes `needs-human`", "Acquires via the seam `work-item-tracker.sh claim` (assignee + lease comment, same-identity aware) — NOT a `status:considering`/`status:claimed` label hold protocol", "On a lost race (`claim` exit 7) advances to the next candidate rather than retrying the same item", - "Executes the selected item through the 8-step workflow (/discovery:explore -> /discovery:research -> /planning:architect -> /implementation:implement -> /testing:plan -> /review:quality-gate -> /verification:confirm outcome -> /session-flow:retro)" + "Executes the selected item through the 8-step workflow (/discovery:explore -> /discovery:research -> /planning:plan -> /implementation:implement -> /testing:plan -> /review:quality-gate -> /verification:confirm outcome -> /session-flow:retro)" ] }, { From 2710bad241739470634a597784c49be2cd9c09b8 Mon Sep 17 00:00:00 2001 From: Kyle Sexton <153232337+kyle-sexton@users.noreply.github.com> Date: Fri, 17 Jul 2026 15:26:39 -0400 Subject: [PATCH 2/3] refactor(planning): bump companion plugins edited by the plan rename Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01YVApnNGoKxYMJKNQx1QK8C --- plugins/claude-ops/.claude-plugin/plugin.json | 2 +- plugins/claude-ops/CHANGELOG.md | 6 ++++++ plugins/implementation/.claude-plugin/plugin.json | 2 +- plugins/implementation/CHANGELOG.md | 6 ++++++ plugins/knowledge/.claude-plugin/plugin.json | 2 +- 5 files changed, 15 insertions(+), 3 deletions(-) diff --git a/plugins/claude-ops/.claude-plugin/plugin.json b/plugins/claude-ops/.claude-plugin/plugin.json index b8a7980bd..c0f0feaa9 100644 --- a/plugins/claude-ops/.claude-plugin/plugin.json +++ b/plugins/claude-ops/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "claude-ops", - "version": "0.10.0", + "version": "0.10.1", "description": "Claude Code operations toolkit. Five skills: observability (read locally captured telemetry — OTEL store, collector, hook-event JSONL, ccusage — with trend reports and store pruning), known-issues (search known Claude product GitHub bugs, check service health, maintain a persistent tracked-issue registry), changelog (ingest Claude Code changelog entries and integrate them into the current repo), plugins (bring a machine's plugin fleet current on demand — marketplace refresh, effective-scope updates including in-repo project/local installs, new-plugin install per policy, scope-divergence detection and explicit convergence), and a re-runnable setup action that settles where the known-issues registry lives. Plus a family of seven advisory *-audit telemetry-emitter hooks (API errors, config changes, instruction loads, permission denials, pre-compaction, skill usage, tool failures) that emit the shared hook-telemetry envelope, and a reference sink that maps envelopes into the hook-events.jsonl the observability skill reads.", "author": { "name": "Melodic Software", diff --git a/plugins/claude-ops/CHANGELOG.md b/plugins/claude-ops/CHANGELOG.md index f26ce51df..3496b8f70 100644 --- a/plugins/claude-ops/CHANGELOG.md +++ b/plugins/claude-ops/CHANGELOG.md @@ -3,6 +3,12 @@ All notable changes to the `claude-ops` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.10.1] + +### Changed + +- References to the renamed `/planning:plan` skill (was `/planning:architect`, planning 0.13.0 breaking rename) retargeted. Version bumped so existing installs receive the rewritten prompts. + ## [0.10.0] ### Changed diff --git a/plugins/implementation/.claude-plugin/plugin.json b/plugins/implementation/.claude-plugin/plugin.json index adfd87ff9..a3cf4bf3a 100644 --- a/plugins/implementation/.claude-plugin/plugin.json +++ b/plugins/implementation/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "implementation", - "version": "0.6.1", + "version": "0.6.2", "description": "Disciplined implementation stage: execute approved plans inline (`/implementation:implement`) or via orchestrated worker subagents (`/implementation:implement-dispatch`) with incremental validation, TDD-by-default cadence, green-checkpoint commits, scope-fence drift detection, and divergence detection that routes back to planning. Build/test/lint, testing, and outcome verification live in the companion `toolchain`, `testing`, and `verification` plugins, invoked when installed.", "author": { "name": "Melodic Software", diff --git a/plugins/implementation/CHANGELOG.md b/plugins/implementation/CHANGELOG.md index 2dd7e66c5..f035539df 100644 --- a/plugins/implementation/CHANGELOG.md +++ b/plugins/implementation/CHANGELOG.md @@ -3,6 +3,12 @@ All notable changes to the `implementation` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.6.2] + +### Changed + +- References to the renamed `/planning:plan` skill (was `/planning:architect`, planning 0.13.0 breaking rename) retargeted. Version bumped so existing installs receive the rewritten prompts. + ## [0.6.1] ### Changed diff --git a/plugins/knowledge/.claude-plugin/plugin.json b/plugins/knowledge/.claude-plugin/plugin.json index a2766bff5..1a11edda2 100644 --- a/plugins/knowledge/.claude-plugin/plugin.json +++ b/plugins/knowledge/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "knowledge", - "version": "0.6.0", + "version": "0.6.1", "description": "Ingest external knowledge into durable, synthesized artifacts. Ships a book-distillation pipeline (PDF/EPUB into concept-organized, author-attributed skill reference files), a YouTube pipeline (watch, transcript, link harvest, and repo-applicability synthesis), and a course-digest pipeline (extract and synthesize online video courses — Dometrain, Teachable — into repo-applicable recommendations), plus a re-runnable setup action; a configurable library directory governs where synthesized artifacts land in the consuming repo.", "author": { "name": "Melodic Software", From c3228649f599784b27f254a1cb108e3e0db62ea7 Mon Sep 17 00:00:00 2001 From: Kyle Sexton <153232337+kyle-sexton@users.noreply.github.com> Date: Fri, 17 Jul 2026 15:27:16 -0400 Subject: [PATCH 3/3] refactor(planning): finish companion bumps for the plan rename Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01YVApnNGoKxYMJKNQx1QK8C --- plugins/knowledge/CHANGELOG.md | 6 ++++++ plugins/prototype/.claude-plugin/plugin.json | 2 +- plugins/prototype/CHANGELOG.md | 6 ++++++ plugins/session-flow/.claude-plugin/plugin.json | 2 +- plugins/session-flow/CHANGELOG.md | 6 ++++++ plugins/testing/.claude-plugin/plugin.json | 2 +- plugins/testing/CHANGELOG.md | 6 ++++++ plugins/work-items/.claude-plugin/plugin.json | 2 +- plugins/work-items/CHANGELOG.md | 6 ++++++ 9 files changed, 34 insertions(+), 4 deletions(-) diff --git a/plugins/knowledge/CHANGELOG.md b/plugins/knowledge/CHANGELOG.md index 6d2ce3a03..b457c2335 100644 --- a/plugins/knowledge/CHANGELOG.md +++ b/plugins/knowledge/CHANGELOG.md @@ -4,6 +4,12 @@ All notable changes to the `knowledge` plugin are recorded here. The `version` i `.claude-plugin/plugin.json` is the delivery vehicle — a consumer receives a change only after that version increases. +## 0.6.1 + +### Changed + +- References to the renamed `/planning:plan` skill (was `/planning:architect`, planning 0.13.0 breaking rename) retargeted. Version bumped so existing installs receive the rewritten prompts. + ## 0.6.0 ### Changed diff --git a/plugins/prototype/.claude-plugin/plugin.json b/plugins/prototype/.claude-plugin/plugin.json index a51721fea..c84d7e86d 100644 --- a/plugins/prototype/.claude-plugin/plugin.json +++ b/plugins/prototype/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "prototype", - "version": "0.2.2", + "version": "0.2.3", "description": "Builds throwaway code to answer a design question before committing to architecture — a logic facet (an interactive terminal app over a portable state model) and a UI facet (radically different visual variants on one route).", "author": { "name": "Melodic Software", diff --git a/plugins/prototype/CHANGELOG.md b/plugins/prototype/CHANGELOG.md index 91abc9e74..2312d0475 100644 --- a/plugins/prototype/CHANGELOG.md +++ b/plugins/prototype/CHANGELOG.md @@ -3,6 +3,12 @@ All notable changes to the `prototype` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.2.3] + +### Changed + +- References to the renamed `/planning:plan` skill (was `/planning:architect`, planning 0.13.0 breaking rename) retargeted. Version bumped so existing installs receive the rewritten prompts. + ## [0.2.2] ### Changed diff --git a/plugins/session-flow/.claude-plugin/plugin.json b/plugins/session-flow/.claude-plugin/plugin.json index ff820a6bf..4760926b2 100644 --- a/plugins/session-flow/.claude-plugin/plugin.json +++ b/plugins/session-flow/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "session-flow", - "version": "0.7.0", + "version": "0.7.1", "description": "Session-lifecycle toolkit of five skills: workflow (navigate a staged dev workflow and suggest the next stage), handoff (write a save-point and resume prompt for /clear, with optional --bg background-agent launch), keep-going (recover and continue after any interruption — inventory off-thread work, inspect its real state, resume or restart it, then continue the main task), retro (structured session retrospective with transcript metrics and learning codification), and orchestrate (arm a session or worker with proactive-orchestration imperatives).", "author": { "name": "Melodic Software", diff --git a/plugins/session-flow/CHANGELOG.md b/plugins/session-flow/CHANGELOG.md index 207895727..c836f6abf 100644 --- a/plugins/session-flow/CHANGELOG.md +++ b/plugins/session-flow/CHANGELOG.md @@ -1,5 +1,11 @@ # Changelog — session-flow plugin +## 0.7.1 + +### Changed + +- References to the renamed `/planning:plan` skill (was `/planning:architect`, planning 0.13.0 breaking rename) retargeted. Version bumped so existing installs receive the rewritten prompts. + ## 0.7.0 — 2026-07-17 Added: diff --git a/plugins/testing/.claude-plugin/plugin.json b/plugins/testing/.claude-plugin/plugin.json index 7216f520d..668d092cd 100644 --- a/plugins/testing/.claude-plugin/plugin.json +++ b/plugins/testing/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "testing", - "version": "0.1.1", + "version": "0.1.2", "description": "Test-stage discipline across all ecosystems: coverage-gap analysis and test planning (`/testing:plan`), TDD test authoring and placement (`/testing:write`), live E2E plus non-UI smoke verification (`/testing:e2e`), and failing-test root-cause diagnosis with the reproduce → isolate → fix → retest loop (`/testing:diagnose`).", "author": { "name": "Melodic Software", diff --git a/plugins/testing/CHANGELOG.md b/plugins/testing/CHANGELOG.md index aff931927..d9568678a 100644 --- a/plugins/testing/CHANGELOG.md +++ b/plugins/testing/CHANGELOG.md @@ -3,6 +3,12 @@ All notable changes to the `testing` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.1.2] + +### Changed + +- References to the renamed `/planning:plan` skill (was `/planning:architect`, planning 0.13.0 breaking rename) retargeted. Version bumped so existing installs receive the rewritten prompts. + ## [0.1.1] ### Changed diff --git a/plugins/work-items/.claude-plugin/plugin.json b/plugins/work-items/.claude-plugin/plugin.json index 616da393b..56673f3ec 100644 --- a/plugins/work-items/.claude-plugin/plugin.json +++ b/plugins/work-items/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "work-items", - "version": "0.8.0", + "version": "0.8.1", "description": "Manages development work items through a provider-neutral tracker seam (GitHub the bound adapter today): dashboard, taxonomy-labeled creation, a race-safe assignee-plus-lease claim protocol, recurring-schedule checks, TODO scanning, stale-lease auditing, plan decomposition into vertical-slice items, and raw-intake triage (issues and unsolicited PRs through raw, verified, briefed, autonomous-eligible states). Canonical role labels remap via the tracker binding; the recurring-schedule seam (.github/recurring-schedule.json) is seeded and reshaped by the re-runnable setup skill.", "author": { "name": "Melodic Software", diff --git a/plugins/work-items/CHANGELOG.md b/plugins/work-items/CHANGELOG.md index fcb36845c..48d6811cd 100644 --- a/plugins/work-items/CHANGELOG.md +++ b/plugins/work-items/CHANGELOG.md @@ -3,6 +3,12 @@ All notable changes to the `work-items` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.8.1] + +### Changed + +- References to the renamed `/planning:plan` skill (was `/planning:architect`, planning 0.13.0 breaking rename) retargeted. Version bumped so existing installs receive the rewritten prompts. + ## [0.8.0] ### Changed (breaking)