task-pipeline-skill 0.9.0 → 0.12.0

package/CHANGELOG.md

@@ -1,5 +1,111 @@
 # Changelog
 
+## v0.12.0 — 2026-07-27
+
+The grill stops being someone else's skill. It is ported in, in full, and gains
+the domain-awareness half it was missing.
+
+- **The intake grill is now BUILT IN — zero external dependency.** New
+  `references/grill.md` carries the whole doctrine: the interview loop, domain
+  awareness, the autonomy sweep and the output contract. No companion skill to
+  install, no provider to resolve, no fallback path, no version skew with someone
+  else's repo. `grill-me` / `grilling` are gone from the companion matrix,
+  the preflight block and every channel's docs.
+- **Ported from [mattpocock/skills](https://github.com/mattpocock/skills)** — the
+  `grilling` / `grill-with-docs` interview loop and its domain discipline, MIT,
+  adapted to this pipeline's flow. `LICENSE` gains a *Third-party* section with
+  Matt Pocock's copyright notice covering the three affected files.
+- **New: domain awareness during the grill.** The grill now reads the project's
+  own `CONTEXT.md` / `CONTEXT-MAP.md` / `docs/adr/` and holds the operator to
+  them — challenging terms that conflict with the glossary, sharpening vague or
+  overloaded words into canonical ones, stress-testing relationships with concrete
+  edge-case scenarios, and surfacing contradictions between the code and what was
+  just said. Resolved terms are written to `CONTEXT.md` inline as they land, never
+  batched.
+- **New: ADR discipline.** An ADR is offered only when a decision is hard to
+  reverse **and** surprising without context **and** the result of a real
+  trade-off; any one missing, skip it. Files are created lazily, numbered
+  sequentially in `docs/adr/`.
+- **New templates** `templates/context.md` and `templates/adr.md` — the formats
+  those two artifacts follow, shipped on every install channel alongside
+  `brief.md`. `references/artifacts.md` now maps `CONTEXT.md` and `docs/adr/` into
+  the canonical layout.
+- **Validator:** requires `references/grill.md` and all three templates; the
+  broken-relative-link check now strips fenced code blocks first, so illustrative
+  paths inside examples stop being false failures (verified it still catches real
+  broken links outside fences).
+
+## v0.11.0 — 2026-07-27
+
+The intake grill becomes mandatory, autonomy becomes something the grill actively
+buys, and the model stops being a hardcoded per-stage tier list.
+
+- **Stage 0 is now MANDATORY — the stage, not a particular skill.** No "clear
+  enough task" exemption, no starting stage 1 without a committed,
+  operator-confirmed brief (the entry-from-super-ux short-circuit remains the one
+  sanctioned bypass, and still demands a scope confirmation). The **provider** is
+  what's swappable: `grill-me`/`grilling` when that chain resolves, otherwise the
+  orchestrator's own grill loop — both implement the same **grill contract**, and
+  the loop is explicitly no longer described as a "fallback".
+- **Grill-provider reality documented.** `grill-me` typically ships
+  `disable-model-invocation: true` (so the orchestrator can't call it — the
+  operator runs `/grill-me`) and is usually a thin wrapper delegating to
+  `/grilling`; if that delegate doesn't resolve the chain is dangling and the
+  built-in loop runs. The install line was also wrong — corrected to
+  `/plugin marketplace add alirezarezvani/claude-skills` →
+  `/plugin install engineering-advanced-skills@claude-code-skills`, with
+  `npx skills add mattpocock/skills` noted as the upstream origin.
+- **New: the autonomy sweep.** The grill no longer only resolves the *task*; a
+  mandatory pass walks stages 1→9 and pre-resolves everything that would otherwise
+  interrupt the run — docs sources, branch/tracker policy, the test command and
+  what "green" means, the lint command, deploy target + release toggle + deploy
+  authorization, log/health locations, docs and wiki targets, the model. Each row
+  gets an answer or an explicit "stop and ask here"; an unasked question is a
+  scheduled interruption. Stages 5–9 read the brief instead of asking.
+  `templates/brief.md` gains the matching `## Autonomy` table.
+- **Deploy authorization has a hard floor.** The brief can carry a standing
+  authorization for the manual stage-7 gate **only if it is specific** (named
+  target + named preconditions). A vague "just do everything" does not authorize an
+  outward, irreversible action.
+- **Model policy replaces model tiering.** One model for the whole run, confirmed
+  **once at preflight** instead of a reminder at every stage boundary. Default
+  recommendation: *the most capable reasoning model the environment offers* — a
+  **tier, not a string**. Vendor ids are gone from everything shipped: they go
+  stale as generations ship and the operator may be on another provider entirely.
+  Stage configs use provider-agnostic tokens (`default` / `inherit`), resolved at
+  runtime; stage-5 subagents are pinned to the confirmed model; an unavailable tier
+  degrades honestly instead of blocking.
+- **Validator gains four enforced invariants** (each with a CI negative self-test
+  proving it can fail): no hardcoded vendor model id anywhere shipped (skill,
+  references, cursor rule, command, README); stage `model` must be a
+  provider-agnostic token; the intake-grill gate must stay `manual` and declare
+  itself mandatory; `templates/brief.md` must keep its autonomy sweep.
+- Docs realigned across every channel — SKILL.md, `references/stages.md`,
+  `references/model-tiering.md`, `references/companion-skills.md`,
+  `pipeline.schema.json`, `pipeline.example.json`, the `/task-pipeline` command,
+  the Cursor rule, and the README in both languages.
+
+## v0.10.0 — 2026-07-25
+
+Review pass — doc drift and a distribution defect found by an adversarial audit.
+
+- **FIX: the stage-0 brief template never reached 3 of 4 install channels.**
+  `templates/brief.md` sat at the repo root, outside the plugin source, so the
+  skills CLI / npx / install.sh installs had no such file while `stages.md` told
+  the agent to seed from it. Moved to
+  `plugins/task-pipeline/skills/task-pipeline/templates/brief.md` — inside the
+  skill dir, so every channel ships it.
+- **FIX: stale super-ux chain in `pipeline.example.json`.** Stage 3 still listed
+  only `ux-foundation` + `ux-scenarios`; it now runs the current chain
+  (`/ux` → `ux-foundation` → **`ux-flows`** → `ux-scenarios` → **`/ux-lint`**),
+  matching SKILL.md and `stages.md`. Stage-4 gate now also names `SCR-` screens.
+- **FIX: README documented the old chain** in both languages, and recommended the
+  skills CLI for Claude Code (which shadows the plugin). Both corrected; multiple
+  agents now shown as repeated `--agent` flags.
+- Description now opens with "Use when …" per canon. `ux-contract` stamp updated
+  v2 → v4. Model tiering moved to the current Opus generation (`claude-opus-5`).
+- README gains npm / CI / license badges.
+
 ## v0.9.0 — 2026-07-23
 
 Full structural parity with the sibling `super-ux` per the ssheleg skill canon

package/LICENSE

@@ -19,3 +19,41 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+
+
+================================================================================
+Third-party
+================================================================================
+
+The built-in intake grill (stage 0) is adapted from the `grilling` /
+`grill-with-docs` skills in https://github.com/mattpocock/skills — specifically
+its interview loop and its domain-awareness discipline (glossary challenges,
+CONTEXT.md, ADR criteria). Affected files:
+
+  plugins/task-pipeline/skills/task-pipeline/references/grill.md
+  plugins/task-pipeline/skills/task-pipeline/templates/context.md
+  plugins/task-pipeline/skills/task-pipeline/templates/adr.md
+
+Those portions are used under the following license:
+
+MIT License
+
+Copyright (c) 2026 Matt Pocock
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,5 +1,9 @@
 # task-pipeline
 
+[![npm](https://img.shields.io/npm/v/task-pipeline-skill)](https://www.npmjs.com/package/task-pipeline-skill)
+[![validate](https://github.com/ssheleg/task-pipeline/actions/workflows/validate.yml/badge.svg)](https://github.com/ssheleg/task-pipeline/actions/workflows/validate.yml)
+[![license](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+
 Full-cycle task delivery pipeline orchestrator for **Claude Code**. One skill that
 runs any substantial task through an up-front **intake grill** + **9 gated stages** —
 built on the [superpowers](https://github.com/obra/superpowers) skills.
@@ -9,24 +13,24 @@ built on the [superpowers](https://github.com/obra/superpowers) skills.
 `intake grill → docs study → brainstorm → spec → plan → subagent build → tests →
 lint/deploy → post-deploy log check → docs/wiki sync`
 
-It **grills you first**: a one-line task ("make me feature X") is expanded, one
-question at a time, into a locked brief — so the remaining stages run to the end
-without mid-flight questions. Each stage gates the next; each names the model to
-use. Every gate is typed — **auto** (the orchestrator verifies it, pass/fail) or
-**manual** (waits for your go).
-
-| # | Stage | Model | Gate | Type |
-|---|---|---|---|---|
-| 0 | Intake grill | Fable | shared understanding reached; brief locked | manual |
-| 1 | Docs study | Fable | contracts grounded on current docs | auto |
-| 2 | Brainstorm | Fable | design approved; UI verdict recorded | manual |
-| 3 | Spec | Fable | committed + reviewed; UI: scenarios + CJM traced | manual |
-| 4 | Plan | Fable | parallel-ready, DoD per task | auto |
-| 5 | Dev | Opus | tasks DONE, TDD green per task | auto |
-| 6 | Tests | Opus | full suite green, new code covered | auto |
-| 7 | Lint + deploy | host | lint clean + suite green before deploy | manual |
-| 8 | Post-deploy | host | clean boot / honest degradation | auto |
-| 9 | Docs + wiki | host | docs + wiki synced | auto |
+It **grills you first, always**: stage 0 is mandatory — a one-line task ("make me
+feature X") is expanded, one question at a time, into a locked brief, and the grill
+also sweeps stages 1→9 for anything that would stop the run later. Each stage gates
+the next. Every gate is typed — **auto** (the orchestrator verifies it, pass/fail)
+or **manual** (waits for your go). One model, confirmed before the run starts.
+
+| # | Stage | Gate | Type |
+|---|---|---|---|
+| 0 | Intake grill — **mandatory** | shared understanding + autonomy sweep; brief locked | manual |
+| 1 | Docs study | contracts grounded on current docs | auto |
+| 2 | Brainstorm | design approved; UI verdict recorded | manual |
+| 3 | Spec | committed + reviewed; UI: super-ux chain validated, linter green | manual |
+| 4 | Plan | parallel-ready, DoD per task | auto |
+| 5 | Dev | tasks DONE, TDD green per task | auto |
+| 6 | Tests | full suite green, new code covered | auto |
+| 7 | Lint + deploy | lint clean + suite green before deploy | manual |
+| 8 | Post-deploy | clean boot / honest degradation | auto |
+| 9 | Docs + wiki | docs + wiki synced | auto |
 
 These stages (0 intake + 1→9) are the plugin's **example** flow. It's a machine-readable config
 ([`pipeline.example.json`](plugins/task-pipeline/skills/task-pipeline/pipeline.example.json))
@@ -36,15 +40,37 @@ a host project copies the example to `pipeline.json` and rewrites it with its ow
 stages (any count), its own `skills[]`, and its own `auto`/`manual` gate types —
 "bring your own skills". The framework bakes in no fixed stages.
 
-## Intake grill (stage 0)
+## Intake grill (stage 0) — mandatory
 
 Inspired by [Matt Pocock's grill-me](https://github.com/mattpocock/skills). Before
 any technical work, task-pipeline interviews you relentlessly — one question per
 turn, each with a recommended answer, exploring the codebase before asking — until
-every decision branch is resolved and locked into a **task brief**. That front-loads
-all the human input so stages 1→9 run autonomously (only the built-in gates pause).
-Uses the `grill-me` / `grilling` skill if installed; otherwise runs a built-in grill
-loop (no hard dependency).
+every decision branch is resolved and locked into a **task brief**. There is no
+"clear enough task" exemption: no stage-1 work starts without a committed,
+confirmed brief.
+
+**Built in — nothing to install.** The full doctrine ships inside the skill
+([`references/grill.md`](plugins/task-pipeline/skills/task-pipeline/references/grill.md)):
+no companion skill, no resolution step, no fallback path, no version skew. Adapted
+from [Matt Pocock's grill-with-docs](https://github.com/mattpocock/skills) (MIT —
+see [LICENSE](LICENSE) → *Third-party*).
+
+**Domain awareness.** While exploring, the grill reads the project's own
+`CONTEXT.md` / `docs/adr/` and holds you to them — calling out terms that conflict
+with the glossary, replacing overloaded words with a canonical one, stress-testing
+relationships against concrete edge cases, and surfacing where the code contradicts
+what you just said. Resolved terms are written into `CONTEXT.md` as they land;
+decisions that are hard to reverse, surprising without context **and** the result of
+a real trade-off get an ADR. Both files are created lazily.
+
+**Autonomy comes from the sweep.** Beyond the task itself, the grill pre-resolves
+everything that would otherwise interrupt stages 1→9: which external libs need docs,
+branch and task-tracker policy, the test command and what "green" means, the lint
+command, the deploy target and its **authorization**, where logs and health live,
+which docs and runbooks to update, and the model. Each gets an answer or an explicit
+"stop and ask me here" — an unasked question is a scheduled interruption. Deploy
+authorization has a hard floor: a standing go counts only if it names the target and
+the preconditions.
 
 ## UX track (user-facing tasks) — super-ux recommended
 
@@ -54,7 +80,8 @@ is the **recommended** workflow, detected early in the stage-0 grill. If it's
 installed, task-pipeline uses it; if not, it gives you the install line on the spot.
 The spec stage runs it **before any plan is written**: `/ux` (setup check) →
 `ux-foundation` (personas, JTBD, **customer journey maps**, user stories) →
-`ux-scenarios` (usage scenarios validated against the base, ux-contract v2). The
+`ux-flows` (user flows + `screens.md` UI map, Figma frames) → `ux-scenarios`
+(usage scenarios validated against the base, ux-contract v4) → `/ux-lint` (must pass). The
 spec then embeds the UX layer — scenario IDs, CJM stages served, applicable UX
 patterns — and the plan's UI tasks carry scenario IDs in their DoD. Scenarios come
 before interface.
@@ -83,10 +110,13 @@ before interface.
 /plugin install task-pipeline@task-pipeline
 ```
 
-**Any agent via the skills CLI (Claude Code, Cursor, Codex, 70+ agents):**
+**Any agent via the skills CLI (Cursor, Codex, OpenCode, 70+ — not Claude Code,
+use the plugin above):**
 ```
-npx skills add ssheleg/task-pipeline
+npx skills add ssheleg/task-pipeline --agent cursor --agent codex --global
 ```
+(one repeated `--agent` per agent; never include `claude-code` while the plugin is
+installed — the plain copy shadows it)
 
 **npm installer (no clone needed):**
 ```
@@ -123,7 +153,7 @@ on the same Claude Code install yields a duplicate skill).
 | Agent / channel | Update |
 |---|---|
 | Claude Code (plugin) | `claude plugin marketplace update task-pipeline` → `claude plugin update task-pipeline@task-pipeline` → restart |
-| Any agent (skills CLI) | `npx skills add ssheleg/task-pipeline --agent <name> --global` (re-run overwrites); `--agent '*'` for all |
+| Any agent (skills CLI) | `npx skills update task-pipeline --global --yes`; to add: repeated `--agent <name>` (never `claude-code` when the plugin is installed) |
 | Cursor | skills CLI (above) with `--agent cursor`, or re-copy the `.mdc` per project |
 | npm | `npx task-pipeline-skill@latest` / `npx github:ssheleg/task-pipeline` (ephemeral — always latest) |
 | Plain skill | `git pull && ./install.sh --force` |
@@ -133,11 +163,20 @@ on the same Claude Code install yields a duplicate skill).
 Say *"run this through the pipeline"* / *"полный цикл"* / *"прогони по конвейеру"*,
 or `/task-pipeline`. The skill creates a per-stage TaskList and walks the gates.
 
-## Model tiering
+## Model policy
+
+**One model, confirmed once, at preflight.** The default recommendation is *the most
+capable reasoning model the environment offers* — currently the latest Opus
+generation, but that's a **tier, not a string**. Model ids go stale as generations
+ship, and you may be on another provider entirely, so nothing is hardcoded: the
+pipeline resolves the top tier available at runtime and stage configs use
+provider-agnostic tokens (`default` / `inherit`).
 
-Stages 0–4 → Fable, stages 5–6 → Opus, 7–9 → inherit. **Reminders only** — a skill
-can't switch the main-loop model; `/model` is the operator's. Stage-5 subagents are
-pinned to Opus automatically.
+You confirm or override it (per-stage overrides welcome) before stage 0 — then it
+**stops asking**. A skill can't switch the main-loop model; `/model` is yours.
+Stage-5 subagents are pinned to the confirmed model automatically. If the
+recommended tier isn't available, the pipeline says which one it's using and
+continues — a reminder, never a block.
 
 ## Release automation (project-configurable, toggleable)
 
@@ -155,9 +194,11 @@ clean checkout. Copy and adapt it per project; nothing is hardcoded.
 
 `references/companion-skills.md` lists what powers each stage and how to install
 it: **superpowers** (required), **super-ux** (required for user-facing tasks —
-install line surfaced on the spot), **grill-me** (optional, enhances the stage-0
-grill), **context7** (docs stage), **wiki-update** (stage 9). A preflight prints
-which are ready and which to install so you can arm the full flow before work.
+install line surfaced on the spot), **context7** (docs stage), **wiki-update**
+(stage 9). The stage-0 grill is **not** on that list — it's built into the skill. A
+single preflight
+block prints which are ready, which to install, and the model recommendation, so you
+arm the whole run in one exchange.
 
 ## Portability
 
@@ -174,25 +215,49 @@ canonical artifact layout each stage writes to is fixed in
 тесты → линт/деплой → пост-деплой проверка логов → синк доков/вики), построенных
 на скиллах [superpowers](https://github.com/obra/superpowers).
 
-- **Грил на входе (стадия 0):** одна строка задачи («сделай фичу X») недостаточна
-  для автономной работы. Пайплайн сначала «допрашивает» оператора — по одному
-  вопросу за ход, с рекомендованным ответом, изучив код до вопроса — пока все
-  ветки решений не закрыты и не зафиксированы в брифе. Это выносит весь ввод
-  человека вперёд, дальше стадии 1→9 идут автономно. Идея взята из
-  [grill-me Мэтта Покока](https://github.com/mattpocock/skills); использует скилл
-  `grill-me`/`grilling` если установлен, иначе — встроенный грил-цикл.
+- **Грил на входе (стадия 0) — обязателен.** Одна строка задачи («сделай фичу X»)
+  недостаточна для автономной работы, поэтому стадию нельзя пропустить: пайплайн
+  «допрашивает» оператора — по одному вопросу за ход, с рекомендованным ответом,
+  изучив код до вопроса — пока все ветки решений не закрыты и не зафиксированы в
+  брифе. Ни одна стадия 1+ не стартует без закоммиченного подтверждённого брифа.
+  **Грил встроен в скилл** — ставить нечего: вся доктрина лежит в
+  `references/grill.md`, без компаньонов, резолва и фолбэков. Портировано из
+  [grill-with-docs Мэтта Покока](https://github.com/mattpocock/skills) (MIT, см.
+  `LICENSE` → *Third-party*).
+- **Доменная осознанность на гриле.** Пайплайн читает `CONTEXT.md` / `docs/adr/`
+  проекта и держит оператора в рамках его же языка: ловит термины, конфликтующие с
+  глоссарием, заменяет размытые слова каноничными, проверяет отношения конкретными
+  краевыми сценариями, вскрывает расхождения между кодом и только что сказанным.
+  Разрешённый термин сразу пишется в `CONTEXT.md`; решение, которое трудно
+  откатить, неочевидно без контекста и стало результатом реального компромисса,
+  получает ADR. Файлы создаются лениво.
+- **Автономию даёт свип по стадиям.** Помимо самой задачи грил заранее закрывает
+  всё, что иначе остановит стадии 1→9: внешние библиотеки и где их доки, политику
+  веток и трекер задач, команду тестов и что значит «зелено», команду линта, цель
+  деплоя и **авторизацию на него**, где живут логи/health, какие доки и раннбуки
+  обновлять, и модель. По каждому пункту — либо ответ, либо явное «здесь
+  остановись и спроси»; незаданный вопрос = запланированное прерывание. У
+  авторизации деплоя жёсткий пол: постоянное «go» засчитывается, только если
+  названы цель и предусловия.
 - Ни одна стадия не стартует, пока не пройден гейт предыдущей; деплой требует
   зелёного полного прогона тестов и явного «go» оператора.
 - **UX-трек (super-ux рекомендуется):** как только задача трогает интерфейс
   (web/mobile/CLI/TUI), [super-ux](https://github.com/ssheleg/super-ux) —
   рекомендуемый воркфлоу, детектится ещё на гриле; если установлен — используется,
   если нет — сразу даётся строка установки. Стадия спеки гоняет `/ux` →
-  `ux-foundation` (персоны, JTBD, CJM) → `ux-scenarios` (сценарии по ux-contract
-  v2) до написания плана; спека включает ID сценариев, стадии CJM и UX-паттерны.
+  `ux-foundation` (персоны, JTBD, CJM) → `ux-flows` (флоу + `screens.md` — карта
+  экранов) → `ux-scenarios` (сценарии, ux-contract v4) → `/ux-lint` (линтер должен
+  быть зелёным) до написания плана; спека включает ID сценариев, `SCR-` экраны,
+  стадии CJM и UX-паттерны.
   Сценарии — до интерфейса.
-- Каждая стадия напоминает, какую модель включить (`/model`): 0–4 — Fable,
-  5–6 — Opus, 7–9 — наследуется. Это только напоминание — модель переключает
-  оператор.
+- **Модель — одна на прогон, подтверждается один раз до старта.** Рекомендация по
+  умолчанию — *самая мощная reasoning-модель, доступная в окружении* (сейчас это
+  последнее поколение Opus, но это **тир, а не строка**). Идентификаторы моделей
+  устаревают, и провайдер может быть другой, поэтому ничего не захардкожено:
+  актуальный топ-тир определяется в рантайме, а в конфиге стадий стоят
+  провайдер-агностичные токены (`default` / `inherit`). Оператор подтверждает или
+  переопределяет (можно по стадиям) — дальше пайплайн больше не переспрашивает.
+  Сабагенты стадии 5 пинятся на подтверждённую модель автоматически.
 - Стадии 6–9 читают конвенции хост-проекта из `CLAUDE.md` (тесты / линт /
   деплой / доки / вики), поэтому скилл работает в любом репозитории.
 

package/cursor/rules/task-pipeline.mdc

@@ -10,9 +10,21 @@ Run a substantial task through an up-front **intake grill + 9 gated stages**. No
 stage advances until its **gate** passes. Each gate is `auto` (verify it yourself,
 pass/fail) or `manual` (wait for the user's explicit go).
 
-## Stage 0 — intake grill (do this FIRST)
+## Model — decide once, before you start
 
-A one-line task ("build feature X") is not enough to finish autonomously. Grill the
+Recommended: **the most capable reasoning model the environment offers** (at time
+of writing, the latest Opus generation — read that as a tier, not a string). Never
+hardcode a model id: generations ship, tiers get renamed, and the user may be on a
+different provider. Resolve the top tier available at runtime, tell the user what
+you recommend and what they're on, let them confirm or override (per-stage
+overrides welcome), record the answer — then **stop asking at every stage**. If the
+recommended tier isn't available, say which one you're using and continue.
+
+## Stage 0 — intake grill (MANDATORY, do this FIRST)
+
+Never skipped, and nothing to install — the grill is part of this rule. No "the
+task was already clear" exemption, no starting stage 1 while the user thinks. A
+one-line task ("build feature X") is not enough to finish autonomously. Grill the
 user up front, then run the rest without mid-flight questions:
 1. One question per turn — never bundle.
 2. Give a recommended answer with every question (+ one-line rationale).
@@ -20,8 +32,36 @@ user up front, then run the rest without mid-flight questions:
 4. Walk the decision tree depth-first; ask prerequisite decisions first.
 5. Reconcile contradictions; chase dodges ("decide later" → "latest you can decide
    and still ship?").
+6. Run the **autonomy sweep** — resolve now whatever would stop stages 1→9 later:
+   external libs and where their docs live; UI verdict; base branch, branch policy,
+   commit convention, task tracker; the test command and what "green" means; the
+   lint command; the deploy target, release toggle and **deploy authorization**;
+   where logs/health live; which docs and runbooks this change updates. Each item
+   gets an answer or an explicit "stop and ask me here" — an unasked question is a
+   scheduled interruption.
+
+**Domain awareness while you grill.** Look for the project's own docs as you
+explore — a root `CONTEXT.md` (or a `CONTEXT-MAP.md` pointing at per-context ones)
+and `docs/adr/`. Then hold the user to them: call out terms that conflict with the
+glossary ("your glossary defines 'cancellation' as X, you seem to mean Y"), replace
+vague or overloaded words with a canonical one ("'account' — Customer or User?"),
+stress-test relationships with concrete edge-case scenarios, and surface
+contradictions between what the code does and what the user just said. Write
+resolved terms into `CONTEXT.md` right then, not in a batch — one tight sentence
+per term, aliases listed as "avoid", no implementation detail. Create these files
+lazily, only once there's something real to write.
+
+Offer an ADR (`docs/adr/NNNN-slug.md`, 1–3 sentences is a complete ADR) only when
+all three hold: hard to reverse, surprising without context, and the result of a
+real trade-off. Any one missing → skip it.
+
 Stop when shared understanding is reached (every branch answered or explicitly
-deferred) and lock the answers into a short brief the user confirms. Only then start.
+deferred) and lock the answers into a short brief the user confirms. Only then
+start. Later stages read that brief instead of asking again.
+
+**Deploy authorization has a hard floor:** a standing go counts only if it is
+specific (named target + named preconditions). A vague "just do everything" does
+not authorize an outward, irreversible action — stage 7 stops and asks.
 
 ## Stages 1→9
 
@@ -37,14 +77,16 @@ deferred) and lock the answers into a short brief the user confirms. Only then s
 6. **Tests** (auto) — full suite green (not just new tests); new/changed code
    covered; no skip/xfail hiding red.
 7. **Lint + deploy** (manual) — lint clean AND suite green before deploy; deploy is
-   outward → explicit user go.
+   outward → explicit user go, or the specific standing authorization recorded in
+   the stage-0 brief.
 8. **Post-deploy** (auto) — tail logs / health-check; clean boot or an honest
    degradation report (never silent success).
 9. **Docs** (auto) — update module docs/runbooks in the SAME change.
 
-Cross-cutting: track tasks, conventional commits, honest degradation (never claim a
-failed/skipped step succeeded), and get explicit go before any outward/irreversible
-action (deploy, publish, repo create).
+Cross-cutting: answer from the brief's autonomy section rather than re-asking, track
+tasks, conventional commits, honest degradation (never claim a failed/skipped step
+succeeded), and get explicit go before any outward/irreversible action (deploy,
+publish, repo create).
 
 ## super-ux for user-facing tasks (recommended)
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "task-pipeline-skill",
-  "version": "0.9.0",
-  "description": "Full-cycle task delivery pipeline orchestrator skill for Claude Code — an intake grill + 9 gated stages (docs, brainstorm, spec, plan, build, tests, deploy, post-deploy, docs/wiki) built on the superpowers skills, with a super-ux UX track for user-facing tasks and toggleable release automation. This package is the installer CLI.",
+  "version": "0.12.0",
+  "description": "Full-cycle task delivery pipeline orchestrator skill for Claude Code \u2014 a mandatory built-in intake grill + 9 gated stages (docs, brainstorm, spec, plan, build, tests, deploy, post-deploy, docs/wiki) built on the superpowers skills, with a super-ux UX track for user-facing tasks and toggleable release automation. This package is the installer CLI.",
   "bin": {
     "task-pipeline": "bin/task-pipeline.js"
   },
@@ -9,7 +9,6 @@
     "bin",
     "plugins",
     "cursor",
-    "templates",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"

package/plugins/task-pipeline/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "task-pipeline",
-  "description": "Thin orchestrator: an intake grill expands the task, then docs study, brainstorm, spec, plan, subagent build, tests, lint/deploy, post-deploy log check, docs/wiki sync — typed auto/manual gates, per-stage model reminders, a super-ux UX track for user-facing tasks, and toggleable project-configurable release automation. Built on the superpowers skills; generic-portable.",
-  "version": "0.9.0",
+  "description": "Thin orchestrator: a mandatory built-in intake grill expands the task, sharpens its domain language and pre-resolves what would stop later stages, then docs study, brainstorm, spec, plan, subagent build, tests, lint/deploy, post-deploy log check, docs/wiki sync — typed auto/manual gates, one provider-agnostic model confirmed up front, a super-ux UX track for user-facing tasks, and toggleable project-configurable release automation. Built on the superpowers skills; generic-portable.",
+  "version": "0.12.0",
   "author": { "name": "ssheleg" },
   "homepage": "https://github.com/ssheleg/task-pipeline",
   "repository": "https://github.com/ssheleg/task-pipeline",

package/plugins/task-pipeline/commands/task-pipeline.md

@@ -4,13 +4,19 @@ argument-hint: <one-line task description>
 ---
 Use the `task-pipeline` skill to run the task below through all gated stages —
 **stage 0 intake grill** → docs study → brainstorm → spec → plan → subagent
-build → tests → lint/deploy → post-deploy → docs/wiki. Start with the **intake
-grill**: interview the operator one question at a time (with a recommended answer
-each, exploring the codebase before asking) until every decision branch is
-resolved and the brief is locked — so the rest runs autonomously. For any
-user-facing task, recommend/use **super-ux**. Honor every stage gate by its type
-(`auto` = verify yourself; `manual` = wait for explicit go) and emit the
-per-stage model reminder when the recommended model differs from the current one.
+build → tests → lint/deploy → post-deploy → docs/wiki. The **intake grill is
+mandatory and built in** (`references/grill.md` — nothing to install): interview the
+operator one question at a time (with a recommended answer each, exploring the
+codebase before asking) until every decision branch is resolved, applying the
+grill's **domain awareness** (challenge terms against `CONTEXT.md`, sharpen fuzzy
+language, ADRs for hard-to-reverse calls) and covering the **autonomy sweep** (what
+would otherwise stop stages 1→9: docs sources, branch/tracker policy, test and lint
+commands, deploy target and authorization, log locations, docs/wiki targets) —
+until the brief is locked, so the rest runs autonomously. For any user-facing task, recommend/use
+**super-ux**. Honor every stage gate by its type (`auto` = verify yourself;
+`manual` = wait for explicit go). Confirm the **model once at preflight** —
+recommend the most capable one the environment offers, never a hardcoded id — then
+run the whole pipeline on it without re-asking.
 
 Task: $ARGUMENTS