The runner · pluggable

The orchestrator

Experimental — in force only when specline.yml setsunattended: true. Off by default; nothing here is checked or listed until you turn it on.

Between the two human gates, something has to drive an approved, unattendedspec to its acceptance checks on its own. That something is the runner — whatever it happens to be. The key word iswhatever: Specline defines the loop's contract and checks that a spec carries its inputs. It does not build the runner. The runner is pluggable.

▲

Specline owns the contract, not the runner. A capable model runs a single spec itself (an agent plus a thin loop harness like /loop); a fuller external runner handles what one model can't do for itself — fresh-context re-entry, parallel builds across the decider budget, model-tier routing, and fresh-context verifier subagents.

What it runs

The build loop, defined in the canon. It's two loops, one nested in the other. The inner loop is mechanical: the implementer against the provable (agent-loopable) checks. One iteration:

the inner loop

resume from status.md (last green checkpoint)
  → work toward the Goal
  → run the agent-loopable acceptance checks   # the mechanical exit
  → red→green? record a new green checkpoint
     else        burn a loop_budget cycle
  → repeat, until checks pass or a boundary fires

The outer loop wraps it: a fresh-context verifier subagent against the judgeable checks — the ones settled by judging against a named spec section, no command to run. It carries its own small bounce budget (review_rounds_before_human) and gates the hand-off to the human. It never holds up the inner loop.

Specline validates the shape; the runner reads it

The split is clean. Specline checks that the spec carries the four loop inputs and that they're well-shaped. The runner reads them and acts. Neither does the other's job.

Loop input	Specline (validates shape)	orchestrator (consumes)
Goal — the target	Goal heading present (advisory)	converges toward it
Agent-loopable checks — the exit	agent-loopable label present; optional run suffix syntax checked	runs them each iteration
status.md — memory	required sections + entries	resumes from / appends to it
loop_budget / stale_after — autonomy	well-formed values	counts cycles / clock; escalates
blast_radius / target_model — routing	allowed values	selects model effort + reviewer depth

Where it stops

The runner hands control back to a human gate at the first of: loop_budgetexhausted (no progress), stale_after reached (too much time), or a true gate — a destructive action, a real scope change, or input only the PO can give. It never quietly extends a boundary and never edits an approved spec without a decider-approved amendment commit. It speaks through artifacts and status.md, not a reasoning transcript.

See the handbook's How agents build and unattended escalation discussion for the narrative, and /spec.md § The build loop for the normative contract.