interview
/interview
Prowadzi rundy ponumerowanych pytań z rekomendacjami, które doprowadzają zadanie, propozycję lub wybór do wspólnego zrozumienia, a dla zadań inżynierskich zatwierdzają Brief w PLAN.md.
- Autor
- melodic-software ↗
- Repozytorium
- claude-code-plugins ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 26.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 19
- Skrypty
- 0
- Komentarze HTML
- 1
- Adresy URL w SKILL.md
- 4
Brak sygnałów. Repozytorium zmienione 26.10.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
- SKILL.md zawiera komentarze HTML (1). Nie widać ich w podglądzie Markdown, a model je czyta.
Co robi i kiedy
Prowadzi rundy ponumerowanych pytań z rekomendacjami, które doprowadzają zadanie, propozycję lub wybór do wspólnego zrozumienia, a dla zadań inżynierskich zatwierdzają Brief w PLAN.md.
Wyzwalacze z opisu
Argumenty
/interview [me|lock|scope|share] [topic]
Oryginalny opis (EN)
Rounds of numbered, recommended questions that bring a task, proposal, or choice to shared understanding. An engineering task locks a PLAN.md Brief (goal, constraints, acceptance criteria, assumptions). Use when: 'interview me', 'lock the brief', 'spec this task', 'grill me', 'this is underspecified', 'ask me questions first', 'what do you need to know', 'I have an idea', 'help me think this through', 'acceptance criteria', 'how will we know this is done', or before work whose diff is not quick to review and cheap to retry; skip one that is.
Jak działa
- Repository context. Gather first
- Variables
- Purpose
- Emit checklist
- Gates
- Action Router
- Stance: supportive, depth-first, opinionated
- Acceptance-criteria capture
- The interview loop
- Session-config recommendation (model, effort, advisor)
Podgląd SKILL.md
---
description: "Rounds of numbered, recommended questions that bring a task, proposal, or choice to shared understanding. An engineering task locks a PLAN.md Brief (goal, constraints, acceptance criteria, assumptions). Use when: 'interview me', 'lock the brief', 'spec this task', 'grill me', 'this is underspecified', 'ask me questions first', 'what do you need to know', 'I have an idea', 'help me think this through', 'acceptance criteria', 'how will we know this is done', or before work whose diff is not quick to review and cheap to retry; skip one that is."
argument-hint: "[me|lock|scope|share] [topic]"
user-invocable: true
disable-model-invocation: false
metadata:
workflow-stage: contract
summary: Interview in frontier rounds until the task contract is locked
---
**Arguments.** `[me|lock|scope|share] [topic]`. e.g., /planning:interview, /planning:interview me, /planning:interview lock, /planning:interview scope, /planning:interview share <topic>, /planning:interview <topic>
## Repository context. Gather first
Collect these with **individual** Bash calls, one command per call, never combined into a single
invocation:
- Current branch, `git branch --show-current`
- Recent commits, `git log --oneline -5`
- Working tree status (empty = clean), `git status --porcelain | head -10`
The pipe is the bound and belongs in the command. A read-time cap ("read only the first 10 entries")
bounds nothing: the Bash tool returns the command's complete output into context before there is
anything to decide about.
Treat a failure (not a repository, git unavailable) as an unknown value and carry on. Keep these as
separate body Bash calls rather than pre-compute lines: the harness runs a skill's whole pre-compute
block as one shell invocation, and a worktree-isolated session refuses a compound command that
contains git. The dated record for that composition claim is the worktree skill's
[reference/gather-block.md](https://raw.githubusercontent.com/melodic-software/claude-code-plugins/main/plugins/source-control/skills/worktree/reference/gather-block.md),
"The pre-compute block runs as one shell invocation".
## Variables
Arguments: `$ARGUMENTS`. `time_units` user layer for [`problem-framing.md`](../../context/problem-framing.md) "Time units": `${user_config.time_units}` (unexpanded means unset).
Shared-session tunnel for [`context/lane-shared.md`](context/lane-shared.md): `tunnel_hostname`: `${user_config.tunnel_hostname}`; `tunnel_token_file`: `${user_config.tunnel_token_file}` (empty means no named tunnel: a quick tunnel).
## Purpose
Rework often comes from acting on assumptions the user never made and the agent never surfaced, an **underspecified** task, one missing the constraints needed to act safely. `/planning:interview` is the pipeline's underspecification resolver: a structured pass driving every unknown the task depends on 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 `/planning:plan`. `/planning:plan` presupposes a coherent task; `/planning:interview` produces one out of fuzzy intent. The contract it writes is the target every later stage aims at.
**Supportive, not adversarial.** `/planning:devils-advocate` attacks an existing artifact after the fact. `/planning:interview` walks alongside the user to extract a clear contract from the start.
**Domain-routed.** The interview loop is universal. Any task, proposal, or choice can be its subject. 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", "interview me on this decision"). An engineering session also reads the consumer's standards before any bundled default, asks the variation-intent question, and prompts quality requirements (NFRs), each scaled by the quality bar: read [`context/loop.md`](context/loop.md) "Engineering defaults" after the Step 1 survey.
**Two invocation modes, one schema.** When intent is fuzzy, `/planning:interview` runs the depth-first Q&A loop. When intent is already clear from conversation, `/planning: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. **Cost framing**: every clarification round-trip skipped is time and tokens saved. Auto-detect removes redundant Q&A; explicit `lock` asks only its one problem question when the user has already given the answer.
## Emit checklist
For interview sessions with ≥2 open questions OR explicit `me` mode, copy `templates/checklist.md` into the topic's memory slice as `<memory_dir>/<topic-slug>/interview-checklist.md` (default `.work/`; **one ledger per topic**. Not per session). Re-interview appends `## Resolved (<round>, <date>)` sections; do not create `interview-checklist-2.md`. Tick each step as completed. Steps 1, 3, 4 are mandatory; Steps 1.5 + 2 are mode-conditional.
The ledger's `## Open-question register` is emitted the moment **any** round is asked, whatever that threshold says. It has to exist before the first reply arrives. The acceptance-criteria coverage prompt is the one thing that does not count as a round for this purpose: it writes no row and does not by itself make the register exist (see "Acceptance-criteria capture"). Register mechanics, the drift check, the unattended ladder, and the gate that grades it: [`context/loop.md`](context/loop.md) "The open-question register".
## Gates
Three gates halt this skill. They are stated here, near the top of the file, so they stay in view; the full rule is in the step each line names, and the two never differ in what they forbid.
- **The user's decisions are never synthesized.** Synthesize-directly and the Mixed path's synthesized rest resolve only codebase-resolvable facts and unambiguous conventional defaults. A decision that is genuinely the user's is asked, never folded into the Brief or captured as an assumption. Unattended, and only when the caller declares it, that decision is recorded `blocked` with arbiter `USER-RESERVED` and named as a blocker. Full rule: Step 1.5, the auto-guard and its unattended path.
- **A gap during `lock` synthesis halts the run.** Stop and surface the gap to the user; never fudge it with a guess. `lock` confirms the problem with one question and takes its invocation as confirmation of the rest; neither exempts it from this halt. Full rule: the Action Router `lock` row and Step 1.5.
- **The register gate runs before the contract locks.** Before persisting the contract or handing off, run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/check-open-questions.sh" --ledger <memory_dir>/<topic-slug>/interview-checklist.md`; exit 1 and exit 2 both halt. Only a run that asked no question skips it; the acceptance-criteria coverage prompt is not a question for this purpose, and any other question is. Full rule: Step 3, "Register gate".
## Action Router
Parse `$ARGUMENTS` to determine the action. Empty argument routes to `auto` (the intelligent default). Which **leans to `me`-mode relentless prose Q&A by default** unless context heavily informs otherwise (see "Default action leans to `me`" below).
| Argument | Action | When to use |
|----------|--------|-------------|
| *(empty)* | **`auto` (default → leans `me`)** | Survey context, detect gaps; route to relentless prose Q&A unless intent is already crystal-clear or the user said "just lock it" |
| `me` | **Force relentless Q&A** | "Interview me", "ask me everything", "relentless". Skip auto-detect; drive EVERY decision-tree branch to a decision, uncapped, no silent assumptions |
| `me <topic>` | **Force Q&A on narrow topic** | "Interview me about the auth approach". Q&A loop scoped to topic |
| `lock` | **Force synthesis, one problem question** | "Stop asking, just write it", "I'm clear, lock the brief". Skip auto-detect, confirm the one-line problem with one question, synthesize directly. If a real gap surfaces during synthesis, STOP and surface it (do not fudge) |
| `scope` / `scope <topic>` | **Ad hoc scope round** | Short scope Q&A before another skill: ledger + register gate; **no** `PLAN.md` Brief; return `Scope decisions:` for the caller |
| `share [<topic>]` | **Shared session** | "Run this interview as a shared session", "let the designer and the PO answer together". Same loop and gates; the round goes to a page several people answer, per [`context/lane-shared.md`](context/lane-shared.md) |
| `<topic>` | **`auto` on narrow topic** | "Interview the caching approach". Same intelligent default, narrower scope |
Unknown actions route to `auto`; surface the unrecognized request as a one-line side note.
**Default action leans to `me` (relentless prose rounds).** When invoked with no args (or by proactive auto-trigger), bias toward `me`-mode. Drive open decisions through frontier-rounds prose Q&A. Fall back to direct synthesis (`lock`-style) ONLY when context heavily informs against asking: intent already crystal-clear with no open decisions, OR the user signaled "just lock it / stop asking". Auto-detect's synthesize-directly path is for the genuinely-clear case, not the default posture.
**Question surface: inline prose by default.** Rounds render as numbered inline prose. Dictation-friendly, no per-question cap, and each question carries its recommendation, reasoning, and probe in one readable block. `AskUserQuestion` is an opt-in surface, enabled via the plugin's `use_ask_user_question` user config (`${user_config.use_ask_user_question}`, default off). When opted in, use it ONLY for a round of mutually independent questions that fits one `AskUserQuestion` call and whose questions are **simple selections or binary confirms** (the per-call question limit: <https://code.claude.com/docs/en/agent-sdk/user-input#limitations>, as of 2026-10-11; recheck when that section changes the per-call question limit). A card carries options, not a recommendation's reasoning or a constraint-surfacing probe, so any question needing its basis argued stays prose. Fall back to prose when the frontier exceeds that limit, any question in the round depends on another, or a question needs more than a pick. The card cannot express a dependency or a rationale, and chunking a round across multiple cards fragments it. When in doubt, prose.
**Question lanes.** Pick the lane from this table and read only its spoke. All three carry one question shape, [`context/question-shape.md`](context/question-shape.md); read it before writing a question to the page or a shared session. Configured `surface`: **`${user_config.surface}`**; `use_emoji_question_markers`: `${user_config.use_emoji_question_markers}`; `shared_session_open_browser`: `${user_config.shared_session_open_browser}`. Spokes arrive unexpanded, so put these values in place of their `${user_config.KEY}` tokens.
| Lane | When | Read |
|---|---|---|
| terminal | `surface` is `terminal`, unset or unknown, and no other lane was asked for | nothing more: "Question surface: inline prose by default" above and the Stance below |
| page | `surface` is `page`, or the user asks for the page (offer it on a dense terminal round): start it before the first round and ask no round inline | [`context/lane-page.md`](context/lane-page.md), then [`context/surface.md`](context/surface.md). The terminal stays an input, mirrored with `record-terminal`. A decision this session records or revises in the ledger is mirrored the same way. |
| shared | `share [<topic>]`, or several people should answer one interview together | [`context/lane-shared.md`](context/lane-shared.md): one session per audience, several may run at once |
## Stance: supportive, depth-first, opinionated
The Q&A path of this skill is one engine wrapped in a stop condition and an output contract. Four working principles drive it:
1. **Frontier-rounds loop**. A question is ready once every decision it rests on has an answer, and the set of ready questions is the **frontier**. On a webhook-retry task, the retry budget is ready on day one, while the alert threshold rests on that budget and so sits out until the budget is answered. Each round numbers every ready question, orders them by how much later work each answer would reshape, largest first, sends them together, and waits; the replies decide what is ready next time. One ready question still makes a round
2. **Survey-then-deep**. Before asking blind, do a fast breadth pass (repo files, recent commits, existing skills, relevant project rules) so questions land in real context
3. **Climb-to-anchor**. Find the nearest `CLAUDE.md`, `AGENTS.md`, domain-vocabulary file, or module README by walking UP from the relevant directory toward repo root; let those shape questions instead of asking what is already documented
4. **Immediate doc maintenance** *(engineering sessions only)*. When an answer resolves a domain
term, invoke `/domain-driven-design:curate-language` via the Skill tool (if that plugin is enabled; else
record the term and its definition in the resolution field of the open-question register row that resolved it) IMMEDIATELY between questions, not
batched at end. Route
decisions, gotchas, and conventions to their proper homes (ADR, project rules, side note) in the
same response. A general session writes no repo docs. It drives to a shared-understanding summary
only
**Intake the starting point.** Early in the loop (or before it), establish where the user is. One intake question that discloses their starting point; questions and recommendations calibrate to that disclosure. Route by what it shows; recommend, never auto-switch:
- **Idea stage** (a half-formed idea, "I just had this thought", the user does not yet know what they want): recommend `/planning:brainstorm`, which explores approaches and returns here with a handoff. If the user stays, follow [`problem-framing.md`](../../context/problem-framing.md) "Idea-stage requests".
- **User-facing product work** whose users or success measures are unsettled: recommend `/planning:prd` first.
- **Unfamiliar territory**: when the domain or codebase area is new to the USER, they can't yet evaluate options. Route to a blindspot-surfacing exploration FIRST (invoke `/discovery:blindspot <area>` via the Skill tool if enabled, otherwise a guided walkthrough of the area); an interview over unknown territory locks a contract the user can't assess.
- **A brainstorm handoff exists**: when `<memory_dir>/<topic-slug>/brainstorm.md` has a `## Handoff` block, read it as a settled upstream artifact and seed the Brief from it: Problem into `### Problem`, the Intent and Vision fields into the Goal's lines of the same names, Chosen direction into the Goal, Rejected options (with reasons) into `### Out-of-scope`, Criteria surfaced as acceptance-criteria candidates. The restatement still confirms each.
Every other skill the interview hands to or detours through: [`context/composition.md`](context/composition.md).
**Ask the quality bar in round 1.** When the request does not already state it, round 1 asks which bar the work is for: a throwaway prototype, an internal tool, or production. When the request states it, never re-ask it; treat it as settled. Grilling depth scales with the bar. A prototype gets the scoping questions only, with production concerns (accounts, scaling, monitoring, CI, coverage targets) named as deferred rather than asked. Production gets the full depth, including failure handling, data correctness, security, monitoring, and rollback; an internal tool sits between the two.
**Open with the problem when the request has none.** When the request names no problem (an idea, or a solution with no stated why), round 1's first question asks what problem it solves and why the user wants it solved; keep that answer in the user's words for the Goal's Intent line.
A new effort starts here, however big. When the interview shows the effort is too big to hold in one session AND still too foggy to phrase as sharp questions, the user can't yet list the decisions, let alone lock them. Name `/planning:wayfind` to the user (it charts the fog as a decision map and works the frontier down decision by decision, graduating to a Brief once it clears); recommend, never auto-switch. The user can run it in this same session: its chart step reads this topic's ledger, so settled answers become decisions so far and open questions become decision items.
**Question budget scales with what's already settled.** Upstream artifacts, research findings, exploration output, a PRD, a design resolution, count as settled prerequisites: an interview invoked after them starts with a smaller tree and fewer rounds; never re-ask what an artifact already answers. There is no numeric question cap, but a frontier that keeps *ballooning* (each round opens more branches than it closes) is the wayfind signal above, not a license for a marathon session. Surface the routing recommendation instead of grinding on.
**Bulk application work is not a decision set. The interview settles it once, it never executes it.** When the task applies a settled shape across a corpus (every document in a set, every file matching a pattern, every page of a spec), the interview's output is TWO things and no more: the small set of genuinely contested decisions, driven to decisions the normal way, plus an **execution contract**. One line in the session's output artifact, routed by domain like every other output: the Brief's `### Acceptance criteria` in an engineering session, the shared-understanding summary in a general one. Naming the per-unit close-out loop (one source unit at a time: apply, verify, close) and what *closed* means for a unit. NEVER enumerate the per-unit applications as decision rows: an interview that becomes the execution container turns every application step into a decision needing its own adoption ceremony, and the corpus's size becomes the session's length. **Tripwire. Count the candidates against the corpus:** when the candidate question count scales with the number of source units rather than with the number of genuine forks, that is execution masquerading as decisions. Collapse the per-unit rows into the loop, keep only the forks, and say what you collapsed. Distinct from the ballooning frontier above and remedied differently: ballooning routes to `/planning:wayfind`, unit-scaling collapses into the execution contract and hands off to execution.
Tone is collaborative but opinionated. You are not interrogating; you are helping the user think out loud by PROPOSING answers grounded in codebase evidence. When the user gives a definitive answer, lock it. When they hesitate, slow down and offer two or three concrete shapes the answer could take. Every option set names exactly ONE recommended option marked **(RECOMMENDED)** with a one-line basis, except a withheld question (see "Recommended answers"), which is asked open with no recommended option. The surface follows the lane table above: inline prose rounds by default, the page or a shared session when that lane is chosen, and `AskUserQuestion` only in the terminal lane, when the user opted in and the round qualifies.
### Relentless mode (`me`)
Read [`context/relentless-mode.md`](context/relentless-mode.md) before the first round when the action resolves to `me`. It holds what relentless mode means and its canonical framing. The round mechanics below apply to every mode that asks questions.
**Ask each round inline as one numbered set.** Per-question shape within the round:
```text
Q<N>: <one question>
[<one line of context — ONLY when the round-header restate doesn't reach this question, or the first round after a session gap>]
[Source: <the exact text the decision rests on, as a > quote> — <link to its exact section> — <one line on why that text makes this a question>. ONLY when the question rests on text the user has not read]
My recommendation: **<answer>** — <2-3 sentences; grounded in codebase/convention; why it beats the alternatives>.
Basis: <verified, file:line / tool output / URL fetched this session | judgment>
[Withheld: <the evidence that would settle it>. ONLY in place of both lines above, for a consequential question research could not settle]
[Commits you to: <ONLY when the recommendation fixes more than one decision; each part of it, numbered>
- Q<N+1>: <sub-decision>: <recommended value>
- Q<N+2>: <sub-decision>: <recommended value>]
Alternatives to consider:
- (a) <option> — <one-line tradeoff>
- (b) <option> — <one-line tradeoff>
- (c) <option> — <one-line tradeoff>
```
`Q<N>` numbering runs continuously across rounds (Q1…Q4 in round one, Q5… in round two; visible depth). Close the round with one probe inviting a constraint that breaks the recommendations, and the note that the user may answer in any order. Wait for the answers before computing the next round. The recommendation+basis discipline holds per question. Inline prose carries the recommendation, its reasoning, AND the probe in one readable block; a card cannot.
**One verdict marker, at most one context line.** The `My recommendation:` line is the *single* verdict marker for the question. Never stack a second one: no standalone `**(RECOMMENDED)**` badge line above it, and no `(recommended)` tag repeated in the Alternatives list; the recommended answer is named once, on that line. The alternatives exclude the recommendation: none restates it. Per-question context is at most ONE line and usually absent. The round-header restate carries shared context, so add a line only when it doesn't reach this question or the session just resumed after a gap.
**Source first, when the user has not read it.** When a question rests on text the user has not read (a doc, a post, a repo file), open it with the `Source:` block before `My recommendation:`: that exact text as a `>` quote, a link to its exact section, and one line on why that text makes this a question. The Brief carries the link, not the quote.
**A recommendation that fixes more than one decision lists every part.** When the recommended answer also settles other decisions (a design that picks a platform, a runtime, a credential, an identity), list each under `Commits you to:` with its own `Q<N>`. They are parts of the one recommendation, not a second verdict, and each is registered `open` at ask-time like any question. An explicit acceptance of the headline ("Q5 yes", "accept all recommendations") resolves each listed part to its recommended value (on the page, only the parts the user ticks); the user can overturn one by its number. When an accept-shorthand resolves commitment rows, name their `Q<N>` ids in one line. Choosing an alternative or rejecting the headline withdraws the parts, and any sub-decision the chosen alternative implies is asked in the next round. A sub-decision the recommendation assumes but does not list is not decided by any answer to the headline: list it, or keep it out of the recommendation. A question with a `Commits you to:` block is never asked through an `AskUserQuestion` card; on the page, its parts are the question's `commits` entries. Row shape: [`context/loop.md`](context/loop.md) "Commitment rows".
**Emoji anchors (default off, still configurable).** Emoji markers: `${user_config.use_emoji_question_markers}` (unexpanded or empty means off). With the emoji-markers setting on, prefix the `Q<N>:` line with `❓` and the `My recommendation:` line with `➡️`; with it off (the default), keep the undecorated shape above. Decoration of the existing single verdict marker, never a second one. Conversational rendering only: the ledger, register, and Brief stay plain, and `Q<N>` remains the answer handle. The option is the plugin's `use_emoji_question_markers` user config; set it true for anchors. A user instruction against emoji as formatting wins over the option: keep the plain shape, and the page start command then passes `--emoji-markers false` so the page matches.
**Define session shorthand once, then park it.** When a round introduces session-local shorthand, a coined label, an abbreviation, or cross-repo jargon the user may not share ("lanes", "gate vacuity"), define it in one clause at first use and record it in the ledger's shorthand glossary, then use the term freely. This is ephemeral session vocabulary, distinct from the project's ubiquitous language (owned by `/domain-driven-design:curate-language`), and never touches a project glossary. Ledger shape: [`context/loop.md`](context/loop.md) "Session-shorthand glossary".
**Partial-round resolution.** The user may answer any subset, in any order, in one reply. Unanswered questions stay OPEN on the frontier. Re-surface them at the top of the next round, labeled "unanswered from last round". NEVER silently resolve an unanswered question to its recommendation; the auto-guard applies inside rounds too. Honor accept-shorthands: "accept all recommendations" resolves the whole round to the recommended answers; "yes to Q5" / "Q5–Q7 yes" resolves that subset. Answers that reshape the tree ("actually, we don't need auth at all") invalidate pending questions. Recompute the frontier before re-asking anything.
**A hedged reply resolves only the headline.** A reply given with doubt ("yes?", "I think so", "probably") resolves at most the headline of the one question it can be tied to, never that question's `Commits you to:` rows and never the rest of the round. A hedged accept-shorthand ("accept all?") is not an accept-shorthand. Record the headline with a `hedged:` resolution, keep its commitment rows `open`, and echo back in one line what the headline commits to and which rows are still open. A hedged reply that cannot be tied to one question resolves nothing: restate the open rows.
**Register at ask-time; a reply that does not answer is not an answer.** The moment a round is asked, before any reply, write one `open` row per question into the ledger's open-question register. Then, after EVERY user reply and before doing anything else, check the reply against the register's `open` rows and restate any it did not address, in one line, even when the reply changed the subject entirely. Conversational drift is never consent, and the register, not the transcript, which a compaction can empty, is the authority. One exception, and only one: the acceptance-criteria coverage prompt gets no row even when it rides along in a round, because it carries no decision to track. Every real question in that same round is registered exactly as always. Row shape, statuses, and the drift-restate wording: [`context/loop.md`](context/loop.md) "The open-question register".
**Out-of-band output gets the same check, keyed on relevance.** A round can be overtaken by content the user did not write: a dispatched sub-agent's return, a background task notification, a team report, a Monitor firing. That is the ordinary consequence of not blocking the round. Check it against the `open` and `superseded-by-plan` rows (a superseded row is restated, never resolved by the return): a return touching nothing gets one line and the round stands, a return that contradicts an asked question's recommendation forces a restate naming the superseded recommendation, and a return that answers an open row from the environment resolves it. Re-present narrowly (a one-line pointer for the untouched, the full shape only for the row that moved), never hold the round, and never depend on being woken. The floor is the next user reply. Outcomes, shape, and the floor: [`context/loop.md`](context/loop.md) "Out-of-band drift".
**Rounds fire at phase boundaries.** When reached from inside another workflow's phase, emit the whole open set where the caller hands over, not partway through its phase; a mid-phase blocking question is the exception and states its justification in one line. Rationale: [`context/loop.md`](context/loop.md) "Where a round may fire".
**Visual-first for structural questions (default, not on-request).** When a question concerns structure, file/folder layout, before/after states, naming shapes, schema or flow alternatives, and a compact visual (fenced tree, diff, small table; roughly ≤30 lines) can carry it, LEAD with the visual and hang the question off it. A paragraph describing a tree is much harder to verify against the user's mental model than the tree itself; the visual IS the question. Before/after pairs beat single-state snapshots when the question is a migration. Skip only when no compact visual exists (genuinely abstract trade-offs) or when it would blow past ~30 lines. Then summarize and offer the full visual on request.
**Dialogue: the user drives too.** They may push back or reframe a decision (e.g. "what's hardest to roll back from?"). When they introduce a new axis, **reversibility** is the most common for V1, re-rank the options on it and REVISE your recommendation out loud, stated as old → new → why, where new may be a withheld open question ([re-emitting a changed recommendation](../../context/recommendation-basis.md)). Default V1 lens: prefer the most *reversible* start; defer the irreversible/expensive as an explicit out-of-scope decision, never a silent assumption.
**Facts are yours; decisions are the user's.** A *fact*, a path, a current value, an existing pattern, what a file already does, is resolved from the environment (Grep/Read/Glob) and STATED, never asked; spending a question on what the code already answers is friction, not interview. Every candidate question first passes the self-answer step, [`${CLAUDE_PLUGIN_ROOT}/context/self-answer.md`](../../context/self-answer.md): codebase, ADRs, docs and history, then connected tools including MCP servers, then research for external facts. A fact it finds is stated with its `Basis:` and source tag and gets no register row; a fact only an unconnected system holds gets one offer to connect it. Register mechanics: [`context/loop.md`](context/loop.md) "Self-answer gate". The environment is not only the working tree: when a task NAMES an external repo or resource, a sibling checkout under a known repo root / workspace layout, or an `owner/repo` reachable through its host, that is a resolvable fact too, so check the filesystem layout and query the repo host directly (e.g. `gh` for a named `owner/repo`) before defaulting to a user question. Cue, not mandate, except where a recommendation is consequential (next paragraph): there grounding is mandatory. Otherwise resolve what's cheaply resolvable, and don't turn every named mention into a research project. A *decision* with real tradeoffs and no environment answer ALWAYS goes to the user; never resolve one on their behalf, however obvious the answer looks. **In-flight lookups.** A slow fact lookup (deep exploration, external research) runs in a sub-agent. Sort the frontier by one test, does this question need the lookup's result? A question that does is held for a later round; a question that does not is asked in this round, without waiting for the lookup.
**Ground before recommending.** Lightweight codebase gate per question (Grep/Read/Glob). If a recommendation needs more, external best-practice, a library API, deeper exploration, dispatch or do the lookup (research/exploration capability, or inline), then recommend grounded. A **consequential** recommendation (cross-repo, shared infrastructure, irreversible, or security) is never made from training recall or convention alone: ground it in the affected code plus its consumers, and in external research that reads official docs first for a tool or API and the canonical source for a design pattern, never a pattern's popularity alone, and notes recency and dissent. That lookup is an in-flight lookup under the rule above. The contract this plugin ships, the bar and its three outcomes, is [`${CLAUDE_PLUGIN_ROOT}/context/recommendation-basis.md`](../../context/recommendation-basis.md).
**Before presenting an option that adds a mechanism** (a branch, workflow, ruleset, app, service, dependency or check), name the existing control that already covers the same risk, saying whether you read its enforcing source or only a document, and recommend dropping the mechanism if one does; a security control (`/overengineering:justify`'s protected classes) is never dropped without the user's decision, and an abstraction for a stated, known repetition stays when it passes the `reference-dont-duplicate` tests of the standards index (resolved per [`${CLAUDE_PLUGIN_ROOT}/reference/standards-contract.md`](../../reference/standards-contract.md) "Resolution ladder"). For a non-trivial new mechanism, run `/overengineering:justify` on the proposal if enabled.
### Recommended answers
For EVERY question but a withheld one (below), propose an answer grounded in observed codebase state. User confirms (fast) or corrects (faster than explaining from scratch). When no codebase signal exists, a non-consequential question may be recommended from conventions, labeled `Basis: judgment`; a consequential one is grounded first, per "Ground before recommending". Every `My recommendation:` line carries a `Basis:` line under it, `verified` with the `file:line`, tool output, or URL it rests on, or `judgment` ([basis label](../../context/recommendation-basis.md)). Like `Checked against:`, it is part of the recommendation, not a second verdict marker and not the context line; on a card or the page it rides inside the option's basis text. Mark each recommendation with its one-line basis. In an inline round that marker IS the `My recommendation:` line (one verdict marker, never a second stacked badge); in an `AskUserQuestion` card it is the option tagged **(RECOMMENDED)**. Detail in [`context/loop.md`](context/loop.md) "Frontier rounds".
**Word each question so yes accepts the recommendation.** When the recommendation is negative, ask "Should X stay out of this change?", never "Should we do X?" answered "No", because "Q<N> yes" and "accept all" must both mean the recommended answer.
**A withheld question carries no recommendation marker.** Two questions are exceptions to "every question carries a recommendation", and their recommendation is **withheld**: a consequential question research cannot settle, and, at the idea stage in the terminal lane, a question about why the user wants this or where it heads, since a proposed answer would put words in their mouth. It is asked open, never on a card, with a `Withheld:` line naming the evidence that would settle it in place of both the `My recommendation:` and `Basis:` lines; no option is tagged **(RECOMMENDED)**, and on the page its `recommendation` field carries the `Withheld:` text. It is registered like any question.
### Domain-aware behaviors
When the task touches domain concepts, these behaviors activate during Q&A. The probing behaviors run in any session; the two that write repo artifacts, **inline vocabulary update** and **ADR**, are engineering-only (per the Step 1 domain classification), so a general session, gated to a shared-understanding summary, never mutates a project glossary or proposes an ADR:
- **glossary challenge**. Two triggers share one response, a probe: any domain term the user uses two ways, and any term that collides with an existing definition
- **domain scenario exploration**. Test where one concept ends and the next begins with a concrete case of your own making ("a member returns one volume of a two-volume loan: is the loan open or closed?")
- **inline vocabulary update** *(engineering sessions only)*. When a term resolves, invoke
`/domain-driven-design:curate-language` immediately (if that plugin is enabled; else
record the term and its definition in the resolution field of the open-question register row that resolved it). That skill owns discovery-first
placement, the consumer's
file shape, purity, canonical terms, rejected synonyms, and known-context routing; the interview
resumes after the update
- **ADR, behind the admission test** *(engineering sessions only)*. Propose an architecture decision record only for a decision that is **costly to undo** AND **not obvious from the code** AND **chosen over a live alternative**; most decisions fail one of the three and get none. When the `architecture` plugin is enabled, invoke `/architecture:record-decision` via the Skill tool, passing the decision and its rationale; it owns convention discovery, the no-convention offer-and-defer, and the write. Otherwise write to the repository's declared ADR convention (a managed `docs/adr/` README, a project rule, or an existing `docs/adr/` shape); if none is declared, offer and defer. Never prescribe a location or format
## Acceptance-criteria capture
Two behaviors ride on the moment acceptance criteria are captured. The first is always on; the
second fires only when the consuming team's convention selects it.
### Coverage prompt. Always on, asked once
While capturing acceptance criteria, ask ONE question: are the criteria missing an
**unwanted-behavior** case (an `IF <trigger>, THEN <response>` criterion) and a **state-driven**
case (a `WHILE <state>, <response>` criterion)? One prompt covering both, never a per-criterion
interrogation, and **"neither applies" is a valid answer** that closes it for the session. This runs
whatever the acceptance-criteria format resolves to, and with no convention surface present at all;
it is a coverage check, not a format.
It is **not** a `Q<N>` decision. Never write it into the open-question register, never mark it
`blocked`, and never route it to `### Deferred questions`. The register gates the contract, and a
coverage check parked there would hold a lock hostage to a question that carries no decision.
**It therefore does not bring the Step 3 register gate into scope by itself.** A synthesize-directly
run whose ONLY question was this prompt wrote no register, has nothing to gate, and skips the gate
exactly as a run that asked nothing does. Without this, that path would ask a question it is
forbidden to register and then trip a gate demanding the row.
**The exemption covers this prompt and nothing else.** It is not a license for a question asked
beside it. A residue decision, a frontier round, a gap surfaced mid-synthesis, a `blocked` row from
an unattended run: any OTHER question is a register question as usual. It writes its row at
ask-time and brings the gate into scope, whether or not the coverage prompt was asked in the same
breath. One coverage check is exempt; a round that happens to contain one is not.
Per action: `me`, `auto` routed to Q&A, and the Mixed path ask it inside a round. `auto` routed to
synthesize-directly asks it as the sole residue question. `lock` skips it, because invoking `lock`
is the user saying stop asking, and reports it unexamined exactly as a non-interactive run does.
### Non-interactive runs skip the ask and say so
A run with nobody to answer, a dispatched worker, a forked subagent, a headless invocation, or any
caller that declared the run unattended, **SKIPS** the ask instead of blocking on it, and the
session's returned summary states that **unwanted-behavior and state-driven coverage went
unexamined**. Write the same line into the Brief's `### Captured assumptions` so it outlives the
summary. A prompt nobody can answer must not stall the run and must not silently vanish.
**That line is the coverage note and nothing else.** It records that a check went unrun. It is never
a place to park a decision, it satisfies no part of the auto-guard, and it changes nothing about the
unattended ladder: a decision genuinely the user's is still recorded `blocked`, still written to
`### Deferred questions` with **arbiter: USER-RESERVED**, and still named as a blocker. Capturing a
user's decision as an assumption is the failure the auto-guard exists to prevent, and no line here
licenses it.
The unattended condition is **declared by the caller, never sniffed**, the same rule the auto-guard's
unattended path states. There is no supported way for a session to observe that it is
non-interactive, so never read an environment variable to decide this.
### EARS tags, when the convention selects them
Resolve `acceptance_criteria_format` per the ladder below. Under `free-text`, the default and every
degrade, emit criteria exactly as today: `- <testable criterion>`, untagged, byte-comparable in
shape to a run with no convention surface at all. Under `ears`, every emitted criterion carries a
bracketed pattern prefix on that same plain-bullet form:
| Tag | Pattern |
|---|---|
| `[ubiquitous]` | an always-true requirement, no trigger and no state |
| `[event-driven]` | `WHEN <trigger>, <response>` |
| `[state-driven]` | `WHILE <state>, <response>` |
| `[unwanted-behavior]` | `IF <trigger>, THEN <response>` |
| `[optional-feature]` | `WHERE <feature is included>, <response>` |
```text
- [event-driven] WHEN the upload completes, the manifest is rewritten
- [unwanted-behavior] IF the upload fails, THEN the partial manifest is discarded
```
The five names are exactly `ubiquitous`, `event-driven`, `state-driven`, `unwanted-behavior`, and
`optional-feature`. This vocabulary is a contract with whatever reads the tag downstream, and a name
spelled any other way, `unwanted_behavior`, `unwanted`, `event`, reads as no tag at all and breaks
detection silently rather than loudly. The tag prefixes the criterion; it never replaces the
testable sentence, and an untaggable criterion is a criterion still owed a shape, not a criterion
owed a sixth pattern.
Where the tags travel: they land in the Brief's `### Acceptance criteria`, and a consumer that
publishes the Brief verbatim as a tracker container body carries them with it. They do not reach
per-slice criteria, which are freshly authored by whatever decomposes the work, because a vertical
slice owns everything it grades.
### Resolution ladder for `acceptance_criteria_format`
Restated here rather than cited: an installed plugin never sees the publishing repository's
convention docs, so a path citation would make that publisher a runtime dependency of this session.
```markdown
1. Anchor at the repository root: `${CLAUDE_PROJECT_DIR}` when set, otherwise
`git rev-parse --show-toplevel`. Never a CWD-relative read.
2. Resolve the convention home `<home>` from the pointer line in the marked
`<!-- BEGIN GENERATED: convention-home -->` region of the root instruction file
(`AGENTS.md` canonical; `CLAUDE.md` unless it is a pure `@AGENTS.md` shim). Use the
bundled resolver where the plugin ships one; never hand-parse the root file.
3. The printed home is repo-relative: join it to the root resolved in step 1,
then read `<home>/authoring-formats/README.md` from that path and take the
key's value from its fenced YAML block.
4. Layer order is one layer deep: an explicit invocation argument, where the skill has
one, then the team convention doc, then the documented default. A convention-doc
surface has no personal overlay, so there is no further layer to consult.
5. Default: `acceptance_criteria_format` is `free-text` — emit untagged plain-bullet
criteria, exactly today's shape.
6. Degrade soft, and say so. No pointer line, no convention home on disk, no
`authoring-formats/README.md`, no YAML block, an absent key, or an unrecognized value
each resolve to the documented default. Name the cause in one clause and continue;
never hard-fail, and never ask the operator to create the surface mid-task.
7. Report provenance whenever the resolved value shapes output: name the key, the value,
and the layer it came from — `argument`, `team convention doc <path>`, or `default`.
```
This plugin ships the step-2 resolver at
`bash "${CLAUDE_PLUGIN_ROOT}/lib/resolve-convention-home.sh"`: exit 0 prints the home on stdout,
exit 1 means no pointer line is bound, exit 2 is usage, and exit 3 is a FAIL (two pointer lines
in one region, an unterminated or nested region, an invalid pointer path, or a pointer whose
target directory does not exist). Every non-zero exit is a
step-6 degrade, `free-text`, cause named in one clause, never a halt and never a prompt to go create
the surface.
## The interview loop
Five steps. Step 1 (Survey) runs every action. Step 1.5 (Auto-detect) runs on `auto` only. Step 2 (Q&A loop) runs on `me` or `auto`-routed-to-Q&A. Detail in [`context/loop.md`](context/loop.md).
### Step 1. Survey before you ask
Spend the first turn grounding yourself. Read the project's `CLAUDE.md` / `AGENTS.md` if not already in context, Glob/Grep keywords, scan `git log --oneline -20`, climb to the nearest domain-vocabulary file, list relevant project rules, check the topic's memory slice `<memory_dir>/<topic-slug>/` (default `.work/`) for a prior PLAN.md / PRD / design artifacts and for exploration / research artifacts.
Survey output: one paragraph "Here is what I see in the repo."
**Classify the domain** from what the survey shows. *engineering* (a build or behavior-change task, or a technical subject that yields a build artifact) or *general* (a decision or idea with no build surface). The deciding signal is the **task/build surface itself**, not the working directory: a general decision raised from inside a code repo is still general, and the engineering machinery must never engage on cwd alone. Repo/cwd is context that breaks the tie only when the task surface is genuinely indeterminate. Then lean engineering inside a code repo, else general. This is inferred, never asked; honor any explicit user override. The domain governs which machinery engages and what the session produces (see Purpose "Domain-routed"); it is orthogonal to the `me`/`auto`/`lock` action.
**Engineering sessions only**. If a prior PLAN.md Brief exists, ask whether to **resume**, **revise**, or **start fresh** (the latter appends a dated scope-change note to the top of the Brief capturing why before rewriting. The Brief is never committed, so that note is its only history; the copy published to the pull request body or the linked issue carries it). On **resume**, before the first resumed round, resolve the surface through `${CLAUDE_PLUGIN_ROOT}` again (never an absolute path copied from a handoff) and run `round.sh --dir '<memory_dir>/<topic-slug>/interview-surface' doctor --ledger <ledger>`; it names each element the running version needs and the ledger lacks. A general session or the `scope` action never creates or edits a PLAN.md Brief, so it skips this prompt.
Then route per action.
### Step 1.5. Auto-detect (default action only)
For `auto`: classify intent against `context/loop.md` "Step 1.5. Auto-detect" criteria. Three outcomes:
- **Synthesize directly** (clear) → skip Step 2; proceed to Step 3 (confirmation gate), then Step 4 (Persist)
- **Q&A loop** (fuzzy) → continue to Step 2
- **Mixed** → ask the residue (one round. The few open questions together), then synthesize; proceed to Step 3, then Step 4
**Auto-guard. Never decide an interactive choice for the user.** Synthesize-directly (and the Mixed path's "synthesize the rest") applies ONLY to decisions with a verifiable answer (codebase-resolvable) or an unambiguous conventional default. When a remaining decision is genuinely the user's, a design choice with real tradeoffs and no codebase answer, do NOT fold it into the Brief. STOP and either ask it inline (a residue round) or offer to switch: *"This is a real design decision, not mine to pick. Answer it, or want me to run `/planning:interview me` and drive every open branch to a decision?"* Silently capturing such a choice as an assumption is the failure mode this guard prevents.
**Unattended path: the guard holds, the run does not idle.** `/planning:interview` can be reached with no human to answer (a loop, a spawned worker, another skill's chain). The condition is **declared by the caller, never sniffed**. There is no supported way for a session to observe that it is non-interactive. Unattended, codebase-resolvable and unambiguous-conventional decisions resolve as usual and are recorded `auto-resolved (unattended)`; a decision genuinely the user's is recorded `blocked` in the register, written to the Brief's `### Deferred questions` with **arbiter: USER-RESERVED**, and named as a blocker in the output. That extends the auto-guard rather than excepting it. The guard forbids the choice *disappearing*, and a named blocker is the choice made maximally visible. Stop on blockers; never wait indefinitely, and never read absence of objection as confirmation. Full ladder: [`context/loop.md`](context/loop.md) "Unattended path".
For `me` / `me <topic>`: skip Step 1.5 except loop.md's "Problem first" paragraph, force Q&A.
For `scope` / `scope <topic>`: skip Step 1.5 except loop.md's "Problem first" paragraph; with no topic, scope the current task. Run Step 2–3, then the **`scope` persist path** below instead of the engineering Brief in Step 4. Do not offer `/planning:plan` handoff; stop after returning decisions.
For `lock`: skip Step 1.5 AND Step 2, synthesize directly. If a gap surfaces mid-synthesis, STOP and surface; do not fudge.
### Step 2. Drive the frontier-rounds loop
Run rounds: restate working understanding → compute the frontier (every open question whose prerequisites are settled) → ask the whole frontier as one numbered set → capture the answers → recompute. Categorize each open item as resolvable / blocked / defer-with-assumption / defer-fully. The restate is also the **session-hop anchor**: after a handoff, resume, or long gap it re-establishes the decided set and this round's stakes before any question, so a returning reader is grounded without re-reading the whole ledger.
Full surfacing-question taxonomy + categorization heuristics in [`context/loop.md`](context/loop.md).
On the page surface, Step 3's confirmation gate runs on the page: post the restatement with a `restate` op and wait for the user's `confirm-understanding` event, per [`context/surface.md`](context/surface.md) "Confirmation gate".
**`me` mode** maintains a **decision-tree ledger**. One live checkbox per branch, ticked on resolve, remaining-open surfaced periodically (not every turn. Keeps the flow clean like the inline format). Persist each answer the moment it locks in (Step 4), loop until zero open consequential branches. Ask via the inline format (Stance "Relentless mode"). Ledger shape + per-round mechanics + reversibility-lens question shape in [`context/loop.md`](context/loop.md) "Decision-tree ledger".
**Keep a running constraint ledger.** The ledger's `## Constraint ledger` section holds one row per constraint. Every constraint the user states is written at once as `confirmed`, the moment it is stated, never batched to Step 4; a constraint taken from an upstream artifact is `inherited` (a prior Brief, a PRD, a design resolution). Every recommendation names the constraints it was checked against on one line under `My recommendation:`, `Checked against: C1, C3` or `Checked against: none`. That line is part of the recommendation, not a second verdict marker and not the question's context line. On the page it opens the question's `facts` field, each constraint named in words, since the page's wording lint flags a bare `C<N>` ([`context/surface.md`](context/surface.md) "Wording lint"). A card has no recommendation line, so a question goes on an `AskUserQuestion` card only when its line would read `Checked against: none`; one that cites a constraint is asked in prose. An `inherited` constraint the contract relies on is asked as a register row at ask-time: the answer flips its tag to `confirmed`, and unattended it takes the ladder (`blocked`, USER-RESERVED, when it is the user's call). In `lock` a relied-on inherited constraint is a gap: STOP and surface it (Step 1.5); in `auto` direct synthesis it makes the path Mixed and is asked in the residue round. Row shape: [`context/loop.md`](context/loop.md) "Constraint ledger".
**Re-ground open recommendations before they are shown.** On resume, and before a queued round is shown, check each open recommendation: its `Basis:` cites a source read this session or a constraint row, and it does not rest on an artifact the constraint ledger now excludes. A consequential one that fails gets a research dispatch before the user sees it, or is shown marked "not yet researched". When the user adds a constraint mid-interview, write the `confirmed` row at once and re-check every open recommendation's `Checked against:` line against it; revise the ones it changes and say which.
**Composed artifacts are candidates.** A design from explore or research output, or read from an existing implementation, is a candidate, never a recommendation, until re-derived against the constraint ledger: check it against every row, recommend only what survives, and name the rows on its `Checked against:` line. A research or exploration brief dispatched mid-interview carries the constraint ledger verbatim.
**Label evidence by when it was true.** When a recommendation rests on historical evidence (past metrics, merged PRs, an existing implementation) and the survey finds a recent process change or cannot tell, label each finding `past`, `current`, or `intended` before a recommendation rests on it. A process change is one the survey finds (a changelog, commit, ticket, or user statement dated after the evidence window) or cannot rule out. State or ask any currency you cannot establish; past-only evidence never alone grounds a recommendation.
**What, not how: the mechanism tripwire.** "Does not plan implementation" has a trigger. When a question or its recommendation names a mechanism (a tool, an API, a credential or token scope, a runtime, a platform per step), ask once whether the user wants mechanism-level decisions settled now or at planning. Ask it in the same round as the first mechanism-naming question and register it like any other question; until it is answered, recommendations carry no mechanism part. When the answer is "at planning", no later recommendation fixes a mechanism, and every still-`open` mechanism row, commitment rows included, becomes `deferred`: carried to the Brief's `### Deferred questions` under the arbiter rule in an engineering session, listed as deferred in the shared-understanding summary in a general one. When the answer is "now", write `C<N> | confirmed | mechanism decisions settled in this interview | user, round <N>` at once, and the Brief's Constraints records that this topic overrides "does not plan implementation".
**Sweep for assumptions before Step 3.** In `me` and `auto` with a register, including the `auto` Mixed path after its residue round, the loop ends with a fresh-context assumption sweep. Once the frontier is empty, and before the Step 3 register gate and confirmation gate, dispatch a non-fork sub-agent to inventory undecided details, hidden defaults, contradictions, and hedged or free-text rows across the ledger, the recommendations, and any composed artifacts. You turn each item into a register row at the next contiguous `Q<N>`, a stated fact, or, for hedged rows, a line in the confirmation restate. Any `open` row it adds returns the run to Step 2, and the next sweep covers only what the new answers changed; Step 3 is reached when a sweep adds no `open` row. A run that asked no question skips it, and so does `lock`; unattended, an item that is the user's decision is `blocked`. The acceptance-criteria coverage prompt is never a sweep item. Scope, item shape, and disposition: [`context/assumption-sweep.md`](context/assumption-sweep.md).
### Step 3. Recognize the stop condition
Stop when no question is left to ask. Every unknown the task depends on resolved OR captured as named assumption. The user can describe the goal in one paragraph without contradicting the constraints, and acceptance criteria are testable. The coverage prompt has been asked once and answered ("neither applies" counts), or skipped and reported unexamined per "Acceptance-criteria capture". Don't stop early on impatience; don't keep asking past the stop condition.
**Register gate.** Before persisting the contract or handing off, run the register through its mechanical check. That no question is left to ask is a judgment, and this is the part of it a script can decide. **Ledger only here**: the Brief does not exist yet (Step 4 writes it), and `--brief` names a file it requires to be present.
```bash
bash "${CLAUDE_PLUGIN_ROOT}/scripts/check-open-questions.sh" \
--ledger <memory_dir>/<topic-slug>/interview-checklist.md
```
Exit 1 (a row is `open` or `superseded-by-plan`) and exit 2 (ungradeable) both HALT. Resolve or explicitly retire an `open` row and re-run; a `superseded-by-plan` row leaves only on the user's reply to it ([`context/loop.md`](context/loop.md) "Superseded by plan"). Never lock a contract over a non-zero exit; that is the reported failure restated. **A run that asked no question wrote no register, has nothing to gate, and skips this**: `auto` routing to synthesize-directly with no open decision. `lock` always writes its problem row, so its register gates. The carve-out is about the absence of questions, never about which action produced it: the moment ANY question exists. Asked, surfaced mid-synthesis, or blocked unattended. A register exists and the gate applies. The `--brief` cross-check runs in Step 4, once there is a Brief to cross-check against; it also exits 1 with `brief=unconfirmed` while the Brief is stamped `Restatement: UNCONFIRMED`. The gate reads only that stamp, so it cannot see a Brief edited after a Confirm: after such an edit, post a new `restate`, get a fresh Confirm and export again.
**One thing is not a question for this purpose: the acceptance-criteria coverage prompt.** It carries no decision, writes no register row, and asking it does not by itself make a register exist or bring this gate into scope, so a synthesize-directly run whose only question was the coverage prompt still skips the gate. Read it narrowly. It exempts that one prompt, never a real question asked in the same round or the same session: any other question still writes its row at ask-time and still brings the gate into scope. See "Acceptance-criteria capture".
**Confirmation gate (`me` and `auto`):** an empty frontier is necessary but not sufficient. Before persisting the contract or handing off, restate the shared understanding, opening with the one-line problem, and get the user's explicit confirmation that it is reached. Do not act on the interview's output until they confirm. `lock` confirms the problem with one question, registered like any row; its invocation confirms the rest (its STOP-on-gap rule still applies).
**Recap and procedure check (`me` and `auto`).** Before asking for confirmation, the restatement carries a Q&A recap: one line per `Q<N>` in the ledger's `## Open-question register`, shaped `Q<N> <status>: <question text> (<resolution>)`, generated from the register on disk, never from the transcript, so it survives a compaction. Then run the procedure check beside the register gate, ledger only, and cite its exit code and `procedure=` field as the evidence that the procedure ran, never your own account of it:
```bash
bash "${CLAUDE_P
[…] pełny plik w paczce .zip
Pliki w paczce (19)
- SKILL.md 74 KB
- context/assumption-sweep.md 5 KB
- context/composition.md 6 KB
- context/gotchas.md 9 KB
- context/lane-page.md 3 KB
- context/lane-shared.md 29 KB
- context/loop.md 61 KB
- context/nfr-prompts.md 3 KB
- context/question-shape.md 7 KB
- context/relentless-mode.md 1 KB
- context/routing.md 6 KB
- context/session-config.md 12 KB
- context/surface.md 67 KB
- evals/evals.json 61 KB
- evals/fixtures/auto-guard-residue/codebase-survey.md 2 KB
- evals/fixtures/auto-guard-residue/task-context.md 2 KB
- evals/fixtures/lock-stop-on-gap/codebase-survey.md 2 KB
- evals/fixtures/lock-stop-on-gap/task-context.md 2 KB
- templates/checklist.md 8 KB
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · melodic-software/claude-code-plugins | 84 | MIT |
| q00/ouroboros | 100 | MIT |
| vanducng/skills | 100 | MIT |
| boshu2/agentops | 100 | Apache-2.0 |
| mthines/agent-skills | 100 | MIT |
| r3dlex/oh-my-auggie | 100 | Apache-2.0 |
| YuDefine/nuxt-supabase-starter | 100 | MIT |
| biliboss/skills | 100 | MIT |
| Soe-Reh/soes-skills | 100 | MIT |
Migawka bazy z 13.11.2026 · wersja paczki 5dff283d024d (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100requirements-interview
Wyjaśnia niejasne zadanie albo prowadzi wywiad projektowy, gdy wynik, ograniczenia lub kompromisy zmieniłyby implementację. - 81grill-me
Przepytuje użytkownika o plan lub decyzję, aż do wspólnego zrozumienia, rozstrzygając każdą gałąź drzewa decyzji. - 82ase-task-grill
Przepytuje użytkownika bez litości o plan zadania, aż do wspólnego zrozumienia, rozstrzygając każdą gałąź drzewa decyzji, aby przetestować plan pod presją. - 90grill-me
Przepytuje użytkownika bez litości o plan lub projekt, aż do wspólnego zrozumienia, rozstrzygając każdą gałąź drzewa decyzji. - 100grill-me
Przepytuje użytkownika o plan lub projekt aż do wspólnego zrozumienia, rozstrzygając po kolei każdą gałąź drzewa decyzyjnego. - 100grill-me
Przepytuje użytkownika o plan lub projekt, aż do wspólnego zrozumienia, rozstrzygając kolejne gałęzie drzewa decyzyjnego, gdy trzeba przetestować plan.