devrites 3.0.4 → 3.0.6

package/pack/generated/codex/skills/rite-build/reference/forge.md

@@ -1,20 +1,19 @@
-# Forge — competing candidate builds for one slice
+# Forge: competing candidate builds for one slice
 
 How `$rite-build` builds a slice that `$rite-vet` flagged `Forge: yes`: instead of one wright,
-**K = 2–3 candidate wrights** each build the slice a genuinely different way in **isolation**, a
+**K = 2-3 candidate wrights** each build the slice a genuinely different way in **isolation**, a
 read-only judge scores them, and exactly **one** winner's diff lands in the working tree. Loaded
 on demand by `$rite-build` step 3; the sibling of single-path
 [`wright-dispatch.md`](wright-dispatch.md).
 
 Forge is the **rare** path. Most slices are single-path (cheaper, and the default). A slice
-forges only when the work is a genuine architecture fork — two or three approaches that actually
-differ, no clear winner on paper, at high enough stakes that building the wrong one costs more
+forges only when the work is a genuine architecture fork: two or three approaches that differ, no clear winner on paper, at high enough stakes that building the wrong one costs more
 than building all of them. That judgment is made at `$rite-vet` and recorded as the slice's
 `Forge:` field; build acts on the flag, it does not invent it.
 
 ## Why this doesn't break the single-writer invariant
 
-DevRites forbids a parallel fan-out of writers **sharing one tree** — concurrent writers on one
+DevRites forbids a parallel fan-out of writers **sharing one tree**: concurrent writers on one
 working tree make conflicting implicit decisions and produce incoherent code
 ([`wright-dispatch.md`](wright-dispatch.md)). Forge keeps that invariant intact by **isolation**:
 every candidate writes in its own worktree (or its own throwaway branch), never touching another
@@ -24,13 +23,13 @@ one slice."
 
 ## Trust the flag, but clear a stale one
 
-Before competing anything, confirm the flag still earns its cost — `$rite-vet` set it, but the
+Before competing anything, confirm the flag still earns its cost: `$rite-vet` set it, but the
 plan may have moved:
 
-- **No objective scorecard** — the slice has no acceptance criteria and no `test-plan.md`
+- **No objective scorecard:** the slice has no acceptance criteria and no `test-plan.md`
   coverage the judge can score against → clear `Forge` to `no`, build single-path. A competition
   with no rubric is a coin toss with K× the cost.
-- **Can't name two genuinely different strategies** — if the candidates would be variations of
+- **Can't name two genuinely different strategies:** if the candidates would be variations of
   one approach, there is nothing to compete → single-path.
 - **Slice shrank below the bar** (now Complexity ≤3, or a dependency landed that picks the
   approach) → single-path.
@@ -40,21 +39,21 @@ slice you can't score, and never forge to avoid making a decision the plan alrea
 
 ## Mechanics
 
