devrites 3.0.4 → 3.0.6

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

@@ -12,13 +12,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-dogfood — diff-scoped browser QA
+# $rite-dogfood: diff-scoped browser QA
 
 Dogfood what changed as a user journey. This complements `$rite-prove`: prove checks acceptance; dogfood finds journey breaks and paper cuts.
 
@@ -58,4 +58,4 @@ required, use `Stopped / blocked` or `Awaiting human`; do not recommend `$rite-p
 ## Gotchas
 - A page list is not a journey map; draw the flow first.
 - A screenshot path is not proof; open it and describe what changed.
-- Do not “fix” ambiguous UX intent just to clear the matrix.
+- Do not "fix" ambiguous UX intent just to clear the matrix.

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

@@ -1,7 +1,7 @@
 ---
 name: rite-explain
 description: User-invoked explainer that teaches one concept, diff, idea, or recent-work recap with an optional retrieval check-in.
-argument-hint: "[a concept | a diff ref | an idea | \"what did I do this week?\"] — or bare to be asked"
+argument-hint: "[a concept | a diff ref | an idea | \"what did I do this week?\"], or bare to be asked"
 user-invocable: true
 disable-model-invocation: true
 ---
@@ -12,25 +12,25 @@ 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-explain — the human half of the learning loop
+# $rite-explain: the human half of the learning loop
 
 Agent-driven development removed the learning that writing code by hand used to give the
 developer. When the agent writes the code, the human stops absorbing the codebase. `$rite-explain`
-is the replacement: it teaches the developer **one** thing well — a concept, a change, an idea, or
-a window of their own recent work — so they keep learning while the agents do the writing. For a
+is the replacement: it teaches the developer **one** thing well (a concept, a change, an idea, or
+a window of their own recent work) so they keep learning while the agents do the writing. For a
 specific change, it can instead write a **walkthrough**: a human review guide organized by concern,
 risk stops, and manual observations.
 
 This is the **complement of [`$rite-learn`](../rite-learn/SKILL.md)**, and the two together are
-the whole compounding story. `$rite-learn` teaches the **repo** — it promotes recurring lessons
-into rules and principles the next feature reads. `$rite-explain` teaches the **person** — the
-mental model the next feature needs a human to actually hold. A team that only runs `$rite-learn`
+the whole compounding story. `$rite-learn` teaches the **repo**. It promotes recurring lessons
+into rules and principles the next feature reads. `$rite-explain` teaches the **person**: the
+mental model the next feature needs a human to hold. A team that only runs `$rite-learn`
 compounds a codebase whose own maintainers understand it less each week. Run both.
 
 Read-only against source. It reads artifacts and code; it writes exactly one explainer file to
@@ -38,9 +38,9 @@ Read-only against source. It reads artifacts and code; it writes exactly one exp
 
 ## Who the explainer is for
 
-The developer, personally. Dense, technical, one voice — no audience adaptation, no "for
+The developer, personally. Dense, technical, one voice: no audience adaptation, no "for
 beginners" softening, no executive summary. It is a display artifact: no embedded quizzes or
-widgets — the check-in (below) happens live in the session, where an answer can actually be
+widgets: the check-in (below) happens live in the session, where an answer can be
 graded. If the user asked for prep for a meeting or a teammate, it preps **them** to explain the
 thing; it does not produce the deck.
 
@@ -48,10 +48,10 @@ thing; it does not produce the deck.
 
 Dispatch by task shape, per [`devrites-lib/reference/model-tiers.md`](../devrites-lib/reference/model-tiers.md):
 
-- **extraction tier** — the work-recap scout and any repo-profiling: search-and-quote, run under a
+- **extraction tier:** the work-recap scout and any repo-profiling: search-and-quote, run under a
   read budget, write findings to the run's scratch dossier, return only a gist.
-- **ceiling tier** — the explainer composition and the check-in reasoning. These run inline in the
-  orchestrator's own model; nothing is dispatched down. Teaching quality is the whole product — do
+- **ceiling tier:** the explainer composition and the check-in reasoning. These run inline in the
+  orchestrator's own model; nothing is dispatched down. Teaching quality is the whole product: do
   not cheapen it.
 
 The degradation rule in that file applies: no per-agent model control → run the scout inline under
@@ -59,26 +59,26 @@ the same budget.
 
 ## Workflow
 
-### 1. Classify the input — load the intake reference
+### 1. Classify the input: load the intake reference
 
 The four input shapes (concept · diff · idea · work-recap) each ground and compose differently,
 and each drives a different check-in. Diff inputs also branch into explainer vs walkthrough
 composition. Getting the shape wrong wastes the whole artifact.
 
-**Load [`reference/intake.md`](reference/intake.md) now** — it owns the classification rules, the
+**Load [`reference/intake.md`](reference/intake.md) now**. It owns the classification rules, the
 `diff:` / `since:` / `output:` token table, the concept-vs-diff tiebreak, and the check-in
 mechanics per shape. Do not improvise classification from this file; the detail lives there so this
 one stays legible, and skipping it means guessing the shape.
 
 **Bare invocation** (no input): ask **one** blocking question (`AskUserQuestion` when the harness
-has it, else the harness's blocking-question tool — `request_user_input` on Codex) — "What should I
-explain?" — offering "a recap of my recent work in this repo" as a shortcut option alongside free
+has it, else the harness's blocking-question tool: `request_user_input` on Codex). "What should I
+explain?": offering "a recap of my recent work in this repo" as a shortcut option alongside free
 text. Never emit a default explainer unprompted.
 
 ### 2. Ground
 
 Match grounding to the shape (full rules in the intake reference). DevRites gives you grounding for
-free — prefer it over re-deriving:
+free: prefer it over re-deriving:
 
 - A **diff** or **recap** → the workspace and archive: `seal.md`, `evidence.md`, `decisions.md`,
   `traceability.md`, the shipped `.devrites/archive/<slug>/`, and `git log` / `git diff`.
@@ -105,13 +105,13 @@ Otherwise write one dense artifact at `$RUN_DIR/explainer.md`. It must **teach**
    teach the highest-leverage slice and say what you cut.
    **Completion:** the first two lines state one takeaway and any deferred topics.
 2. **Build the model, don't list facts.** Start from what the developer already knows in *this*
-   codebase and move to the new thing. Concrete before abstract — a real symbol, file, or line
+   codebase and move to the new thing. Concrete before abstract: a real symbol, file, or line
    from the grounding beats a generic example every time.
    **Completion:** the explanation connects a known project anchor to the new model without a fact dump.
 3. **Show the load-bearing detail.** Quote the actual diff hunk, the real function, the specific
-   config — with `file:line` pointers so the developer can go read it.
+   config, with `file:line` pointers so the developer can go read it.
 4. **Visual where it earns it.** A small diagram, a before/after, or a worked trace when the shape
-   is spatial or sequential. Not decoration — only when it carries the idea faster than prose.
+   is spatial or sequential. Not decoration: only when it carries the idea faster than prose.
    **Completion:** the visual carries a named relationship faster than prose, or this branch is explicitly skipped.
 5. **Human voice.** Follow [`prose-style.md`](../devrites-lib/reference/standards/prose-style.md):
    no throat-clearing, no false-binary contrast, no marketing adjectives. One senior engineer
@@ -120,7 +120,7 @@ Otherwise write one dense artifact at `$RUN_DIR/explainer.md`. It must **teach**
 ### 4. Offer the check-in (optional, active recall)
 
 Retention comes from *retrieving*, not re-reading. After the explainer, offer one check-in via the
-harness's blocking-question tool (`AskUserQuestion`, or `request_user_input` on Codex) — the user
+harness's blocking-question tool (`AskUserQuestion`, or `request_user_input` on Codex): the user
 answers **first**, then you confirm or correct. The shape sets the
 form (mechanics in the intake reference):
 
@@ -138,7 +138,7 @@ not force it; offer once.
   rest as "next time".
 - **Ground it or don't claim it.** A concept explainer with no `file:line` or real example is a
   Wikipedia paragraph. If it has footprint in this repo, quote the repo.
-- **Not a review.** `$rite-explain` never judges the code or files findings — that is `$rite-review`.
+- **Not a review.** `$rite-explain` never judges the code or files findings, that is `$rite-review`.
   It explains what *is*, adversarially neutral.
 - **Not `$rite-learn`.** It writes to `.devrites/explainers/`, never to `learnings.md`,
   `principles.md`, or any rule file. Teaching the human is not promoting a repo rule.

package/pack/generated/codex/skills/rite-explain/reference/intake.md

@@ -1,4 +1,4 @@
-# rite-explain intake — classify the input, then ground and check-in by shape
+# rite-explain intake: classify the input, then ground and check-in by shape
 
 Owned by `$rite-explain`. Loaded at Phase 1 because the four input shapes ground, compose, and
 check-in differently, and this detail would bloat the SKILL if inlined. This file is the single
@@ -9,11 +9,11 @@ source for classification; the SKILL improvises none of it.
 | Shape | The input is… | Grounds in | Composes as | Check-in |
 |---|---|---|---|---|
 | **concept** | a named idea / pattern / technology ("explain optimistic locking", "how does our gate engine work") | this repo's footprint of the concept (codegraph first) + external sources only if they sharpen it | build the mental model from a known part of *this* codebase outward | **checked exercise** |
-| **diff** | a specific change — a ref, a slice, a PR, "this diff" | `git diff` / the hunks + `decisions.md` + `seal.md` for the *why* + `touched-files.md` `Review trail` when present | explainer, or **walkthrough** when the user asks to review/approve/checkpoint the change | **predict-then-reveal** |
+| **diff** | a specific change: a ref, a slice, a PR, "this diff" | `git diff` / the hunks + `decisions.md` + `seal.md` for the *why* + `touched-files.md` `Review trail` when present | explainer, or **walkthrough** when the user asks to review/approve/checkpoint the change | **predict-then-reveal** |
 | **idea** | a hypothesis or "what if" with no code yet | the user's framing + prior art (external, date-weighted; year is 2026) | steelman the idea, name its hinge and its failure mode | **checked exercise** |
 | **recap** | a time window of the user's own work ("what did I ship this week") | the shipped archive + `git log`/`git diff` over the window + `evidence.md` | narrate what changed and what was learned, ranked by leverage | **predict-then-reveal** |
 
-## Token overrides — explicit beats inferred
+## Token overrides: explicit beats inferred
 
 If the user's input carries any of these tokens, they **override** shape inference:
 
@@ -30,20 +30,20 @@ use the diff shape with walkthrough composition.
 
 ## Tiebreaks
 
-- **concept vs diff** — if the input names both a concept *and* a specific change ("explain how
+- **concept vs diff:** if the input names both a concept *and* a specific change ("explain how
   this diff does optimistic locking"), it is a **diff** explainer that teaches the concept through
   the change. Ground in the diff; use the concept as the model to build.
-- **idea vs concept** — if the thing exists in the codebase or the wider world already, it is a
+- **idea vs concept:** if the thing exists in the codebase or the wider world already, it is a
   **concept** (teach what is). If it is a proposal not yet built, it is an **idea** (teach whether
   it holds).
-- **conflict** — a token and the prose disagree (`diff:` set but the text asks to explain a
+- **conflict:** a token and the prose disagree (`diff:` set but the text asks to explain a
   concept) → the token wins for shape; honor the prose for emphasis. State the resolution in one
   line at the top of the explainer.
 
 ## Check-in mechanics
 
 Retention comes from retrieval. Offer exactly one check-in via the harness's blocking-question tool
-(`AskUserQuestion`, or `request_user_input` on Codex); the user answers **before** any reveal. Grade honestly — a wrong prediction that gets corrected teaches more than a
+(`AskUserQuestion`, or `request_user_input` on Codex); the user answers **before** any reveal. Grade honestly: a wrong prediction that gets corrected teaches more than a
 confirmed one, so do not lead the witness.
 
 ## Walkthrough composition (diff only)
@@ -51,26 +51,26 @@ confirmed one, so do not lead the witness.
 A walkthrough is for human review, not retention. Write it under the normal run directory as
 `walkthrough.md` and include:
 
-1. **Intent** — one sentence naming what the change is for, grounded in `spec.md` / `decisions.md` when available.
-2. **Scope** — files changed, modules touched, and boundary crossings.
-3. **Concern walkthrough** — group `path:line` stops by design intent, not file order. Prefer the existing `touched-files.md` `Review trail`; generate one from the diff only when absent.
-4. **Risk stops** — 2–5 highest-blast-radius places to inspect, tagged `[auth]`, `[data]`, `[schema]`, `[public API]`, `[migration]`, `[ui]`, `[perf]`, or `[test]` where relevant.
-5. **Manual observations** — 2–5 concrete ways a human can observe the change working. If there is no user-visible behavior, say so and name the automated evidence instead.
-6. **Decision options** — approve / rework / ask for a targeted review, each with the next command.
+1. **Intent:** one sentence naming what the change is for, grounded in `spec.md` / `decisions.md` when available.
+2. **Scope:** files changed, modules touched, and boundary crossings.
+3. **Concern walkthrough:** group `path:line` stops by design intent, not file order. Prefer the existing `touched-files.md` `Review trail`; generate one from the diff only when absent.
+4. **Risk stops:** 2-5 highest-blast-radius places to inspect, tagged `[auth]`, `[data]`, `[schema]`, `[public API]`, `[migration]`, `[ui]`, `[perf]`, or `[test]` where relevant.
+5. **Manual observations:** 2-5 concrete ways a human can observe the change working. If there is no user-visible behavior, say so and name the automated evidence instead.
+6. **Decision options:** approve / rework / ask for a targeted review, each with the next command.
 
 Completion criterion: every concern has at least one clickable repo-relative `path:line` stop, or the walkthrough states why the change has no source stops.
 
 ### Predict-then-reveal (diff / recap)
 
 1. Pick the single most load-bearing hunk or decision in the explainer.
-2. Ask the user to predict: "what does this change do?" / "why was `<decision>` made here?" —
-   offer 2–4 plausible options where one is the real answer and the distractors are *reasonable*
+2. Ask the user to predict: "what does this change do?" / "why was `<decision>` made here?":
+   offer 2-4 plausible options where one is the real answer and the distractors are *reasonable*
    (a distractor no one would pick teaches nothing).
 3. On answer, reveal: confirm or correct, pointing at the exact `file:line` that settles it.
 
 ### Checked exercise (concept / idea)
 
-1. Pose one small problem the developer solves using the model just taught — "given `<situation>`,
+1. Pose one small problem the developer solves using the model just taught: "given `<situation>`,
    what would `<mechanism>` do?" or "where would this break?".
 2. Let them answer, then grade against the taught model: name what they got right, correct what
    they missed, and cite the part of the explainer (or the repo) that covers it.

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

@@ -11,25 +11,25 @@ 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-frame — frame the goal, audit the diff
+# $rite-frame: frame the goal, audit the diff
 
 LLMs reliably get four things wrong: they **assume** silently, **overcomplicate**, edit
 **out of scope**, and run on an **unverifiable** "make it work". The full DevRites
 lifecycle catches all four at its gates (spec readiness, the Spec Drift Guard,
 `touched-files.md` + `devrites-engine reconcile`, `$rite-seal`). But the express lane and plain
-"just do X" requests **skip those gates** — and a raw diff has no gate at all.
+"just do X" requests **skip those gates**, and a raw diff has no gate at all.
 
 `rite-frame` is the gate's reflex made portable. Two moves, no workspace required:
 
-- **FRAME** (before code) — turn the imperative ask into a falsifiable success criterion
+- **FRAME** (before code): turn the imperative ask into a falsifiable success criterion
   and the command that proves it. *"Give it success criteria and watch it go."*
-- **AUDIT** (after the change) — read the diff against the four failure modes; route each
+- **AUDIT** (after the change): read the diff against the four failure modes; route each
   finding to the DevRites cure that already exists for it.
 
 It is a self-applied lens, not a subagent and not a phase. Light enough to run at the top
@@ -46,51 +46,51 @@ an adversarial second read (`devrites-doubt`) · a fresh-context axis review of
 feature (`devrites-audit <security|perf|simplify>`) · the final GO/NO-GO (`$rite-seal`).
 rite-frame is the *inline* reflex; those are the *gates*. Don't use it to dodge one.
 
-## FRAME — before you touch code
+## FRAME: before you touch code
 
 Restate the ask as a check, not a chore. Convert the verb into a condition that can be
 **false**:
 
 | Imperative ask | Falsifiable success criterion |
 |---|---|
-| "Add validation" | "Inputs `{empty, oversize, wrong-type}` are rejected with a 4xx + message — a test asserts each, and fails today." |
-| "Fix the bug" | "A test reproduces the bug (red now), and turns green after the fix — nothing else changes." |
+| "Add validation" | "Inputs `{empty, oversize, wrong-type}` are rejected with a 4xx + message: a test asserts each, and fails today." |
+| "Fix the bug" | "A test reproduces the bug (red now), and turns green after the fix: nothing else changes." |
 | "Make it faster" | "Operation X drops from `<measured baseline>` to `<target>` on `<named benchmark>`." |
 | "Refactor X" | "The existing suite is green before and after; behavior is byte-identical." |
 | "Clean this up" | *(no falsifiable criterion → the ask is ambiguous → mode 1 → ask what "clean" means, or route to `$rite-spec`)* |
 
 Checklist (copy it):
 
-- [ ] **Criterion** — one sentence: *"Done WHEN `<observable, falsifiable check>`."* If you
-      can't write one that could be false, the ask is ambiguous — **stop, name it, ask** (that
+- [ ] **Criterion**: one sentence: *"Done WHEN `<observable, falsifiable check>`."* If you
+      can't write one that could be false, the ask is ambiguous: **stop, name it, ask** (that
       is failure mode 1, surfaced early instead of after the diff).
-- [ ] **Verify command** — the exact test / build / runtime / screenshot that decides it.
+- [ ] **Verify command**: the exact test / build / runtime / screenshot that decides it.
       No command → no proof → you're about to confidence-assert. Name it now.
-- [ ] **Scope boundary** — the files/areas you will **not** touch. Anything outside is mode 3.
-- [ ] **Loop** — with a falsifiable criterion you can iterate to green unattended; with a weak
+- [ ] **Scope boundary**: the files/areas you will **not** touch. Anything outside is mode 3.
+- [ ] **Loop**, with a falsifiable criterion you can iterate to green unattended; with a weak
       one ("make it work") you'll need the user every few minutes. Sharpen the criterion until
       it can drive the loop.
 
-## AUDIT — after the change
+## AUDIT: after the change
 
 Read the diff (or `$ARGUMENTS`) against the four modes. One line per finding, severity-tagged
 (`Critical / Important / Suggestion / Nit / FYI`), each routed to its existing cure. Full
 map + worked examples: [`reference/failure-modes.md`](reference/failure-modes.md).
 
-- [ ] **1 · Silent assumption** — did I pick one reading of an ambiguous ask and run with it?
+- [ ] **1 · Silent assumption**: did I pick one reading of an ambiguous ask and run with it?
       Any value, contract, or behavior I *guessed*? → surface it; route material ones through
       the Spec Drift Guard (`core.md` #2/#3).
-- [ ] **2 · Overcomplication** — an abstraction / flag / indirection nobody asked for? 200 lines
+- [ ] **2 · Overcomplication**: an abstraction / flag / indirection nobody asked for? 200 lines
       where 50 would do? A defensive check inside trusted code? → apply the **deletion test**;
       simplify (`coding-style.md`, `patterns.md`, `devrites-audit simplify`).
-- [ ] **3 · Out-of-scope edit** — did I touch code, comments, or formatting outside the ask?
+- [ ] **3 · Out-of-scope edit**: did I touch code, comments, or formatting outside the ask?
       "While I'm here" refactors? → revert to the boundary; record the rest as an FYI follow-up
       (`core.md` #7, `touched-files.md`).
-- [ ] **4 · Unverifiable goal** — is there a command that proves this, run, with output? Or am
+- [ ] **4 · Unverifiable goal**: is there a command that proves this, run, with output? Or am
       I asserting "it works"? Tautological test that can't fail? → run the FRAME verify command;
       record command + output (`testing.md`, evidence-over-confidence).
-- [ ] **Principle check** — if `.devrites/principles.md` exists, does the change break a declared
-      invariant? A violation with no recorded, human-approved exception is a **Critical** — the
+- [ ] **Principle check**, if `.devrites/principles.md` exists, does the change break a declared
+      invariant? A violation with no recorded, human-approved exception is a **Critical**: the
       express lane is not a way around a project gate; escalate it, don't ship it (`principles.md`).
 
 The test for each changed line: **it traces directly to the criterion, and the criterion can
@@ -99,10 +99,10 @@ be proven false.** A line that fails either is a finding.
 ## Escalation
 
 If FRAME can't produce a falsifiable criterion, or AUDIT surfaces a mode-1 / mode-3 issue that
-is actually a hidden design decision (new dependency, data model, second design system, an
+is a hidden design decision (new dependency, data model, second design system, an
 auth/migration/public-API touch), or a **declared-principle violation** with no recorded
 exception → **STOP and route to `$rite-spec`** (a needed exception is a human-approved decision,
-not an inline call). Same drift guard the express lane enforces — don't quietly grow an unframed
+not an inline call). Same drift guard the express lane enforces: don't quietly grow an unframed
 ask into unreviewed work.
 
 ## Rules
@@ -111,7 +111,7 @@ ask into unreviewed work.
   active feature use `devrites-audit`.
 - FRAME before code, AUDIT after. Running AUDIT without having framed the criterion first means
   mode 4 has nothing to check against.
-- A criterion that can't be false isn't a criterion — it's a wish. Rewrite it or ask.
+- A criterion that can't be false isn't a criterion. It's a wish. Rewrite it or ask.
 - Feature/ask scope only. Out-of-scope findings become FYI follow-ups, never silent fixes.
 
 ## Output

package/pack/generated/codex/skills/rite-frame/reference/failure-modes.md

@@ -1,28 +1,28 @@
-# The four failure modes — mapped to their DevRites cure
+# The four failure modes: mapped to their DevRites cure
 
 The lens behind `rite-frame`. Each mode is a thing LLMs reliably get wrong; each already
 has a cure somewhere in the pack. The value of naming them here is a **portable
-vocabulary** — a fast self-check you can run on ad-hoc or express-lane work that never
+vocabulary**: a fast self-check you can run on ad-hoc or express-lane work that never
 reaches the gates where those cures normally fire.
 
 ## The map
 
 | # | Failure mode | The tell in a diff / a reply | Cure already in the pack |
 |---|---|---|---|
-| 1 | **Silent assumption** | A value, contract, edge case, or interpretation was *guessed* and run with — no note, no question. The ask had two readings and one was picked silently. | `core.md` #2 (no silent assumptions) / #3 (no guessing through confusion); the Spec Drift Guard; `devrites-doubt` for a single high-stakes call; `devrites-interview` when the ask is underspecified. |
+| 1 | **Silent assumption** | A value, contract, edge case, or interpretation was *guessed* and run with: no note, no question. The ask had two readings and one was picked silently. | `core.md` #2 (no silent assumptions) / #3 (no guessing through confusion); the Spec Drift Guard; `devrites-doubt` for a single high-stakes call; `devrites-interview` when the ask is underspecified. |
 | 2 | **Overcomplication** | An abstraction, flag, config knob, or indirection nobody asked for. 200 lines where 50 would do. A single-use factory. Defensive `try/catch` + null checks inside trusted code. A dependency added where an in-repo option exists. | `coding-style.md` (simplicity, reuse-first), `patterns.md` (avoid over-engineering), `devrites-audit simplify` (deletion test, Chesterton's Fence), the "over-defensive guarding is slop" anti-pattern. |
 | 3 | **Out-of-scope edit** | Touched code, comments, or formatting outside the ask. A "while I'm here" refactor. Renamed something orthogonal. Reflowed an import block. | `core.md` #7 (feature scope only), `touched-files.md` (the recorded diff boundary), `devrites-engine reconcile` (hard-stops a source file changed outside the claimed set), the "it's only a small refactor" anti-pattern. |
 | 4 | **Unverifiable goal** | "It works" with no command, no output, no test. A success criterion that can't be false ("make it better"). A tautological test that passes no matter what. | `rite-spec/reference/acceptance-criteria.md` (measurable acceptance), `core.md` #6 (evidence over confidence), `testing.md` (assertion strength, see it fail first), the TDD wright. |
 
-The first three are the **diseases** Karpathy named; the fourth is the **leverage** — a
+The first three are the **diseases** Karpathy named; the fourth is the **leverage**: a
 falsifiable criterion is what lets the model loop to done without a human in the loop every
-few minutes. FRAME front-loads mode 4 so the AUDIT of modes 1–3 has something to check
+few minutes. FRAME front-loads mode 4 so the AUDIT of modes 1-3 has something to check
 against.
 
 ## FRAME: the imperative → falsifiable reframe
 
 The move is to rewrite the *verb* as a *condition that can be false*. If you can't, the ask
-is ambiguous — that's mode 1, caught before the diff instead of after.
+is ambiguous. That's mode 1, caught before the diff instead of after.
 
 | Imperative ask | Weak (still a wish) | Falsifiable criterion + verify |
 |---|---|---|
@@ -38,7 +38,7 @@ pass or fail without asking you what you meant. If they'd have to ask, sharpen i
 
 ## AUDIT: worked finding lines
 
-Findings read like the rest of the pack — one line, severity-tagged, cite `file:line`, route
+Findings read like the rest of the pack: one line, severity-tagged, cite `file:line`, route
 to the cure. Severity ladder is the pack standard (`Critical / Important / Suggestion / Nit /
 FYI`).
 
@@ -49,20 +49,20 @@ utils.ts:5  FYI        mode 3 (scope): reflowed an unrelated import block. → r
 sum.spec:12 Important  mode 4 (unverifiable): test asserts `mock.called`, not the result — passes if the fn is empty. → assert the value; see it fail first (testing.md).
 ```
 
