devrites 3.0.4 → 3.0.6

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

@@ -1,4 +1,4 @@
-# $rite-adopt — anti-patterns
+# $rite-adopt: anti-patterns
 
 Start with the universal table in [`../../devrites-lib/reference/standards/anti-patterns.md`](../../devrites-lib/reference/standards/anti-patterns.md).
 Below are the rationalizations specific to onboarding an existing codebase.
@@ -7,13 +7,13 @@ Below are the rationalizations specific to onboarding an existing codebase.
 
 | Excuse | Rebuttal |
 |---|---|
-| "I'll improve this messy bit while I document it." | Adoption *documents* what exists; it changes nothing. A cleanup is the *next* feature through the normal lifecycle — recording it as a drive-by here hides the baseline and balloons the diff. |
-| "This looks like the convention, so I'll seed it." | Seed only what the code *actually and consistently* follows. A guessed seed becomes a high-confidence-looking prior that steers the first slice wrong. Observe it in ≥2 places or leave it out. |
-| "I'll spec the ideal architecture, not the current one." | The spec's baseline is *current behavior*. Aspirations go in the next objective, not the baseline — otherwise every later slice drifts against a spec that never matched reality. |
-| "Whole repo in one adopt." | Onboard the area you'll actually work in. A repo-wide adopt produces an unfocused spec and a ledger full of conventions no slice will touch. |
+| "I'll improve this messy bit while I document it." | Adoption *documents* what exists; it changes nothing. A cleanup is the *next* feature through the normal lifecycle: recording it as a drive-by here hides the baseline and balloons the diff. |
+| "This looks like the convention, so I'll seed it." | Seed only what the code *and consistently* follows. A guessed seed becomes a high-confidence-looking prior that steers the first slice wrong. Observe it in ≥2 places or leave it out. |
+| "I'll spec the ideal architecture, not the current one." | The spec's baseline is *current behavior*. Aspirations go in the next objective, not the baseline: otherwise every later slice drifts against a spec that never matched reality. |
+| "Whole repo in one adopt." | Onboard the area you'll work in. A repo-wide adopt produces an unfocused spec and a ledger full of conventions no slice will touch. |
 
 ## Red flags
 
 - A seeded convention with no concrete code location behind it.
 - `spec.md` describing behavior the code does **not** currently have (that's the next feature, not the baseline).
-- Editing source during adoption — adoption writes `.devrites/` + the ledger, never project code.
+- Editing source during adoption: adoption writes `.devrites/` + the ledger, never project code.

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

@@ -11,17 +11,17 @@ 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-autocomplete — full lifecycle, unattended
+# $rite-autocomplete: full lifecycle, unattended
 
 Drives every DevRites phase in order without stopping for discretionary input. The
-prompt may be vague — autocomplete asks its clarifying questions **up front**, then
-runs to completion. It does **not** disable the safety gates: hard irreversible-risk,<!-- pack-scan-ignore: negated statement — gates are NOT disabled -->
+prompt may be vague: autocomplete asks its clarifying questions **up front**, then
+runs to completion. It does **not** disable the safety gates: hard irreversible-risk,<!-- pack-scan-ignore: negated statement: gates are NOT disabled -->
 blocking / escalating gates, and any NO-GO still pause.
 
 ## Rules consulted (read on demand from `.agents/skills/devrites-lib/reference/standards/`)
@@ -30,15 +30,15 @@ blocking / escalating gates, and any NO-GO still pause.
 ## Operating rules
 - **One human window.** Clarifying questions are batched up front via
   `devrites-interview`. After that, discretionary decisions are made automatically and
-  recorded in `decisions.md` — not asked. See [reference/decision-policy.md](reference/decision-policy.md).
+  recorded in `decisions.md`, not asked. See [reference/decision-policy.md](reference/decision-policy.md).
 - **Safety gates are not bypassable.** AFK never auto-passes destructive migration /
   auth-authz change / public-API break / external-contract change / red tests; blocking
   and escalating gates and any open `gate: validating` always pause. `--ship` auto-confirms
-  the **final** type-GO only — nothing else. A change that violates a declared project
-  principle (`.devrites/principles.md`) with no recorded exception pauses too — autocomplete
+  the **final** type-GO only: nothing else. A change that violates a declared project
+  principle (`.devrites/principles.md`) with no recorded exception pauses too: autocomplete
   never grants a principle exception on its own (`principles.md`: that's a human decision).
 - **Loop budget = the plan's own slice count, not a fixed number.** After `$rite-vet`
-  (not `$rite-define` — vet may split or add slices, so the count isn't final until then),
+  (not `$rite-define`: vet may split or add slices, so the count isn't final until then),
   set the AFK budget to however many slices the plan has, so the loop builds exactly the
   task's slices and stops when they're done. `--max-slices N` is an OPTIONAL *lower* safety
   cap (partial / babysat run); omit it to run the whole plan. The budget is finite
@@ -46,13 +46,13 @@ blocking / escalating gates, and any NO-GO still pause.
 - **Best option, recorded.** For each discretionary choice, pick the option the relevant
   specialist / reviewer favours and record the rationale. Never silently coin-flip.
 - **Strategic review runs, but never auto-grows scope.** After `$rite-spec`, run `$rite-temper`
-  (significance-gated — it skips low-stakes specs in one line). Unattended it auto-applies only
+  (significance-gated; it skips low-stakes specs in one line). Unattended it auto-applies only
   `hold-rigor` + `reduce-to-MVP` (these never grow acceptance); **any `expand` is a blocking
   pause**, and irreversible-risk findings always pause. Autocomplete hardens and may *prune* the
   spec on its own; it never *expands* the build's scope without the human.
 - **Engineering review runs on every plan, but never auto-grows scope.** After `$rite-define`,
-  run `$rite-vet` on **every** feature (depth scales — a light pass on simple plans, full rigor on
-  big/risky; never skipped). Unattended it auto-applies only *hardening* findings — added test
+  run `$rite-vet` on **every** feature (depth scales: a light pass on simple plans, full rigor on
+  big/risky; never skipped). Unattended it auto-applies only *hardening* findings: added test
   requirements, error-handling / failure-mode coverage, tightened scope, reuse-over-rebuild,
   ordering / parallel-lane fixes (these never grow acceptance); **any finding that grows scope,
   adds a slice, or changes acceptance is a blocking pause**, and irreversible-risk findings always
@@ -64,11 +64,11 @@ blocking / escalating gates, and any NO-GO still pause.
    type-GO), `--max-slices N` (OPTIONAL *lower* safety cap for a partial run; default =
    the plan's slice count, i.e. run all planned slices).
 2. **Clarify up front.** If the idea is underspecified, run `devrites-interview` to
-   ~95% confidence — the only interactive window. If already clear, skip.
+   ~95% confidence: the only interactive window. If already clear, skip.
 3. **Arm AFK.** Write `.devrites/AFK` with `allow_gates: [advisory]`; set the slice budget
    from the plan's count after `$rite-vet` (the slice count is only final post-vet), or from
    an explicit `--max-slices` ([reference/loop.md](reference/loop.md)). validating / blocking / escalating +
-   irreversible-risk still pause. Also `touch .devrites/CHECKPOINT` — an unattended run is the
+   irreversible-risk still pause. Also `touch .devrites/CHECKPOINT`: an unattended run is the
    case checkpoint mode earns its keep, so each proven slice is committed local-only as
    crash-survivable `WIP` ([rite-build/reference/checkpoint.md](../rite-build/reference/checkpoint.md));
    `$rite-ship` collapses them into the one feature commit.
@@ -84,12 +84,12 @@ blocking / escalating gates, and any NO-GO still pause.
    type-GO. Without it, render the type-GO prompt and stop for the human.
 
 > **Mid-flight discipline.** When tempted to auto-pass a blocking gate "to keep moving",
-> answer a material question yourself instead of pausing, or run past red tests — stop.
+> answer a material question yourself instead of pausing, or run past red tests: stop.
 > Autonomy is for the routine path; the gates exist for everything else.
 
 ## Output
 A compact phase-by-phase log, then the final status. **Progress first for the final
-status** — run `devrites-engine progress`, then use the shared typed states from
+status**: run `devrites-engine progress`, then use the shared typed states from
 [`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md):
 `Shipped`, `Stopped`, `Awaiting human`, `NO-GO`, or `GO`.
 

package/pack/generated/codex/skills/rite-autocomplete/reference/decision-policy.md

@@ -1,8 +1,8 @@
-# Decision policy — how autocomplete "chooses the best option"
+# Decision policy: how autocomplete "chooses the best option"
 
 Unattended ≠ careless. Every discretionary choice is made the way a senior engineer
 would, then **recorded** so the seal can audit it. The difference from interactive mode
-is only *who answers* a discretionary question — not whether it's reasoned.
+is only *who answers* a discretionary question, not whether it's reasoned.
 
 ## The rule
 
@@ -20,7 +20,7 @@ not pick the option that's merely easiest to implement.
 
 ## Defaults autocomplete may assume (record them)
 
-- Follow the project's existing conventions, components, and test commands — always.
+- Follow the project's existing conventions, components, and test commands: always.
 - Prefer the smallest vertical slice that proves the acceptance criterion.
 - Reuse → extend → build new, in that order (`coding-style.md`).
 - When two options are equivalent on the evidence, choose the lower-risk / more
@@ -29,7 +29,7 @@ not pick the option that's merely easiest to implement.
 ## When a choice is NOT autocomplete's to make
 
 If a discretionary choice would change **product behaviour, scope, data model, security
-posture, or acceptance criteria**, it is no longer discretionary — it is a material
+posture, or acceptance criteria**, it is no longer discretionary. It is a material
 question. Route it through the Spec Drift Guard / a `blocking` question and **stop**
 (see [stop-conditions.md](stop-conditions.md)). Autocomplete answers *how*, never
 *what to build* beyond what the up-front interview settled.

package/pack/generated/codex/skills/rite-autocomplete/reference/loop.md

@@ -1,8 +1,8 @@
-# The autocomplete loop — arm AFK, drive every phase
+# The autocomplete loop: arm AFK, drive every phase
 
 Autocomplete is an orchestrator: it runs the existing `/rite-*` skills in order,
 exactly as a human would, but without stopping between them. It owns no workflow of
-its own — the phases do the work; autocomplete sequences them and enforces stops.
+its own: the phases do the work; autocomplete sequences them and enforces stops.
 
 ## Arm AFK
 
@@ -16,11 +16,11 @@ allow_gates: [advisory]        # only advisory auto-handles; validating+ pause
 # caps how many run unattended (default = all the plan's slices).
 ```
 
-The budget is the plan's own slice count, not a fixed number — so the loop builds exactly
+The budget is the plan's own slice count, not a fixed number, so the loop builds exactly
 the task's slices and stops when they're done; `--max-slices N` only *lowers* it for a
 partial run. Arm the gate policy at step 3; write `max_slices` / `AFK slices remaining`
 **after `$rite-vet`** (it runs before the build loop and may split or add a slice, so the
-count isn't final until then — vet runs on every plan here, so always set the budget after it).
+count isn't final until then: vet runs on every plan here, so always set the budget after it).
 
 `allow_gates: [advisory]` is deliberate: an open `gate: validating` is merge-blocking
 at seal (`afk-hitl.md`), so autocomplete must *pause* on it rather than queue it and
@@ -30,7 +30,7 @@ then hit NO-GO. Widen `allow_gates` only if the caller explicitly asked.
 
 Run each by Reading its `SKILL.md` and executing that workflow. State flows through the
 workspace files (`state.md`, `tasks.md`, `evidence.md`, …), so each phase picks up where
-the last left off — there is nothing to thread through chat.
+the last left off. There is nothing to thread through chat.
 
 | Step | Phase | Loop / gate |
 |---|---|---|
@@ -38,7 +38,7 @@ the last left off — there is nothing to thread through chat.
 | 2 | `$rite-temper` | significance-gated strategic review; harden spec + write `strategy.md`. Skip low-stakes specs in one line. AFK: `hold-rigor` / `reduce-to-MVP` auto-apply; **any `expand` pauses (blocking)**; irreversible-risk pauses |
 | 3 | `$rite-define` | reads `strategy.md`; `plan.md` + `tasks.md`; record `Plan approved` |
 | 4 | `$rite-vet` | engineering plan review on **every** plan (light pass on simple plans, full on big/risky; never skipped); harden `plan.md` / `tasks.md` + write `eng-review.md` + `test-plan.md`. AFK: hardening / coverage findings auto-apply; **any scope-growing / acceptance-changing finding pauses (blocking)**; irreversible-risk pauses. Set the slice budget after this (vet may split a slice) |
-| 5 | `$rite-build` ×N | **loop** while any slice is `pending`; build one (the slice-wright reads `test-plan.md` for coverage), then run `devrites-engine tick-afk state.md` — exit 3 (budget hit) ⇒ STOP |
+| 5 | `$rite-build` ×N | **loop** while any slice is `pending`; build one (the slice-wright reads `test-plan.md` for coverage), then run `devrites-engine tick-afk state.md`: exit 3 (budget hit) ⇒ STOP |
 | 6 | `$rite-prove` | once all slices `built`; walks `test-plan.md`; on failure → `devrites-debug-recovery` within scope |
 | 7 | `$rite-polish` | re-verify after code edits (evidence must stay fresh) |
 | 8 | `$rite-review` | apply in-scope fixes; re-prove if code changed |
@@ -48,7 +48,7 @@ the last left off — there is nothing to thread through chat.
 ## Between phases
 
 - Re-read the active workspace before each phase (don't trust chat memory).
-- After a phase that edits code (build, polish, review), evidence may be stale — let
+- After a phase that edits code (build, polish, review), evidence may be stale: let
   the next gate re-prove rather than carrying a stale pass (see
   `.agents/skills/devrites-lib/reference/standards/development-workflow.md`).
 - Check [stop-conditions.md](stop-conditions.md) at every gate **before** advancing.

package/pack/generated/codex/skills/rite-autocomplete/reference/stop-conditions.md

@@ -1,10 +1,10 @@
-# Stop conditions — when autocomplete must pause for a human
+# Stop conditions: when autocomplete must pause for a human
 
 Autonomy covers the routine path. These are the cases where autocomplete writes
 `state.md` (`Status: awaiting_human` or `blocked`), surfaces *why* + the single resume
 command, fires `notify` if set, and **stops**. None are bypassable by `--ship`.
 
-## Always stop (irreversible-risk list — from `afk-hitl.md`)
+## Always stop (irreversible-risk list: from `afk-hitl.md`)
 
 Regardless of `allow_gates` or `--ship`:
 - Destructive data migration (drop column/table, irreversible backfill).
@@ -23,8 +23,8 @@ Regardless of `allow_gates` or `--ship`:
 
 ## Stop on strategic-review scope expansion (`$rite-temper`)
 
-- `$rite-temper` choosing scope mode `expand` — or otherwise **adding** any acceptance
-  criterion to `spec.md` — → synchronous pause, regardless of `allow_gates` / `--ship`.
+- `$rite-temper` choosing scope mode `expand`, or otherwise **adding** any acceptance
+  criterion to `spec.md`: → synchronous pause, regardless of `allow_gates` / `--ship`.
   Autocomplete may auto-apply only `hold-rigor` and `reduce-to-MVP` (they harden / prune and
   never grow the build's scope); **growing scope unattended is never automatic**. A low-stakes
   spec that temper skips, or a `hold-rigor` / `reduce-to-MVP` run, does **not** pause.
@@ -35,13 +35,13 @@ Regardless of `allow_gates` or `--ship`:
   direction. Do not round NO-GO up to GO.
 - **Spec Drift Guard fires** (`$rite-build` finds the plan is wrong and the change
   alters product behaviour) → stop; route through `$rite-plan repair`.
-- **Budget exhausted with slices still pending** — `devrites-engine tick-afk` exit 3 while `tasks.md`
+- **Budget exhausted with slices still pending:** `devrites-engine tick-afk` exit 3 while `tasks.md`
   still has unbuilt slices (only when an explicit `--max-slices` capped the run below the
   plan's count) → stop; report slices remaining. Exhausting the default budget = all
   planned slices built = normal completion → continue to `$rite-prove`, don't pause.
-- **Still low-confidence after the interview** — the idea can't be pinned to testable
+- **Still low-confidence after the interview:** the idea can't be pinned to testable
   acceptance criteria → stop and ask, rather than guessing the product.
-- **Repeated failure** — a phase fails, `devrites-debug-recovery` can't fix it within
+- **Repeated failure:** a phase fails, `devrites-debug-recovery` can't fix it within
   scope after a bounded number of attempts → stop with the reproduction.
 
 ## The final type-GO

package/pack/generated/codex/skills/rite-build/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-build — one verified slice
+# $rite-build: one verified slice
 
 Build the next single slice, leave it working and proven, then **stop**. **Read the
 active workspace first**; if none, tell the user to run `$rite-spec <feature>`.
@@ -30,55 +30,55 @@ run the post-return gates (doubt, fail-on-red, record, stop). See
 
 ## Rules consulted (read on demand from `.agents/skills/devrites-lib/reference/standards/`)
 Read `.agents/skills/devrites-lib/reference/standards/core.md` first (workflow step 0). The
-following load on demand — **the wright reads them** (they are named in its contract) while it
+following load on demand: **the wright reads them** (they are named in its contract) while it
 writes; read them yourself for the doubt/record gates or in the inline fallback:
-- `coding-style.md` — naming, function shape, guard clauses, comments, reuse-first.
-- `error-handling.md` — fail fast, no silent catches, fail closed.
-- `testing.md` — pyramid, behaviour over implementation, see-it-fail-first.
-- `patterns.md` — composition over inheritance, avoid premature abstraction.
-- `principles.md` — the project invariants (`.devrites/principles.md`) the slice must honor; the wright reads them as **binding**, not priors.
-- `security.md` — when the slice touches user input, auth, data, or external integrations.
-- `definition-of-done.md` — standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
+- `coding-style.md`: naming, function shape, guard clauses, comments, reuse-first.
+- `error-handling.md`: fail fast, no silent catches, fail closed.
+- `testing.md`: pyramid, behaviour over implementation, see-it-fail-first.
+- `patterns.md`: composition over inheritance, avoid premature abstraction.
+- `principles.md`: the project invariants (`.devrites/principles.md`) the slice must honor; the wright reads them as **binding**, not priors.
+- `security.md`: when the slice touches user input, auth, data, or external integrations.
+- `definition-of-done.md`: standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
 
 
 ## Operating rules
 - **One slice at a time. DO NOT** start the next slice without the user asking.
-- Evidence over confidence. Prefer existing conventions. Feature scope only — no
+- Evidence over confidence. Prefer existing conventions. Feature scope only: no
   drive-by refactors.
 - **Noticed, not touched.** An adjacent smell the wright sees outside `touched-files.md` is
-  recorded as an FYI follow-up in `decisions.md`, never fixed inline — the slice's change summary
+  recorded as an FYI follow-up in `decisions.md`, never fixed inline: the slice's change summary
   states what it *deliberately left alone* ([`git-workflow.md`](../devrites-lib/reference/standards/git-workflow.md) "Things
   I didn't touch"), so the reviewer reads a feature-scoped diff, not a renovation. The `devrites-engine reconcile`
   gate (step 6) enforces this by exit code.
 - **Don't re-run an unchanged check.** Re-running the same build/test command on code that hasn't
-  changed since proves nothing new — it's motion, not evidence. Re-verify after an edit, not before.
+  changed since proves nothing new. It's motion, not evidence. Re-verify after an edit, not before.
 - Surface material assumptions; ask before adding dependencies or a second design
   system. The [Spec Drift Guard](reference/spec-drift-guard.md) is active throughout.
 - **Avoid AI slop while writing.** `devrites-slice-wright` enforces the anti-slop charter **at
-  the source** — the canonical do-not list is `rite-polish/reference/anti-ai-slop.md` (the
+  the source**: the canonical do-not list is `rite-polish/reference/anti-ai-slop.md` (the
   wright reads it; don't restate it here). It writes the code the *project* would write, in its
-  idiom, reusing before building; **you verify the charter held on return** — you do not re-list
+  idiom, reusing before building; **you verify the charter held on return**. You do not re-list
   it and you do not fix slop by editing source. Polish catches what slips; build prevents.
-  The **prose you write yourself** — `evidence.md`, `decisions.md`, the slice report — follows
+  The **prose you write yourself** (`evidence.md`, `decisions.md`, the slice report) follows
   the human-voice charter (`.agents/skills/devrites-lib/reference/standards/prose-style.md`; depth in `devrites-prose-craft`): no
   filler openers, no marketing adjectives, exact commands and identifiers kept verbatim.
 - **Honor declared project principles.** The wright reads `.devrites/principles.md` and treats
-  each invariant as **binding** (not a prior to weigh like a convention) — a slice it cannot build
+  each invariant as **binding** (not a prior to weigh like a convention): a slice it cannot build
   without breaking one is an **Escalation**, not a silent violation. On return **you verify no
-  principle was broken**; a fresh violation is handled like any irreversible-risk item — a
+  principle was broken**; a fresh violation is handled like any irreversible-risk item: a
   human-approved, scoped exception in the register or a stop, never folded into the slice. No
   `.devrites/principles.md` → none declared → nothing to honor.
-- **You never edit source — the wright is the only writer of code + tests.** You write only
+- **You never edit source: the wright is the only writer of code + tests.** You write only
   `.devrites/` bookkeeping. On any red gate, doubt finding, or coverage gap your only remedies
-  are **continue the same wright once** (it fixes in its own context) or **stop + escalate** —
+  are **continue the same wright once** (it fixes in its own context) or **stop + escalate**:
   never patch the code yourself. The `devrites-engine reconcile` gate (step 6) enforces this by exit code:
   any source file changed outside the wright's claimed set is a hard STOP.
-- **A `Forge: yes` slice competes candidates — one author still lands.** When `$rite-vet`
-  flagged the slice a genuine architecture fork, step 3 runs K=2–3 candidate wrights in
+- **A `Forge: yes` slice competes candidates: one author still lands.** When `$rite-vet`
+  flagged the slice a genuine architecture fork, step 3 runs K=2-3 candidate wrights in
   **isolated worktrees** and lands exactly one winner's diff; the single-writer invariant holds
   because no tree ever has two authors and only the winner reaches the working tree. You still
   never edit source, and reconcile runs against the winner's claimed set. The default slice is
-  single-path — forge is the rare exception ([`reference/forge.md`](reference/forge.md)).
+  single-path: forge is the rare exception ([`reference/forge.md`](reference/forge.md)).
 
 ## Workflow
 

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

@@ -1,4 +1,4 @@
-# AFK discipline — running `$rite-build` unattended without burning the trunk
+# AFK discipline: running `$rite-build` unattended without burning the trunk
 
 AFK mode is `.devrites/AFK` present. It lets `$rite-build` chain slices without per-slice
 user input. The discipline below is what keeps an AFK loop from drifting into damage.
@@ -25,13 +25,13 @@ notify: "ntfy.sh/my-topic"           # shell command run on awaiting_human trans
 allow_gates: [advisory, validating]  # gate severities AFK may auto-handle
 ```
 
-`.devrites/AFK` is **read-only config** — never rewritten in place. `max_slices` is the
+`.devrites/AFK` is **read-only config**: never rewritten in place. `max_slices` is the
 initial budget; the mutable remaining count lives in `state.md` as `AFK slices remaining:
 <n>`, seeded from `max_slices` on the first AFK build and decremented by `devrites-engine tick-afk`
 (see "Iteration cap").
 
 Defaults when keys are omitted:
-- `max_slices`: unlimited (a missing cap is risky — see "Always cap iterations").
+- `max_slices`: unlimited (a missing cap is risky: see "Always cap iterations").
 - `notify`: none.
 - `allow_gates`: `[advisory]`.
 
@@ -44,13 +44,13 @@ into HITL.
 remaining` by 1 each time a slice is marked `built`, by running
 `devrites-engine tick-afk <state.md path>`. The script reads the
 field, decrements, writes it back, prints the new value, and **exits `3` when it hits 0**.
-The cap is enforced by `devrites-engine tick-afk`, not by prose — when it exits 3:
+The cap is enforced by `devrites-engine tick-afk`, not by prose, when it exits 3:
 
 - `$rite-build` treats exit 3 as a forced HITL stop:
   ```
   AFK cap reached. Raise `state.md` `AFK slices remaining` or remove the sentinel to continue.
   ```
-- The workspace stays consistent — no half-built slice, no pending question.
+- The workspace stays consistent: no half-built slice, no pending question.
 
 Step 0 re-derives the remaining budget from `state.md` (seeding it from `.devrites/AFK`
 `max_slices` on the first AFK build); `max_slices` itself is read-only and never rewritten.
@@ -66,7 +66,7 @@ types / lint are red. The reasoning:
 
 - A red signal means either the slice's contract is wrong or the failing code is. Neither
   is something AFK can resolve.
-- Marking it `built` and letting the AFK loop chain to the next slice burns the trunk —
+- Marking it `built` and letting the AFK loop chain to the next slice burns the trunk:
   the next slice builds on broken state.
 
 The fail-on-red path:
@@ -92,7 +92,7 @@ any of:
   rewriting `.gitignore`-listed paths, deleting fixtures).
 - Anything the slice's `Gate: blocking` plus `tasks.md` `Why HITL:` flags as irreversible.
 
-The list is the same one Claude Code auto-mode's transcript classifier protects — adapted
+The list is the same one Claude Code auto-mode's transcript classifier protects: adapted
 to DevRites's workspace shape.
 
 ## The `notify:` hook contract
@@ -117,13 +117,13 @@ Example targets:
 - `osascript -e "display notification \"$DEVRITES_QUESTION\" with title \"DevRites: $DEVRITES_GATE\""`
 - `pb push "$DEVRITES_SLUG: $DEVRITES_QUESTION"` (via pushbullet CLI)
 
-DevRites owns no notification logic — the hook is a seam, not a feature.
+DevRites owns no notification logic: the hook is a seam, not a feature.
 
 ## When to leave AFK
 
 Drop the sentinel before:
 
-- A novel feature where you have not yet seen `$rite-build` work on this codebase HITL —
+- A novel feature where you have not yet seen `$rite-build` work on this codebase HITL:
   Ralph's progression: HITL first → refine prompt → AFK once trusted.
 - A risky slice you marked `Mode: HITL` and want to walk through interactively even if
   the gate is technically `validating`.

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

@@ -1,4 +1,4 @@
-# rite-build — anti-patterns
+# rite-build: anti-patterns
 
 Load this when standing a non-trivial implementation decision, or when the
 agent feels reluctance toward stopping after one slice, applying TDD, or
@@ -19,18 +19,18 @@ generic AI naming, drive-by refactors): see
 
 | Excuse | Rebuttal |
 |---|---|
-| "This slice is hard — I'll forge it." | Hard ≠ forkable. Forge competes ≥2 *genuinely-different* approaches with no clear winner. One hard approach is single-path; building it K times wastes K× for one answer. |
+| "This slice is hard. I'll forge it." | Hard ≠ forkable. Forge competes ≥2 *genuinely-different* approaches with no clear winner. One hard approach is single-path; building it K times wastes K× for one answer. |
 | "I'm not sure which approach is right, so let me compete them and decide." | Forge is for a real fork the plan couldn't settle, not for dodging a decision you can make now. Decide from the code/docs first; forge only when the alternatives are genuinely undecidable on paper. |
-| "Candidate A's data layer plus B's UI would be the best of both." | Don't hand-merge candidates — two authors in one tree is the incoherence the single-writer rule exists to prevent. Land one winner whole; graft a *specific* runner-up idea only by continuing the winning wright once. |
-| "The judge already scored these, so I can skip the post-return doubt." | The judge picks *between* candidates; it doesn't replace doubting the winner's standing decisions. Steps 4–7 run on the winner unchanged. |
-| "A fourth candidate might be even better." | K is capped at 3. A fourth rarely moves the winner and multiplies cost; if none of three is right, the plan is wrong — `$rite-plan repair`, don't add candidates. |
+| "Candidate A's data layer plus B's UI would be the best of both." | Don't hand-merge candidates: two authors in one tree is the incoherence the single-writer rule exists to prevent. Land one winner whole; graft a *specific* runner-up idea only by continuing the winning wright once. |
+| "The judge already scored these, so I can skip the post-return doubt." | The judge picks *between* candidates; it doesn't replace doubting the winner's standing decisions. Steps 4-7 run on the winner unchanged. |
+| "A fourth candidate might be even better." | K is capped at 3. A fourth rarely moves the winner and multiplies cost; if none of three is right, the plan is wrong: `$rite-plan repair`, don't add candidates. |
 
 ## Red Flags
 
 - About to start slice N+1 without the user asking.
 - Skipping `devrites-doubt` on a branching, boundary, data-model, auth, public-API, or migration decision.
 - Adding a dependency or a second design system without recording rationale in `decisions.md`.
-- Writing a `try/catch` block wider than what you actually handle.
+- Writing a `try/catch` block wider than what you handle.
 - A comment that restates what the next line does.
 - Touching files that aren't in `touched-files.md` for "tidiness".
 - Forging a slice with no acceptance / `test-plan.md` coverage for the judge to score against.

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

@@ -1,12 +1,12 @@
-# Checkpoint protocol — what `$rite-build` does when a slice is HITL
+# Checkpoint protocol: what `$rite-build` does when a slice is HITL
 
 When `$rite-build` reaches a slice with `Mode: HITL`, it does **not** start writing code. It
 surfaces the checkpoint as a ranked **option set** and resolves it **before** any code lands:
 
-- **Human present (interactive)** — ask inline via `AskUserQuestion` (the option set below).
+- **Human present (interactive):** ask inline via `AskUserQuestion` (the option set below).
   The human picks; record the pick to `questions.md` (`answered`) + `decisions.md`, clear the
-  gate, and **continue building in place** — no STOP, no `$rite-resolve` round-trip.
-- **Human absent / AFK-pausing / notify-only** — persist the checkpoint (`questions.md` open +
+  gate, and **continue building in place**: no STOP, no `$rite-resolve` round-trip.
+- **Human absent / AFK-pausing / notify-only:** persist the checkpoint (`questions.md` open +
   `state.md` `Awaiting human`), fire the `notify:` hook, and **stop**. Resume later via
   `$rite-resolve` (or `--batch`).
 
@@ -15,13 +15,13 @@ Either way the pause is **pre-action**, not post-action: code never lands before
 ## Render contract
 
 The checkpoint must be rendered in user-facing output **and** persisted to the workspace.
-Both are required — the output is for the human in the room (or the notification target),
+Both are required: the output is for the human in the room (or the notification target),
 the persisted form is for the next session or the AFK observer.
 
-### User-facing render — the option set
+### User-facing render: the option set
 
 Present the checkpoint as an `AskUserQuestion` with a ranked **option set**
-(`afk-hitl.md` → "Option set"): 2–4 options, **recommended first** + labelled `(Recommended)`,
+(`afk-hitl.md` → "Option set"): 2-4 options, **recommended first** + labelled `(Recommended)`,
 each option's description carrying the dimension-tagged rationale + the trade-off it accepts,
 plus the escape hatch. The header names the slice + gate:
 
@@ -35,7 +35,7 @@ Slice <N — name> — HITL (<gate>, SLA <SLA>). <Checkpoint text from tasks.md>
   4. Something else — I'll describe it
 ```
 
-The recommended option (#1) is **required** — a checkpoint without a recommendation is a worse
+The recommended option (#1) is **required**: a checkpoint without a recommendation is a worse
 interrupt than one with shape; the human reacts to a ranked draft faster than to a blank prompt
 (the "give the human something to approve" rule). The recommendation reflects *this* project
 (its conventions, stack, scale), not a generic default. On an interactive pick, resolve in
@@ -93,14 +93,14 @@ In one atomic write (one `state.md` rewrite + one `questions.md` append):
    ```
 
    The hook fires after the workspace write so the notification target sees a workspace
-   that already records the pause. Failures in the hook **do not** roll back the pause —
+   that already records the pause. Failures in the hook **do not** roll back the pause:
    the gate is authoritative; the notification is best-effort.
 
 ## qid generation
 
 Format: `q-YYYY-MM-DD-NNN`, where `NNN` is the next sequential integer for that date in
 `questions.md`. For the write side, call
-`devrites-engine resolve next-qid <questions.md path>` — it
+`devrites-engine resolve next-qid <questions.md path>`. It
 counts existing `## q-YYYY-MM-DD-` headers for today, prints the next zero-padded id, and
 refuses to print an id whose header already exists. Use that id verbatim so each qid is
 unique within the date.
@@ -114,7 +114,7 @@ If `.devrites/AFK` exists and the slice's `Gate` is in `allow_gates`, `$rite-bui
   `decisions.md`, and **dispatch the wright** to build the slice (workflow step 3).
 - For `validating` (only when `allow_gates` includes it): **dispatch the wright** (step 3); on
   return, write a `gate: validating` entry to `questions.md`, mark the slice
-  `built (pending review)` in `state.md`, and continue. A slice's only states are `pending` and `built` —
+  `built (pending review)` in `state.md`, and continue. A slice's only states are `pending` and `built`:
   acceptance is proven at the **feature** level by `$rite-prove` (recorded in
   `evidence.md`), not per slice. The `built (pending review)` slice is not done until the
   open `validating` gate resolves via `$rite-resolve`; an open `validating` gate is a
@@ -122,8 +122,8 @@ If `.devrites/AFK` exists and the slice's `Gate` is in `allow_gates`, `$rite-bui
 
 For gates in `allow_gates`, AFK **auto-picks the recommended option** (option 1 of the set)
 instead of pausing, recording it as above. For `blocking` and `escalating` (and every
-irreversible-risk item), AFK **always** invokes the checkpoint protocol — the sentinel does
-not unlock these gates — **unless `allow_irreversible: true`** is set, which makes AFK
+irreversible-risk item), AFK **always** invokes the checkpoint protocol: the sentinel does
+not unlock these gates: **unless `allow_irreversible: true`** is set, which makes AFK
 auto-pick the recommendation on *every* gate, irreversible included (maximal autonomy, opt-in;
 see `afk-hitl.md`). See `afk-discipline.md` for the irreversible-risk list.
 
@@ -141,7 +141,7 @@ written as a single block.
   updates means the workspace lies on `/clear`.
 - **Don't self-answer a question that *paused* for a human.** When a gate stopped the session
   (an AFK queue, or a HITL pause the human walked away from), `$rite-resolve` requires an
-  explicit answer — the agent doesn't confirm its own `proposed:` on resume. This is distinct
+  explicit answer: the agent doesn't confirm its own `proposed:` on resume. This is distinct
   from the two legitimate auto-resolutions: an interactive `AskUserQuestion` pick the human
   just made, and an AFK auto-pick of the recommended option on a gate `allow_gates` permits.
 - **Don't bundle the `notify:` hook output into chat.** Fire-and-forget; the chat already

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

@@ -1,18 +1,18 @@
-# Checkpoint — crash-survivable WIP commits (opt-in)
+# Checkpoint: crash-survivable WIP commits (opt-in)
 
 `.devrites/` markdown survives compaction, but a slice's *source* stays uncommitted until
-`$rite-ship`. A crash or killed session mid-build — the AFK / `$rite-autocomplete` case —
+`$rite-ship`. A crash or killed session mid-build: the AFK / `$rite-autocomplete` case:
 loses that source **and** the reasoning behind it. Checkpoint mode commits each proven
 slice as a local `WIP`, so the work and its context outlive the session.
 
 ## When it's on
-Opt-in via the `.devrites/CHECKPOINT` sentinel — the mirror of `.devrites/AFK`. Absent →
+Opt-in via the `.devrites/CHECKPOINT` sentinel: the mirror of `.devrites/AFK`. Absent →
 no checkpoints; `$rite-build` behaves exactly as before. A long unattended run
 (`$rite-autocomplete`) is the case it earns its keep, so that path sets the sentinel for
-the run. **Local-only by rule:** a checkpoint is never pushed — scratch work must not
+the run. **Local-only by rule:** a checkpoint is never pushed: scratch work must not
 trigger CI.
 
-## The checkpoint commit — orchestrator, at RECORD, after gates are green
+## The checkpoint commit: orchestrator, at RECORD, after gates are green
 A checkpoint records a **proven** slice; it fires only after PROVE is green, never on a red
 gate. Stage only the slice's `touched-files.md`, then commit locally with a
 `[devrites-context]` body a cold reader can restore from:
@@ -29,14 +29,14 @@ BODY
 ```
 
 ## Restore
-The commit body is a durable record, not just a marker. After a crash, a fresh session —
-or `$rite-status` — reads the last `WIP(<slug>)` body to reconstruct the decisions,
+The commit body is a durable record, not just a marker. After a crash, a fresh session:
+or `$rite-status`: reads the last `WIP(<slug>)` body to reconstruct the decisions,
 remaining slices, and dead-ends that in-session `.devrites/` state would have held. No
 special tooling: it's a git log entry any agent can read.
 
 ## Collapse at ship
 WIP commits are scratch and never reach shared history. `$rite-ship` folds them into the
-one atomic feature commit before the Conventional-Commit ladder — see the collapse step in
+one atomic feature commit before the Conventional-Commit ladder: see the collapse step in
 [git-ship.md](../../rite-ship/reference/git-ship.md). Result: one clean commit, bisect
 stays green.
 

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

@@ -26,7 +26,7 @@ Evidence beats confidence. A slice isn't built until there's a record that prove
 ```
 
 ## Honesty rules
-- If a test fails, record the failure and the output — don't hide it.
+- If a test fails, record the failure and the output: don't hide it.
 - If a step was skipped (no browser available, command not found), say so and record
   the manual verification steps instead.
 - Unproven acceptance criteria stay unchecked. The seal will catch them.