-The orchestrator runs F1–F7. Steps 4–7 of the [one-slice-cycle](one-slice-cycle.md) (doubt,
+The orchestrator runs F1-F7. Steps 4-7 of the [one-slice-cycle](one-slice-cycle.md) (doubt,
 fail-on-red, reconcile, record, stop) then run **unchanged** on the winner.
 
-### F1 — Confirm the K strategies
-Take the 2–3 candidate strategies `$rite-vet` named (in the slice brief). Each must be a
-**distinct, complete approach** to the same slice contract — a different seam, data shape,
-reuse-vs-build call, or algorithm — not a tweak of one. Name them `A`, `B`, (`C`) with a
+### F1: Confirm the K strategies
+Take the 2-3 candidate strategies `$rite-vet` named (in the slice brief). Each must be a
+**distinct, complete approach** to the same slice contract (a different seam, data shape,
+reuse-vs-build call, or algorithm) not a tweak of one. Name them `A`, `B`, (`C`) with a
 one-line description each. K is capped at 3: a fourth candidate rarely changes the winner and
 multiplies cost.
 
-### F2 — Snapshot, then isolate each candidate
+### F2: Snapshot, then isolate each candidate
 Snapshot the working tree first (the winner's landing is reconciled against it later), then give
 each candidate its own isolated tree. **Prefer parallel isolated worktrees** when the harness can
 dispatch a sub-agent with worktree isolation; the **always-available** path is one throwaway git
-branch per candidate, built sequentially (slower, universally works — the
+branch per candidate, built sequentially (slower, universally works: the
 [`tooling.md`](../../devrites-lib/reference/standards/tooling.md) "fallback is first-class" discipline):
 
 ```bash
@@ -68,7 +67,7 @@ for C in A B; do
 done
 ```
 
-### F3 — Dispatch K candidate wrights
+### F3: Dispatch K candidate wrights
 Send **each** candidate the identical single-path slice contract from
 [`wright-dispatch.md`](wright-dispatch.md), with **one** line added naming its assigned strategy
 and its isolated tree:
@@ -81,32 +80,32 @@ candidate's work. Same discipline as always — orient → RED → implement sma
 verify → return your structured artifact. Code + tests only.
 ```
 
-Each is still **one wright, one tree** — the invariant holds per candidate. Parallel where the
+Each is still **one wright, one tree**: the invariant holds per candidate. Parallel where the
 harness isolates them; otherwise build candidate A to green, capture its diff, reset to `BASE`,
 then candidate B. A candidate that hits an irreversible-risk item escalates exactly as a
-single-path wright does — **forge never bypasses a gate** (see AFK below).
+single-path wright does: **forge never bypasses a gate** (see AFK below).
 
-### F4 — Judge (read-only, fresh context)
+### F4: Judge (read-only, fresh context)
 Dispatch [`devrites-forge-judge`](.codex/agents/devrites-forge-judge.toml) with the K finished
 candidate diffs and the scorecard inputs (slice acceptance, `test-plan.md`, `.devrites/principles.md`,
 the anti-slop charter). It scores each candidate, ranks them, names the **winner** and the
 specific runner-up ideas worth grafting, and returns the structured verdict. The judge **never
-writes code** — it reads the diffs and returns findings, like every reviewer agent. If sub-agent
+writes code**. It reads the diffs and returns findings, like every reviewer agent. If sub-agent
 dispatch is unavailable, do the judge's rubric pass yourself in a fresh read, discarding your
 authoring reasoning (a flagged fallback, not an independent judgment).
 
-### F5 — Land the winner, graft sparingly
+### F5: Land the winner, graft sparingly
 Apply **only** the winner's diff to the working tree (merge its worktree / cherry-pick its
 branch). If the judge named a cheap, specific improvement in a runner-up, graft it by
-**continuing the winning wright once** with that instruction — never hand-merge two candidates'
+**continuing the winning wright once** with that instruction: never hand-merge two candidates'
 code (that re-creates the incoherent-tree failure the invariant exists to prevent). The landed
 tree has exactly one author: the winner (plus its own grafted follow-up).
 
-### F6 — Write `forge-report.md`
+### F6: Write `forge-report.md`
 The durable record of the competition (template below). One per forged slice; archived with the
 feature.
 
-### F7 — Clean up, then return to the cycle
+### F7: Clean up, then return to the cycle
 Remove only clean losing worktrees / delete their candidate branches. If a losing worktree is dirty,
 preserve it and record the path in `forge-report.md`; never `--force` away unlanded work.
 
@@ -152,18 +151,18 @@ slice that might be tempted to retry one>.
 ```
 
 The **Discarded** section matters: it is a dead-end record at the slice level, the same role
-`decisions.md` "Dead ends" plays for the feature — a later slice shouldn't re-litigate an
+`decisions.md` "Dead ends" plays for the feature: a later slice shouldn't re-litigate an
 approach forge already rejected.
 
 ## AFK & budget
 
 - **Cost.** Forge multiplies the build by K. Under `.devrites/AFK`, each candidate counts against
   the slice budget (`devrites-engine tick-afk` once per candidate dispatched), so a forge slice can exhaust the
-  cap faster — that is intended back-pressure, not a bug.
+  cap faster, that is intended back-pressure, not a bug.
 - **Gates are unchanged.** Forge changes *how many candidates build*, never *what pauses*. An
   irreversible-risk item, a blocking/escalating gate, or a red-on-completion in **any** candidate
   pauses per [`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md) exactly as single-path. AFK widens what is
-  automatic, never what is irreversible — forge included.
+  automatic, never what is irreversible: forge included.
 - **Stuck loop still applies.** Re-dispatching the same candidate without progress trips
   `devrites-engine stuck` the same as a single wright.
 
@@ -171,11 +170,11 @@ approach forge already rejected.
 
 No git, or neither worktrees nor throwaway branches are usable → **degrade to single-path** and
 say so. Forge is an accelerator for choosing between real alternatives; it is never a requirement
-for building the slice. A slice always has a single-path build available — the competition is the
+for building the slice. A slice always has a single-path build available: the competition is the
 optional part.
 
 ## Anti-patterns
 
-See [`anti-patterns.md`](anti-patterns.md) § Forge — the short version: don't forge a decided or
+See [`anti-patterns.md`](anti-patterns.md) § Forge: the short version: don't forge a decided or
 trivial slice, don't forge to dodge a decision, don't hand-merge candidates, don't exceed K=3,
 and don't let a forged slice skip the post-return doubt because "the judge already looked."

package/pack/generated/codex/skills/rite-build/reference/frontend-trigger.md

@@ -12,7 +12,7 @@ A slice is **frontend/UI** if it touches or plans to touch any of:
 
 ## When triggered
 - `$rite-spec` applies **`devrites-ux-shape`** (spec step 3a) to write the feature-level
-  **`design-brief.md`** before any code — design direction, key states, interaction model,
+  **`design-brief.md`** before any code: design direction, key states, interaction model,
   optional Figma/image visual-direction probe.
 - `$rite-build` applies **`devrites-frontend-craft`**, building **to** that `design-brief.md`
   (register detection, refine the brief per slice, existing design system, all states,
@@ -31,7 +31,7 @@ If the slice spans both layers, it's both a frontend **and** a backend slice. De
 `devrites-frontend-craft/reference/fullstack.md`.
 
 ## When NOT triggered
-Pure backend/data/CLI/infra slices skip craft and browser proof — but still get tests
+Pure backend/data/CLI/infra slices skip craft and browser proof, but still get tests
 and evidence. If unsure whether a slice is "UI enough", treat copy/empty/error states
 and any rendered output as UI.
 

package/pack/generated/codex/skills/rite-build/reference/one-slice-cycle.md

@@ -27,12 +27,12 @@ STOP      → report + recommend next; do not start slice N+1
 ## Why stop after one slice
 - Keeps the diff reviewable (~one capability, roughly ≤100 lines of meaningful change).
 - Surfaces integration/drift problems while they're cheap.
-- Gives the user a decision point — they may reprioritize, reslice, or polish now.
-- Prevents the "90% done" pile-up where nothing is actually proven.
+- Gives the user a decision point. They may reprioritize, reslice, or polish now.
+- Prevents the "90% done" pile-up where nothing is proven.
 
 ## Restate the scope boundary
 Before coding, write what this slice will and will **not** touch. This is the contract
-you check yourself against — anything outside it is scope creep or a drift event.
+you check yourself against: anything outside it is scope creep or a drift event.
 
 ## When the slice can't be completed cleanly
 - Discovered the plan is wrong → **Spec Drift Guard** (stop, record, classify, maybe

package/pack/generated/codex/skills/rite-build/reference/output.md

@@ -38,4 +38,4 @@ For a **forged slice**, the `Built` line names the competition and points at the
 `Done: built slice 3 — csv-streaming (forged: 3 candidates, winner B).` and
 `Record: .devrites/work/<slug>/forge-report.md`.
 
-**DO NOT continue to the next slice automatically** — even at `✅ ALL BUILT`, `$rite-prove` is the user's call.
+**DO NOT continue to the next slice automatically**: even at `✅ ALL BUILT`, `$rite-prove` is the user's call.

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

@@ -40,7 +40,7 @@ gates.
 > but phase gates should treat a missing engine as a setup problem.
 
 0. **Rules + AFK + readiness check.** Read `.agents/skills/devrites-lib/reference/standards/core.md` first. Then **run the
-   shared orientation preamble** — it prints `state.md`, the artifacts present, the run
+   shared orientation preamble**. It prints `state.md`, the artifacts present, the run
    mode (HITL/AFK), and the open-question tally by gate, deterministically:
    ```bash
    devrites-engine preamble
@@ -48,7 +48,7 @@ gates.
    ```
    Treat the snapshot as the canonical machine-readable status; if you need to tell the
    user the next command, use `nextCommands.claude` in Claude Code or `nextCommands.codex`
-   in Codex. Then **run the readiness gate** — it enforces the step-0 stop conditions by exit code,
+   in Codex. Then **run the readiness gate**. It enforces the step-0 stop conditions by exit code,
    not by memory:
    ```bash
    devrites-engine build-readiness; echo "readiness rc=$?"
@@ -65,9 +65,9 @@ gates.
    the count in `state.md` or remove the sentinel to continue). See
    [`afk-discipline.md`](afk-discipline.md).
 1. Read `spec.md`, `plan.md`, `tasks.md`, `assumptions.md`, `drift.md`, and `test-plan.md`
-   if present (the vetted coverage target from `$rite-vet` — the slice's tests come from
+   if present (the vetted coverage target from `$rite-vet`: the slice's tests come from
    here when it exists). `state.md` and the open-`questions.md` tally are already in the
-   preamble digest from step 0 — re-read `questions.md` only for the full text of a flagged
+   preamble digest from step 0: re-read `questions.md` only for the full text of a flagged
    blocking question.
    If a **blocking `[NEEDS CLARIFICATION]`** remains or the spec/plan readiness gates
    don't pass, stop → `$rite-spec` (to resolve) or `$rite-plan` (to repair). Don't build
@@ -81,22 +81,22 @@ gates.
     checkpoint as a ranked **option set** and resolve it **before** any code lands, per
     [`checkpoint-protocol.md`](checkpoint-protocol.md). Branch on whether
     a human is here:
-    - **Human present (interactive — no `.devrites/AFK`) → ask inline via `AskUserQuestion`.**
+    - **Human present (interactive: no `.devrites/AFK`) → ask inline via `AskUserQuestion`.**
       This is the default for an interactive build. Render 2-4 options, the recommended one
       **first and labelled `(Recommended)`**, each with its dimension-tagged rationale + the
       trade-off it accepts, plus the `Something else — I'll describe it` escape hatch. The
       human picks; record the pick to `questions.md` (`answered`) + `decisions.md` (through the
-      `devrites-engine resolve` writer), clear the gate, and **continue to step 3 in place** — do **not**
+      `devrites-engine resolve` writer), clear the gate, and **continue to step 3 in place**: do **not**
       STOP, do **not** route through `$rite-resolve`.
     - **Human absent / AFK (`.devrites/AFK` present) → auto-pick or persist + STOP.** For a gate
       in `allow_gates`, auto-pick the recommended option (option 1) and proceed; otherwise
       append the `questions.md` entry, write the `Awaiting human` block to `state.md`, set
-      `Status: awaiting_human`, fire the `notify:` hook, then **STOP** — resume when the user
+      `Status: awaiting_human`, fire the `notify:` hook, then **STOP**: resume when the user
       runs `$rite-resolve <qid> "<answer>"`. `blocking` / `escalating` / irreversible-risk gates
       always take this stop path, never the AFK auto-pick.
-3. **Snapshot the tree, then dispatch the build core to `devrites-slice-wright`** — one `Task`
+3. **Snapshot the tree, then dispatch the build core to `devrites-slice-wright`:** one `Task`
    call, fresh context. **First**, capture the pre-dispatch tree so the reconcile gate (step 6)
-   can prove you never touched source — run this immediately before the `Task` call:
+   can prove you never touched source: run this immediately before the `Task` call:
    ```bash
    devrites-engine reconcile snapshot
    ```
@@ -105,7 +105,7 @@ gates.
    ```bash
    devrites-engine stuck log "$(cat .devrites/ACTIVE 2>/dev/null)" dispatch "<slice id>"
    ```
-   **Forge branch — only if the selected slice is `Forge: yes`.** Instead of the single dispatch
+   **Forge branch: only if the selected slice is `Forge: yes`.** Instead of the single dispatch
    below, run the competitive build per [`forge.md`](forge.md): K=2-3 candidate
    wrights, each in an **isolated git worktree** on the distinct strategy `$rite-vet` named, then a
    fresh-context [`devrites-forge-judge`](.codex/agents/devrites-forge-judge.toml) scores them against
@@ -115,7 +115,7 @@ gates.
    a single wright does (one structured artifact, for the winner), so steps 4-7 (doubt, fail-on-red,
    reconcile against the winner's claimed set, record, stop) run **unchanged**. If you cannot give
    the judge an objective scorecard (the slice lacks acceptance / `test-plan.md` coverage) or cannot
-   name two genuinely different strategies, the flag is stale — clear it and build single-path. The
+   name two genuinely different strategies, the flag is stale: clear it and build single-path. The
    single-writer invariant is intact: each candidate owns its own tree, exactly one author's diff
    lands. Then **stop** here for this slice; the steps below are the default single-path dispatch.
 
@@ -123,33 +123,33 @@ gates.
    [`wright-dispatch.md`](wright-dispatch.md): the slice goal, acceptance
    criteria, and **scope boundary**; the paths it may touch (`touched-files.md`); the context
    paths to read (`spec.md`, `plan.md`, `decisions.md`, `assumptions.md`, `.devrites/principles.md`
-   when present — the binding invariants the slice must honor — plus `test-plan.md`
-   when present — its per-gap test requirements + regression-criticals for this slice are the
-   coverage the wright must write — and `design-brief.md`
+   when present (the binding invariants the slice must honor) plus `test-plan.md`
+   when present (its per-gap test requirements + regression-criticals for this slice are the
+   coverage the wright must write) and `design-brief.md`
    when the slice touches UI per [`frontend-trigger.md`](frontend-trigger.md)); and the
    `.agents/skills/devrites-lib/reference/standards/` files in scope. The wright **orients** on the project's idiom (using a
-   code-intelligence index **if available** — `codebase-memory-mcp` first, cross-checked with
+   code-intelligence index **if available** (`codebase-memory-mcp` first, cross-checked with
    `codegraph` (`.codegraph/` / `codegraph_*`) + `graphify` (`graphify-out/`), else standard
-   methods (LSP / `Read`/`Grep`/`Glob`); see `.agents/skills/devrites-lib/reference/standards/tooling.md` — for
+   methods (LSP / `Read`/`Grep`/`Glob`); see `.agents/skills/devrites-lib/reference/standards/tooling.md`) for
    placement/callers/impact), writes the **failing test first** when
    behaviour changes ([`tdd.md`](tdd.md)), implements the **smallest complete** version in
    the project's style (applying `devrites-frontend-craft` to `design-brief.md` for UI, and
-   `devrites-source-driven` — with context7 if available — for uncertain framework facts), runs the slice's **targeted tests**
+   `devrites-source-driven` (with context7 if available) for uncertain framework facts), runs the slice's **targeted tests**
    (plus typecheck / lint / build where the project has them), and returns a structured artifact
-   — **code + tests only; it does not write the workspace files.** If the slice is UI but no `design-brief.md` exists (e.g. a spec written before
+  : **code + tests only; it does not write the workspace files.** If the slice is UI but no `design-brief.md` exists (e.g. a spec written before
    shaping), shape it via `devrites-ux-shape` before the wright codes. If the `Task` tool is
-   unavailable, run the wright's discipline **inline** as a flagged fallback (see the reference)
-   — same one-slice cycle, no isolation; in that case write
+   unavailable, run the wright's discipline **inline** as a flagged fallback (see the reference).
+   Same one-slice cycle, no isolation; in that case write
    `.devrites/work/<slug>/.reconcile-inline` so the reconcile gate skips (you are legitimately
    the writer in this fallback).
 4. **Doubt the decisions it stood up.** For each entry in the wright's `Decisions stood`
    (branching, boundary crossing, data model, auth, public API, migration, user-flow change,
-   "this is safe/scales") apply `devrites-doubt` **before accepting the slice** — the writer
+   "this is safe/scales") apply `devrites-doubt` **before accepting the slice**: the writer
    doesn't grade its own decisions. Each `devrites-doubt` invocation **dispatches the
    `devrites-doubt-reviewer` subagent** (doing the adversarial pass inline is the writer grading
-   itself — the thing this step exists to forbid). **Completion criterion (checkable):** step 4
+   itself: the thing this step exists to forbid). **Completion criterion (checkable):** step 4
    is done only when **every** `Decisions stood` entry carries a recorded `devrites-doubt`