-Clean lanes say so explicitly — `1 assumption: clean` — so the audit is a positive
+Clean lanes say so explicitly (`1 assumption: clean`) so the audit is a positive
 statement, not a silent skip.
 
 ## How this differs from the heavier tools (so you don't reach past it)
 
-- **`devrites-doubt`** — adversarial *fresh-context subagent* pre-mortem on **one** decision.
+- **`devrites-doubt`:** adversarial *fresh-context subagent* pre-mortem on **one** decision.
   Heavier, independent, anti-anchoring. rite-frame is *self-applied* and covers the four modes
   broadly; escalate a single load-bearing claim to doubt.
-- **`devrites-audit <axis>`** — *fresh-context subagent* review of an **active feature's** diff
+- **`devrites-audit <axis>`:** *fresh-context subagent* review of an **active feature's** diff
   on one axis (security / perf / simplify). Needs a `.devrites/` workspace. rite-frame needs no
-  workspace and runs in your own context — cheaper, less independent.
-- **`$rite-review` · `$rite-seal`** — the **gates**: parallel reviewer fan-out, blocking
+  workspace and runs in your own context: cheaper, less independent.
+- **`$rite-review` · `$rite-seal`:** the **gates**: parallel reviewer fan-out, blocking
   severities, written verdict. rite-frame is the inline reflex for work that never reaches a
   gate; it does not replace one. If the work is a real feature, the gate is the answer.
 
