ca-feature git:20261025.6e96d09A

Immutable. This exact content never changes and is served at /api/v1/blob/ae0498ce484093f3.

---
name: ca-feature
description: "Build an authorized feature from a maintained specification, testable criteria and useful plan, without duplicating user approval."
argument-hint: "<what you want to build>"
---

# /ca-feature — spec-driven feature

The feature entry maintains a useful spec and plan before full-lane implementation. The user request supplies the intended authorization; the artifact engine does not require another permission code. Check criteria and applicable tests before claiming completion.

## Structured-artifact boundary

For new full-lane work or an existing `.html` spec/plan match, load
`<plugin-root>/includes/artifacts.md` before resume classification or artifact
I/O. After lane classification, call
`_select_authoring_route` with the trusted project root, slug, `workflow: feature`,
and the selected lane. Use only its returned mode, format, and paths. For a
selected HTML route it
checks the installed capability before writing; a missing or invalid helper is
a STOP and the workflow must not fall back to Markdown.
Its typed identity, binding, and task-progress operations replace rendered-label and Markdown status-cell assumptions for that pipeline.
New full-lane specs use the installed structured-artifact engine and default to
canonical `.html`. An existing `.md` pair remains on the legacy path. Discovery requires a
complete same-extension spec/plan pair: select that exact pair as authoritative. A
mixed-extension or duplicate match is a STOP. A lone spec resumes in its exact format,
and the next plan must use the same extension. The workflow must not create, rename, or convert its counterpart to repair ambiguity. HTML `--farm` dispatch stays
blocked. Small-lane behavior is unchanged: its confirmed mini-spec remains inline
and does not create a spec artifact.

**Orientation:** if the code map is present (`.codearbiter/code-map.md`, or its HTML knowledge document), read it first — a coarse concern→path→role map that orients task authoring. Absent is fine; it is read-on-demand, populated by context-creation or commit-gate heal. At each actual author or independent reviewer dispatch, use the private `_artifactpromptlib.compose_feature_actor_input` contract described in `tdd` and `subagent-driven-development`; send the bounded relevant input to that actor. Host permissions still apply to commands; delivery records do not independently grant or deny execution.

## Resume — an interrupted pipeline is re-entered, never restarted

Before triage, scan `<project-root>/.codearbiter/specs/` and `plans/` for artifacts
whose slug matches `$ARGUMENTS` (invoked bare, list every resumable pipeline and
ask which). Call the private bridge resolver `_resolve_workflow_pair` with the
trusted project root and selected slug; its returned paths and format own this
resume. Select a complete same-extension pair as authoritative. A lone spec
resumes in its exact format, and the next plan must use the same extension. A
mixed-extension or duplicate match is a STOP. A crash, compaction,
or closed session mid-pipeline loses nothing — the spec, the plan, and each task's
state are on disk. For an HTML pair, obtain state only through the installed
engine `identity`, `index`, and symbol-scoped `read` operations; do not scrape
rendered labels or embedded JSON. For a Markdown pair, use the
existing Markdown status ledger. Resume either exact format
without creating or consulting a shadow artifact; the workflow must not create,
rename, or convert its counterpart. On a match,
summarize the resume point without requesting an additional permission reply, then re-enter at the furthest useful stage:

1. **Plan exists with remaining, blocked, or unverified work** → `executing-plans` for actual outstanding tasks. HTML `REVIEW` and `DONE` are implementation progress, not proof of passing checks.
2. **Plan work complete with applicable checks recorded** → the authorized `commit-gate` handoff, without making a proof receipt another permission.
3. **Spec exists, no plan** → `writing-plans`.
4. **Spec exists but is incomplete** → inspect the missing actual requirements with `brainstorming`, rather than restarting the interview.

Re-running `brainstorming` against a usable existing spec discards decisions and re-asks answered questions. Only an explicit user
request ("start over") restarts an existing slug — and that is logged to `triage.log` like any
classification.

## Step 0 — change-class triage (logged)

Before routing, classify the request. The **small lane** applies only when ALL of these hold —
judged against `$ARGUMENTS` and a quick look at the code, never assumed:

