task-pipeline-skill 0.8.1 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## v0.9.0 — 2026-07-23
+
+Full structural parity with the sibling `super-ux` per the ssheleg skill canon
+(make-skill): the Cursor channel and a templates dir were the last gaps.
+
+- **Cursor channel.** New `cursor/rules/task-pipeline.mdc` — a self-contained,
+  agent-requested rule (`alwaysApply: false` + a trigger `description`, no external
+  links so it survives being copied into any project) that carries the full
+  intake-grill + 9-stage discipline and the super-ux recommendation. Install
+  globally via `npx skills add ssheleg/task-pipeline --agent cursor --global`, or
+  copy per project into `.cursor/rules/`.
+- **Templates dir.** New `templates/brief.md` — the stage-0 intake-brief skeleton
+  this plugin seeds into `docs/superpowers/specs/…-brief.md` (create-if-absent,
+  never overwrite), plus `templates/README.md` mapping template → destination →
+  stage. Spec/plan and `docs/ux/*` skeletons remain owned by superpowers / super-ux.
+- **Validator + packaging.** The validator now checks every `cursor/rules/*.mdc`
+  has `description` + `alwaysApply` frontmatter and that `templates/brief.md`
+  exists; `package.json` `files` ships `cursor` and `templates`. All prior gates
+  (four-way version sync, config conformance, gate types, release shape, links)
+  retained.
+- **Docs.** README gains a Cursor install block and an "Updating everywhere" table
+  (one channel per agent — the plugin+plain duplicate caveat spelled out);
+  `references/artifacts.md` and stage 0 reference the brief template.
+
 ## v0.8.1 — 2026-07-23
 
 - Docs consistency: the SKILL.md super-ux intro now lists the full current chain

package/README.md

@@ -97,6 +97,15 @@ npx task-pipeline-skill                   # from the npm registry
 on npm; installs the same skill + `/task-pipeline` command into `~/.claude`,
 idempotent, `--force` to overwrite)
 
+**Cursor:**
+```
+npx skills add ssheleg/task-pipeline --agent cursor --global   # global, or…
+```
+…or per project, copy `cursor/rules/task-pipeline.mdc` into the repo's
+`.cursor/rules/`. Cursor has no global rules directory — use the skills CLI for a
+global install, the `.mdc` for per-project, or paste it into Cursor Settings →
+Rules. The rule is self-contained (no external links), so it works copied anywhere.
+
 **Plain skill:**
 ```
 git clone https://github.com/ssheleg/task-pipeline
@@ -106,6 +115,19 @@ cd task-pipeline && ./install.sh
 command into `~/.claude/commands/`; idempotent — rerun skips existing installs,
 `./install.sh --force` overwrites)
 
+## Updating everywhere
+
+Pick **one** channel per agent (running the plugin and the plain/skills-CLI copy
+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 |
+| 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` |
+
 ## Use
 
 Say *"run this through the pipeline"* / *"полный цикл"* / *"прогони по конвейеру"*,

package/cursor/rules/task-pipeline.mdc

