From 91cbd014d6843f2af62a7ceecf539b47293a7432 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 19 Aug 2026 21:37:34 +0000 Subject: [PATCH 1/4] feat(planning): route the ungrillable question to a prototype detour (#2998) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Course lane 5's `/planning:audit-answers` pass (two fresh-context validators against the upstream primaries) overturned the lane's provisional zero-work-items answer and surfaced two grilling-family techniques absent from `planning:interview`. ## The ungrillable question Some questions cannot be answered by asking, however well the round is framed: the user has to see a thing and react to it. Upstream fires the escape mid-grilling — stop grilling, build the throwaway, come back and answer in one line. Our route existed only downstream (`wayfind`, `plan`, `brainstorm`); the interview's mid-session composition named research, exploration, and handoff only, and its categorization taxonomy had no needs-an-artifact arm. - `interview/SKILL.md` "Mid-interview composition" now carries the detour, routing a look-and-feel question to `/prototype:explore-directions` and a logic/state/data-shape question to `/prototype:pressure-test` (via the Skill tool, if installed), with a matching composition-table row. - `interview/context/loop.md` gains a **Needs-an-artifact** arm beside resolvable / blocked / defer, marked explicitly as a route rather than a deferral. The prototype is the instrument that produces the answer, not a deliverable. The question is registered `open` before the detour so it cannot be lost. ## Plan mode off while interviewing Beyond upstream's taste point, a mechanical edge: the ask-time open-question register is a disk write (the ledger's `## Open-question register` section), and plan mode's read-only enforcement blocks it — so a round asked under plan mode leaves nothing on disk holding it, the exact failure the register exists to prevent. - New `interview/context/gotchas.md` entry under the Q&A surface, beside the other register gotchas. - `plan/SKILL.md` "Plan Mode Integration" reconciled with lane 4's asset-rush doctrine: its plan-mode round is scoped to a scoping confirm, and substantive what-are-we-building questions route to `/planning:interview` outside plan mode. ## Verification Documentation only; no behavior change. planning 0.31.0 -> 0.32.0. validate-plugins, both generator --check runs, all four check-changelog-parity modes, check-changed-skills (2 checked, 0 failed), markdownlint on the five touched files, typos, and the three planning test suites all pass. The two check-changed-skills warnings (SKILL.md soft line target; the Plan Review Mode numbered list) are pre-existing on origin/main, not introduced here. Co-authored-by: Claude --- plugins/planning/.claude-plugin/plugin.json | 2 +- plugins/planning/CHANGELOG.md | 30 +++++++++++++++++++ plugins/planning/skills/interview/SKILL.md | 3 +- .../skills/interview/context/gotchas.md | 2 ++ .../planning/skills/interview/context/loop.md | 1 + plugins/planning/skills/plan/SKILL.md | 4 ++- 6 files changed, 39 insertions(+), 3 deletions(-) diff --git a/plugins/planning/.claude-plugin/plugin.json b/plugins/planning/.claude-plugin/plugin.json index 162928c501..003e1ed326 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.31.0", + "version": "0.32.0", "userConfig": { "use_ask_user_question": { "type": "boolean", diff --git a/plugins/planning/CHANGELOG.md b/plugins/planning/CHANGELOG.md index a45c1df2d2..649419cfc8 100644 --- a/plugins/planning/CHANGELOG.md +++ b/plugins/planning/CHANGELOG.md @@ -3,6 +3,36 @@ 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.32.0] + +### Added + +- **The interview can stop grilling and go build one (#2998).** Some questions are ungrillable: the + user has to see a thing and react to it before they know what they think, and another round of + framing will not produce the answer. `interview` now carries that escape. "Mid-interview + composition" routes a look-and-feel question to `/prototype:explore-directions` and a + logic/state/data-shape question to `/prototype:pressure-test` (invoked via the Skill tool when + installed), then returns and answers it in one line; the categorization taxonomy in + `context/loop.md` gains a **Needs-an-artifact** arm beside resolvable / blocked / defer, marked + explicitly as a route rather than a deferral. The prototype is the instrument that produces the + answer, not a deliverable. Adopted from the grilling-family upstream at the course lane 5 audit, + where both validators grep-confirmed the route existed in our fleet only downstream, in + `wayfind` / `plan` / `brainstorm`. + +### Changed + +- **Leave plan mode off while interviewing (#2998).** New `interview` gotcha covering a mechanical + edge beyond upstream's taste point: the ask-time open-question register is a disk write (the + ledger's `## Open-question register` section), and plan mode's read-only enforcement blocks it, + so a round asked under plan mode leaves nothing on disk holding it — the exact failure the + register exists to prevent, reintroduced by the permission mode. +- **`plan`'s plan-mode round is a scoping confirm, not a substitute for the interview (#2998).** + "Plan Mode Integration" previously licensed open-ended clarifying questions inside plan mode, + which sat in tension with lane 4's asset-rush doctrine. That round is now scoped to what the plan + covers, and substantive *what are we building* questions route to `/planning:interview` outside + plan mode — on the register-write mechanics above and on the doctrine that plan mode primes the + run toward producing the asset while the job is still reaching shared understanding. + ## [0.31.0] ### Changed diff --git a/plugins/planning/skills/interview/SKILL.md b/plugins/planning/skills/interview/SKILL.md index a7f2fc7b79..9b02322394 100644 --- a/plugins/planning/skills/interview/SKILL.md +++ b/plugins/planning/skills/interview/SKILL.md @@ -291,11 +291,12 @@ knob-picking signals in [`context/session-config.md`](context/session-config.md) | Product intent fuzzy (whose problem, what success) | `/planning:prd` | Upstream of `/planning: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 | +| A question needs something built to react to | `/prototype:explore-directions` (look and feel) or `/prototype:pressure-test` (logic, state, data shape) (if installed) | Mid-interview detour: build the throwaway, react to it, return and answer in one line | | Plan the implementation | `/planning:plan` | Reads PLAN.md Brief + explore + research findings | | Stress-test the plan | `/planning:devils-advocate` | Adversarial pass on `/planning:plan` output | | Validate the interview's answers via agents | `/planning:audit-answers` | Fresh validators challenge each answer in the filled ledger (hand-answered or auto-accepted); only the doubtful ones return as human questions | | 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. +**Mid-interview composition (`me` mode):** research, exploration, prototyping, and handoff are not only downstream — invoke them *during* the interview when a recommendation needs external/codebase grounding, when a question needs something built to react to, or when branches outgrow the session. Return to the open branch after. **The ungrillable question:** when a look, feel, or behavior question cannot be answered by asking — the user has to see the thing to know what they think — stop grilling, invoke `/prototype:explore-directions` (look and feel) or `/prototype:pressure-test` (logic, state, data shape) via the Skill tool if installed, then return and answer it in one line. The prototype is the instrument that produces the answer, not a deliverable; it is thrown away. Register the question `open` before leaving so the detour cannot lose it. `/planning: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/gotchas.md b/plugins/planning/skills/interview/context/gotchas.md index 91b72aecf2..570ff5544a 100644 --- a/plugins/planning/skills/interview/context/gotchas.md +++ b/plugins/planning/skills/interview/context/gotchas.md @@ -16,6 +16,8 @@ Failure patterns from real sessions. Loaded on demand from `/planning:interview` - **Registering a question only once it is answered** — the register then holds exactly the questions that never needed it, and the gate over it grades nothing. The write belongs at ask-time. +- **Interviewing with plan mode on** — the ask-time register write is a disk write (the ledger's `## Open-question register` section), and plan mode's read-only enforcement blocks it, so the round gets asked with nothing on disk holding it: precisely the failure the register exists to prevent, reintroduced by the permission mode. Plan mode also primes the run to rush toward producing a plan when the job is still resolving *what*. Leave plan mode off while interviewing — it is `/planning:plan`'s mode, not this skill's. + - **Passing `--brief` to the Step 3 gate run** — Step 4 writes PLAN.md, so at Step 3 the file does not exist and a named-but-missing `--brief` exits 2; a first-time interview deadlocks before it can persist anything. Ledger-only at Step 3, `--brief` on the Step 4 re-run. - **Assuming `lock` never needs a register** — a clean lock synthesis writes none, but its STOP-on-gap and the unattended ladder both produce unresolved questions, and a question outside the register is a question outside the gate. diff --git a/plugins/planning/skills/interview/context/loop.md b/plugins/planning/skills/interview/context/loop.md index 739eac762a..a4b770763d 100644 --- a/plugins/planning/skills/interview/context/loop.md +++ b/plugins/planning/skills/interview/context/loop.md @@ -77,6 +77,7 @@ Each open item is one of: - **Resolvable** — the user can answer it now. Ask with recommended answer - **Blocked** — depends on another unresolved decision. Name the blocker +- **Needs-an-artifact** — ungrillable by asking: the answer only arrives once the user reacts to something concrete (a look, a feel, a behavior), and another round of framing will not produce it. Not a deferral — route it to a throwaway prototype now, then answer it in one line. The detour and the skills that own it: SKILL.md "Mid-interview composition" - **Defer-with-assumption** — the user can pick a working assumption, with a known revisit trigger. Capture the assumption and the trigger ("assume Postgres for now; revisit if write throughput exceeds X") - **Defer-fully** — out of scope for this task; record in **Deferred questions** so it doesn't silently become a hidden assumption later diff --git a/plugins/planning/skills/plan/SKILL.md b/plugins/planning/skills/plan/SKILL.md index 0eb9eb6978..f6ba371e0d 100644 --- a/plugins/planning/skills/plan/SKILL.md +++ b/plugins/planning/skills/plan/SKILL.md @@ -248,7 +248,9 @@ Claude Code's built-in plan mode provides read-only enforcement — Claude reads The skill does not automatically enter plan mode — the user controls permission modes. But if you're about to plan a complex change and are NOT in plan mode, suggest it: "Consider entering plan mode (`shift+tab`) for safe exploration while we design this." -Plan mode is also a natural moment for clarifying questions — if you're entering plan mode for safe exploration during planning, treat it as a license to ask 1–4 clarifying questions before proposing the plan, as one numbered round. The round renders via `AskUserQuestion` only when the plugin's `use_ask_user_question` user config (`${user_config.use_ask_user_question}`) is on and the questions are independent — inline prose otherwise. +Plan mode is also a natural moment for a **scoping confirm** — if you're entering plan mode for safe exploration during planning, treat it as a license to ask 1–4 questions that settle what this plan covers, as one numbered round before proposing it. The round renders via `AskUserQuestion` only when the plugin's `use_ask_user_question` user config (`${user_config.use_ask_user_question}`) is on and the questions are independent — inline prose otherwise. + +**Substantive rounds do not belong in plan mode.** A question that resolves *what we are building* — real tradeoffs, contested requirements, anything whose answer changes the plan's shape — routes to `/planning:interview` via the Skill tool, run with **plan mode off**, for two reasons. Mechanically, that skill's ask-time open-question register is a disk write, and plan mode's read-only enforcement blocks it, so questions get asked with nothing on disk holding them. Doctrinally, plan mode primes the run toward producing the plan — the asset rush lane 4 records — when the job is still reaching shared understanding. Plan mode's round confirms scope; it is not a substitute for the interview. ## Plan Review Mode From 423389df118ac270d1786eb2141ec872412ed4ed Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 19 Aug 2026 21:38:59 +0000 Subject: [PATCH 2/4] docs(upstream): record the lane 5 delivery pointer on both ADOPT rows (#2998) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The two lane 5 ADOPT rows carried only their `Filed:` pointer. Both are now delivered by #3045, so each row names the delivering PR and what actually landed — the prototype detour plus the Needs-an-artifact categorization arm on one, the plan-mode gotcha plus the `planning:plan` scoping-confirm reconciliation on the other — and moves its as-of date. This is the row-home the issue's criteria point at: the originally cited `docs/upstream/aihero-core-lanes.md` dissolved at the lane 6 harvest and its lane 5 rows now live here, per the redirect recorded on #2998. Co-authored-by: Claude --- docs/upstream/aihero-course.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/upstream/aihero-course.md b/docs/upstream/aihero-course.md index ad34080bc6..85c0775891 100644 --- a/docs/upstream/aihero-course.md +++ b/docs/upstream/aihero-course.md @@ -249,8 +249,8 @@ the chain record's "course side UNVERIFIED" caveat on the clear step. | `grill-me` is a user-invoked pointer that calls the model-invoked `grilling` | One skill, three actions (`me`/`auto`/`lock`), user- and model-invocable under trigger discipline | **COVERED** (different shape, deliberate) | His two-skill split expresses his invocation-reach invariant; our single-skill shape predates it and the difference is recorded, not a gap. As-of 2026-08-17 | | Walkthrough machinery (npm run reset, `.agents/skills`, the `/` picker) and the lesson-comments example questions | Course-platform machinery and illustration | **NOT RELEVANT** | No repo counterpart owed. As-of 2026-08-17 | | The loop's "clear" leg (clear your mind between features) | Recommend-clear (never auto-clear) sits post-Brief, licensed by Brief/ledger persistence — which dissolves upstream's own recorded no-ledger complaint | **DELIBERATELY DIFFERENT** (course side resolved) | The chain record carried "course side UNVERIFIED (lesson unreachable)" with a reopen-on-text condition; the condition fired at harvest — the committed lesson paste teaches no clear-step mechanics beyond one sentence plus a dictionary link, so the deliberate difference is confirmed against the actual text and the UNVERIFIED caveat retires. Upstream's own repo docs teach the opposite of a mandatory clear ("Hand the same conversation straight to to-spec"); loop-position nuance recorded. As-of 2026-08-18 | -| Ungrillable question → prototype detour (upstream fires it mid-grilling: "stop grilling… build the throwaway version… come back and answer in one line") | Absent from the interview (grep-confirmed by both audit validators); our route exists only downstream (wayfind / plan / brainstorm) | **ADOPT** | Chain audit finding, upstream-repo-grounded. Filed: [#2998](https://github.com/melodic-software/claude-code-plugins/issues/2998). As-of 2026-08-18 | -| Plan-mode-off while grilling | Beyond upstream's taste point, a mechanical edge the audit surfaced: the ask-time register write is load-bearing and plan mode's read-only enforcement blocks it | **ADOPT** | Includes reconciling `planning:plan`'s clarifying-rounds-in-plan-mode sentence with the lane 4 asset-rush doctrine. Filed: [#2998](https://github.com/melodic-software/claude-code-plugins/issues/2998). As-of 2026-08-18 | +| Ungrillable question → prototype detour (upstream fires it mid-grilling: "stop grilling… build the throwaway version… come back and answer in one line") | Absent from the interview (grep-confirmed by both audit validators); our route exists only downstream (wayfind / plan / brainstorm) | **ADOPT** (delivered) | Chain audit finding, upstream-repo-grounded. Filed: [#2998](https://github.com/melodic-software/claude-code-plugins/issues/2998); delivered by [#3045](https://github.com/melodic-software/claude-code-plugins/pull/3045) — `interview` now carries the detour in "Mid-interview composition" (routing look-and-feel to `/prototype:explore-directions`, logic/state/data-shape to `/prototype:pressure-test`) plus a **Needs-an-artifact** arm in the `context/loop.md` categorization taxonomy; planning 0.32.0. As-of 2026-08-19 | +| Plan-mode-off while grilling | Beyond upstream's taste point, a mechanical edge the audit surfaced: the ask-time register write is load-bearing and plan mode's read-only enforcement blocks it | **ADOPT** (delivered) | Includes reconciling `planning:plan`'s clarifying-rounds-in-plan-mode sentence with the lane 4 asset-rush doctrine. Filed: [#2998](https://github.com/melodic-software/claude-code-plugins/issues/2998); delivered by [#3045](https://github.com/melodic-software/claude-code-plugins/pull/3045) — the gotcha lands in `interview/context/gotchas.md`, and `plan`'s plan-mode round is now scoped to a scoping confirm with substantive rounds routed to `/planning:interview` outside plan mode; planning 0.32.0. As-of 2026-08-19 | | Provenance correction (adjacent, from the chain audit) | SSOT PR-#532 row | **CORRECTED in SSOT** | The row's "ADR 3-gate + glossary purity are house additions" claim is contradicted on current upstream main (`domain-modeling` carries both near-identically); annotated as convergent-or-derived, direction unverifiable. As-of 2026-08-18 | House decisions recorded alongside the rows (Q36-Q37 this run; chain audit 2026-08-18): no term From 5d4212c3c7dee340e4d5a2af063a8a6efca2883c Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 19 Aug 2026 21:41:45 +0000 Subject: [PATCH 3/4] fix(planning): honor the prototype skills' auto-invoke gate before the detour (#2998) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Codex review on #3045, verified against the tree: the prototype skills gate model-initiated entry — stop and confirm scope before writing any throwaway code, and do not detour out of an active workflow without checkpointing first. The detour as written invoked them immediately, so the interview handed off without the confirm and without an explicit checkpoint of its own live state. The detour now confirms the spike's scope with the user and checkpoints the interview before handing off, and names what that checkpoint already consists of: the question registered `open` at ask-time plus the ledger and Brief written per lock-in, which is exactly what lets the open branch survive the detour. The composition-table row and the CHANGELOG entry carry the same sequence. The gate is described rather than cited: another skill's `context/` files are private, so the requirement is stated in the interview's own terms. Co-authored-by: Claude --- plugins/planning/CHANGELOG.md | 4 +++- plugins/planning/skills/interview/SKILL.md | 4 ++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/plugins/planning/CHANGELOG.md b/plugins/planning/CHANGELOG.md index 649419cfc8..fb34f06f97 100644 --- a/plugins/planning/CHANGELOG.md +++ b/plugins/planning/CHANGELOG.md @@ -15,7 +15,9 @@ All notable changes to the `planning` plugin are documented here. Format follows installed), then returns and answers it in one line; the categorization taxonomy in `context/loop.md` gains a **Needs-an-artifact** arm beside resolvable / blocked / defer, marked explicitly as a route rather than a deferral. The prototype is the instrument that produces the - answer, not a deliverable. Adopted from the grilling-family upstream at the course lane 5 audit, + answer, not a deliverable. The detour honors the prototype skills' own model-initiated entry gate: + confirm the spike's scope and checkpoint the interview before handing off, which the ask-time + register write and the per-lock-in ledger/Brief persistence already supply. Adopted from the grilling-family upstream at the course lane 5 audit, where both validators grep-confirmed the route existed in our fleet only downstream, in `wayfind` / `plan` / `brainstorm`. diff --git a/plugins/planning/skills/interview/SKILL.md b/plugins/planning/skills/interview/SKILL.md index 9b02322394..4c1870db33 100644 --- a/plugins/planning/skills/interview/SKILL.md +++ b/plugins/planning/skills/interview/SKILL.md @@ -291,12 +291,12 @@ knob-picking signals in [`context/session-config.md`](context/session-config.md) | Product intent fuzzy (whose problem, what success) | `/planning:prd` | Upstream of `/planning: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 | -| A question needs something built to react to | `/prototype:explore-directions` (look and feel) or `/prototype:pressure-test` (logic, state, data shape) (if installed) | Mid-interview detour: build the throwaway, react to it, return and answer in one line | +| A question needs something built to react to | `/prototype:explore-directions` (look and feel) or `/prototype:pressure-test` (logic, state, data shape) (if installed) | Mid-interview detour: confirm scope and checkpoint, build the throwaway, react to it, return and answer in one line | | Plan the implementation | `/planning:plan` | Reads PLAN.md Brief + explore + research findings | | Stress-test the plan | `/planning:devils-advocate` | Adversarial pass on `/planning:plan` output | | Validate the interview's answers via agents | `/planning:audit-answers` | Fresh validators challenge each answer in the filled ledger (hand-answered or auto-accepted); only the doubtful ones return as human questions | | 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, prototyping, and handoff are not only downstream — invoke them *during* the interview when a recommendation needs external/codebase grounding, when a question needs something built to react to, or when branches outgrow the session. Return to the open branch after. **The ungrillable question:** when a look, feel, or behavior question cannot be answered by asking — the user has to see the thing to know what they think — stop grilling, invoke `/prototype:explore-directions` (look and feel) or `/prototype:pressure-test` (logic, state, data shape) via the Skill tool if installed, then return and answer it in one line. The prototype is the instrument that produces the answer, not a deliverable; it is thrown away. Register the question `open` before leaving so the detour cannot lose it. +**Mid-interview composition (`me` mode):** research, exploration, prototyping, and handoff are not only downstream — invoke them *during* the interview when a recommendation needs external/codebase grounding, when a question needs something built to react to, or when branches outgrow the session. Return to the open branch after. **The ungrillable question:** when a look, feel, or behavior question cannot be answered by asking — the user has to see the thing to know what they think — stop grilling and route it to a throwaway prototype: `/prototype:explore-directions` (look and feel) or `/prototype:pressure-test` (logic, state, data shape), invoked via the Skill tool if installed. Those skills gate their own model-initiated entry, so confirm the spike's scope with the user and checkpoint this interview before handing off — the detour leaves an active workflow. Checkpointing is persistence the interview already owes: the question registered `open` at ask-time, plus the ledger and Brief written per lock-in, which is what lets the open branch survive the detour. Then come back and answer the question in one line. The prototype is the instrument that produces the answer, not a deliverable; it is thrown away. `/planning:interview` is sister to `/planning:plan`: one resolves *what*, the other resolves *how*. They share the topic slug, share the directory, feed each other. From 19c7cbee29001add9ce5c6cab955ea6af34b916c Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 19 Aug 2026 21:44:25 +0000 Subject: [PATCH 4/4] fix(planning): say how plan mode gets turned off before the interview (#2998) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Code-review finding on #3045, verified against the section: the new "substantive rounds do not belong in plan mode" text asserted the interview runs with plan mode off but named no mechanism, and the paragraph four lines above already settles that the skill toggles no permission mode — it *suggests* entering and lets the user act. Asserting the exit case without the symmetric step left the rule unsatisfiable: a run mid-formulation in plan mode ("stay in it") that hits a substantive question had no scripted way to reach plan-mode-off, and the likely fallback — invoking the interview from inside plan mode — reproduces the exact register-write failure the paragraph exists to prevent. The exit is now the user's move, stated the same way as the entry: say why, ask the user to exit (shift+tab), invoke the interview once they have, and never invoke it from inside plan mode assuming the register write will survive. The CHANGELOG entry carries the same clause. Co-authored-by: Claude --- plugins/planning/CHANGELOG.md | 5 ++++- plugins/planning/skills/plan/SKILL.md | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/plugins/planning/CHANGELOG.md b/plugins/planning/CHANGELOG.md index fb34f06f97..af0d8afff7 100644 --- a/plugins/planning/CHANGELOG.md +++ b/plugins/planning/CHANGELOG.md @@ -33,7 +33,10 @@ All notable changes to the `planning` plugin are documented here. Format follows which sat in tension with lane 4's asset-rush doctrine. That round is now scoped to what the plan covers, and substantive *what are we building* questions route to `/planning:interview` outside plan mode — on the register-write mechanics above and on the doctrine that plan mode primes the - run toward producing the asset while the job is still reaching shared understanding. + run toward producing the asset while the job is still reaching shared understanding. Exiting is + the user's move, stated symmetrically to how the section already handles entering: the skill + toggles no permission mode, so it asks the user to exit (`shift+tab`) and invokes the interview + once they have. ## [0.31.0] diff --git a/plugins/planning/skills/plan/SKILL.md b/plugins/planning/skills/plan/SKILL.md index f6ba371e0d..6f39a2dcce 100644 --- a/plugins/planning/skills/plan/SKILL.md +++ b/plugins/planning/skills/plan/SKILL.md @@ -250,7 +250,7 @@ The skill does not automatically enter plan mode — the user controls permissio Plan mode is also a natural moment for a **scoping confirm** — if you're entering plan mode for safe exploration during planning, treat it as a license to ask 1–4 questions that settle what this plan covers, as one numbered round before proposing it. The round renders via `AskUserQuestion` only when the plugin's `use_ask_user_question` user config (`${user_config.use_ask_user_question}`) is on and the questions are independent — inline prose otherwise. -**Substantive rounds do not belong in plan mode.** A question that resolves *what we are building* — real tradeoffs, contested requirements, anything whose answer changes the plan's shape — routes to `/planning:interview` via the Skill tool, run with **plan mode off**, for two reasons. Mechanically, that skill's ask-time open-question register is a disk write, and plan mode's read-only enforcement blocks it, so questions get asked with nothing on disk holding them. Doctrinally, plan mode primes the run toward producing the plan — the asset rush lane 4 records — when the job is still reaching shared understanding. Plan mode's round confirms scope; it is not a substitute for the interview. +**Substantive rounds do not belong in plan mode.** A question that resolves *what we are building* — real tradeoffs, contested requirements, anything whose answer changes the plan's shape — routes to `/planning:interview` via the Skill tool, run with **plan mode off**, for two reasons. Mechanically, that skill's ask-time open-question register is a disk write, and plan mode's read-only enforcement blocks it, so questions get asked with nothing on disk holding them. Doctrinally, plan mode primes the run toward producing the plan — the asset rush lane 4 records — when the job is still reaching shared understanding. Plan mode's round confirms scope; it is not a substitute for the interview. **Getting there is the user's move, not yours** — symmetric to entering plan mode above: you do not toggle permission modes, so when plan mode is active and a substantive round comes due, say why and ask the user to exit it (`shift+tab`), then invoke the interview once they have. Do not invoke it from inside plan mode on the assumption the register write will survive — it will not. ## Plan Review Mode