devrites 3.0.5 → 3.0.6

package/pack/generated/codex/skills/rite-seal/SKILL.md

@@ -11,13 +11,13 @@ This is the Codex mirror of a DevRites skill. In Codex:
 
 - Load DevRites engineering standards from `.agents/skills/devrites-lib/reference/standards/`. Read `.agents/skills/devrites-lib/reference/standards/core.md` before workflow work, then load the other `.agents/skills/devrites-lib/reference/standards/*.md` files exactly when this skill asks for them.
 - Use the installed `devrites-engine` binary as the canonical runtime helper surface for orientation, gates, and state mutation.
-- When this skill asks for a DevRites specialist or writer agent, **explicitly** spawn the matching Codex custom agent from `.codex/agents/devrites-*.toml` through Codex subagents (`spawn_agent`), then wait for its result and reconcile it as the skill instructs. Do not do the review inline just because the instruction to spawn is embedded here — Codex under-fires embedded spawn/skill instructions (openai/codex #23496), so treat the spawn as required, not optional.
-- The independence of a fresh-context subagent is the point. If Codex genuinely cannot spawn subagents in the current surface, run the documented inline fallback and **label the result an inline fallback, not an independent review** — an inline pass shares the calling context and is weaker evidence.
+- When this skill asks for a DevRites specialist or writer agent, **explicitly** spawn the matching Codex custom agent from `.codex/agents/devrites-*.toml` through Codex subagents (`spawn_agent`), then wait for its result and reconcile it as the skill instructs. Do not do the review inline just because the instruction to spawn is embedded here: Codex under-fires embedded spawn/skill instructions (openai/codex #23496), so treat the spawn as required, not optional.
+- The independence of a fresh-context subagent is the point. If Codex genuinely cannot spawn subagents in the current surface, run the documented inline fallback and **label the result an inline fallback, not an independent review**: an inline pass shares the calling context and is weaker evidence.
 - Codex project hooks are installed in `.codex/hooks.json`. Review and trust them with `/hooks` before relying on hook enforcement.
-- When this skill asks a HITL question via `AskUserQuestion`: Codex's equivalent (`request_user_input`) exists only in Plan mode. Outside Plan mode, render the option set as a plain numbered list in chat and **end the turn** so the human answers — NEVER silently pick an option yourself; auto-picking is AFK's contract, gated by the `.devrites/AFK` sentinel.
+- When this skill asks a HITL question via `AskUserQuestion`: Codex's equivalent (`request_user_input`) exists only in Plan mode. Outside Plan mode, render the option set as a plain numbered list in chat and **end the turn** so the human answers: NEVER silently pick an option yourself; auto-picking is AFK's contract, gated by the `.devrites/AFK` sentinel.
 
 
-# $rite-seal — GO / NO-GO
+# $rite-seal: GO / NO-GO
 
 The decision gate before shipping. **Read the active workspace first**; if none, tell
 the user to run `$rite-spec <feature>`. Produces `seal.md` with a clear verdict.
@@ -25,24 +25,24 @@ the user to run `$rite-spec <feature>`. Produces `seal.md` with a clear verdict.
 live in `$rite-ship`, which refuses to run without a GO recorded here.
 
 ## Rules consulted (read on demand from `.agents/skills/devrites-lib/reference/standards/`)
-**Step 0:** Read `.agents/skills/devrites-lib/reference/standards/core.md` first. The other rule files load on demand —
+**Step 0:** Read `.agents/skills/devrites-lib/reference/standards/core.md` first. The other rule files load on demand:
 pull these via `Read` before sealing:
-- `agents.md` — review-subagent fan-out at seal.
-- `code-review.md` — severity labels (Critical / Important / Suggestion / Nit / FYI).
-- `review-checklist.md` — compact final review pass/fail sweep.
-- `test-proof-checklist.md` — compact proof-quality gate for tests and evidence.
-- `browser-proof-checklist.md` — for UI scope, the browser-state and Visual Verdict gate.
-- `security-checklist.md` — when input / auth / data / integrations / secrets are in scope.
-- `principles.md` — declared project invariants (`.devrites/principles.md`) are a pass/fail gate; a diff that violates one with no recorded, human-approved exception is a NO-GO.
-- `documentation.md` — record decisions in `decisions.md` before sealing.
-- `observability.md` — a runtime surface that ships blind is an Important finding.
-- `deprecation.md` — when the diff removes / migrates code, API, or data (read with the
+- `agents.md`: review-subagent fan-out at seal.
+- `code-review.md`: severity labels (Critical / Important / Suggestion / Nit / FYI).
+- `review-checklist.md`: compact final review pass/fail sweep.
+- `test-proof-checklist.md`: compact proof-quality gate for tests and evidence.
+- `browser-proof-checklist.md`: for UI scope, the browser-state and Visual Verdict gate.
+- `security-checklist.md`: when input / auth / data / integrations / secrets are in scope.
+- `principles.md`: declared project invariants (`.devrites/principles.md`) are a pass/fail gate; a diff that violates one with no recorded, human-approved exception is a NO-GO.
+- `documentation.md`: record decisions in `decisions.md` before sealing.
+- `observability.md`: a runtime surface that ships blind is an Important finding.
+- `deprecation.md`: when the diff removes / migrates code, API, or data (read with the
   risk-and-rollback step below).
-- `definition-of-done.md` — standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
+- `definition-of-done.md`: standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
 
 
 ## Operating rules
-- Evidence over confidence — a criterion is met only if evidence proves it.
+- Evidence over confidence: a criterion is met only if evidence proves it.
 - Spec Drift Guard applies: unresolved drift is a NO-GO.
 - **Honest verdict.** DO NOT round a NO-GO up to GO to be agreeable.
 
@@ -56,15 +56,15 @@ Read `review.md` and the latest reviewer outputs.
 | `Critical == 0` and `Important > 0` and acceptance proven and drift resolved | Render interactive prompt: *"`Important > 0` open. Proceed to seal? [y/N]"*. Default **N**. If the user types `y`, GO; otherwise NO-GO with the open Important findings listed as blockers-by-policy. |
 | `Critical > 0` | **NO-GO**, no exceptions. List every Critical with `file:line` and fix direction. |
 | Any acceptance criterion unproven, any bespoke `Prohibitions (must-NOT)` `resolved/test` row lacking linked proof, or any `plan.md` Key links row with no covering `EVID-###` wiring check (built-but-not-wired; `none declared` → n/a) | **NO-GO**, list the unproven criteria/prohibitions/links. |
-| Any criterion tagged `proof: judgment` in `evidence.md` (untagged reads `judgment`) | Judgment proof needs a human eye. HITL: enumerate them in the verdict digest — the human's GO covers them. AFK: **no auto-GO** — append a `gate: validating` question listing them and stop. |
-| Fan-out roster incomplete — `devrites-engine footprint roster` rc=3 (a reviewer neither dispatched nor skip-recorded) | **NO-GO** on the review's *completeness*, not a verdict on the diff: dispatch the missing reviewer or record a justified skip, then re-seal. Same standing as an unproven criterion. |
-| Silent review axis — `devrites-engine review-integrity` rc=1 (an adversarial axis in `review.md` reported nothing and justified nothing) | **Important** — a suspected rubber-stamp, on the review's *completeness* not the diff. Re-run that axis or record its `No-findings:` justification (`code-review.md` § Zero findings is suspicious), then re-seal. |
-| A declared extension check unaddressed — a valid `.devrites/extensions/*/component.yaml` declares `checks: at: seal` and `seal.md` records neither the check's outcome nor a skip justification | **Important** — same standing as a silent axis, on the review's *completeness*. Address the check's instruction or record why it doesn't apply, then re-seal. Checks are additive-only (an extension raises the bar, never lowers it); an extension that fails `extensions validate` has inactive checks — not a blocker. |
-| Visual Verdict `FAIL` on an acceptance-mapped UI criterion (`browser-evidence.md`) | **NO-GO** — an unmet acceptance criterion. A declared-state `FAIL` is Important (the `Important > 0` row). UI build with a `design-brief.md` but no Visual Verdict → Important evidence gap. No brief → not applicable. |
+| Any criterion tagged `proof: judgment` in `evidence.md` (untagged reads `judgment`) | Judgment proof needs a human eye. HITL: enumerate them in the verdict digest: the human's GO covers them. AFK: **no auto-GO**: append a `gate: validating` question listing them and stop. |
+| Fan-out roster incomplete: `devrites-engine footprint roster` rc=3 (a reviewer neither dispatched nor skip-recorded) | **NO-GO** on the review's *completeness*, not a verdict on the diff: dispatch the missing reviewer or record a justified skip, then re-seal. Same standing as an unproven criterion. |
+| Silent review axis (`devrites-engine review-integrity` rc=1 (an adversarial axis in `review.md` reported nothing and justified nothing) | **Important**) a suspected rubber-stamp, on the review's *completeness* not the diff. Re-run that axis or record its `No-findings:` justification (`code-review.md` § Zero findings is suspicious), then re-seal. |
+| A declared extension check unaddressed (a valid `.devrites/extensions/*/component.yaml` declares `checks: at: seal` and `seal.md` records neither the check's outcome nor a skip justification | **Important**) same standing as a silent axis, on the review's *completeness*. Address the check's instruction or record why it doesn't apply, then re-seal. Checks are additive-only (an extension raises the bar, never lowers it); an extension that fails `extensions validate` has inactive checks, not a blocker. |
+| Visual Verdict `FAIL` on an acceptance-mapped UI criterion (`browser-evidence.md`) | **NO-GO**: an unmet acceptance criterion. A declared-state `FAIL` is Important (the `Important > 0` row). UI build with a `design-brief.md` but no Visual Verdict → Important evidence gap. No brief → not applicable. |
 | Diff violates a declared project principle (`.devrites/principles.md`) with no recorded, human-approved exception | **NO-GO**, list each violated principle with `file:line`. Same standing as an unproven criterion (absent / empty file → none declared → not a blocker). |
 | Unresolved drift in `drift.md` | **NO-GO**, route through `$rite-plan` first. |
-| Any `questions.md` entry with `gate: validating` and `status: open` | **NO-GO** regardless of behavior impact — an open validating gate is merge-blocking by definition. A slice marked `built (pending review)` is not done. |
-| A stood decision (boundary / data-model / auth / public-API / migration / branching) in the `decisions.md` `## Decisions stood` ledger with no recorded `devrites-doubt` verdict — `doubt: MISSING` / `doubt-coverage` rc=3 | **Important** — **NO-GO** when the undoubted decision is irreversible-risk (auth / public-API / migration), the same standing as an unproven acceptance criterion. Severity rides the unverified **decision**, not the exit code: `doubt-coverage` rc=1 (zero doubt dispatched) is a **prompt to verify**, not itself a finding — confirm against the ledger, where every-slice-trivial (`- none`) passes and a skipped triggering decision is the finding. |
+| Any `questions.md` entry with `gate: validating` and `status: open` | **NO-GO** regardless of behavior impact: an open validating gate is merge-blocking by definition. A slice marked `built (pending review)` is not done. |
+| A stood decision (boundary / data-model / auth / public-API / migration / branching) in the `decisions.md` `## Decisions stood` ledger with no recorded `devrites-doubt` verdict: `doubt: MISSING` / `doubt-coverage` rc=3 | **Important**. **NO-GO** when the undoubted decision is irreversible-risk (auth / public-API / migration), the same standing as an unproven acceptance criterion. Severity rides the unverified **decision**, not the exit code: `doubt-coverage` rc=1 (zero doubt dispatched) is a **prompt to verify**, not itself a finding: confirm against the ledger, where every-slice-trivial (`- none`) passes and a skipped triggering decision is the finding. |
 | `devrites-engine docs-stale` warns that user-facing CLI/API/install/docs-referenced code changed without README/docs updates | **FYI** unless the spec promised docs or users need docs to satisfy acceptance; then escalate to Important. |
 | Outside voice (`devrites-engine outside-voice`) is unavailable in `auto` mode | Advisory only; record `outside-voice: skipped-unavailable`. Disabled mode records `outside-voice: disabled`. |
 
@@ -78,8 +78,8 @@ devrites-engine outside-voice; echo "outside-voice rc=$?"
 If outside voice is `available`, ask the same artifacts/diff second opinion;
 findings stay advisory until verified with line quotes or accepted into the normal review pipeline.
 If `.devrites/extensions/` exists, read each valid extension's `component.yaml` for `checks:
-at: seal` entries and record every declared check's outcome (or skip justification) in `seal.md`
-— the severity gate treats an unaddressed one as Important.
+at: seal` entries and record every declared check's outcome (or skip justification) in `seal.md`.
+The severity gate treats an unaddressed one as Important.
 For developer-facing surfaces, compare `devex.md` predicted TTHW against the measured proof path and
 record the boomerang result.
 
@@ -91,17 +91,17 @@ review-integrity, verdict, convention, and learning steps for this gate.
 ## On GO → hand off to $rite-ship
 
 `$rite-seal` makes the **decision** and stops. It does **not** run `git commit`,
-`git push`, `git tag`, publish, or deploy — those moved to `$rite-ship`, which renders
+`git push`, `git tag`, publish, or deploy. Those moved to `$rite-ship`, which renders
 the type-GO prompt and refuses to run without a GO recorded here. Keeping the decision
 and the irreversible action as two separately-auditable steps is the point: a GO seal
 is a verdict, not an authorization to push.
 
 On **GO**: write `seal.md`, set `state.md` `Next step: $rite-ship`, and tell the user
-the feature is cleared to ship. Do **not** set phase `done` — `$rite-ship` marks done
+the feature is cleared to ship. Do **not** set phase `done`: `$rite-ship` marks done
 after the task is shipped and archived. The `Important > 0` interactive y/N earlier in
 the gate is the one off-ramp seal still owns; the type-GO off-ramp now lives in ship.
 For a **UI feature**, note in the hand-off that `$rite-ship` offers an optional
-**design-memory** rollup — persist this feature's proven design language into a project
+**design-memory** rollup: persist this feature's proven design language into a project
 `DESIGN.md` so later features inherit it (`../rite-ship/reference/design-memory.md`).
 
 ## Output

package/pack/generated/codex/skills/rite-seal/reference/anti-patterns.md

@@ -1,8 +1,8 @@
-# rite-seal — anti-patterns
+# rite-seal: anti-patterns
 
 Load this when standing the final GO/NO-GO decision, or when tempted to round
 NO-GO up to GO. (The irreversible push/tag/deploy and its type-GO gate now live in
-`$rite-ship` — see that skill's anti-patterns for the type-GO discipline.)
+`$rite-ship`: see that skill's anti-patterns for the type-GO discipline.)
 
 Pack-wide rationalizations + red flags (incl. user-wants-it-bypass-gate):
 see [standards/anti-patterns.md](../../devrites-lib/reference/standards/anti-patterns.md).
@@ -11,12 +11,12 @@ see [standards/anti-patterns.md](../../devrites-lib/reference/standards/anti-pat
 
 | Excuse | Rebuttal |
 |---|---|
-| "All Important findings are minor; just GO." | `Important > 0` triggers an interactive y/N — do not bypass the prompt, present it. |
+| "All Important findings are minor; just GO." | `Important > 0` triggers an interactive y/N: do not bypass the prompt, present it. |
 | "User clearly wants this to ship." | Ship is evidence-driven, not consent-driven. A Critical finding outranks "the user said go". |
 | "Drift is small; resolve it inline and seal." | Unresolved drift = NO-GO, no exceptions. Route through `$rite-plan` to repair, then seal. |
-| "Reviewer findings overlap; average them away." | Surface disagreements explicitly. Averaging hides where the reviewers actually disagree. |
-| "Carry the old reviewer verdicts though the diff changed." | If the diff changed since `$rite-review`, re-run the Spec + Code axes — don't carry stale verdicts forward. |
-| "Build never doubted a decision, but the wright seemed confident — GO without checking." | Doubt is a gate, not a vibe. `doubt-coverage` rc=1 — or a stood boundary / data-model / auth / public-API / migration decision in `decisions.md` with no recorded `devrites-doubt` verdict — is an Important finding, escalating to NO-GO when the undoubted decision is irreversible-risk (auth / public-API / migration). An empty `Decisions stood` on every slice passes only when confirmed against `decisions.md`, never assumed. |
+| "Reviewer findings overlap; average them away." | Surface disagreements explicitly. Averaging hides where the reviewers disagree. |
+| "Carry the old reviewer verdicts though the diff changed." | If the diff changed since `$rite-review`, re-run the Spec + Code axes: don't carry stale verdicts forward. |
+| "Build never doubted a decision, but the wright seemed confident. GO without checking." | Doubt is a gate, not a vibe. `doubt-coverage` rc=1 (or a stood boundary / data-model / auth / public-API / migration decision in `decisions.md` with no recorded `devrites-doubt` verdict) is an Important finding, escalating to NO-GO when the undoubted decision is irreversible-risk (auth / public-API / migration). An empty `Decisions stood` on every slice passes only when confirmed against `decisions.md`, never assumed. |
 
 ## Red Flags
 
@@ -25,5 +25,5 @@ see [standards/anti-patterns.md](../../devrites-lib/reference/standards/anti-pat
 - Reviewer subagents spawned with the author's reasoning attached (defeats the fresh-context point).
 - `seal.md` written before walking *every* acceptance criterion one by one.
 - A NO-GO rounded up to GO "to be agreeable".
-- Unresolved drift, unresolved questions, or pending tasks — and you're sealing anyway.
-- `doubt-coverage` rc=1 left unexamined, or a stood irreversible-risk decision (auth / public-API / migration) carrying no recorded `devrites-doubt` verdict — and you're sealing GO anyway.
+- Unresolved drift, unresolved questions, or pending tasks, and you're sealing anyway.
+- `doubt-coverage` rc=1 left unexamined, or a stood irreversible-risk decision (auth / public-API / migration) carrying no recorded `devrites-doubt` verdict, and you're sealing GO anyway.

package/pack/generated/codex/skills/rite-seal/reference/conventions-ledger.md

@@ -1,6 +1,6 @@
 # Recording proven conventions (the ledger, on GO)
 
-Loaded on demand by `$rite-seal` step 9. On a **GO** seal — and only then — promote the
+Loaded on demand by `$rite-seal` step 9. On a **GO** seal (and only then) promote the
 durable project conventions this feature *proved* into the local conventions ledger
 (`.devrites/conventions.md`). Orient reads it on later slices so the wright stops
 re-deriving the same idioms every time.
@@ -11,14 +11,14 @@ The discipline mirrors DevRites' whole thesis: a convention is not "learned" unt
 ## What to promote
 
 Durable, reusable facts about *this codebase* that a future slice would otherwise
-re-discover — each as one entry:
+re-discover: each as one entry:
 
-- **Commands** — the real build / test / typecheck / lint commands and how tests are run
+- **Commands:** the real build / test / typecheck / lint commands and how tests are run
   (runner, file layout, co-location).
-- **Idioms** — naming + casing, layering, the error model, the result/exception style, the
+- **Idioms:** naming + casing, layering, the error model, the result/exception style, the
   http/client/data-access pattern.
-- **Placement** — where a kind of thing lives (where new endpoints / components / migrations go).
-- **Gotchas** — a non-obvious constraint this feature hit and proved (ordering requirement,
+- **Placement:** where a kind of thing lives (where new endpoints / components / migrations go).
+- **Gotchas:** a non-obvious constraint this feature hit and proved (ordering requirement,
   a "don't call X before Y", a framework quirk verified against the source).
 
 Do **not** promote: feature-specific details, one-off decisions (those live in
@@ -27,8 +27,8 @@ If it isn't both *durable* and *proven by the evidence*, leave it out.
 
 ## How (deterministic band, idempotent, graceful)
 
-For each convention, run the store. The confidence band is **earned** — computed from how
-many independent sealed slices corroborated the entry — never set by you. Re-sealing the
+For each convention, run the store. The confidence band is **earned** (computed from how
+many independent sealed slices corroborated the entry) never set by you. Re-sealing the
 same slice is idempotent (it won't double-count). If the `devrites-engine` binary is absent
 the step is skipped with a notice; the ledger is an enhancement, never a gate.
 

package/pack/generated/codex/skills/rite-seal/reference/final-evidence.md

@@ -7,38 +7,38 @@ Walk `spec.md` → "Acceptance criteria" one by one. For each:
 - Find the proving evidence in `evidence.md` / `browser-evidence.md` (command output,
   observation, screenshot described).
 - Mark `[x]` + the evidence, or `[ ] unproven` + why.
-- A criterion "proven" only by reading the code is **not proven** — require a runtime/
+- A criterion "proven" only by reading the code is **not proven**: require a runtime/
   test artifact, or downgrade it.
 - Hold the claim→evidence line: **"tests pass" is not "the feature works"** (the acceptance
   walk is); **"bug fixed"** requires the original-symptom test now passing, not "code changed,
-  assumed fixed"; **"the agent reported success"** is never evidence — the command output is.
+  assumed fixed"; **"the agent reported success"** is never evidence: the command output is.
 
 Tag each new-workspace criterion `AC-###` in `spec.md` and carry the same id onto its checked line in
-`seal.md`, then grade coverage deterministically — every spec criterion id must be checked:
+`seal.md`, then grade coverage deterministically: every spec criterion id must be checked:
 ```bash
 devrites-engine check-acceptance .devrites/work/<slug>   # exit 1 = a criterion is uncovered/unproven → NO-GO
 ```
 
 ## Cross-check the artifacts
 - `tasks.md`: are all slices in scope `built` AND is feature acceptance proven
-  (`evidence.md`)? Acceptance proof lives at the feature level, not per slice — a slice
+  (`evidence.md`)? Acceptance proof lives at the feature level, not per slice: a slice
   is `built`, the feature is proven. Any pending slice that's part of this feature's
   definition of done is a gap.
 - `review.md`: are all **Critical** and **Important** findings resolved (or accepted)?
 - `drift.md`: every entry marked resolved? Open drift blocks.
 - `questions.md`: any open question that changes behavior? Blocks. **Any entry with
-  `gate: validating` and `status: open` is a NO-GO regardless of behavior impact** — an
+  `gate: validating` and `status: open` is a NO-GO regardless of behavior impact**: an
   open validating gate is merge-blocking by definition; a slice marked
   `built (pending review)` is not done.
 - `polish-report.md` (if UI): normalize+polish done, browser evidence present.
 - `references/` (if the spec gathered design references): does the built UI **match the
   agreed references**? A mismatch on a referenced screen is a finding.
 
-## Evidence freshness — a GATE, not a courtesy
+## Evidence freshness: a GATE, not a courtesy
 Evidence must post-date the code it proves. **If `evidence.md` or `browser-evidence.md`
 predates the latest edit to any file in `touched-files.md`** (e.g. a polish- or
 review-phase edit landed after `$rite-prove`), a fresh `$rite-prove` run is **REQUIRED
-before GO** — stale evidence is not proof. Compare the evidence timestamps against the
+before GO**: stale evidence is not proof. Compare the evidence timestamps against the
 touched-files mtimes; if any code edit is newer, the proof is stale and this is a NO-GO
 until re-proven. Record the fresh result.
 
@@ -47,7 +47,7 @@ Run the deterministic check rather than eyeballing mtimes:
 devrites-engine evidence-fresh   # exit 3 = STALE proof → NO-GO until $rite-prove re-runs
 ```
 
-## Test integrity & mutation — the suite must be real
+## Test integrity & mutation: the suite must be real
 Stale proof isn't the only path to a false GO; a *weakened* test suite is. Run the deterministic
 gates:
 ```bash
@@ -55,7 +55,7 @@ devrites-engine test-integrity; echo "test-integrity rc=$?"   # exit 3 = a test
 devrites-engine mutation-gate   # changed-files mutation score — band the verdict; survivors are unproven behaviours
 devrites-engine package-existence; echo "package-existence rc=$?"   # exit 3 = a new import isn't declared in any manifest (hallucinated/typo-squatted dep) → Critical NO-GO
 ```
-A test weakened since the slice base is a **Critical NO-GO** — the suite went green by lowering the
+A test weakened since the slice base is a **Critical NO-GO**: the suite went green by lowering the
 bar, not by the code being right. Record the mutation score in `seal.md`; under
 `DEVRITES_MUTATION=enforce` a sub-threshold score blocks GO.
 

package/pack/generated/codex/skills/rite-seal/reference/go-no-go.md

@@ -2,7 +2,7 @@
 
 The seal verdict is binary and evidence-based. When in doubt, NO-GO with a clear blocker
 list beats a hopeful GO. The **authoritative gate is the severity table in
-[`../SKILL.md`](../SKILL.md) ("Severity gate")**; this file is the rationale behind it — keep
+[`../SKILL.md`](../SKILL.md) ("Severity gate")**; this file is the rationale behind it: keep
 the two in sync.
 
 ## NO-GO if any of these hold
@@ -14,20 +14,20 @@ the two in sync.
 - A **security-critical issue** remains (auth bypass, data exposure, injection).
 - A **data migration or destructive change lacks a rollback plan**.
 - A **declared project principle is violated** (`.devrites/principles.md`) with no recorded,
-  human-approved exception — same standing as an unproven criterion (absent / empty file →
+  human-approved exception: same standing as an unproven criterion (absent / empty file →
   none declared → not a blocker).
-- A **stood decision was never independently doubted** — a `## Decisions stood` entry in
-  `decisions.md` carrying `doubt: MISSING` (or `devrites-engine doubt-coverage` rc=3) — when that decision
+- A **stood decision was never independently doubted**. This means a `## Decisions stood` entry in
+  `decisions.md` carries `doubt: MISSING`, or `devrites-engine doubt-coverage` returns rc=3, when that decision
   is irreversible-risk (auth / public-API / migration). Severity rides the undoubted decision,
   not the exit code.
-- Any `questions.md` entry with `gate: validating` and `status: open` — **NO-GO
+- Any `questions.md` entry with `gate: validating` and `status: open`. **NO-GO
   regardless of behavior impact** (an open validating gate is merge-blocking by
   definition). A slice marked `built (pending review)` is not done.
-- A **test was weakened to go green** (`devrites-engine test-integrity` exit 3 — a test deleted, skipped,
+- A **test was weakened to go green** (`devrites-engine test-integrity` exit 3: a test deleted, skipped,
   `xfail`-ed, or de-asserted since the slice base). A suite that passes on a lowered bar is not
   proof; this is a Critical NO-GO.
 - Under `DEVRITES_MUTATION=enforce`, a **mutation score below threshold** (`devrites-engine mutation-gate`
-  exit 3 — survived mutants are behaviours no test actually checks).
+  exit 3: survived mutants are behaviours no test checks).
 
 ## GO requires
 - Every critical acceptance criterion checked with evidence attached.
@@ -39,12 +39,12 @@ the two in sync.
 
 ## Important findings (`Critical == 0`, `Important > 0`)
 Open `Important` findings do not auto-pass. With acceptance proven and drift resolved, render
-the interactive prompt *"`Important > 0` open. Proceed to seal? [y/N]"* — default **N**. `y`
+the interactive prompt *"`Important > 0` open. Proceed to seal? [y/N]"*: default **N**. `y`
 → GO; otherwise NO-GO with the open Important findings listed as blockers-by-policy. Don't
 silently fold Important findings into a GO.
 
 ## Conditional GO
-If only **non-blocking follow-ups** remain, it's a GO with a recorded follow-up list —
+If only **non-blocking follow-ups** remain, it's a GO with a recorded follow-up list:
 not a NO-GO. Distinguish "must fix to ship" (blocker) from "should do next" (follow-up).
 
 ## Honesty

package/pack/generated/codex/skills/rite-seal/reference/phase-contract.md

@@ -31,7 +31,7 @@ footprints must account for the whole roster; learnings run only on GO; progress
 is rendered before the final response from [`output.md`](output.md). Seal decides
 only; `$rite-ship` owns irreversible git/publish/deploy actions.
 
-1. **Run the shared orientation preamble** — it prints `state.md`, the artifacts present,
+1. **Run the shared orientation preamble:** it prints `state.md`, the artifacts present,
    the run mode (HITL/AFK), and the open-question tally by gate, so you orient deterministically
    instead of re-deriving state from raw Markdown:
    ```bash
@@ -44,11 +44,11 @@ only; `$rite-ship` owns irreversible git/publish/deploy actions.
    (see `.agents/skills/devrites-lib/reference/standards/tooling.md`), use it for
    blast-radius checks on the final diff in step 5; context7 if available can confirm a current
    external-API signature a reviewer flags.
-2. Check **acceptance criteria one by one** — first run `devrites-engine spec-validate .devrites/work/<slug>`;
+2. Check **acceptance criteria one by one**: first run `devrites-engine spec-validate .devrites/work/<slug>`;
    unresolved or unproven `resolved/test` prohibitions are a NO-GO until the linked evidence exists.
    Then use [final-evidence](final-evidence.md).
    Each gets a checkbox + the evidence that proves it (or "unproven"). Verify each criterion
-   **independently against the evidence artifact** — the slice report or the build narrative is not
+   **independently against the evidence artifact**: the slice report or the build narrative is not
    proof; the `devrites-spec-reviewer` + `devrites-test-analyst` fan-out in step 7 is the
    independent cross-check (a verifier that never saw the optimistic narrative).
 3. Verify tests, build/typecheck/lint, and browser proof are present and green for the
@@ -57,33 +57,33 @@ only; `$rite-ship` owns irreversible git/publish/deploy actions.
    criterion is an unmet acceptance criterion (NO-GO, per the severity gate), a declared-state
    `FAIL` is **Important**, and a UI build whose brief exists but whose verdict is **absent** is an
    Important evidence gap (the scorecard should have been emitted at browser-proof).
-4. Check unresolved **questions** and **drift** — any open item that changes product
+4. Check unresolved **questions** and **drift**: any open item that changes product
    behavior blocks. **Any `questions.md` entry with `gate: validating` and `status: open`
    is a NO-GO regardless of behavior impact** (an open validating gate is merge-blocking by
    definition); a slice marked `built (pending review)` is not done.
-4a. **Doubt coverage — every stood decision was independently doubted.** Run the deterministic
+4a. **Doubt coverage: every stood decision was independently doubted.** Run the deterministic
    check, then judge it against `decisions.md`:
    ```bash
    devrites-engine doubt-coverage <slug>; echo "doubt-coverage rc=$?"
    ```
-   The script reads two records `$rite-build` writes — the `## Decisions stood` ledger in
+   The script reads two records `$rite-build` writes: the `## Decisions stood` ledger in
    `decisions.md` (each entry ends `— doubt: <accept | reject-resolved | MISSING>`) and the `doubt`
    footprint. Read the exit code:
-   - **rc=3** — the ledger records a stood decision with `doubt: MISSING`: doubt was definitively
+   - **rc=3:** the ledger records a stood decision with `doubt: MISSING`: doubt was definitively
      skipped for a decision on record. **Important**; **NO-GO** when that decision is irreversible-risk
      (auth / public-API / migration). This is the per-slice skip the footprint count alone can't catch.
-   - **rc=1** — zero doubt dispatched across the build. A **prompt to verify, not a finding**: confirm
-     against the ledger — an every-slice-trivial feature (`- none`) is a valid pass; a stood triggering
+   - **rc=1:** zero doubt dispatched across the build. A **prompt to verify, not a finding**: confirm
+     against the ledger: an every-slice-trivial feature (`- none`) is a valid pass; a stood triggering
      decision (boundary / data-model / auth / public-API / migration / branching) with no verdict is
      the finding, same severity as rc=3.
-   - **rc=0** — covered, or not assessable (an inline build logs no dispatch — verify the ledger's
+   - **rc=0:** covered, or not assessable (an inline build logs no dispatch: verify the ledger's
      verdicts by hand).
    Either way, walk the `## Decisions stood` ledger yourself: severity rides the unverified
    **decision**, never the exit code alone.
-5. Check **security, data, migration, rollback** risk —
+5. Check **security, data, migration, rollback** risk:
    [risk-and-rollback](risk-and-rollback.md). If `strategy.md` exists (from
    `$rite-temper`), confirm its **top pre-mortem risks are mitigated** in the diff/evidence and
-   that no **Non-goal / deferred item crept into the diff** (scope creep) — either is a finding
+   that no **Non-goal / deferred item crept into the diff** (scope creep): either is a finding
    (an unmitigated top risk or smuggled-in out-of-scope work).
    - **Principles** (`principles.md`): score the final diff against each declared invariant in
      `.devrites/principles.md`. A violation with no matching, human-approved exception in the
@@ -91,20 +91,20 @@ only; `$rite-ship` owns irreversible git/publish/deploy actions.
      trigger) or wider than its stated scope is itself a finding. No file / no principles → skip.
    - **Observability** (`observability.md`): if the diff added a runtime surface (endpoint,
      job, integration, user flow, error path), a feature shipping with no way to debug it in
-     prod is an **Important** finding, not a pass — `evidence.md` should show telemetry observed
+     prod is an **Important** finding, not a pass: `evidence.md` should show telemetry observed
      to emit (`$rite-prove` step 5b).
    - **Developer experience** (`developer-experience.md`): if the diff ships a developer-facing
      surface, reconcile `devex.md` (the `$rite-vet` predicted scorecard vs the `$rite-prove`
-     measured one — the boomerang). A broken public dev contract (a documented command that errors,
+     measured one: the boomerang). A broken public dev contract (a documented command that errors,
      a getting-started flow that can't complete) or an unexplained measured DX regression is
-     **Important** — **Critical** on a frozen public surface (`principles.md`). No surface → skip.
+     **Important**. **Critical** on a frozen public surface (`principles.md`). No surface → skip.
    - **Removal / migration** (`deprecation.md`): if the diff deletes or migrates code, an API,
      or data, confirm it followed expand→contract, proved the old path unused before removing it,
      and carries a rollback for every destructive step. A surprise deletion or a one-shot
      breaking migration is a finding (and trips the irreversible-risk gate, `afk-hitl.md`).
 6. Check **frontend polish** if UI is involved (states, a11y, responsive, design-system,
    browser evidence).
-7. **Independent review** — seal is the final gate, not a re-run of `$rite-review`.
+7. **Independent review:** seal is the final gate, not a re-run of `$rite-review`.
    It **always re-spawns** the axes `$rite-review` did not cover: `devrites-test-analyst`,
    `devrites-security-auditor`, `devrites-performance-reviewer`, and
    `devrites-frontend-reviewer` (UI). It **only re-runs the Spec and Code-review axes**
@@ -112,60 +112,60 @@ only; `$rite-ship` owns irreversible git/publish/deploy actions.
    `$rite-review` ran (compare against `review.md`); if the diff is unchanged, carry
    review's verdicts on those axes forward rather than re-litigating them.
    If subagents are available, fan out **in parallel** (one `Task` block, multiple tool
-   calls) to the **roster** — the seven reviewers and their checkable triggers are the single
+   calls) to the **roster**: the seven reviewers and their checkable triggers are the single
    source in [`parallel-dispatch.md`](../../devrites-lib/reference/parallel-dispatch.md) (dispatch
-   shape + reconciliation there too; `.agents/skills/devrites-lib/reference/standards/agents.md` — "Run independent reviewers in
+   shape + reconciliation there too; `.agents/skills/devrites-lib/reference/standards/agents.md`. "Run independent reviewers in
    parallel"). Dispatch every always-on reviewer and every conditional whose trigger the diff
-   meets; `devrites-devex-reviewer` runs in **measure mode** — grade the measured DX scorecard
+   meets; `devrites-devex-reviewer` runs in **measure mode**: grade the measured DX scorecard
    and reconcile the boomerang against the `$rite-vet` prediction. Give each the workspace path +
    diff *without the author's reasoning*. If subagents are unavailable, run the equivalent
    reviews sequentially yourself and flag each as a fallback.
    The reviewer **AGENTS** here (fresh context, no author reasoning) are the seal
    GATE; `devrites-audit` is the inline single-axis pass run during build/polish.
-   The two paths are intentional, not divergent — the inline audit catches issues
+   The two paths are intentional, not divergent: the inline audit catches issues
    early; the fresh-context agents are the independent gate before ship.
-   **Footprint — account for the whole roster.** For each reviewer you dispatch, append
-   `devrites-engine footprint log <slug> reviewer devrites-<x>-reviewer` (the reviewer's **exact agent name** —
+   **Footprint: account for the whole roster.** For each reviewer you dispatch, append
+   `devrites-engine footprint log <slug> reviewer devrites-<x>-reviewer` (the reviewer's **exact agent name**:
    the roster gate matches on it, so a freehand label like `spec` will read as unaccounted); for
    each roster reviewer you consciously do **not** dispatch, append
    `devrites-engine footprint log <slug> skip devrites-<x>-reviewer` and note the one-line reason in `seal.md`.
-   A conditional reviewer that does not apply is a *recorded skip*, never a silent omission — step 7b
+   A conditional reviewer that does not apply is a *recorded skip*, never a silent omission: step 7b
    proves the roster complete before the verdict.
-7a. **Reconcile findings — confidence over volume.** Band each reviewer finding by confidence
-   (1–10); a low-confidence (≤4) finding that can't be verified against the diff is **suppressed**
+7a. **Reconcile findings: confidence over volume.** Band each reviewer finding by confidence
+   (1-10); a low-confidence (≤4) finding that can't be verified against the diff is **suppressed**
    to a `Suppressed (low-confidence): n` line, not a blocker. Every Critical/Important must cite
    the `file:line` (or spec line) that proves it. Surface genuine cross-reviewer disagreement
    **explicitly** rather than averaging it away, and don't let a pile of low-confidence nits
-   inflate the verdict — the gate is `Critical == 0` + acceptance + drift, not "few findings".
+   inflate the verdict: the gate is `Critical == 0` + acceptance + drift, not "few findings".
    (A seal that fires noise teaches the next one to be ignored.)
-7b. **Account for the roster — no reviewer silently skipped.** Before the verdict, prove every
+7b. **Account for the roster: no reviewer silently skipped.** Before the verdict, prove every
    roster reviewer carries a decision (dispatched or skip-recorded in step 7's footprint):
    ```bash
    devrites-engine footprint roster <slug>; echo "roster rc=$?"
    ```
-   - **rc=3** — a roster reviewer was neither dispatched nor skip-recorded: the silent omission
-     this gate exists to catch. **NO-GO** on the review's *completeness* (not the diff) — dispatch
+   - **rc=3:** a roster reviewer was neither dispatched nor skip-recorded: the silent omission
+     this gate exists to catch. **NO-GO** on the review's *completeness* (not the diff): dispatch
      the missing reviewer or record a justified skip, then re-run. Same standing as an unproven
      criterion (severity gate).
-   - **rc=1** — an always-on axis (Spec / Code-review) was skip-recorded: legitimate **only** as a
+   - **rc=1:** an always-on axis (Spec / Code-review) was skip-recorded: legitimate **only** as a
      carry-forward of `$rite-review`'s verdict on an **unchanged** diff (step 7). Confirm that;
      otherwise dispatch it.
-   - **rc=0** — every reviewer accounted for; proceed.
-7c. **No silent reviewer — a zero-findings axis is justified, not assumed.** Confirm no adversarial
+   - **rc=0:** every reviewer accounted for; proceed.
+7c. **No silent reviewer: a zero-findings axis is justified, not assumed.** Confirm no adversarial
    axis rubber-stamped: an axis that reported nothing must carry a `No-findings:` justification.
    ```bash
    devrites-engine review-integrity <slug>; echo "review-integrity rc=$?"
    ```
-   - **rc=1** — an axis in `review.md` is silent (no finding, no justification): **Important** on the
+   - **rc=1:** an axis in `review.md` is silent (no finding, no justification): **Important** on the
      review's completeness. Re-run that axis or record its `No-findings:` account, then re-seal.
-   - **rc=0** — every axis has findings or a justified clean bill; proceed. (No `review.md`, or a
-     freeform one, is a clean pass — the gate keys on per-axis sections.)
+   - **rc=0:** every axis has findings or a justified clean bill; proceed. (No `review.md`, or a
+     freeform one, is a clean pass: the gate keys on per-axis sections.)
    Then write stable finding IDs for learning and recurring-dismissal correlation:
    ```bash
    devrites-engine review-fingerprints --write <slug>
    ```
-8. Decide GO / NO-GO — [go-no-go](go-no-go.md) — and write `seal.md`. Then render the
-   **fan-out footprint** into `seal.md` and the output — deterministic run-weight (subagents
+8. Decide GO / NO-GO: [go-no-go](go-no-go.md), and write `seal.md`. Then render the
+   **fan-out footprint** into `seal.md` and the output: deterministic run-weight (subagents
    dispatched · slices · wall-clock), **never a token or dollar figure** (DevRites can't
    truthfully source one):
    ```bash
@@ -178,20 +178,20 @@ only; `$rite-ship` owns irreversible git/publish/deploy actions.
      "acceptance": "<proven>/<total>", "test_integrity": "ok | weakened", "mutation": "<score | n/a>",
      "blockers": ["<one line each, empty on GO>"] }
    ```
-9. **On GO only — record proven conventions** to the local ledger
+9. **On GO only: record proven conventions** to the local ledger
    (`.devrites/conventions.md`) so later slices stop re-deriving this project's idioms:
    the durable, *evidence-proven* commands / idioms / placement / gotchas this feature
    established. Evidence-gated like the seal itself; the band is earned, not guessed; the
    step degrades gracefully when unavailable. Full contract + command:
    [conventions-ledger](conventions-ledger.md). (Skip entirely on NO-GO.)
-9a. **On GO only — auto-capture learnings** (`.devrites/learnings.md`). Learning is automatic, not a
+9a. **On GO only: auto-capture learnings** (`.devrites/learnings.md`). Learning is automatic, not a
    command anyone must remember: append this feature's durable signal so the **next** feature's
-   review starts warmer — (a) any reviewer finding the gate **dismissed as intentional here** (a
+   review starts warmer: (a) any reviewer finding the gate **dismissed as intentional here** (a
    "don't re-flag X in this project" class, tag `dismiss`); (b) a recurring correction or dead-end
    worth not repeating (tag `note`). The review skills load this ledger **before** they fan out, so a
-   dismissed-finding class stops recurring. It is an untrusted prior — live code always overrides
+   dismissed-finding class stops recurring. It is an untrusted prior: live code always overrides
    (`.agents/skills/devrites-lib/reference/standards/security.md`). Promotion of a recurring lesson to a *project rule* stays the
-   human's call (`$rite-learn` — propose, don't impose). Skip on NO-GO.
+   human's call (`$rite-learn`: propose, don't impose). Skip on NO-GO.
    ```bash
    devrites-engine learnings add "<slug>" "<dismissed-as-intentional class or dead-end>" dismiss
    ```
@@ -208,4 +208,4 @@ only; `$rite-ship` owns irreversible git/publish/deploy actions.
 Loaded on demand from [`seal-template.md`](seal-template.md). Fill in
 each section + write to `.devrites/work/<slug>/seal.md` as the durable record.
 
-> **Mid-flight discipline.** When tempted to round NO-GO up to GO, bypass the y/N prompt, average reviewer disagreements, or seal with unresolved drift — see [`anti-patterns`](anti-patterns.md). Load it the moment you reach for the excuse.
+> **Mid-flight discipline.** When tempted to round NO-GO up to GO, bypass the y/N prompt, average reviewer disagreements, or seal with unresolved drift: see [`anti-patterns`](anti-patterns.md). Load it the moment you reach for the excuse.