-   verdict — `accept`, or `reject` + the required changes — in `decisions.md` (accepted
+   verdict (`accept`, or `reject` + the required changes) in `decisions.md` (accepted
    trade-offs) / `questions.md` (open gates). A `Decisions stood` entry with **no verdict on
    record** means doubt did not run for it: **do not enter step 5 and do not mark the slice
    `built`.** Log each dispatch so the seal can prove doubt ran (the footprint already counts a
@@ -163,49 +163,49 @@ gates.
    `Status: awaiting_human`; a scope-changing answer → `$rite-plan repair` (Spec Drift Guard),
    never silently into the slice. **If an irreversible-risk item shows up under the wright's
    `Decisions stood` rather than `Escalation`**, treat that misclassification as itself a
-   blocking protocol violation — pause and re-dispatch with the item flagged out-of-bounds, do
-   **not** doubt-and-accept it. (The wright's return is the not-yet-load-bearing moment — the
-   slice isn't `built` or merged yet — so this post-return doubt is still pre-commit.)
+   blocking protocol violation: pause and re-dispatch with the item flagged out-of-bounds, do
+   **not** doubt-and-accept it. (The wright's return is the not-yet-load-bearing moment (the
+   slice isn't `built` or merged yet) so this post-return doubt is still pre-commit.)
    **Principle check (same standing):** a wright return that breaks a declared principle
    (reported in its `Principles` field, or that you detect against `.devrites/principles.md`) is
-   handled here like an irreversible-risk item — block, route to a human-approved scoped
+   handled here like an irreversible-risk item: block, route to a human-approved scoped
    exception in the register or stop; never doubt-and-accept a principle violation into the slice.
 5. **Fail-on-red.** If the wright's `Gates` were red (targeted tests / types / lint) or it
    couldn't verify: do **not** mark the slice `built`, and **do not fix the code yourself**.
-   First remedy — **continue the same wright once** (`SendMessage` to it, carrying the failing
+   First remedy: **continue the same wright once** (`SendMessage` to it, carrying the failing
    gate + its real output) so it fixes in its own context. This retry is for **objective
-   failures only** — red gate / type / lint / missing test coverage / UI browser-proof fail —
+   failures only**: red gate / type / lint / missing test coverage / UI browser-proof fail:
    never a contested decision (that routes to `$rite-plan repair`). **Still red after the one
    retry** → escalate: AFK → append a blocking question to `questions.md` (gate=blocking,
    slice's SLA) + set `Status: awaiting_human`; HITL → pause as a blocking gate. Either way,
    `Next step: $rite-plan unblock` until resolved.
-6. **Record — you are the canonical writer.** **First, run the reconcile gate (A1):** write the
+6. **Record. You are the canonical writer.** **First, run the reconcile gate (A1):** write the
    wright's reported `Files changed` paths (one per line) to
    `.devrites/work/<slug>/.reconcile-claimed` (or the active legacy
    `.devrites/features/<slug>/` workspace during migration), then:
    ```bash
    devrites-engine reconcile check; echo "reconcile rc=$?"
    ```
-   **Exit 5 → hard STOP:** a source file changed outside the wright's claimed set — code was
+   **Exit 5 → hard STOP:** a source file changed outside the wright's claimed set: code was
    edited by something other than the wright (A1 breach). Revert it and re-dispatch the wright;
    do **not** mark the slice `built`.
 
-   **Then run the test-integrity gate (anti-reward-hacking)** — prove the slice didn't reach
+   **Then run the test-integrity gate (anti-reward-hacking)**: prove the slice didn't reach
    green by weakening its tests:
    ```bash
    devrites-engine test-integrity; echo "test-integrity rc=$?"
    ```
-   **Exit 3 → hard STOP:** a test was deleted, skipped, or de-asserted since the slice base — the
+   **Exit 3 → hard STOP:** a test was deleted, skipped, or de-asserted since the slice base: the
    slice went green by weakening its tests, a Critical protocol violation. Revert the weakening and
    re-dispatch the wright; do **not** mark the slice `built`.
 
-   **Then run the package-existence gate (anti-hallucination)** — every new third-party import must
+   **Then run the package-existence gate (anti-hallucination)**: every new third-party import must
    be declared in a project manifest, not just imported:
    ```bash
    devrites-engine package-existence; echo "package-existence rc=$?"
    ```
    **Exit 3 → STOP:** an imported package is not declared in any manifest (`package.json`, `go.mod`,
-   `requirements.txt`, `pyproject.toml`, `Pipfile`, `Cargo.toml`) — the classic shape of a
+   `requirements.txt`, `pyproject.toml`, `Pipfile`, `Cargo.toml`): the classic shape of a
    hallucinated or typo-squatted dependency. Confirm the name on the registry and declare it via the
    package manager, or remove the import; do **not** mark the slice `built`. The gate is deterministic
    and fail-open (not a git repo / no manifest / stdlib-only import → rc 0).
@@ -213,10 +213,10 @@ gates.
    Then, from the wright's artifact, update `state.md`,
    `evidence.md`, `touched-files.md` (and `browser-evidence.md` for UI). Add a `## Review trail`
    to `touched-files.md`: group the slice's important `path:line` stops by concern (design intent,
-   not file order), 1–5 concerns, each stop under 15 words. This is for a later human walkthrough;
+   not file order), 1-5 concerns, each stop under 15 words. This is for a later human walkthrough;
    keep it factual and skip invented rationale. **Persist every
    `Decisions stood` entry from the wright's artifact to a `## Decisions stood` section in
-   `decisions.md`, one line each ending `— doubt: <accept | reject-resolved | MISSING>`** — the
+   `decisions.md`, one line each ending `— doubt: <accept | reject-resolved | MISSING>`**: the
    verdict from step 4, or `MISSING` if step 4 was skipped for that entry. Write this ledger at
    record-time **independent of the doubt step**, so a stood decision lands on disk even when it
    was never doubted: `$rite-seal` cross-checks the ledger, and a `doubt: MISSING` entry is the
@@ -226,13 +226,13 @@ gates.
    an approach it tried and backed out of, record it under a `## Dead ends` section in
    `decisions.md` so a retry or the next agent doesn't repeat it.
    **If the wright's `Conventions` field reports a contradiction** (the live code now
-   disagrees with a held convention), record the drift — you own this bookkeeping:
+   disagrees with a held convention), record the drift. You own this bookkeeping:
    ```bash
    devrites-engine conventions contradict --key <key> --slug <slug> \
      --evidence "<what the live code does>" --drift-file .devrites/work/<slug>/drift.md
    ```
    It lowers the convention's band (or retires it) and appends a `convention-drift` entry to
-   `drift.md`. The ledger is **promoted only at `$rite-seal` on GO** — build only records
+   `drift.md`. The ledger is **promoted only at `$rite-seal` on GO**: build only records
    contradictions, never new conventions. **Evidence is the
    wright's real command output, not its say-so.** Capture per
    [`evidence-standard.md`](evidence-standard.md). Append a footprint record for this
@@ -241,10 +241,10 @@ gates.
    devrites-engine footprint log <slug> wright "<slice id>"
    ```
    If `.devrites/AFK` is present, decrement
-   the budget by running `devrites-engine tick-afk <state.md path>` —
+   the budget by running `devrites-engine tick-afk <state.md path>`:
    it decrements `state.md`'s `AFK slices remaining` field, prints the new value, and exits `3`
    when it hits 0. **Exit 3 → STOP** (forced HITL stop; the cap is exhausted). Never rewrite
-   `.devrites/AFK` `max_slices` in place — it is read-only initial budget.
+   `.devrites/AFK` `max_slices` in place. It is read-only initial budget.
 7. **STOP.** Render the progress footer, then report and recommend the next step. Run the
    shared footer (mirror of the step-0 preamble) so the slice meter + flow ribbon are
    deterministic, not model-typed:
@@ -252,7 +252,7 @@ gates.
    devrites-engine progress
    ```
    It reads `state.md` (already updated in step 6), so the meter reflects the slice you
-   just built. **When every slice is built** (`✅ ALL BUILT`) say so explicitly — the build
-   phase is complete, the next phase is `$rite-prove` — don't leave completion implicit.
+   just built. **When every slice is built** (`✅ ALL BUILT`) say so explicitly (the build
+   phase is complete, the next phase is `$rite-prove`) don't leave completion implicit.
 
-> **Mid-flight discipline.** The wright (or you, in the inline fallback) must resist doing two slices, skipping TDD, adding a defensive check, or wandering outside `touched-files.md`; you must resist skipping the post-return `devrites-doubt` because the wright "seems confident" — see [`anti-patterns.md`](anti-patterns.md). Load it the moment you reach for the excuse.
+> **Mid-flight discipline.** The wright (or you, in the inline fallback) must resist doing two slices, skipping TDD, adding a defensive check, or wandering outside `touched-files.md`; you must resist skipping the post-return `devrites-doubt` because the wright "seems confident": see [`anti-patterns.md`](anti-patterns.md). Load it the moment you reach for the excuse.

package/pack/generated/codex/skills/rite-build/reference/spec-drift-guard.md

@@ -1,6 +1,6 @@
 # Spec Drift Guard (build phase)
 
-Active throughout `$rite-build`. The spec is living, not sacred — but you may not
+Active throughout `$rite-build`. The spec is living, not sacred, but you may not
 silently code against a plan you know is wrong. This is the canonical Spec Drift Guard;
 other phases reference it here.
 

package/pack/generated/codex/skills/rite-build/reference/tdd.md

@@ -1,18 +1,18 @@
 # TDD / Prove-It pattern
 
-When a slice changes behavior, prove the change with a test that fails first — so you
+When a slice changes behavior, prove the change with a test that fails first, so you
 know the test can fail, and that your code is what makes it pass.
 
 ## Red → Green → Refactor
-1. **Red** — write the smallest test that expresses the new behavior. Run it; watch it
+1. **Red:** write the smallest test that expresses the new behavior. Run it; watch it
    fail for the *expected* reason (not a typo/import error).
-2. **Green** — write the minimum code to pass. Resist gold-plating.
-3. **Refactor** — clean up with the test as a safety net. Re-run; stay green.
+2. **Green:** write the minimum code to pass. Resist gold-plating.
+3. **Refactor:** clean up with the test as a safety net. Re-run; stay green.
 
 ## Prove-It (when strict TDD doesn't fit)
 For code where a test-first flow is awkward (exploratory glue, config, some UI), still
 produce evidence:
-- Capture the current (wrong/absent) behavior — a failing assertion, a screenshot, a
+- Capture the current (wrong/absent) behavior: a failing assertion, a screenshot, a
   log line.
 - Make the change.
 - Capture the new behavior the same way. The before/after pair *is* the proof.
@@ -21,6 +21,6 @@ produce evidence:
 - Use the project's existing test framework and commands (discovered in `spec.md` →
   "Commands discovered"). Don't introduce a new test runner to prove a slice.
 - One behavior per test; name it for the behavior, not the function.
