devrites 3.0.4 → 3.0.6

package/pack/generated/codex/skills/rite-converge/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-converge — make the code and the intent converge
+# $rite-converge: make the code and the intent converge
 
 Read `spec.md` + `plan.md` + `tasks.md` as the **sole source of intent** (with
 `.devrites/principles.md` as governing constraints), assess what the **live codebase**
-actually implements, and **append every unmet piece as a new traceable `SLICE-###`** at the
+implements, and **append every unmet piece as a new traceable `SLICE-###`** at the
 bottom of `tasks.md` so `$rite-build` can finish it. The recovery bridge for work that fell
 out of sync with its plan: a half-built feature picked up cold, a `$rite-adopt`'d codebase
 that drifted from its derived spec, or a build that stalled mid-slice. **Read the active
@@ -29,37 +29,37 @@ workspace first**; if there's no `spec.md`/`plan.md`/`tasks.md`, tell the user w
 prerequisite skill to run.
 
 > **Not a diff tool.** `$rite-converge` assesses the **present state** of the code against
-> intent — no git, no branch comparison, no history. "What does this codebase do *now* vs
-> what the artifacts asked for" — not "what changed since commit X". For a change-scoped
+> intent: no git, no branch comparison, no history. "What does this codebase do *now* vs
+> what the artifacts asked for", not "what changed since commit X". For a change-scoped
 > review use `$rite-review`; to prove a finished feature use `$rite-prove`.
 
 ## Rules consulted (read on demand from `.agents/skills/devrites-lib/reference/standards/`)
 Pull on demand:
-- `principles.md` — the project invariants (`.devrites/principles.md`); code that violates a
+- `principles.md`: the project invariants (`.devrites/principles.md`); code that violates a
   MUST principle is the highest-severity gap and produces a remediation slice.
