pipeline

Skill: Pipeline

Objective

Take a feature from idea to verified change by chaining the six squad skills into one auto-executed sequence: brainstorm → grillme → tasks → next → implement → review.

The pipeline is an executor with explicit gates (v1.5+). It (1) reconstructs how far the feature has progressed from the conversation context, (2) auto-invokes the next sub-skill via the Skill tool, and (3) halts at each phase boundary to ask the user whether to proceed. The user fires ONE entry command and answers inline gate questions; no re-typing slash commands between phases.

Position in the workflow:

• The six skills run standalone when you want one step.
• /squad:pipeline runs them as an executed sequence for a feature going cradle-to-grave, so the user never has to copy-paste a slash command between phases.

Inviolable Rules

1. No telemetry of its own. The pipeline is an orchestration skill. It MUST NOT call record_run. Every sub-skill it invokes already records its own run; a "pipeline run" is not a tracked entity. /squad:stats aggregates the sub-runs — that is the pipeline's telemetry, by composition. (The thin .squad/pipeline-state.json resume cache from Rule 3 is NOT telemetry — it is per-feature state for resume only and never feeds /squad:stats.)
2. Auto-execution between explicit gates. Pre-v1.5 the pipeline only recommended commands and the user typed them. From v1.5 the pipeline invokes sub-skills directly via the Skill tool, but ONLY between explicit user-decision gates. Every phase boundary is a halt with an AskUserQuestion (proceed / adjust / skip / exit); sub-skills' own internal gates (e.g. /squad:implement Gate 1 plan approval, Gate 2 Blocker halt) keep firing as before. The pipeline never silently advances past a gate. The reserved interruption commands (see "Reserved commands" below) let the user break out at any point.
3. State persistence is a thin resume cache, not a journal. From v1.5+ the pipeline writes a minimal .squad/pipeline-state.json so the user can resume across context compaction or a closed session. The file carries phase status + 1-line outcomes only — NO full sub-skill outputs, NO secrets, NO conversation transcripts. File mode 0o600, single-writer (only the pipeline writes), gitignored. On every /squad:pipeline invocation the pipeline reads this file FIRST, then falls back to scanning conversation context for anything the file does not cover. See "State persistence" section below for schema + lifecycle.
4. No git commit, no git push. Read-only git for context is fine. Sub-skills own their own writes; the user owns commits.
5. Never edits source code directly. The pipeline only invokes sub-skills and prints inter-phase gate text. The sub-skills it invokes do the building.
6. No AI attribution in anything the pipeline prints. Consistent with the squad-wide commit-authorship rule.