AI Cycle

Two halves, and a person between them

Not an engine. Each stage is a skill with its own file; load that file and follow it, the way the generated slash command already says. There is no state file, no new verb and nothing here that decides anything a stage would not decide on its own.

What it produces

Half one ends with the brief page a person decides on — docs/solution-intent.html, regenerated by ai-eng report intent --html. Half two ends with the green gate output, shown in the conversation, or with a page that says exactly why it is not green.

First half — up to the person

/ai-cycle <what you want>

The order of the halves is data, not prose here: read policy/skill-sequence.toml and follow it. First half — research, then spec, then challenge, then council, then a brief published as a page: what is proposed, what was refuted, what is missing, and what it costs. Then stop.

Stopping is the whole of this half. ai-eng report blocked already lists a drafted specification nobody has approved, so the halt exists and fires; this hands the person the thing they need to decide instead of a status line. The approval is a record with the specification's exact digest in it, and until that record exists the second half has nothing to run against — the task envelope refuses outright when the bytes moved.

Second half — after them

/ai-cycle build <NNN>

The same map's second half, in order, once an approval record carrying the specification's exact digest exists — the map's [gate] section is the line between the halves. Inside ai-build, run one task at a time through ai-eng spec show <NNN> --task <n>: two kilobytes, not the whole plan. Where the plan's order allows two tasks at once and the host can start two agents, start two; where it cannot, do them in turn. The critics — review, verify, security — run each in its own context, then ai-eng audit verify, then ai-ship.

When the gate goes red

It does not stop at the first red and it does not get to cheat.

• just stops at the first failing recipe, so a red gate has exactly one guilty recipe. An attempt is counted per task and failing recipe, never per message and never per gate run: counting messages would give one mistake that broke six tests twelve attempts, and counting runs lets somebody else's failure eat this task's budget.
• Before spending an attempt, run the same command again, unchanged, the way the gate runs it — in parallel, because a test that only fails in parallel fails where it matters. Green on the repeat spends nothing and is written down as non-determinism. Two of those notes on the same test in one build is not repair any more: escalate.
• Two attempts. Only a whole green gate resets the count. A recipe that went green and goes red again keeps its count — measured: one review went red three times in a row before passing, and resetting would have spent six attempts and never escalated.
• Never repair by silencing: no --no-verify, no suppression comment, no skip mark, no loosened bound, no raised ceiling. If the honest fix is a raised ceiling, that is the escalation, with the arithmetic.
• If the count cannot be read, treat the attempts as spent and escalate.
• Escalating means a page a person can act on: what failed, what was tried, what it would cost to fix properly. Never a terminal paragraph and never a silent stop.

What this is not

• "The stages are ceremony; the person wants the result" — the order is data, not prose, and the second half refuses to run until an approval record carrying the specification's exact digest exists.

Done when

Half one ends with a brief and no approval written by anybody here. Half two ends with a green gate whose output is shown, or with a page saying exactly why it is not green.