-The point is not redundancy — it's a tiered ladder. rite-frame is the cheapest rung: a lens
+The point is not redundancy. It's a tiered ladder. rite-frame is the cheapest rung: a lens
 you run yourself in seconds. Climb to doubt / audit / the gates as the stakes rise.

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

@@ -12,20 +12,20 @@ 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-handoff — chat-only context, into a fresh-agent doc
+# $rite-handoff: chat-only context, into a fresh-agent doc
 
 DevRites' workspace `.devrites/work/<slug>/` already captures everything that *should*
 persist (spec, plan, tasks, decisions, evidence, drift, review). This skill captures
-what the **chat** is holding that is **not** in the workspace, so a fresh agent — or
-the same user after `/clear` — can pick the work up without re-reading the transcript.
+what the **chat** is holding that is **not** in the workspace, so a fresh agent (or
+the same user after `/clear`) can pick the work up without re-reading the transcript.
 
-Read `.agents/skills/devrites-lib/reference/standards/core.md` first — its "Persistence before stopping" discipline is
+Read `.agents/skills/devrites-lib/reference/standards/core.md` first: its "Persistence before stopping" discipline is
 exactly what this skill executes. The other rule files load on demand.
 
 Then run `devrites-engine preamble` for deterministic workspace orientation.
@@ -37,7 +37,7 @@ Then run `devrites-engine preamble` for deterministic workspace orientation.
 - **No active feature** → OS temp dir (`$TMPDIR` / `/tmp` / `%TEMP%`) as
   `rite-handoff-<ISO-timestamp>.md`. Print the absolute path after writing.
 