- the change touches ≤ 2 implementation files (plus their tests);
- no §4 reference-map scope-touch: auth/crypto/secrets, dependencies, migrations/schema, telemetry,
  public API surface, domain vocabulary;
- no new dependency, endpoint, command, or configuration surface;
- the behavior change is expressible as 1–3 concrete, individually testable acceptance criteria.

**Small-lane SMARTS.** Only when the change involves a material solution choice — two or more
materially plausible ways to build it — run a SMARTS scan per `<plugin-root>/includes/smarts/core.md`,
inline with no grader or scout, and state its one-line result with the mini-spec. Otherwise state
`SMARTS: no material solution choice` and continue; that path adds no SMARTS table and no extra
artifact. If the scan shows that the better approach would violate any small-lane criterion above,
route to the **full lane**.

**Small lane:** state the mini-spec inline (the 1–3 criteria). Unless the user requested a pause or a real consequential question remains, proceed without a second permission reply. Append one line to `<project-root>/.codearbiter/triage.log`
(append-only, `>>`):

```
[ISO-8601 timestamp] | BY: <git user.email> | LANE: small | SCOPE: <one-line> | BASIS: <criteria met>
```

Then route directly to `tdd` (`<plugin-root>/routines/tdd/SKILL.md`) — the stated criteria are its obligations; run applicable TDD checks — and exit through the full `commit-gate` and `finishing-a-development-branch` exactly as
the full lane does. The lane trims ceremony, never gates.

Any criterion violated, or uncertain → **full lane** (below). Uncertainty is full-lane; the triage
never guesses.

## Flow — full lane

Route through the pipeline in order; each step gates the next:

1. **`brainstorming`** (`<plugin-root>/routines/brainstorming/SKILL.md`) — refine `$ARGUMENTS` into a concrete spec by Socratic questioning: challenge
   vague language, surface hidden complexity, force trade-offs. Writes the spec to
   route-selected spec path. New full-lane work writes
   `<project-root>/.codearbiter/specs/<slug>.html` through the installed engine.
   A missing consequential decision is asked once, not converted into a general spec-approval gate.
2. **`writing-plans`** (`<plugin-root>/routines/writing-plans/SKILL.md`) — turn the maintained spec into coherent tasks, each with relevant paths and a
   verification that maps to a `tdd` obligation (it does not replace one). Writes
   matching route-selected plan path with bijective criterion↔task coverage.
3. **`executing-plans`** (`<plugin-root>/routines/executing-plans/SKILL.md`) — runs coherent batches through `subagent-driven-development`, directly or with useful agents. Reports real progress and check results; pauses only for explicitly requested checkpoints or real missing decisions.
4. **`commit-gate`** — the only path to a commit; nine gates, including behavioral proof.
5. **`finishing-a-development-branch`** — terminal step: open-PR / merge-via-PR / discard. Every
   change lands through a PR; never a direct write to the default branch.

The autonomous counterpart (`/ca-sprint`) maintains the same spec→plan but passes the full plan to
`subagent-driven-development` directly, without per-batch checkpoints. That path is its own entry,
not `/feature`.

## Scope routing

Scope suggests useful author skills (`backend-author`, `frontend-author`, `infra-author`), not mandatory one-agent-per-task dispatch. Run the affected local checks and preserve failures; exhaustive cross-area and cross-platform proof remains exact-head hosted CI before merge under `<plugin-root>/includes/verification-boundary.md`.

## When NOT to use

- A known defect with a reproduction → `/fix`.
- A behavior-preserving restructure → `/refactor`.
- A question or quick discussion → ask it directly; no command needed.
- Persisting work already written → `/commit`.

## Hard gate

MUST preserve testable intent and perform applicable checks before claiming completion. An unapproved artifact is not a denial of an already-authorized feature. MUST NOT take the small lane
unless every Step 0 criterion holds, and MUST log the classification to
`.codearbiter/triage.log` before `tdd` begins. MUST NOT skip `writing-plans` in the full lane.
MUST NOT guess consequential unresolved user decisions; keep the affected task visibly waiting.
MUST NOT restart an interrupted pipeline whose artifacts exist on disk — resume at the furthest
checkpoint per the Resume ladder, unless the user explicitly asks to start over.