-- A green test you never saw fail proves nothing — always see red first.
+- A green test you never saw fail proves nothing: always see red first.
 - Don't delete or weaken a failing test to "pass". If it's wrong, that may be drift.
 - Record the test command + result in `evidence.md`.

package/pack/generated/codex/skills/rite-build/reference/wright-dispatch.md

@@ -1,25 +1,25 @@
 # Slice-wright dispatch
 
-How `$rite-build` hands the **build core** of one slice to `devrites-slice-wright` — the
+How `$rite-build` hands the **build core** of one slice to `devrites-slice-wright`: the
 fresh-context, **write-capable** executor under `.codex/agents/`. Loaded on demand by
 `$rite-build`; not a skill itself. Sibling of
 [`../../devrites-lib/reference/parallel-dispatch.md`](../../devrites-lib/reference/parallel-dispatch.md)
-(the read-only reviewer fan-out) — same isolation principle, opposite direction: this one
+(the read-only reviewer fan-out): same isolation principle, opposite direction: this one
 **writes**.
 
 Pattern: the orchestrator owns the **gates and the workspace**; the wright owns the **writing**.
-Brief it precisely, in a clean context, with only the slice contract — then doubt, record, and
+Brief it precisely, in a clean context, with only the slice contract, then doubt, record, and
 gate its return.
 
 ## Why a fresh context writes the slice
 The orchestrator's window is full of spec investigation, planning, prior slices, and tool