@@ -0,0 +1,56 @@
+---
+description: "task-pipeline: run a substantial task through a disciplined, gated delivery cycle — an intake grill that expands the request, then docs→brainstorm→spec→plan→build→tests→lint/deploy→post-deploy→docs. Apply when the user asks to run a task through the pipeline, the full cycle / полный цикл / прогони по конвейеру, or starts any substantial feature/fix/build."
+alwaysApply: false
+---
+
+# task-pipeline — gated delivery cycle (Cursor)
+
+Self-contained rule (Cursor copies this file into projects — no external links).
+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)
+
+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).
+3. Explore the codebase before asking — if a search/read answers it, do that.
+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?").
+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.
+
+## Stages 1→9
+
+1. **Docs study** (auto) — ground every external lib/API on current docs, not recall.
+2. **Brainstorm** (manual) — 2–3 approaches + a recommendation; design approved.
+   Record whether the task touches a user-facing surface (UI verdict).
+3. **Spec** (manual) — write and commit the design; lock shared contracts. For UI
+   tasks, run the UX chain FIRST (see super-ux below) and embed it.
+4. **Plan** (auto) — zero-context tasks, exact paths, TDD steps, DoD each,
+   dependency graph + parallel groups, non-overlapping file ownership.
+5. **Dev** (auto) — isolate (worktree), TDD per task (failing test → minimal impl →
+   green → commit); two-stage review (spec compliance, then code quality).
+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.
+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).
+
+## super-ux for user-facing tasks (recommended)
+
+If the task touches any UI (web/mobile/CLI/TUI), the WHY→UI→scenario chain comes
+BEFORE interface code. If super-ux is available, use it: foundation (personas,
+JTBD, customer journey maps, user stories) → flows + screens → scenarios (the
+source of truth) → run its linter. Otherwise still design that chain, get it
+approved, and trace every user-facing requirement to a scenario before building.
+Install (Cursor/Claude/others): `npx skills add ssheleg/super-ux`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "task-pipeline-skill",
-  "version": "0.8.1",
+  "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.",
   "bin": {
     "task-pipeline": "bin/task-pipeline.js"
@@ -8,6 +8,8 @@
   "files": [
     "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.8.1",
+  "version": "0.9.0",
   "author": { "name": "ssheleg" },
   "homepage": "https://github.com/ssheleg/task-pipeline",
   "repository": "https://github.com/ssheleg/task-pipeline",

package/plugins/task-pipeline/skills/task-pipeline/references/artifacts.md

@@ -33,7 +33,7 @@ design → plan is traceable at a glance.
 
 | Stage | Writes | Consumed by |
 |---|---|---|
-| 0 Intake | `specs/<topic>-brief.md` | stages 2–4 |
+| 0 Intake | `specs/<topic>-brief.md` (seed from `templates/brief.md`) | stages 2–4 |
 | 3 Spec | `specs/<topic>-design.md` (+ links `docs/ux/*` for UI) | stage 4 |
 | 4 Plan | `plans/<topic>.md` | stage 5 |
 | 3 UX track | `docs/ux/{foundation,flows,screens,scenarios}.md` | stages 4–9 + `/ux-lint` |
@@ -52,6 +52,8 @@ plugins/task-pipeline/
     pipeline.schema.json                      # generic pipeline contract
     pipeline.example.json                     # this plugin's own flow, as config
     references/{stages,model-tiering,conventions,artifacts,companion-skills}.md
+cursor/rules/task-pipeline.mdc                # Cursor channel (self-contained rule)
+templates/brief.md                            # skeleton seeded at stage 0
 bin/task-pipeline.js                          # npx installer (package task-pipeline-skill)
 package.json
 install.sh                                    # POSIX installer

package/plugins/task-pipeline/skills/task-pipeline/references/stages.md

@@ -45,8 +45,9 @@ stages/agents/types (see SKILL.md → *Bring your own skills*).
   *Prerequisites*); this arms the stage-3 UX track.
 - **Artifact:** lock the resolved decisions into a **task brief** committed at
   `docs/superpowers/specs/YYYY-MM-DD-<topic>-brief.md` (scope, users/UI verdict,
-  constraints, assumptions, explicitly-deferred items, done-criteria). Stages
-  2–4 build on this brief.
+  constraints, assumptions, explicitly-deferred items, done-criteria). Seed it from
+  the plugin's `templates/brief.md` skeleton — but only when absent, never
+  overwrite an existing brief. Stages 2–4 build on this brief.
 - **GATE (manual):** shared understanding reached — every detected branch has a
   recorded answer or an explicit deferral, no open contradictions, and the
   operator confirms the brief. Stop when a re-scan surfaces no new branches

package/templates/README.md

@@ -0,0 +1,12 @@
+# templates
+
+Skeletons task-pipeline seeds into a host project. Only the **brief** is owned by
+this plugin (it is the stage-0 intake artifact); the spec and plan skeletons come
+from the `superpowers` skills, and the `docs/ux/*` skeletons from `super-ux`.
+
+| Template | Seeded to | Stage |
+|---|---|---|
+| `brief.md` | `docs/superpowers/specs/YYYY-MM-DD-<topic>-brief.md` | 0 — intake grill |
+
+Seeding rule (per the ssheleg canon): create a template copy **only when the
+target is absent**; never overwrite an existing brief.

package/templates/brief.md

@@ -0,0 +1,35 @@
+# Task brief — <topic>
+
+> Stage-0 intake artifact. The grill fills this in and the operator confirms it
+> before stage 1. Copy to `docs/superpowers/specs/YYYY-MM-DD-<topic>-brief.md`.
+> Every field is a resolved decision or an explicit deferral — no open unknowns.
+
+- **Date:** YYYY-MM-DD
+- **Task (one line):** <what the operator asked for, restated>
+- **UI verdict:** yes / no — does this touch a user-facing surface (web/mobile/CLI/TUI)?
+  If yes, the stage-3 super-ux UX track is armed.
+
+## Scope
+
+- **In scope:** …
+- **Out of scope / explicitly deferred:** … (with the reason and, for deferrals,
+  the latest moment the decision can still be made)
+
+## Users & context
+
+- **Who / for what:** … (personas, the job being done)
+- **Where it runs / constraints:** platform, runtime, data, integrations, limits
+
+## Decisions locked (the grill's output)
+
+| # | Decision | Chosen | Rationale |
+|---|---|---|---|
+| 1 | … | … | … |
+
+## Done-criteria
+
+- Observable, verifiable conditions that mean "this task is finished".
+
+## Open assumptions / risks
+
+- Assumption → how it's validated (or flagged risky-untested).