feature-build

name	feature-build
description	Phase 2 of the feature flow, standalone: implement the approved plan from the ft/N issue (or a directly-stated small build) with parallel implementers, a fast per-task typecheck gate, and deep review reserved for the foundational task. Use when the user says /feature-build, "build the plan", "implement the tasks", or "just build X" mid-flight on a feature branch.
argument-hint	[issue# | what to build]
allowed-tools	Bash(git *) Bash(gh *) Bash(pnpm *)
model	inherit

Build — autonomous, parallel by structure

Source of tasks: the current ft/<issue#> issue body (read via gh issue view) if it exists; otherwise the user's direct instruction is the plan (small-build mode — still one branch, still no scope creep beyond what they said).

Preflight

• Dependency preflight before any task: pnpm install; an unmet-peer warning on a feature-relevant package is a BLOCKER — stop and present (proven in #39: a green build hid a worker crash).
• Mirror tasks into TaskCreate, dependencies via addBlockedBy; the task graph decides concurrency.

Execution — implementer by default

• Every plan task → dispatch implementer (.claude/agents/implementer.md) once per task — including a single task (its model pin is the point: the session model plans and reviews, the implementer's cheaper pinned model writes the code). Unblocked tasks with disjoint files dispatch ALL in one message, same working tree. NO worktree isolation (it branches from the default branch).
• Inline in this session for any trivial mechanical task where writing the brief would exceed the diff — a rename, a one-line signature change, a mechanical sweep of a few call sites — plan task or user-dictated alike. The implementer's model pin pays off on real code; brief + dispatch + gate around a three-line edit is pure latency. When genuinely unsure whether a task is trivial, dispatch the implementer.
• Live mutual negotiation needed → agent team (disjoint file assignment; watch task-status lag).
• Massive mechanical sweep (rare) → Workflow, ≤10 agents TOTAL.

Briefs and reports

Each dispatched task gets .feature/task-<N>-brief.md (plan text verbatim + prior tasks' interfaces + report path). Thin dispatch prompt: scene line, brief path, the skills the plan names for that task + the .claude/rules/ area-guards it must read, report contract. The brief is the implementer's ONLY requirements source. Reports are deviations-only: the implementer writes .feature/task-<N>-report.md only when it deviated from the brief or noticed out-of-scope work (what + why); no report file means implemented-as-briefed.

Review — typecheck every task, deep-review only the foundational one

As a wave's implementers return, the SESSION (not the implementer) runs a fast typecheck gate: pnpm exec tsc --noEmit, then confirm no error line names any of that wave's own files. This catches the interface breaks a bad task propagates to dependents — a wrong signature, a missing export, a collapsed generic (all real; the last was a #59 build-breaker) — in seconds, not a multi-minute review. The branch as a whole may not typecheck until later waves land (a leaf task can reference a not-yet- written module) — that is expected; only the wave's OWN files must be clean before its dependents unblock.

Dispatch a full task-reviewer (brief path, commit range, report path if any) ONLY for the foundational task(s) — the one or two at the root of the dependency graph that the most downstream tasks build on. A subtle bug in a load-bearing interface is expensive to unwind after four tasks have built on it, so it earns a deep pre-dependency review; a leaf task does not. Every other task's deep correctness is caught by the QC review fan-out (/feature-qc), which sees the whole branch diff and is the effective net — per-task review of leaf tasks duplicates it more weakly while sitting on the critical path (measured on #59: the fan-out caught 14 issues, including a HIGH bug that every per-task review had passed). Fix any typecheck failure or foundational-review finding before dependents unblock. Everything converges into the feature branch as ordinary commits.

Hard rules

• Agents never push / branch / open PRs.
• Implementers write code only — no builds or lint (that's /feature-qc).
• ≤10 agents total per fan-out.
• Mid-flight new scope → append to the single living backlog issue via .claude/skills/feature/scripts/backlog-add.sh "<item; origin #<issue>; · agent if agent-surfaced>" (never a new per-item issue, never onto the branch). Scribe the user's deferral; don't self-initiate scope.
• Skill grounding is binding: name the skills the plan grounds each task in, plus the area's .claude/rules/ guards, in every dispatch.