-- `spec-grammar.md` — buildable acceptance criteria vs `## Success metrics` (outcome KPIs the
+- `spec-grammar.md`: buildable acceptance criteria vs `## Success metrics` (outcome KPIs the
   code can't make true and this pass never enqueues); structured `### Requirement:` /
   `#### Scenario:` blocks, each scenario one behavior to check as built / partial / absent.
-- `tooling.md` — prefer a code-intelligence index (codebase-memory-mcp → codegraph → graphify,
+- `tooling.md`: prefer a code-intelligence index (codebase-memory-mcp → codegraph → graphify,
   else LSP / Read/Grep/Glob) to read the live code, not assumptions.
-- `testing.md` — a criterion with code but no covering test is *partial*, not done.
+- `testing.md`: a criterion with code but no covering test is *partial*, not done.
 
 ## Operating rules
 - **APPEND-ONLY, never rewrite.** The only write to `tasks.md` is **appending** new
   `SLICE-###` entries. Never rewrite, renumber, reorder, or delete an existing slice
   (including slices a prior convergence appended). Never edit `spec.md` or `plan.md`. Never
-  touch application code — completing the appended slices is `$rite-build`'s job, not this
+  touch application code: completing the appended slices is `$rite-build`'s job, not this
   skill's.
 - **Clean means byte-for-byte unchanged.** When the code already satisfies everything, leave
-  `tasks.md` untouched — no empty convergence header — and report a clean result. Recommend
+  `tasks.md` untouched (no empty convergence header) and report a clean result. Recommend
   `$rite-prove`.
 - **Intent is the artifacts, not your memory.** The spec/plan/tasks (+ principles) are the
   contract. If assessing reveals the *spec* is wrong (the code is right and the requirement is
-  stale), that's **Spec Drift** — stop and route it through the Spec Drift Guard
+  stale), that's **Spec Drift**: stop and route it through the Spec Drift Guard
   (`rite-build/reference/spec-drift-guard.md`) + a recorded decision; never paper over a spec
   bug by appending a task that "fixes" the code to a wrong requirement.
 - **Partial is not done.** Code that exists but is untested, half-wired, or covers only the
-  happy path is an unmet gap — enqueue the remainder, don't round it up.
+  happy path is an unmet gap: enqueue the remainder, don't round it up.
 - **Principles are non-negotiable.** A live violation of a declared invariant with no recorded
   exception is the top-severity gap, walked first. Absent/empty principles file → none declared
   → skip the check gracefully, never block for its absence.
@@ -71,7 +71,7 @@ Pull on demand:
    any is missing, **STOP** and name the prerequisite (`$rite-spec` for a missing spec,
    `$rite-define` for a missing plan/tasks, `$rite-adopt` to onboard existing code). Do not
    produce partial output.
-2. **Load intent** — [`reference/convergence-assessment.md`](reference/convergence-assessment.md).
+2. **Load intent:** [`reference/convergence-assessment.md`](reference/convergence-assessment.md).
    From `spec.md`: buildable `AC-###` / `### Requirement:` scenarios (skip `## Success metrics`);
    from `plan.md`: architecture decisions + named touch-points (files/components the plan says
    get built); from `tasks.md`: existing slices + their `Satisfies:`; from
@@ -79,7 +79,7 @@ Pull on demand:
    **Completion:** every buildable criterion, touch-point, slice output, and principle is in the assessment inventory.
 3. **Run the mechanical backbone**, then read the code. `devrites-engine analyze` gives coverage +
    consistency; `devrites-engine coverage` gives the AC→slice→proven matrix. They catch *unmapped*
-   criteria; they do **not** see whether mapped code is actually built and correct — for that,
+   criteria; they do **not** see whether mapped code is built and correct, for that,
    read the live code (code-intelligence index per `tooling.md`).
    ```bash
    S="$(cat .devrites/ACTIVE 2>/dev/null)"
@@ -119,13 +119,13 @@ Convergence: 2026-07-07      # marks this as a convergence-appended slice, not a
 
 > **Mid-flight discipline.** When tempted to rewrite an existing slice instead of appending, to
 > edit the code directly "while you're in there", to mark a happy-path-only implementation as
-> built, or to enqueue a task that bends the code to a spec you suspect is wrong — see
+> built, or to enqueue a task that bends the code to a spec you suspect is wrong: see
 > [`reference/anti-patterns.md`](reference/anti-patterns.md). Load it the moment you reach for
 > the excuse.
 
 ## Output
 
-**Progress first** — run `devrites-engine progress`, then use the shared completion reply contract
+**Progress first**: run `devrites-engine progress`, then use the shared completion reply contract
 ([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md)).
 Default success shape:
 ```
@@ -140,4 +140,4 @@ Record: .devrites/work/<slug>/tasks.md
 When nothing was unmet, render the same green form with `Next: $rite-prove`.
 If spec drift or another blocker remains, use the shared `Stopped / blocked` form
 and route `Fix:` to `$rite-plan`; do not recommend `$rite-build`.
-**DO NOT write application code, rewrite existing slices, or edit spec.md/plan.md here** — convergence assesses and enqueues; `$rite-build` implements.
+**DO NOT write application code, rewrite existing slices, or edit spec.md/plan.md here**: convergence assesses and enqueues; `$rite-build` implements.

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

@@ -4,23 +4,23 @@ Load the moment you reach for one of these excuses.
 
 ## Common rationalizations
 
-- *"I'll just fix this existing slice instead of appending a new one."* — No. The append-only
+- *"I'll just fix this existing slice instead of appending a new one."*. No. The append-only
   rule is what makes convergence **re-runnable** and its output **auditable**: a reader diffs
   `tasks.md` and sees exactly what this pass added. Rewriting an existing slice destroys that
   and can silently drop coverage. Append; never edit an existing `SLICE-###`.
-- *"The gap is tiny — I'll just patch the code while I'm here."* — No. Convergence **assesses
+- *"The gap is tiny. I'll just patch the code while I'm here."*. No. Convergence **assesses
   and enqueues**; `$rite-build` implements. The moment you edit application code you've skipped
   the build's slice discipline, tests, and reviewer. Enqueue it, however small.
-- *"It's basically built — I'll call it done."* — Happy-path-only, untested, or half-wired is
+- *"It's basically built. I'll call it done."*. Happy-path-only, untested, or half-wired is
   **partial**, not built (`convergence-assessment.md`). Rounding partial up to built is how a
   feature ships with the edge cases that were the whole reason for the scenario.
-- *"The code does X, the spec says Y — I'll enqueue a slice to make the code match the spec."* —
+- *"The code does X, the spec says Y. I'll enqueue a slice to make the code match the spec."*:
   Only if you're sure the **spec** is right. If the code is right and the requirement is stale,
-  that's **Spec Drift** — route it through the guard, don't launder a spec bug into a code task.
-- *"The spec has no `AC-###` ids, so there's nothing to converge."* — Assess plan touch-points
+  that's **Spec Drift**: route it through the guard, don't launder a spec bug into a code task.
+- *"The spec has no `AC-###` ids, so there's nothing to converge."*. Assess plan touch-points
   and existing-slice Produces directly against the code; a coverage id is convenient, not
   required. (And flag the untagged spec so `$rite-spec` can add ids.)
-- *"I'll rewrite the whole tasks.md to be clean while I'm at it."* — That is a **reslice**, and
+- *"I'll rewrite the whole tasks.md to be clean while I'm at it."*, That is a **reslice**, and
   it belongs to `$rite-plan`, not here. Convergence only ever *appends*.
 
 ## Red flags in your own output

package/pack/generated/codex/skills/rite-converge/reference/convergence-assessment.md

@@ -1,31 +1,31 @@
-# Convergence assessment — built / partial / absent
+# Convergence assessment: built / partial / absent
 
-The rubric `$rite-converge` applies to every unit of intent. Load when running step 2–5.
+The rubric `$rite-converge` applies to every unit of intent. Load when running step 2-5.
 
 ## The unit set
 
 Assess three kinds of unit against the live code:
 
-1. **Acceptance criteria / scenarios** — each buildable `AC-###` and each `#### Scenario:`
-   (WHEN/THEN) in `spec.md`. `## Success metrics` lines are **not** units — they carry no
+1. **Acceptance criteria / scenarios:** each buildable `AC-###` and each `#### Scenario:`
+   (WHEN/THEN) in `spec.md`. `## Success metrics` lines are **not** units. They carry no
    `AC-###` id, no slice can satisfy them, and this pass never enqueues one (`spec-grammar.md`).
-2. **Plan touch-points** — the files/components/modules `plan.md` says get built or edited, and
+2. **Plan touch-points:** the files/components/modules `plan.md` says get built or edited, and
    each existing slice's stated **Produces** (the interface it was meant to expose).
-3. **Principles** — each invariant in `.devrites/principles.md`, checked against the code as it
+3. **Principles:** each invariant in `.devrites/principles.md`, checked against the code as it
    stands.
 
 ## The three verdicts
 
-For each unit, decide **built / partial / absent** — and only *partial* and *absent* enqueue a
+For each unit, decide **built / partial / absent**, and only *partial* and *absent* enqueue a
 slice.
 
 | Verdict | Test | Action |
 |---|---|---|
-| **built** | The behavior exists in the code **and** a test covers it (a criterion with code but no covering test is not built — `testing.md`). | Nothing — do not append. |
+| **built** | The behavior exists in the code **and** a test covers it (a criterion with code but no covering test is not built: `testing.md`). | Nothing: do not append. |
 | **partial** | Some of it exists: happy path only, un-wired, untested, a TODO stub, or an edge case from the scenario's WHEN/THEN missing. | Append a slice for the **remainder**, its `Known-Gotchas` naming what's already there so `$rite-build` extends rather than rebuilds. |
 | **absent** | No code implements it. | Append a full slice. |
 
-Read the code to decide — do not infer from the plan. Use the code-intelligence index
+Read the code to decide: do not infer from the plan. Use the code-intelligence index
 (codebase-memory-mcp → codegraph → graphify, else LSP / grep) so the verdict reflects live
 code, not the artifacts' claims. `devrites-engine analyze` / `devrites-engine coverage` tell you what's
 *mapped*; only reading the code tells you what's *built*.
@@ -34,16 +34,16 @@ code, not the artifacts' claims. `devrites-engine analyze` / `devrites-engine co
 
 A live violation of a declared invariant (secret in logs, money as float, a datastore added
 with no ADR) is the **top-severity** gap regardless of coverage. It sorts **first** in the
-appended batch as a remediation slice, and — because reshaping to honor an invariant can be an
-irreversible-risk change — it pauses for a human even under AFK. Absent/empty principles file →
+appended batch as a remediation slice, and (because reshaping to honor an invariant can be an
+irreversible-risk change) it pauses for a human even under AFK. Absent/empty principles file →
 none declared → skip, never block.
 
 ## Spec drift vs code gap
 
 Before appending a slice, separate the two failure directions:
 
-- **Code gap** — the spec is right, the code falls short. → append a slice. (This skill's job.)
-- **Spec drift** — the code is right, the requirement is stale or wrong. → **do not** append a
+- **Code gap:** the spec is right, the code falls short. → append a slice. (This skill's job.)
+- **Spec drift:** the code is right, the requirement is stale or wrong. → **do not** append a
   slice that bends correct code to a wrong spec. Stop, route through the Spec Drift Guard
   (`rite-build/reference/spec-drift-guard.md`) + a recorded decision, and let `$rite-plan
   repair` reshape intent. Convergence enqueues work; it never launders a spec bug into a code
@@ -51,7 +51,7 @@ Before appending a slice, separate the two failure directions:
 
 ## Numbering + ordering the appended batch
 
-- **Continue the ids** — the highest existing `SLICE-###` + 1, ascending. Never reuse or
+- **Continue the ids:** the highest existing `SLICE-###` + 1, ascending. Never reuse or
   renumber an existing id.
 - **Order after the existing slices**, dependency-first among the new ones (`depends_on`);
   a principle-remediation slice sorts before feature gaps.

package/pack/generated/codex/skills/rite-customize/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-customize — guided project customization
+# $rite-customize: guided project customization
 
 Create, list, validate, or scaffold one project-local DevRites customization without forking the pack.
 
@@ -75,5 +75,5 @@ Record: <path(s)>
 ## Gotchas
 
 - **Do not fork by accident.** If a reviewer override is enough, do not create a copied reviewer agent.
-- **Do not weaken gates.** “Ignore”, “waive”, “lower severity”, or “skip type-GO” means rewrite the customization or refuse it.
+- **Do not weaken gates.** "Ignore", "waive", "lower severity", or "skip type-GO" means rewrite the customization or refuse it.
 - **Do not invent an extension surface.** If the user wants behavior outside DevRites' extension contract, say what the contract supports and stop.

package/pack/generated/codex/skills/rite-define/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-define — plan from the spec
+# $rite-define: plan from the spec
 
 Read the active feature's `spec.md` and turn it into a buildable workspace: feature
 architecture, approach, a dependency-ordered set of **vertical slices**, traceability, and
@@ -27,10 +27,10 @@ spec, architecture, plan, tasks, and traceability keeps each file small and phas
 
 ## Rules consulted (read on demand from `.agents/skills/devrites-lib/reference/standards/`)
 Pull these via `Read` when shaping the plan:
-- `development-workflow.md` — small batches, trunk-always-green, definition of done.
-- `principles.md` — the project invariants (`.devrites/principles.md`) the chosen approach must conform to.
-- `documentation.md` — record plan-time decisions and rationale.
-- `../workspace-artifact-schema.md` — artifact purposes, budgets, IDs, and read triggers.
+- `development-workflow.md`: small batches, trunk-always-green, definition of done.
+- `principles.md`: the project invariants (`.devrites/principles.md`) the chosen approach must conform to.
+- `documentation.md`: record plan-time decisions and rationale.
+- `../workspace-artifact-schema.md`: artifact purposes, budgets, IDs, and read triggers.
 
 ## Operating rules
 - **Requires a readied spec.** Read the active workspace first; if `.devrites/ACTIVE` is empty,
@@ -43,8 +43,8 @@ Pull these via `Read` when shaping the plan:
   be deepened right there with a technique from
   [`elicitation.md`](../devrites-lib/reference/standards/elicitation.md) (Tournament for two viable
   designs, Delphi for the estimate) before it hardens into slices.
-- **Slice count is derived, never dictated.** The number of slices falls out of the work
-  — one per independently-shippable increment, sized by `slicing.md`, every acceptance
+- **Slice count is derived, never dictated.** The number of slices falls out of the work.
+  One per independently-shippable increment, sized by `slicing.md`, every acceptance
   criterion mapped to ≥1 slice. A user-named count is a hint at most: slice logically and,
   if your honest count differs, present it and why. Never pad or compress to hit a figure.
   (`.devrites/AFK` `max_slices` is a separate AFK iteration budget, not the decomposition.)
@@ -54,8 +54,8 @@ Pull these via `Read` when shaping the plan:
   integration branch plus a final verify slice.
 
 ## Workflow
-0. **Read `.agents/skills/devrites-lib/reference/standards/core.md`** — the always-on operating rules and anti-rationalizations.
-   Then **run the shared orientation preamble** — it confirms the active feature and which
+0. **Read `.agents/skills/devrites-lib/reference/standards/core.md`:** the always-on operating rules and anti-rationalizations.
+   Then **run the shared orientation preamble**. It confirms the active feature and which
    artifacts exist (it prints `state.md`, the artifacts present, the run mode, and the
    open-question tally):
    ```bash
@@ -65,12 +65,12 @@ Pull these via `Read` when shaping the plan:
    ```
    If there is no active workspace, no `spec.md`, `spec-skeleton` blocks, or its readiness gate hasn't passed →
    **STOP** and tell the user to run `$rite-spec <feature>` first.
-1. **Read the spec** — `spec.md` (objective, requirements, acceptance, **placement**,
+1. **Read the spec:** `spec.md` (objective, requirements, acceptance, **placement**,
    design references, gaps/decisions), plus `references.md`, `decisions.md`,
    `assumptions.md`, **`strategy.md` if present** (the scope mode, deferred / out-of-scope
-   register, and pre-mortem risks from `$rite-temper` — cut slices to mitigate the top risks
+   register, and pre-mortem risks from `$rite-temper`: cut slices to mitigate the top risks
    and respect the IN/OUT line; map coverage against the **hardened** spec), and
-   **`design-brief.md` if the feature touches UI** (the UX/UI contract `$rite-spec` shaped —
+   **`design-brief.md` if the feature touches UI** (the UX/UI contract `$rite-spec` shaped:
    its key states, interaction model, and proof targets drive how UI slices are cut). If a blocking
    `[NEEDS CLARIFICATION]` remains, stop → `$rite-spec`.
 2. **Decide the architecture + approach** (the HOW the spec deliberately omitted): write
@@ -81,14 +81,14 @@ Pull these via `Read` when shaping the plan:
    `.agents/skills/devrites-lib/reference/standards/tooling.md`) for structure/impact; for the current API or behaviour of
    an external library/framework the architecture will rely on, consult context7 if available.
    Record significant options in `decisions.md` as `DEC-###` ADR entries.
-   **Deep-modules check** — while sketching the major modules, look for opportunities
+   **Deep-modules check**, while sketching the major modules, look for opportunities
    to extract a **deep module**: a small, stable interface that hides a meaningful chunk
-   of behavior, and is therefore independently testable. A *shallow* module — interface
-   nearly as complex as its implementation — earns nothing; either deepen it or delete
+   of behavior, and is therefore independently testable. A *shallow* module (interface
+   nearly as complex as its implementation) earns nothing; either deepen it or delete
    it. Where a slice will produce a deep module, confirm with the user which deep
    modules they want unit-tested in isolation (this informs the slice's "Tests to
    write/run" field).
-3. **Slice into vertical tasks** — each delivers one observable capability end-to-end and
+3. **Slice into vertical tasks:** each delivers one observable capability end-to-end and
    is verifiable on its own; the **count emerges from the work, not a target number**;
    first slice = thinnest useful end-to-end path; order by dependency (risk-first within a
    tier). For a broad mechanical refactor, use expand → migrate batches → contract instead
@@ -98,21 +98,21 @@ Pull these via `Read` when shaping the plan:
    and **Browser proof required** (UI), and whether it's **fullstack** (FE+BE → contract
    first, see `devrites-frontend-craft/reference/fullstack.md`). **For UI slices, name which
    of `design-brief.md`'s key states + interaction the slice delivers, and give it a binary
-   **Visual acceptance** target (state × viewport × input + target R-id/brief rule)** — so
+   **Visual acceptance** target (state × viewport × input + target R-id/brief rule)**, so
    the design contract maps onto slices, not just acceptance criteria.
-4. **Map coverage** — every `AC-###` spec acceptance criterion maps to ≥1 `SLICE-###`
+4. **Map coverage:** every `AC-###` spec acceptance criterion maps to ≥1 `SLICE-###`
    (`rite-spec/reference/acceptance-criteria.md`); no orphaned criteria, no slice without a
    criterion. Lift covered/backstop `Edge Coverage` rows and resolved `Prohibitions (must-NOT)`
    rows into `traceability.md` and `test-plan.md`; unresolved rows go to `assumptions.md` with
    their gate/owner.
-4a. **Parallel-lane sanity check** — after drafting `tasks.md` but before asking for plan
+4a. **Parallel-lane sanity check**: after drafting `tasks.md` but before asking for plan
    approval, run the advisory lane planner:
    ```bash
    devrites-engine lanes plan "$(cat .devrites/ACTIVE 2>/dev/null)"
    ```
    Use it to spot independent read-only/review lanes and dependency mistakes, but do not
    weaken DevRites' default of one production-write slice at a time.
-4b. **Persist the traceability matrix** — write `traceability.md` (`AC/REQ ID → slice(s) →
+4b. **Persist the traceability matrix**: write `traceability.md` (`AC/REQ ID → slice(s) →
    test/proof → evidence ID → touched files → status`), the living map `$rite-prove` and
    `$rite-seal` walk. Generate it with `devrites-engine coverage` when available, then save/rename
    the output as `traceability.md`, or write the table by hand from the same inputs if the
@@ -121,17 +121,17 @@ Pull these via `Read` when shaping the plan:
    S="$(cat .devrites/ACTIVE 2>/dev/null)"
    devrites-engine coverage "$S" > ".devrites/work/$S/traceability.md"
    ```
-5. **Complexity & deviations gate** — justify anything off DevRites defaults (new dep,
+5. **Complexity & deviations gate:** justify anything off DevRites defaults (new dep,
    extra abstraction, second design system) in the plan; if you can't justify it, simplify.
    **Principles conformance:** read `.devrites/principles.md` (if present) and confirm the
    approach honors every declared invariant. A plan that conflicts with one is not "a deviation
-   to justify away" — either reshape the approach to conform, or, when the conflict is genuine and
+   to justify away": either reshape the approach to conform, or, when the conflict is genuine and
    intended, route it through the Spec Drift Guard plus a recorded decision and a scoped principle
    exception a human approves. Never ready a plan that silently violates an invariant. (Re-scored
    as a blocking gate at `$rite-vet`; no file → none declared → nothing to check.)
 6. **Write** `architecture.md`, `plan.md`, `tasks.md`, and `traceability.md`; update
    `state.md` (phase: plan → next `$rite-vet`).
-6a. **Cross-artifact gate — now that `tasks.md` exists.** Run the deterministic
+6a. **Cross-artifact gate: now that `tasks.md` exists.** Run the deterministic
    spec↔tasks coverage/consistency check; any non-zero result blocks plan readiness:
    ```bash
    S="$(cat .devrites/ACTIVE 2>/dev/null)"
@@ -153,11 +153,11 @@ Use the canonical slice grammar in
 Every slice must satisfy that complete field set; phase-specific gate details live in
 [`reference/gates.md`](reference/gates.md).
 
-> **Mid-flight discipline.** When tempted to skip vertical slicing, coverage mapping, or dependency-order discipline — see [`anti-patterns`](reference/anti-patterns.md) (Common Rationalizations + Red Flags). Load it the moment you reach for the excuse.
+> **Mid-flight discipline.** When tempted to skip vertical slicing, coverage mapping, or dependency-order discipline: see [`anti-patterns`](reference/anti-patterns.md) (Common Rationalizations + Red Flags). Load it the moment you reach for the excuse.
 
 ## Output
 
-**Progress first** — run `devrites-engine progress`, then use the shared completion reply contract
+**Progress first**: run `devrites-engine progress`, then use the shared completion reply contract
 ([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md)).
 Default success shape:
 ```

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

@@ -1,4 +1,4 @@
-# rite-define — anti-patterns
+# rite-define: anti-patterns
 
 Load this when standing a non-trivial planning decision in `$rite-define`,
 or when the agent feels reluctance toward vertical slicing or coverage
@@ -10,16 +10,16 @@ Pack-wide rationalizations + red flags: see [standards/anti-patterns.md](../../d
 
 | Excuse | Rebuttal |
 |---|---|
-| "Spec is good enough; just start coding." | Plan separates HOW from WHAT for a reason — missed HOW shows up as drift at slice 3. |
-| "One big slice is fine, the work is all related." | If slice 1 isn't shippable on its own, you're not slicing vertically — you're staging waterfall in disguise. |
-| "Tests can come at build time, not in tasks." | Every slice's `Tests to write/run` line is the contract that proves its acceptance — leave it blank, lose the contract. |
+| "Spec is good enough; just start coding." | Plan separates HOW from WHAT for a reason: missed HOW shows up as drift at slice 3. |
+| "One big slice is fine, the work is all related." | If slice 1 isn't shippable on its own, you're not slicing vertically. You're staging waterfall in disguise. |
+| "Tests can come at build time, not in tasks." | Every slice's `Tests to write/run` line is the contract that proves its acceptance: leave it blank, lose the contract. |
 | "Backend + frontend belong in one slice." | Fullstack goes contract-first: split the contract, then build a thin vertical slice that crosses both layers. |
 | "I can skip mapping every spec criterion." | An unmapped criterion is one nobody will build. Coverage isn't bureaucracy. |
 
 ## Red Flags
 
 - A slice with no acceptance criterion link back to `spec.md`.
-- A slice whose name contains "and" — two capabilities smuggled into one slice (the "and" test, [slicing](../../rite-plan/reference/slicing.md)).
+- A slice whose name contains "and": two capabilities smuggled into one slice (the "and" test, [slicing](../../rite-plan/reference/slicing.md)).
 - No first slice that's end-to-end thin (every slice depends on infra that doesn't exist yet).
 - A new dependency added without rationale in `decisions.md`.
 - A slice that doesn't list "Existing to reuse / extend" (you didn't search).

package/pack/generated/codex/skills/rite-define/reference/gates.md

@@ -1,4 +1,4 @@
-# Gate taxonomy — advisory · validating · blocking · escalating
+# Gate taxonomy: advisory · validating · blocking · escalating
 
 DevRites uses a four-gate model for HITL pauses, adapted from the regulated-agentic-workflow
 governance pattern. Picking the right gate for each `Mode: HITL` slice is the difference
@@ -22,29 +22,29 @@ audit / future record / FYI.
 **Example:** "We picked option A from the prototype's verdict but option B is also viable.
 Recording the choice for posterity."
 
-**SLA:** `none` — there is no waiting time because nothing is waiting.
+**SLA:** `none`. There is no waiting time because nothing is waiting.
 
 ### validating
 
 **Stakes:** medium. The slice can be built but should not merge before a human signs off.
-Async — the human reviews when they get to it, but the loop does not stall.
+Async: the human reviews when they get to it, but the loop does not stall.
 
 **Behavior:** in HITL mode, `$rite-build` pauses on this gate and writes
 `Awaiting human` to `state.md`. In AFK mode with `allow_gates: [advisory, validating]`,
 `$rite-build` builds the slice but marks it `built (pending review)` and writes the
 validating question; the feature does not seal until the entry is resolved. An open
-`gate: validating` entry is **merge-blocking by definition** — a slice marked
+`gate: validating` entry is **merge-blocking by definition**: a slice marked
 `built (pending review)` is not done, and seal is a NO-GO while it stands open.
 
 **Example:** "Schema migration adds a non-null column with a default. Backfill plan is
 recorded; reviewer should confirm the default is the right one for archived rows."
 
-**SLA:** `4h` — the work continues but the validating queue should drain within hours,
+**SLA:** `4h`: the work continues but the validating queue should drain within hours,
 not days.
 
 ### blocking
 
-**Stakes:** high. The slice cannot proceed safely without the answer. Synchronous —
+**Stakes:** high. The slice cannot proceed safely without the answer. Synchronous:
 the loop stops.
 
 **Behavior:** **always pauses regardless of `.devrites/AFK` config.** `$rite-build`
@@ -59,7 +59,7 @@ STOPs. The slice is not built until `$rite-resolve` lands.
 - Tests / types / lint are red and the agent cannot tell whether the slice's contract is
   wrong or the failing code is.
 
-**SLA:** `15m` — synchronous gates demand fast turnaround; otherwise treat the work as
+**SLA:** `15m`: synchronous gates demand fast turnaround; otherwise treat the work as
 genuinely blocked and re-plan around it.
 
 ### escalating
@@ -71,11 +71,11 @@ needs to route to a specialist (legal, security, principal engineer, designer-of
 `route:` field naming the specialist tag. `$rite-status` shows it under a separate
 "Escalating" line so it doesn't compete with synchronous blockers for the same reviewer.
 
-**Example:** "Slice introduces a contract with an external partner — needs legal review
+**Example:** "Slice introduces a contract with an external partner: needs legal review
 of the data-sharing language."
 
-**SLA:** `24h` — specialist routing implies the SLA is loose; if it needs to be tight,
-it's actually `blocking`.
+**SLA:** `24h`: specialist routing implies the SLA is loose; if it needs to be tight,
+it's `blocking`.
 
 ## Picking the gate
 
@@ -95,7 +95,7 @@ Apply this decision tree per HITL slice:
 
 | Gate | SLA | Synchronous? |
 |---|---|---|
-| advisory | `none` | — (does not pause) |
+| advisory | `none` |: (does not pause) |
 | validating | `4h` | no (async; build continues, merge blocks) |
 | blocking | `15m` | yes |
 | escalating | `24h` | yes, but to a specialist |
@@ -118,11 +118,11 @@ defaults and the always-pause rules:
 | `[advisory, validating, blocking]` | log + proceed | build + queue | log + proceed* | pause |
 
 \* but **never** for destructive migrations, auth/authz boundary changes, public API
-breaks, or red tests/types/lint — those always pause. See
+breaks, or red tests/types/lint. Those always pause. See
 [`.agents/skills/devrites-lib/reference/standards/afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md) for the irreversible-risk
 list.
 
-`escalating` is never in `allow_gates` — specialist routing is not something AFK can
+`escalating` is never in `allow_gates`: specialist routing is not something AFK can
 shortcut.
 
 ## Anti-patterns

package/pack/generated/codex/skills/rite-define/reference/plan-template.md

@@ -1,6 +1,6 @@
 # `plan.md` template
 
-Write **how** to build what `spec.md` defines. The plan is **living, not sacred** —
+Write **how** to build what `spec.md` defines. The plan is **living, not sacred**:
 `$rite-plan` repairs it when reality disagrees. This is where technology choices live
 (they're banned from the spec).
 

package/pack/generated/codex/skills/rite-doctor/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-doctor — health check
+# $rite-doctor: health check
 
 The on-demand deep report. The same checks run **silently at session start** (the orient
-hook surfaces issues only when there are any); `$rite-doctor` runs them **verbosely** —
-printing every check, pass or fail — so you can inspect health even when nothing is broken.
+hook surfaces issues only when there are any); `$rite-doctor` runs them **verbosely**:
+printing every check, pass or fail, so you can inspect health even when nothing is broken.
 It covers version drift, Claude Code wiring, optional Codex mirrors/hooks, stale host artifacts, and missing install markers when those files are present. With `--code`, it also runs the read-only project code-health dashboard (`devrites-engine health`).
 It also reports an in-progress git merge/rebase and points to `git-workflow.md`'s conflict
 recovery playbook.
@@ -33,7 +33,7 @@ It is **read-only**: it never edits the workspace, never advances a phase, never
    ```bash
    devrites-engine doctor --verbose; echo "doctor rc=$?"
    ```
-1a. **Surface the learnings nudge** — point the user at `$rite-learn` when a pattern recurs across
+1a. **Surface the learnings nudge**: point the user at `$rite-learn` when a pattern recurs across
    shipped features (read-only; silent when there's nothing to say):
    ```bash
    devrites-engine learnings nudge
@@ -42,18 +42,18 @@ It is **read-only**: it never edits the workspace, never advances a phase, never
    ```bash
    devrites-engine health; echo "health rc=$?"
    ```
-1c. **Validate project extensions + overrides** (read-only — report, don't sync). A user rite/
+1c. **Validate project extensions + overrides** (read-only: report, don't sync). A user rite/
    reviewer under `.devrites/extensions/` is held to the same schema as the shipped pack; a
    reviewer override under `.devrites/overrides/` may add emphasis but never relax a gate:
    ```bash
    devrites-engine extensions validate; echo "extensions rc=$?"
    devrites-engine overrides validate;  echo "overrides rc=$?"
    ```
-   - **extensions rc=1** — an extension is malformed (missing frontmatter, empty, duplicate name).
+   - **extensions rc=1:** an extension is malformed (missing frontmatter, empty, duplicate name).
      Fix the named file; once valid, the user mirrors it into the harness with
      `devrites-engine extensions sync`.
-   - **overrides rc=1** — an override reads like it waives a gate. That is the one thing overrides
-     must not do — hand the user the offending file to rewrite as added emphasis, not a waiver.
+   - **overrides rc=1:** an override reads like it waives a gate. That is the one thing overrides
+     must not do: hand the user the offending file to rewrite as added emphasis, not a waiver.
 1d. **Refresh indexes only when `$ARGUMENTS` includes `--reindex`.** Load and execute
    `devrites-refresh-indexes`; report its synchronous refresh result, then continue the
    diagnostic. This changes optional indexes, never project source or DevRites state.
@@ -63,12 +63,12 @@ It is **read-only**: it never edits the workspace, never advances a phase, never
    `$rite-resolve <qid>`; an incomplete install → reinstall). If the output includes
    `git-state: merge in progress` or `git-state: rebase in progress`, make the next action the
    `git-workflow.md` merge-conflict recovery playbook.
-3. **Do not fix anything yourself** — doctor is diagnostic. Hand the user the fix command.
+3. **Do not fix anything yourself:** doctor is diagnostic. Hand the user the fix command.
    **Completion:** exactly one highest-priority fix command is reported and no source/workspace file changed.
 
 ## Gotchas
-- Read-only — never write the workspace or advance a phase (that's the lifecycle skills' job).
-- It diagnoses **DevRites** health, not the user's application — code bugs go to
+- Read-only: never write the workspace or advance a phase (that's the lifecycle skills' job).
+- It diagnoses **DevRites** health, not the user's application: code bugs go to
   `devrites-debug-recovery`; feature progress goes to `$rite-status`.
 - Healthy is the common case; say so plainly and stop. Don't invent issues.