ADR-0001.

Enforce declared rule-conformance at the gate

Date: 2026-07-07 Status: accepted Deciders: Thibault Souris (maintainer) Method: decision-loop — field-test reality-check against the code, doctrine cross-check (operator-role, when-to-use), challenge of the proposed remedies, durable position

Context

The force is an observed failure in a live end-to-end run of the method, not a hypothesis. A coding agent building a floor cited the craft rule frontier-deterministic-boundary in its ADR but shipped no grounding guard: a figure produced inside model prose reached the deliverable unchecked, violating a hard framing constraint ("no invented figure"). The floor still passed runward check green.

The cause is structural and confirmed in the code, and it recurs with any competent model:

The charter states rule application declaratively and globally. AGENTS.md says "apply the craft rules in runward/rules/ while building" — one imperative pointing at a whole directory, with no task-to-rule mapping and no reminder at the point of action. init writes the full text of all 51 rules to disk (impact levels: CRITICAL, HIGH, MEDIUM, LOW — 13/19/18/1), so the agent has the text; nothing routes the applicable rule to it while it builds. The build workflow (floor.md) routes zero rules.
runward check verifies deliverable presence, not rule conformance: it classifies a note as filled once it diverges from its template with few remaining placeholders. It never reads project code and runs nothing. Consequently, citing a rule and applying it are indistinguishable to the gate.

This is structuring, not local: it changes how every mission enforces its own craft discipline, and any remedy risks colliding with the founding bet — judgment concentrated in one accountable operator, "cheap in tooling, expensive in discipline", no deciding AI personas. The decision is taken at the method/tooling boundary (rule frontmatter schema, workflows, the check command, the charter), never inside a mission's domain.

Decision

Apply the doctrine's own default — bound the non-deterministic with the deterministic at the gate — by adding a deterministic conformance layer, governed by one invariant: the gate verifies the presence of a traced decision, never the quality of an implementation; no LLM sits anywhere in the gate path. The operator still owns the gate.

Four deterministic pieces:

Phase-to-rule mapping. CRITICAL/HIGH rules declare an additive phases: frontmatter field (e.g. phases: [floor, govern]). It is surfacing, never masking: it says where a rule applies; MEDIUM/LOW stay advisory. This is the coarse, deterministic form of routing — the phase is already the unit check works in. Finer per-task triggers are deferred until evidence demands them.
Conformance manifest. Build-phase deliverables (starting with floor.md) carry a Rule conformance table: one row per mapped CRITICAL/HIGH rule, status applied | deviated | n/a. applied requires a non-empty evidence pointer (file:line or a test); deviated requires a reference to an existing ADR; n/a requires a one-line reason.
runward check --strict (opt-in). A deterministic pass verifies the manifest is complete and well-formed: every mapped CRITICAL/HIGH rule has a row, every applied carries a pointer, every deviated resolves to an ADR file that exists, every n/a carries a reason. It never opens project code, never runs tests, never judges whether the pointer truly implements the rule. Default check is unchanged, so this is non-breaking; the operator opts into the stricter gate.
Rule confrontation at the point of action. Build workflows and the generated /rw-* commands name the phase-routed rules and instruct the agent to read them before building and account for each in the manifest. Verbatim text injection is a later refinement, on evidence.

The manifest does not stop an agent from citing without applying; it makes that a visible, located lie the operator catches at the gate — an unbacked applied, a dangling deviated, or a missing row turns green into red.

Alternatives discarded

Do nothing, rely on the charter's declaration. The field test is the disproof: it fails by default, even with a willing model that had the rule text in hand.
An auto-blocking quality gate (an LLM or heuristic that fails the build on a "bad" artifact). Discarded — it violates "the operator owns every gate" and turns Runward into "a framework that decides for you", the exact anti-pattern named in when-to-use.md.
An LLM-judge review as the safety net (a runward review that scores cite-vs-apply). Discarded as pillar and as gate. It reintroduces the machine persona the doctrine excludes ("judgment is concentrated in you"), it is non-deterministic, and review.md itself flags judge-model bias as a hazard. Its real danger is drift: an "advisory" opinion becomes the de-facto gate and reproduces this very incident. Tolerable only strictly outside the exit-code path, never blocking — and not the answer here.
Drastically cutting the rule set. Discarded — it discards captured craft. The problem is activation and routing, not volume.

Consequences

Positive: rules get applied, not merely cited; compliance theater becomes catchable at the gate; the operator judges on a real, located signal; cognitive load shifts from "hold 51 rules in mind" to "account for the few that fired on this phase". The tooling finally implements, at the gate, the doctrine it ships.
Negative, accepted: more tooling than Runward's minimalist default prefers — accepted only because each piece serves the operator's gate or the agent's between-gate fidelity, and none decides. The phases: mapping must be kept honest; the manifest adds a writing step per build deliverable; --strict adds a parser and a code path to maintain.
On other boundaries: the rule frontmatter schema evolves (versioned, additive — per contracts-governance); check gains a --strict mode and a manifest parser; AGENTS.md is updated so the charter names the build-time confrontation and the manifest; doctor and the smoke test cover the new field and mode.

Reevaluation trigger (mandatory, dated)

Reopen if any of:

(a) cited-not-applied incidents persist above an agreed threshold despite the layer — activation is insufficient; tighten routing/injection.
(b) operators rubber-stamp --strict green without reading the pointers — judgment has silently migrated from the human to the tool, contradicting the founding bet; re-tighten toward the operator (e.g. require a pointer to resolve to an existing file:line — still deterministic).
(c) the phases: mapping produces false negatives — a CRITICAL/HIGH rule that should have fired on a phase was not mapped.

Trigger set on: 2026-07-07 · Watched via: an incident log of rule-conformance failures, plus a periodic charter/doctrine review.

References

docs/operator-role.md — the operator owns every gate; the method constrains the agent, not the reverse.
docs/when-to-use.md — "cheap in tooling, expensive in discipline"; "not a framework that decides for you".
templates/rules/frontier-deterministic-boundary.md — the rule the incident violated (the model writes prose, the program owns the facts; the guard fails closed).
templates/workflows/review.md, templates/workflows/decision-loop.md — one architect wearing five hats; judgment not distributed across autonomous personas.
Architectural Decision Records — https://adr.github.io/

← Tous les ADR