-## Before you write — sync, don't duplicate
+## Before you write: sync, don't duplicate
 
 For each of these, write the content into its **canonical home** first, then merely
 *note* in the handoff that the sync happened:
@@ -63,20 +63,20 @@ themselves. The workspace is the canonical store; the handoff is the chat-only d
    to the named focus. Where you were mid-thought, **quote the most recent next-step
    verbatim** from the chat (the exact sentence describing what to do next) so no nuance
    is lost to paraphrase.
-2. **What just happened in this chat** (3–5 bullets). Distil — do not transcribe.
+2. **What just happened in this chat** (3-5 bullets). Distil: do not transcribe.
 3. **External references** that exist only in chat: URLs, Figma links, screenshot paths,
    video timestamps the user pasted. List as references; do not embed.
 4. **Live assumptions the agent is acting on** that the workspace doesn't reflect yet
-   (after the sync above, this section should be near-empty — flag anything that
+   (after the sync above, this section should be near-empty: flag anything that
    remains).
-5. **How to resume** — fixed boilerplate (see template below).
+5. **How to resume:** fixed boilerplate (see template below).
 
 ## What NOT to include
 
 - Anything already in `spec.md`, `plan.md`, `tasks.md`, `state.md`, `decisions.md`,
-  `evidence.md`, `review.md` — link by path instead.
-- `git diff` output — the next agent runs `git diff` themselves.
-- The full conversation transcript — distil.
+  `evidence.md`, `review.md`: link by path instead.
+- `git diff` output: the next agent runs `git diff` themselves.
+- The full conversation transcript: distil.
 - Secrets (API keys, tokens, PII, credentials). Redact aggressively.
 - **New ideas the user didn't confirm.** A handoff records what *happened* and what's *next*.
   Leave out fresh suggestions, scope the user didn't agree to, and redesigns you thought of. Capture
@@ -102,7 +102,7 @@ Record: <absolute path to handoff.md>
 Print the absolute path in `Record:` so the user or next agent can open it without searching.
 
 ## Session hygiene
-Close with the one-line hygiene advisory + the single resume command — this skill *is* the
+Close with the one-line hygiene advisory + the single resume command. This skill *is* the
 pre-`/clear` bridge, so it's where the advisory matters most (`context-hygiene.md`):
 ```
 ↻ Hygiene: /clear