-output — the exact "lost-in-the-middle" load that degrades instruction-following and pulls the
+output: the exact "lost-in-the-middle" load that degrades instruction-following and pulls the
 model toward generic code. The wright starts clean and sees only the contract, so it holds the
 slice boundary strictly and writes to the *project's* idiom instead of drifting. Single-threaded
-by design: **one** wright per slice, never a parallel fan-out of writers *sharing a tree* —
+by design: **one** wright per slice, never a parallel fan-out of writers *sharing a tree*:
 concurrent writers on one working tree make conflicting implicit decisions and produce incoherent
 code. The one sanctioned exception is a **forge** slice, which competes K candidates in *isolated*
-worktrees and lands exactly one — no tree ever has two authors, so the invariant holds (see
+worktrees and lands exactly one: no tree ever has two authors, so the invariant holds (see
 [Forge](#forge--competing-candidates-the-deliberate-exception)).
 
 ## The contract `$rite-build` sends
@@ -58,29 +58,29 @@ bookkeeping files; return that data. Return your structured artifact, not your t
 Rules:
 - **One `Task` call, one wright.** Never dispatch two writers on the same slice.
 - **No author reasoning beyond the contract.** Give the slice spec, not your analysis of *how*
-  to code it — a clean, undirected read is the point.
+  to code it: a clean, undirected read is the point.
 - **Name the boundary explicitly.** The scope boundary is the single most load-bearing field; an
   underspecified one is the main cause of drift.
 
-## On return — the orchestrator's job (don't delegate these)
+## On return: the orchestrator's job (don't delegate these)
 **You never edit source here.** The wright is the only writer of code + tests; you write only
 `.devrites/` bookkeeping. Every remedy below is **continue the same wright once** or **stop +
-escalate** — never an inline patch. You snapshotted the tree before dispatch (`devrites-engine reconcile snapshot`); the reconcile check in step 4 proves no source changed outside the wright's claimed
+escalate**: never an inline patch. You snapshotted the tree before dispatch (`devrites-engine reconcile snapshot`); the reconcile check in step 4 proves no source changed outside the wright's claimed
 set.
 
 1. **Doubt the surfaced decisions.** For each entry in the wright's `Decisions stood`, apply
-   `devrites-doubt` (→ `devrites-doubt-reviewer`) before accepting — the writer must not grade
+   `devrites-doubt` (→ `devrites-doubt-reviewer`) before accepting: the writer must not grade
    its own decisions. The wright's return is the not-yet-load-bearing moment (slice not `built`,
    not merged), so this post-return doubt is still pre-commit. Irreversible-risk items always
-   pause — and an irreversible item that the wright filed under `Decisions stood` instead of
+   pause, and an irreversible item that the wright filed under `Decisions stood` instead of
    `Escalation` is a protocol violation: pause and re-dispatch with it flagged out-of-bounds,
    don't doubt-and-accept.
 2. **Honor escalations.** A non-empty `Escalation` → do **not** mark the slice built. Write the
    `questions.md` entry + `state.md` `Awaiting human` (blocking gate), or route a scope change
    through `$rite-plan repair` (Spec Drift Guard). You are the canonical writer of these files.
 3. **Fail-on-red.** If `Gates` show red (or the wright couldn't verify), the slice is **not
-   built** — and you do **not** fix the code. First remedy: **continue the same wright once**
-   (`SendMessage`, carrying the failing gate + real output) so it fixes in its own context —
+   built**, and you do **not** fix the code. First remedy: **continue the same wright once**
+   (`SendMessage`, carrying the failing gate + real output) so it fixes in its own context:
    objective failures only (red gate / type / lint / missing coverage / UI browser-proof fail),
    never a contested decision. Still red after that one retry → blocking question (AFK) or
    blocking gate (HITL); `Next: $rite-plan unblock`.
@@ -89,17 +89,17 @@ set.
    slice (don't mark it built). Continue the same wright to cover it, or record a blocker.
 4. **Reconcile, then record.** First prove A1 held: write the wright's `Files changed` paths
    (one per line) to `.devrites/work/<slug>/.reconcile-claimed` and run `devrites-engine reconcile check`.
-   **Exit 5 → STOP** — a source file changed outside the wright's claimed set (A1 breach); revert
+   **Exit 5 → STOP**: a source file changed outside the wright's claimed set (A1 breach); revert
    it and re-dispatch, don't mark the slice built. Then persist the wright's artifact to
    `state.md`, `evidence.md`, `touched-files.md` (and `browser-evidence.md` for UI) per
    [`evidence-standard.md`](evidence-standard.md). Evidence is the wright's real command output,
    not its say-so. Add a concern-ordered `## Review trail` to `touched-files.md` from the wright's changed paths and summary so a human can review by design intent instead of file order. **Persist every `Decisions stood` entry to a `## Decisions stood` section in
-   `decisions.md`, one line each ending `— doubt: <accept | reject-resolved | MISSING>`** —
+   `decisions.md`, one line each ending `— doubt: <accept | reject-resolved | MISSING>`**:
    independent of the doubt step (step 1 above), so a skipped decision still lands on record for
    the seal's doubt-coverage cross-check (`- none` when the wright stood nothing). Then tick AFK if
    `.devrites/AFK` is present (`devrites-engine tick-afk`; exit 3 → STOP).
 
-## Forge — competing candidates (the deliberate exception)
+## Forge: competing candidates (the deliberate exception)
 
 The single-writer rule forbids parallel writers **sharing one tree**. A `Forge: yes` slice
 (flagged by `$rite-vet` as a genuine architecture fork at Complexity ≥4) is the one sanctioned
@@ -112,29 +112,29 @@ tree. No tree ever has two authors; exactly one author's work ships. Everything
 fail-on-red, reconcile against the winner's claimed set, record) runs on the winner as if a single
 wright had built it.
 
-Full mechanics — strategy derivation, worktree setup, the judge contract, landing + grafting the
-winner, `forge-report.md`, AFK budgeting, and the worktree-unavailable fallback — live in
+Full mechanics (strategy derivation, worktree setup, the judge contract, landing + grafting the
+winner, `forge-report.md`, AFK budgeting, and the worktree-unavailable fallback) live in
 [`forge.md`](forge.md).
 
 ## Fallback
 If the `Task` tool / sub-agent dispatch is unavailable, `$rite-build` runs the wright's
 discipline **inline** in its own context and flags it as a fallback (no clean-context benefit).
-The slice still gets the full one-slice cycle — orient → RED → implement → verify — under the
+The slice still gets the full one-slice cycle (orient → RED → implement → verify) under the
 same anti-slop charter; it just doesn't get the isolation. In this path the orchestrator is
-legitimately the writer, so write `.devrites/work/<slug>/.reconcile-inline` before editing — the
+legitimately the writer, so write `.devrites/work/<slug>/.reconcile-inline` before editing: the
 reconcile gate (step 4) skips when that sentinel is present. Mirrors the reviewer-dispatch
 fallback in
 [`../../devrites-lib/reference/parallel-dispatch.md`](../../devrites-lib/reference/parallel-dispatch.md).
 
 ## Optional pre-block hook (defense in depth)
-`devrites-engine reconcile` is the **post-hoc** gate — it always runs and catches an A1 breach at record time.
+`devrites-engine reconcile` is the **post-hoc** gate. It always runs and catches an A1 breach at record time.
 A companion **pre-block** hook, `devrites-engine hook a1-guard` (a `PreToolUse` matcher on
 `Edit|Write|MultiEdit`), stops the breach *before* the write lands. It is armed only inside the
 mid-build window (between `devrites-engine reconcile snapshot` and a clean `check`, keyed on `.reconcile-base`),
 allows the wright (subagent calls carry `agent_id`), the inline fallback (`.reconcile-inline`),
-and any `.devrites/` write — so it never touches `$rite-polish`, `$rite-quick`, or ordinary
+and any `.devrites/` write, so it never touches `$rite-polish`, `$rite-quick`, or ordinary
 manual edits. It ships **observe-only** (logs would-be blocks to `.a1-guard.log`, never blocks);
 flip to enforce with `DEVRITES_A1_HOOK=enforce` or a `.devrites/work/<slug>/.a1-enforce` file once
 the log confirms it never flags the wright's own edits (older Claude Code builds may not populate
-`agent_id` — the log is the proof before you enforce). The post-hoc gate stands on its own; the
+`agent_id`: the log is the proof before you enforce). The post-hoc gate stands on its own; the
 hook is belt-and-suspenders.