The runner · pluggable

The orchestrator

Between the two human gates, something has to drive a signed spec to its acceptance checks on its own. That something is the runner — whatever it happens to be. The key word is whatever: 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	present & falsifiable-shaped	converges toward it
Agent-loopable checks — the exit	runnable command present	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_budget exhausted (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 a ratified spec. It speaks through artifacts and status.md, not a reasoning transcript.

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