task-pipeline-skill 0.4.0

package/CHANGELOG.md

@@ -0,0 +1,64 @@
+# Changelog
+
+## v0.4.0 — 2026-07-19
+
+npm installer.
+
+- **`bin/task-pipeline.js`** — zero-dependency Node installer CLI (mirrors
+  `install.sh`: skill → `~/.claude/skills/task-pipeline`, command →
+  `~/.claude/commands/`; idempotent, overwrite only behind `--force`).
+- **`package.json`** — package name **`task-pipeline-skill`** (unscoped
+  `task-pipeline` is taken on npm); bin command stays `task-pipeline`;
+  `files` whitelist ships `bin` + `plugins`. Works without npm publish via
+  `npx github:ssheleg/task-pipeline`; after publish also `npx task-pipeline-skill`.
+- **Version sync is now four-way** (marketplace.json, plugin.json,
+  package.json, CHANGELOG top entry) — validator enforces, plus checks the
+  bin entry resolves and the files whitelist ships the skill sources.
+- **CI:** `node --check` + a functional install run (fresh → rerun-skip →
+  `--force`) against a fake `$HOME`.
+
+## v0.3.0 — 2026-07-19
+
+Packaging/tooling alignment with the ssheleg skill-repo canon (make-skill).
+
+- **CI:** `.github/workflows/validate.yml` runs the structural validator on every
+  push/PR, plus a **negative self-test** — corrupts a copy of the repo and expects
+  the validator to FAIL (a validator that can't fail is decoration) — and a
+  `bash -n` syntax check of `install.sh`.
+- **Validator hardened:** now also enforces command frontmatter
+  (`description` + `argument-hint`), **CHANGELOG top-entry version sync** with the
+  manifests, and resolution of every relative markdown link in the repo.
+- **`install.sh` is idempotent:** reruns skip already-installed skill/command;
+  destructive overwrite only behind `--force` (never silently `rm -rf`s an
+  existing install).
+- **`/task-pipeline` is an idempotent entry point:** detects an existing pipeline
+  TaskList and resumes from the first incomplete stage instead of restarting.
+- **README:** added the `npx skills add ssheleg/task-pipeline` install path
+  (vercel-labs skills CLI, 70+ agents) and a closing Russian section.
+
+## v0.2.0 — 2026-07-18
+
+- Added a dedicated **Tests** stage (new stage 6, model Opus) between Dev and
+  Lint/deploy: writes tests for new functionality, updates/repairs existing tests
+  touched by the change, and adds edge-case + failure-path coverage.
+- Hard **full-suite-green gate before deploy** — the deploy stage now requires both
+  lint clean and the whole suite green; never advances on a red or partial run.
+- Pipeline grew 8 → 9 stages; deploy/post-deploy/docs renumbered 7/8/9. Model
+  tiering: Fable 1–4, Opus 5–6, inherit 7–9. Docs/tables/references synced.
+- Added a real `/task-pipeline` slash command (`commands/task-pipeline.md`);
+  `install.sh` now installs it to `~/.claude/commands/` alongside the skill so the
+  command works for the plain-skill path too.
+- Validator hardened: enforces marketplace↔plugin.json **version sync** and the
+  presence of the command file.
+
+## v0.1.0 — 2026-07-18
+
+Initial release.
+
+- Thin orchestrator skill that runs a task through 8 gated stages (docs study →
+  brainstorm → spec → plan → subagent build → lint/deploy → post-deploy log check
+  → docs/wiki sync), built on the [superpowers](https://github.com/obra/superpowers) skills.
+- Hybrid distribution: Claude Code plugin/marketplace + plain `~/.claude/skills` copy.
+- Soft per-stage model tiering (Fable stages 1–4, Opus stage 5, inherit 6–8) — reminder only.
+- Generic-portable: stages 6–8 read the host project's `CLAUDE.md` conventions with detection fallbacks.
+- Structural validator (`test/validate.py`); spec + plan under `docs/superpowers/`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ssheleg
+
+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

@@ -0,0 +1,105 @@
+# task-pipeline
+
+Full-cycle task delivery pipeline orchestrator for **Claude Code**. One skill that
+runs any substantial task through **9 gated stages** — built on the
+[superpowers](https://github.com/obra/superpowers) skills.
+
+## What it does
+
+`docs study → brainstorm → spec → plan → subagent build → tests → lint/deploy →
+post-deploy log check → docs/wiki sync`
+
+Each stage gates the next; each names the model to use.
+
+| # | Stage | Model | Gate |
+|---|---|---|---|
+| 1 | Docs study | Fable | contracts grounded on current docs |
+| 2 | Brainstorm | Fable | design approved |
+| 3 | Spec | Fable | committed + reviewed |
+| 4 | Plan | Fable | parallel-ready, DoD per task |
+| 5 | Dev | Opus | tasks DONE, TDD green per task |
+| 6 | Tests | Opus | full suite green, new code covered |
+| 7 | Lint + deploy | host | lint clean + suite green before deploy |
+| 8 | Post-deploy | host | clean boot / honest degradation |
+| 9 | Docs + wiki | host | docs + wiki synced |
+
+## Prerequisite
+
+**superpowers** — https://github.com/obra/superpowers
+
+```
+/plugin marketplace add obra/superpowers
+/plugin install superpowers@superpowers
+```
+
+## Install
+
+**Plugin (recommended):**
+```
+/plugin marketplace add ssheleg/task-pipeline
+/plugin install task-pipeline@task-pipeline
+```
+
+**Any agent via the skills CLI (Claude Code, Cursor, Codex, 70+ agents):**
+```
+npx skills add ssheleg/task-pipeline
+```
+
+**npm installer (no clone needed):**
+```
+npx github:ssheleg/task-pipeline          # straight from GitHub
+npx task-pipeline-skill                   # from the npm registry
+```
+(package is `task-pipeline-skill` — the unscoped `task-pipeline` name is taken
+on npm; installs the same skill + `/task-pipeline` command into `~/.claude`,
+idempotent, `--force` to overwrite)
+
+**Plain skill:**
+```
+git clone https://github.com/ssheleg/task-pipeline
+cd task-pipeline && ./install.sh
+```
+(copies the skill into `~/.claude/skills/task-pipeline` and the `/task-pipeline`
+command into `~/.claude/commands/`; idempotent — rerun skips existing installs,
+`./install.sh --force` overwrites)
+
+## Use
+
+Say *"run this through the pipeline"* / *"полный цикл"* / *"прогони по конвейеру"*,
+or `/task-pipeline`. The skill creates a per-stage TaskList and walks the gates.
+
+## Model tiering
+
+Stages 1–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.
+
+## Portability
+
+Stages 6–9 read the host project's `CLAUDE.md` conventions (tests / lint / deploy /
+docs / wiki) with detection fallbacks, so the skill works in any repo.
+
+## По-русски
+
+**task-pipeline** — оркестратор полного цикла доставки задачи для Claude Code:
+один скилл проводит любую существенную задачу через **9 гейтованных стадий**
+(изучение доков → брейншторм → спека → план → сборка сабагентами → тесты →
+линт/деплой → пост-деплой проверка логов → синк доков/вики), построенных на
+скиллах [superpowers](https://github.com/obra/superpowers).
+
+- Ни одна стадия не стартует, пока не пройден гейт предыдущей; деплой требует
+  зелёного полного прогона тестов и явного «go» оператора.
+- Каждая стадия напоминает, какую модель включить (`/model`): 1–4 — Fable,
+  5–6 — Opus, 7–9 — наследуется. Это только напоминание — модель переключает
+  оператор.
+- Стадии 6–9 читают конвенции хост-проекта из `CLAUDE.md` (тесты / линт /
+  деплой / доки / вики), поэтому скилл работает в любом репозитории.
+
+Запуск: скажите *«полный цикл»* / *«прогони по конвейеру»* или `/task-pipeline
+<задача>`. Установка — см. раздел Install выше (плагин, `npx skills add
+ssheleg/task-pipeline`, `npx task-pipeline-skill` / `npx
+github:ssheleg/task-pipeline` или `./install.sh`).
+
+## License
+
+MIT © 2026 ssheleg.

package/bin/task-pipeline.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+/*
+ * task-pipeline installer CLI.
+ *
+ * Installs the task-pipeline skill into ~/.claude/skills/task-pipeline and
+ * the /task-pipeline slash command into ~/.claude/commands/ (same layout as
+ * install.sh). Idempotent: existing installs are skipped unless --force.
+ *
+ * Zero dependencies, non-interactive. For other agents (Cursor, Codex, 70+)
+ * use: npx skills add ssheleg/task-pipeline
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const ROOT = path.resolve(__dirname, '..');
+const REPO = 'ssheleg/task-pipeline';
+
+function usage() {
+  console.log(`task-pipeline installer
+
+Usage:
+  npx task-pipeline-skill [--force]   install skill + /task-pipeline command
+                                      into ~/.claude (skip existing unless --force)
+  npx task-pipeline-skill --help
+
+Other install paths:
+  Claude Code plugin:  /plugin marketplace add ${REPO}
+                       /plugin install task-pipeline@task-pipeline
+  Any agent (70+):     npx skills add ${REPO}`);
+}
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dest, entry.name);
+    if (entry.isDirectory()) copyDir(s, d);
+    else fs.copyFileSync(s, d);
+  }
+}
+
+function installOne(label, src, dest, isDir, force) {
+  if (fs.existsSync(dest) && !force) {
+    console.log(`skip: ${label} already installed at ${dest} (rerun with --force to overwrite)`);
+    return;
+  }
+  fs.rmSync(dest, { recursive: true, force: true });
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  if (isDir) copyDir(src, dest);
+  else fs.copyFileSync(src, dest);
+  console.log(`Installed ${label} -> ${dest}`);
+}
+
+function main(argv) {
+  const args = argv.slice(2);
+  if (args.includes('--help') || args.includes('-h')) {
+    usage();
+    return 0;
+  }
+  const force = args.includes('--force');
+  const unknown = args.filter((a) => a !== '--force');
+  if (unknown.length) {
+    console.error(`unknown argument(s): ${unknown.join(' ')}`);
+    usage();
+    return 2;
+  }
+
+  const skillSrc = path.join(ROOT, 'plugins/task-pipeline/skills/task-pipeline');
+  const cmdSrc = path.join(ROOT, 'plugins/task-pipeline/commands/task-pipeline.md');
+  for (const [p, what] of [[skillSrc, 'skill sources'], [cmdSrc, 'command source']]) {
+    if (!fs.existsSync(p)) {
+      console.error(`error: ${what} missing at ${p} — corrupted package?`);
+      return 1;
+    }
+  }
+
+  const home = os.homedir(); // respects $HOME on POSIX — tests override via env
+  installOne(
+    'task-pipeline skill  ',
+    skillSrc,
+    path.join(home, '.claude', 'skills', 'task-pipeline'),
+    true,
+    force
+  );
+  installOne(
+    '/task-pipeline command',
+    cmdSrc,
+    path.join(home, '.claude', 'commands', 'task-pipeline.md'),
+    false,
+    force
+  );
+  return 0;
+}
+
+process.exit(main(process.argv));

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "task-pipeline-skill",
+  "version": "0.4.0",
+  "description": "Full-cycle task delivery pipeline orchestrator skill for Claude Code — 9 gated stages (docs, brainstorm, spec, plan, build, tests, deploy, post-deploy, docs/wiki) built on the superpowers skills. This package is the installer CLI.",
+  "bin": {
+    "task-pipeline": "bin/task-pipeline.js"
+  },
+  "files": [
+    "bin",
+    "plugins",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "repository": "github:ssheleg/task-pipeline",
+  "homepage": "https://github.com/ssheleg/task-pipeline",
+  "license": "MIT",
+  "author": "ssheleg",
+  "engines": {
+    "node": ">=16"
+  },
+  "keywords": [
+    "pipeline",
+    "workflow",
+    "superpowers",
+    "orchestrator",
+    "tdd",
+    "deploy",
+    "spec-driven",
+    "claude-code",
+    "skill"
+  ]
+}

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

@@ -0,0 +1,10 @@
+{
+  "name": "task-pipeline",
+  "description": "Thin orchestrator that runs a task through the full delivery pipeline: docs study, brainstorm, spec, plan, subagent build, test suite, lint/deploy, post-deploy log check, docs/wiki sync. Built on the superpowers skills; per-stage model reminders; generic-portable.",
+  "version": "0.4.0",
+  "author": { "name": "ssheleg" },
+  "homepage": "https://github.com/ssheleg/task-pipeline",
+  "repository": "https://github.com/ssheleg/task-pipeline",
+  "license": "MIT",
+  "keywords": ["pipeline", "workflow", "superpowers", "orchestrator", "tdd", "deploy", "spec-driven", "claude-code"]
+}

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

@@ -0,0 +1,17 @@
+---
+description: Run a task through the full 9-stage task-pipeline (docs → brainstorm → spec → plan → build → tests → deploy → post-deploy → docs/wiki).
+argument-hint: <one-line task description>
+---
+Use the `task-pipeline` skill to run the task below through all **nine gated
+stages** — docs study → brainstorm → spec → plan → subagent build → tests →
+lint/deploy → post-deploy → docs/wiki. Honor every stage gate (never advance a
+red gate) and emit the per-stage model reminder when the recommended model
+differs from the current one.
+
+Task: $ARGUMENTS
+
+Idempotent entry — inspect state first, never restart blindly:
+- If a pipeline TaskList from a previous run already exists for this task,
+  **resume** from the first incomplete stage instead of starting over.
+- Otherwise, if no task is given above, ask the operator for the task in one
+  line before starting stage 1.

package/plugins/task-pipeline/skills/task-pipeline/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: task-pipeline
+description: "Orchestrates a task through the full end-to-end delivery pipeline — docs study, brainstorm, spec, plan, subagent-driven build, test suite, lint/deploy, post-deploy log check, and docs/wiki sync — as nine gated stages built on the superpowers skills. Use when the user wants to run a task through the pipeline, asks for the full cycle / полный цикл / прогони по конвейеру, invokes /task-pipeline, or starts any substantial feature, fix, or build that should follow the disciplined cycle rather than ad-hoc coding. Reminds which model to switch to per stage; reads host-project conventions for deploy/docs/wiki so it stays project-agnostic."
+---
+
+# task-pipeline
+
+Thin orchestrator. Runs a task through **9 gated stages**, each built on an
+existing skill. Keeps the main thread disciplined: no stage advances until its
+gate passes; each stage names the model to use.
+
+## Prerequisite
+
+Requires the **superpowers** skills. Preflight: confirm `superpowers:brainstorming`,
+`superpowers:writing-plans`, `superpowers:subagent-driven-development`,
+`superpowers:using-git-worktrees`, `superpowers:test-driven-development` resolve.
+If missing → tell the operator to install from **https://github.com/obra/superpowers**
+(`/plugin marketplace add obra/superpowers` → `/plugin install superpowers@superpowers`)
+and stop.
+
+## How to run
+
+1. Restate the task in one line. Create a **TaskList: one task per stage** (survives
+   context loss; lets you resume).
+2. Walk stages 1→8. Before each: **model check** (see `references/model-tiering.md`) —
+   if recommended ≠ current, emit the reminder block and wait for the operator to `/model`.
+3. Do **not** advance until the stage **gate** passes (`references/stages.md`).
+4. Cross-cutting, every stage: task tracker + conventional commits per host
+   conventions; worktree isolation for the build; honest degradation (never claim a
+   failed/skipped step succeeded); outward/irreversible actions (deploy, publish,
+   repo create) need explicit operator go.
+
+## Stages (detail in `references/stages.md`)
+
+| # | Stage | Model | Invoke | Gate |
+|---|---|---|---|---|
+| 1 | Docs study | Fable | `context7` (resolve-library-id → get-library-docs) / `context7-docs` | contracts grounded on fetched docs |
+| 2 | Brainstorm | Fable | `superpowers:brainstorming` | design approved by user |
+| 3 | Spec | Fable | brainstorming writes `docs/superpowers/specs/…-design.md` | committed + user-reviewed |
+| 4 | Plan | Fable | `superpowers:writing-plans` → `docs/superpowers/plans/…md` | parallel-ready, DoD per task |
+| 5 | Dev | **Opus** | `superpowers:using-git-worktrees` + `superpowers:subagent-driven-development` (TDD) | tasks DONE, TDD green per task |
+| 6 | Tests | **Opus** | host test runner + `superpowers:test-driven-development` | full suite green; new/changed code covered |
+| 7 | Lint + deploy | host | host lint → deploy per host convention | lint clean + suite green before deploy; deploy needs go |
+| 8 | Post-deploy | host | tail deploy logs / health-check | clean boot or honest degradation report |
+| 9 | Docs + wiki | host | host module docs/runbook rules → `wiki-update` | docs synced, wiki synced |
+
+## Model reminder (emit at a boundary when recommended ≠ current)
+
+> ⏸ **Stage N (`<stage>`) recommends `<model>` (`<id>`).** You're on `<current>`.
+> Switch: `/model <id>` — then say "continue". *(Reminder only — override if you
+> don't have that model.)*
+
+## References
+
+- `references/stages.md` — per-stage detail + exact gate criteria
+- `references/model-tiering.md` — model map, ids, the `/model` reminder mechanic, override
+- `references/conventions.md` — how stages 6–9 read the host project's CLAUDE.md

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

@@ -0,0 +1,26 @@
+# Host conventions (stages 6–9)
+
+The orchestrator is project-agnostic. For tests / lint / deploy / docs / wiki it reads the
+**host project's `CLAUDE.md` / `AGENTS.md` first**, then falls back to detection.
+Prefer explicit host instructions over detection; if a step's convention can't be
+found, surface it and **ask** rather than guessing.
+
+## Lint + test
+- `CLAUDE.md` usually names the commands. Else detect: `package.json` scripts
+  (`npm test` / `npm run lint`), `pyproject.toml` / `ruff` (`ruff check`), `pytest`,
+  `Makefile` targets, `.golangci.yml`, `cargo test`.
+
+## Deploy
+- `CLAUDE.md` deploy section (e.g. deploy-from-main rule, Heroku auto-deploy on
+  push, `Procfile`). Else detect: `Procfile` / heroku remote, `Dockerfile`,
+  `.github/workflows/*.yml`, Vercel / Netlify config. **Never invent a deploy
+  path** — if none is discoverable, ask.
+
+## Post-deploy logs
+- Heroku: `heroku logs -a <app>`. Docker / k8s: `docker logs` / `kubectl logs`.
+  CI: the workflow run. Hit the health endpoint if one is defined.
+
+## Docs + wiki
+- Host self-update rules (module docs, runbooks, agent-self cards, etc.) — update
+  in the same change. Wiki: the `wiki-update` skill (resolves the vault via
+  `~/.obsidian-wiki/config`). Fix dangling links.

package/plugins/task-pipeline/skills/task-pipeline/references/model-tiering.md

@@ -0,0 +1,31 @@
+# Model tiering
+
+A **reminder**, not a hard block. Not every environment has every model — if you
+lack one, keep your current model; the pipeline still runs.
+
+| Stages | Recommended | id |
+|---|---|---|
+| 1–4 (docs, brainstorm, spec, plan) | Fable 5 | `claude-fable-5` |
+| 5–6 (subagent dev, tests) | Opus 4.8 | `claude-opus-4-8` |
+| 7–9 (lint/deploy, logs, docs) | inherit current | — |
+
+## Mechanic
+
+At each stage boundary compare recommended vs current. If they differ, emit:
+
+> ⏸ **Stage N (`<name>`) recommends `<model>` (`<id>`).** You're on `<current>`.
+> Switch: `/model <id>` — then say "continue". *(Reminder only.)*
+
+## Why manual
+
+A skill runs inside the current context; it **cannot change the main-loop model**.
+Only the operator can, via `/model` (or `/fast`). The stages that most benefit from
+Fable (1–4) are interactive anyway, so the operator is present to switch.
+
+Stage 5 spawns subagents; those **are** pinned to Opus by the orchestrator via the
+`Agent` / `Workflow` model override — no operator action needed for subagents.
+
+## Override
+
+Set your own map if your task warrants it (e.g. a heavy design needs Opus at
+stage 2). The recommendations are defaults, not rules.

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

@@ -0,0 +1,67 @@
+# Stages — detail & gates
+
+For each stage: what it does, what to invoke, artifacts, and the **GATE** that
+must pass before advancing.
+
+## 1 — Docs study (Fable)
+- **What:** ground every external library / API / SDK the task touches on the
+  *current* docs, before locking any contract.
+- **Invoke:** `context7` MCP (`resolve-library-id` → `get-library-docs`, scope by
+  `topic`) or the `context7-docs` skill. Web-search fallback for libs context7
+  can't resolve.
+- **GATE:** every contract the design will lock is grounded in fetched docs, not
+  recall. Unresolvable libraries are flagged in the spec.
+
+## 2 — Brainstorm (Fable)
+- **Invoke:** `superpowers:brainstorming`. One question at a time; 2–3 approaches +
+  a recommendation; design presented in sections.
+- **GATE:** the user approves the design.
+
+## 3 — Spec (Fable)
+- brainstorming writes the design to
+  `docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md` and commits it. Lock all
+  shared contracts (types, schemas, signatures, file layout).
+- **GATE:** spec committed **and** user-reviewed.
+
+## 4 — Plan (Fable)
+- **Invoke:** `superpowers:writing-plans` →
+  `docs/superpowers/plans/YYYY-MM-DD-<feature>.md`. Zero-context tasks, exact
+  paths, TDD steps, DoD each, dependency graph + parallel groups, non-overlapping
+  file ownership.
+- **GATE:** every spec requirement maps to a task; no placeholders; parallel-group
+  tasks share no files.
+
+## 5 — Dev (Opus)
+- **Invoke:** `superpowers:using-git-worktrees` (isolate) →
+  `superpowers:subagent-driven-development` (or `superpowers:executing-plans`).
+  TDD per task (failing test → minimal impl → green → commit). Pin subagents to Opus.
+- **GATE:** all plan tasks DONE (two-stage review: spec compliance, then code
+  quality); full test suite green.
+
+## 6 — Tests (Opus)
+- **What:** consolidate test coverage for the change: confirm new functionality
+  has tests (written test-first in stage 5), update/repair existing tests the
+  change touched, and add edge-case + failure-path tests per DoD.
+- **Invoke:** the host test runner (see `conventions.md` → *Lint + test*);
+  `superpowers:test-driven-development` for any uncovered gap.
+- **GATE:** the **full** suite is green (not just the new tests); new/changed code
+  is covered; no `skip`/`xfail` smuggling a red suite past the gate. Never advance
+  to deploy on a red or partial run.
+
+## 7 — Lint + deploy (host model)
+- Read host conventions (`conventions.md`): run the linter; fix failures. The suite
+  is already green from stage 6 — re-run it if code changed since. Then deploy per
+  the project's convention.
+- **GATE:** lint clean **and** suite green **before** deploy. Deploy is outward →
+  explicit operator go. Respect deploy-from-main rules if the project mandates them.
+
+## 8 — Post-deploy (host model)
+- Tail deploy logs / health-check per conventions. Confirm clean boot, no error
+  spike, live subsystems healthy.
+- **GATE:** clean boot confirmed, or an **honest degradation report** with next
+  steps — never silent success.
+
+## 9 — Docs + wiki (host model)
+- Update host module docs / runbooks per the project's self-update rules, in the
+  **same change**. Then sync knowledge to the wiki (`wiki-update` skill).
+- **GATE:** docs in sync with code; wiki synced; dangling links fixed.