devrites 3.0.5 → 3.0.7

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

@@ -12,16 +12,16 @@ 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-learn — the cross-feature learning loop
+# $rite-learn: the cross-feature learning loop
 
 Recurring corrections, dismissed review findings, timeline decisions, and health dips are durable
-signal. **Capture is automatic** — `$rite-seal` appends lessons to `.devrites/learnings.md` on every
+signal. **Capture is automatic**: `$rite-seal` appends lessons to `.devrites/learnings.md` on every
 GO (step 9a), while the engine can keep `.devrites/timeline.jsonl`,
 `.devrites/health-history.jsonl`, and per-feature review fingerprints as supporting evidence. The
 review skills load the learning ledger **before** a fan-out, so a dismissed-finding class stops
@@ -29,22 +29,22 @@ being re-flagged without anyone running a command. The system learns as it ships
 
 `$rite-learn` is the periodic **review + promote** pass on that auto-populated ledger: cluster the
 signal across features and decide which recurring lessons graduate into a project rule. **Propose,
-never impose** — promotion is the human's call, which is why it stays a deliberate command rather
+never impose**: promotion is the human's call, which is why it stays a deliberate command rather
 than firing on its own.
 
 Read-mostly. It reads the auto-populated ledger + the archive; it writes only `.devrites/learnings.md`
-(consolidation, via `devrites-engine learnings`) and drafts proposed rule/ledger edits for the user to confirm —
+(consolidation, via `devrites-engine learnings`) and drafts proposed rule/ledger edits for the user to confirm:
 it never edits source or rule files on its own.
 
 ## Modes
 
-- `$rite-learn` or `$rite-learn --mine` — **mine + propose** (the default).
-- `$rite-learn "<lesson>"` — **record one lesson** directly to the ledger and stop.
+- `$rite-learn` or `$rite-learn --mine`: **mine + propose** (the default).
+- `$rite-learn "<lesson>"`: **record one lesson** directly to the ledger and stop.
 
 ## Workflow (mine + propose)
 
 1. **Gather the signal.** Start from the **auto-populated ledger** `.devrites/learnings.md` (seal
-   appends to it on every GO — step 9a), then run `devrites-engine learnings mine` over the archive (it clusters
+   appends to it on every GO: step 9a), then run `devrites-engine learnings mine` over the archive (it clusters
    repeated finding / decision / drift phrases across shipped
    features) to surface cross-feature patterns the per-feature entries don't show on their own:
    ```bash
@@ -54,38 +54,38 @@ it never edits source or rule files on its own.
    `.devrites/work/*/review-fingerprints.jsonl` as supporting evidence when they exist; do not
    promote from those traces without the same repeated-feature threshold.
 2. **Cluster + name.** Group the recurring corrections into candidate lessons. A candidate needs
-   **≥2 occurrences across distinct features** — one-offs are noise, not a pattern. Name the
+   **≥2 occurrences across distinct features**: one-offs are noise, not a pattern. Name the
    pattern in one specific sentence (the specificity rule from `prose-style.md` applies: a lesson
    you could swap onto any project says nothing).
    **Completion:** every candidate cites two distinct features, except a single deliberate
    rejected direction with its durable reason.
 3. **Classify each candidate** into its durable home:
-   - **project rule** — a craft/standard that belongs in a `.agents/skills/devrites-lib/reference/standards/*` file or `CLAUDE.md`.
-   - **project principle** — a recurring correction that is really a *non-negotiable invariant*
+   - **project rule:** a craft/standard that belongs in a `.agents/skills/devrites-lib/reference/standards/*` file or `CLAUDE.md`.
+   - **project principle:** a recurring correction that is really a *non-negotiable invariant*
      (not just an idiom or a craft standard): graduate it to `.devrites/principles.md`
-     ([`principles.md`](../devrites-lib/reference/standards/principles.md)). This is the **trusted, gating** layer — higher
-     stakes than a rule — so `$rite-learn` **drafts** the principle + a dated Governance entry for
+     ([`principles.md`](../devrites-lib/reference/standards/principles.md)). This is the **trusted, gating** layer (higher
+     stakes than a rule) so `$rite-learn` **drafts** the principle + a dated Governance entry for
      the human to confirm; it never writes a principle silently.
-   - **conventions-ledger entry** — a proven project idiom for `.devrites/conventions.md`.
-   - **dismissed-finding class** — a pattern reviewers keep flagging that is *intentional here*;
+   - **conventions-ledger entry:** a proven project idiom for `.devrites/conventions.md`.
+   - **dismissed-finding class:** a pattern reviewers keep flagging that is *intentional here*;
      recording it stops the recurring false positive (`learnings.md`, loaded pre-fan-out).
-   - **rejected direction** — an approach or product direction weighed and ruled out with a
+   - **rejected direction:** an approach or product direction weighed and ruled out with a
      reason that outlives one feature; recording it (tag `rejected-direction`) stops ideation
      skills (`$rite-pressure-test`, `$rite-pov`) from re-proposing it. Exempt from the
-     ≥2-occurrence rule — one deliberate rejection is the whole pattern.
-   - **drop** — not durable; let it go.
+     ≥2-occurrence rule: one deliberate rejection is the whole pattern.
+   - **drop:** not durable; let it go.
 4. **Propose, don't impose.** Present the candidates with their evidence (which features, how many
-   times, the proposed home) via `AskUserQuestion` — the human picks which to promote. Never
+   times, the proposed home) via `AskUserQuestion`: the human picks which to promote. Never
    promote a lesson to a rule silently; an unproven "lesson" hardened into a rule is its own slop.
    **Completion:** every candidate is explicitly accepted, rejected, or deferred by the human.
 5. **Record the accepted.** For each the user accepts, append it with `devrites-engine learnings add <slug>
    "<lesson>" <tag>` (`tag` ∈ `rule | convention | dismiss`). If the user approves a **rule**,
    **principle**, or **ledger** promotion, draft the exact edit and let the user confirm it through
-   the normal flow — `$rite-learn` writes the ledger, not the rule or principle files. A
+   the normal flow: `$rite-learn` writes the ledger, not the rule or principle files. A
    **principle** promotion is the highest-stakes of these: draft the `.devrites/principles.md` entry
-   **plus its dated Governance line**, and let the human confirm before it lands — a principle is a
+   **plus its dated Governance line**, and let the human confirm before it lands: a principle is a
    gate, so it is amended deliberately, never auto-written. **Amendment ripple:** a confirmed
-   add/change/retire of a principle has a blast radius — grep its `P#` (and its key nouns) across
+   add/change/retire of a principle has a blast radius: grep its `P#` (and its key nouns) across
    `.devrites/` and every open `.devrites/work/*/` workspace, and append to the same dated
    Governance entry one line per referencing artifact: *still-aligned* or *needs-follow-up (what)*.
    An open plan that bakes in the now-retired or now-tightened invariant is a `needs-follow-up`
@@ -99,11 +99,11 @@ The review skills (`$rite-review`, `$rite-seal`) read `.devrites/learnings.md` b
 out: a **dismissed-finding class** suppresses the recurring false positive; a **proven
 convention** raises the bar. The ideation skills (`$rite-pressure-test`, `$rite-pov`) read the
 **rejected-direction** entries before proposing, so a ruled-out direction returns only with new
-evidence against its recorded why. The ledger is an **untrusted prior** — a fresh observation of the
+evidence against its recorded why. The ledger is an **untrusted prior**: a fresh observation of the
 live code always overrides a ledger entry (see `.agents/skills/devrites-lib/reference/standards/security.md`). Confidence in a
 recorded lesson never raises its authority.
 
-A **project principle** (`.devrites/principles.md`) is the opposite layer — prescriptive,
+A **project principle** (`.devrites/principles.md`) is the opposite layer: prescriptive,
 trusted, and **gating**. Promoting a lesson there is a deliberate amendment, not a prior the next
 fan-out can override: a violation becomes a blocking finding, not a suppressed false positive.
 That asymmetry is why principle promotion is human-confirmed and dated, never auto-written.

package/pack/generated/codex/skills/rite-plan/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-plan — (re)plan an active feature
+# $rite-plan: (re)plan an active feature
 
 Reshape the plan when reality and the plan disagree. **Read the active workspace
 first.** If `.devrites/ACTIVE` is empty or its workspace is missing, stop and tell the
@@ -29,17 +29,17 @@ editing source code.
 Pull `development-workflow.md` via `Read` when reshaping slice cadence or DoD criteria.
 
 ## Operating rules
-- Spec is living, not sacred — but never plan around a known-wrong assumption silently.
+- Spec is living, not sacred, but never plan around a known-wrong assumption silently.
 - If a change alters product behavior, scope, architecture, data model, UX, security,
   or migration risk → **ask the user first** (use the Spec Drift Guard question format).
 - Keep each slice small enough for one focused build → prove cycle.
-- **Slice count is derived, never dictated** — reslice when a slice fails the sizing rule
+- **Slice count is derived, never dictated:** reslice when a slice fails the sizing rule
   (multiple "and"s, can't build+prove in one cycle), not to hit a user-named tally. A
   requested count is a hint at most; slice logically and explain if it differs. See
   [`reference/slicing.md`](reference/slicing.md) ("How many slices?").
 - **Size by complexity, order by dependency.** A slice carries a `Complexity: N/5` score (from
   `$rite-define`); a slice scoring **>3** is a reslice trigger unless its inline reason justifies
-  the irreducible complexity. Honor each slice's `depends_on:` — the next *buildable* slice is the
+  the irreducible complexity. Honor each slice's `depends_on:`: the next *buildable* slice is the
   lowest pending one whose dependencies are all built (keeps one-slice-at-a-time correct, not parallel).
 
 ## Workflow
@@ -47,35 +47,35 @@ Pull `development-workflow.md` via `Read` when reshaping slice cadence or DoD cr
    Then run `devrites-engine preamble` for deterministic workspace orientation.
 1. Read `spec.md`, `plan.md`, `tasks.md`, `state.md`, `drift.md`, and the current
    `git diff` (if a repo). Read `decisions.md` and `assumptions.md`. If a code-intelligence
-   index is available — `codebase-memory-mcp` first, cross-checked with `codegraph`
+   index is available: `codebase-memory-mcp` first, cross-checked with `codegraph`
    (`.codegraph/` / `codegraph_*` tools) + `graphify` (`graphify-out/`), else standard methods
-   (LSP / `Read`/`Grep`/`Glob`); see `.agents/skills/devrites-lib/reference/standards/tooling.md` —
+   (LSP / `Read`/`Grep`/`Glob`); see `.agents/skills/devrites-lib/reference/standards/tooling.md`:
    prefer it for structural questions (what calls X, what would
    changing Y break) over reading whole files, to keep planning context lean. For an external
    dependency's current API surface, consult context7 if available.
 2. **Pick the mode** (`$ARGUMENTS` or infer):
-   - **decompose** — first/again break the feature into vertical slices.
-   - **reslice** — a slice is too large; split into thinner end-to-end slices.
-   - **repair** — a Spec Drift Guard event; fold the resolution into plan + tasks.
-   - **reorder** — fix the dependency order.
-   - **split** — separate backend/frontend contracts (see `devrites-api-interface`).
-   - **unblock** — a verification failed; re-route around the blocker.
-   - **course-correct** — a deliberate mid-build *pivot* (the user changed their mind), distinct
+   - **decompose:** first/again break the feature into vertical slices.
+   - **reslice:** a slice is too large; split into thinner end-to-end slices.
+   - **repair:** a Spec Drift Guard event; fold the resolution into plan + tasks.
+   - **reorder:** fix the dependency order.
+   - **split:** separate backend/frontend contracts (see `devrites-api-interface`).
+   - **unblock:** a verification failed; re-route around the blocker.
+   - **course-correct:** a deliberate mid-build *pivot* (the user changed their mind), distinct
      from accidental drift: classify the change, assess its impact across the remaining slices,
      decide rollback vs forward-fix, and update `spec.md` + `plan.md` + `tasks.md` + `decisions.md`
      atomically. An acceptance/behavior change still goes through the user first. When the plan
      names an `MVP cut`, offer it as the retreat option: falling back to the cut is a pre-agreed
      scope, not a new negotiation.
-   - **revise** — apply a requested planning-artifact revision and reconcile existing artifacts in
+   - **revise:** apply a requested planning-artifact revision and reconcile existing artifacts in
      any direction; propose the file edit set first, confirm each file before writing, and **never
-     edit source code**. **Gate first — revise or new?** Same intent? >50% of existing scope
+     edit source code**. **Gate first: revise or new?** Same intent? >50% of existing scope
      survives? original *not* completable without this? Two "no"s → new work: recommend
      sealing/shipping the current workspace (MVP cut if named) then `$rite-spec` for the new
      intent, and stop. Revise preserves context; a new workspace provides clarity.
    See [replan-and-repair](reference/replan-and-repair.md) for each mode's steps.
-3. Reason about dependencies — [dependency-graph](reference/dependency-graph.md).
+3. Reason about dependencies: [dependency-graph](reference/dependency-graph.md).
    **Completion:** the slice graph is cycle-free and every dependency names an existing slice.
-4. Re-slice using vertical-slice rules — [slicing](reference/slicing.md) and
+4. Re-slice using vertical-slice rules: [slicing](reference/slicing.md) and
    [task-breakdown](reference/task-breakdown.md). Prefer thin, shippable, verifiable.
    **Completion:** every slice is independently shippable/provable or carries an irreducibility reason.
 5. Update `plan.md`, `tasks.md`, `state.md`, and append rationale to `decisions.md`.
@@ -83,17 +83,17 @@ Pull `development-workflow.md` via `Read` when reshaping slice cadence or DoD cr
 6. If product behavior/acceptance criteria change, confirm with the user before writing.
    **Completion:** the change is classified, and every behavior/acceptance change has explicit
    confirmation recorded before the artifacts are updated.
-7. **Done when** — every slice is sized (builds + proves in one cycle; no slice scoring >3
+7. **Done when:** every slice is sized (builds + proves in one cycle; no slice scoring >3
    left unjustified), the dependency order is acyclic, every `drift.md` entry you stopped for
    is marked resolved, revised artifacts agree with each other, no source files changed in
    `revise` mode, and behavior-change-vs-not is confirmed (`no`, or asked + answered).
-   If any check fails, loop back — don't hand off a half-reshaped plan.
+   If any check fails, loop back: don't hand off a half-reshaped plan.
 
-> **Mid-flight discipline.** When tempted to change product behavior without asking, absorb drift silently, or skip the user — see [`anti-patterns`](reference/anti-patterns.md). Load it the moment you reach for the excuse.
+> **Mid-flight discipline.** When tempted to change product behavior without asking, absorb drift silently, or skip the user: see [`anti-patterns`](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:
 ```

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

@@ -1,4 +1,4 @@
-# rite-plan — anti-patterns
+# rite-plan: anti-patterns
 
 Load this when standing a non-trivial re-plan decision, or when the agent
 feels reluctance toward asking the user before a behavior change.
@@ -9,7 +9,7 @@ Pack-wide rationalizations + red flags: see [standards/anti-patterns.md](../../d
 
 | Excuse | Rebuttal |
 |---|---|
-| "User didn't ask for a re-plan." | A Spec Drift Guard event *is* a re-plan trigger — ask is courtesy, the route is automatic. |
+| "User didn't ask for a re-plan." | A Spec Drift Guard event *is* a re-plan trigger: ask is courtesy, the route is automatic. |
 | "I can fix the slice mid-build, no need to update tasks." | `tasks.md` is the contract `$rite-build` reads. A fix that isn't there isn't visible to the next phase. |
 | "Reordering slices is cosmetic." | Dependency order controls risk discovery; risk-first wins because it surfaces blockers early. |
 | "This drift is small enough to absorb silently." | Silent drift = unrecorded decision = future "why does this work?" debugging session. |
@@ -20,5 +20,5 @@ Pack-wide rationalizations + red flags: see [standards/anti-patterns.md](../../d
 - About to change product behavior, acceptance, or scope without asking the user.
 - `drift.md` entry unresolved while planning the next slice.
 - A "mode" invented that isn't one of `decompose / reslice / repair / reorder / split / unblock`.
-- Slices reordered without updating dependency notes — order changed, rationale didn't.
+- Slices reordered without updating dependency notes: order changed, rationale didn't.
 - Repairing a drift event by silently widening the spec rather than narrowing the plan.

package/pack/generated/codex/skills/rite-plan/reference/dependency-graph.md

@@ -16,7 +16,7 @@ SLICE-006 (config)  -> independent
 ```
 
 ## Within a tier: risk-first
-Among slices that are equally unblocked, do the **riskiest** first — the one most
+Among slices that are equally unblocked, do the **riskiest** first: the one most
 likely to invalidate the plan (new integration, uncertain library behavior, migration).
 Finding drift early is cheap; finding it at seal time is not.
 

package/pack/generated/codex/skills/rite-plan/reference/replan-and-repair.md

@@ -8,7 +8,7 @@ First (or fresh) breakdown into vertical slices. Use `task-breakdown.md` +
 
 ## reslice
 A slice proved too large (couldn't build+prove in one cycle, or its goal has multiple
-"and"s). Split into thinner end-to-end slices, preserving acceptance coverage — split
+"and"s). Split into thinner end-to-end slices, preserving acceptance coverage: split
 **by the sizing rule, not to a target count**. Update `tasks.md`; renumber; fix
 dependency edges.
 
@@ -20,7 +20,7 @@ A drift event stopped the build. Steps:
    reality. Adjust acceptance criteria if they were wrong.
 4. Mark the `drift.md` entry **resolved** with the resolution + date.
 5. Resume at the corrected slice.
-Never repair by quietly deleting the inconvenient requirement — if behavior changes,
+Never repair by quietly deleting the inconvenient requirement, if behavior changes,
 that was a user question.
 
 ## reorder
@@ -29,7 +29,7 @@ re-sort risk-first within tiers, update `plan.md`'s implementation order.
 
 ## split (backend/frontend contract)
 A slice couples two sides too tightly. Define the contract first (shape, status codes,
-errors — `devrites-api-interface`), then split into a backend slice (can land with a
+errors: `devrites-api-interface`), then split into a backend slice (can land with a
 stub consumer) and a frontend slice (can land against a mock/real contract).
 
 ## unblock

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

@@ -25,41 +25,41 @@ A slice is the right size when it:
 
 Too big if: it touches many unrelated files, or you can't name its single observable outcome.
 **The "and" test:** if the slice's *name* needs an "and" ("create **and** list tasks"), it's two
-slices — split on the "and". → reslice.
+slices: split on the "and". → reslice.
 
 Sizing isn't cosmetic. An agent builds a small or medium slice reliably in one pass but drifts on
 an outsized one, which is why a slice over `Complexity: 3/5` reslices (the `tasks.md` slice format
 in [`rite-define`](../../rite-define/SKILL.md)). Push every slice to the smallest cut that still
 stands alone end-to-end.
 
-## How many slices? — derive, don't dictate
+## How many slices?: derive, don't dictate
 The slice **count is an output, not an input.** It falls out of the work: one slice per
 independently-shippable vertical increment that satisfies one (or a tight group of)
-acceptance criteria and passes the sizing test above. A 2-criterion feature is 1–2 slices;
+acceptance criteria and passes the sizing test above. A 2-criterion feature is 1-2 slices;
 a 12-criterion feature is however many thin end-to-end cuts those 12 need.
 
 - **Never slice to a target number.** Don't pad a small feature into "5 slices" or
   compress a large one into "3" because a figure was named.
 - **A user-supplied count is a hint at most.** If the user says "do it in 4", slice the
   work logically first; if your honest decomposition differs, present the logical count
-  and *why*, then let them redirect — don't silently force their number.
+  and *why*, then let them redirect: don't silently force their number.
 - **Re-size by the rule, not the tally** (`$rite-plan reslice`): split a slice because it
   failed the sizing test, not to hit a count.
 
-Not to be confused with `.devrites/AFK` `max_slices` — that's an AFK *iteration budget*
+Not to be confused with `.devrites/AFK` `max_slices`. That's an AFK *iteration budget*
 capping how many slices the unattended loop builds before it stops, **not** the plan's
 decomposition. The plan always holds exactly the slices the work needs; `max_slices` only
 limits how many run unattended.
 
 ## First slice
-Make slice 1 the **thinnest useful end-to-end path** — it flushes out integration and
+Make slice 1 the **thinnest useful end-to-end path**. It flushes out integration and
 convention surprises early, while changes are cheap.
 
-**Risk-first exception.** When the biggest risk is a technical *unknown* — "will this library
-even do X?", "can we hit the latency target?" — let slice 1 (or a throwaway spike ahead of it)
+**Risk-first exception.** When the biggest risk is a technical *unknown*: "will this library
+even do X?", "can we hit the latency target?": let slice 1 (or a throwaway spike ahead of it)
 prove that unknown, even if it isn't the thinnest user-facing path. Fail the risky bet first,
 while pivoting is still cheap.
 
 ## Slice independence
 Order by dependency, but minimize coupling. A slice that needs three other slices first
-is a smell — look for a thinner cut that stands alone.
+is a smell: look for a thinner cut that stands alone.

package/pack/generated/codex/skills/rite-plan/reference/task-breakdown.md

@@ -24,10 +24,10 @@ This reference owns decomposition; the shared schema owns field names and meanin
 ## Keep it honest
 - **Interfaces prevent cross-slice drift.** A slice-wright sees only its own contract; the
   `Interfaces` line is how it learns the names and types neighboring slices use. A function
-  called `clearLayers()` in slice 3 and `clearFullLayers()` in slice 7 is a planning bug —
+  called `clearLayers()` in slice 3 and `clearFullLayers()` in slice 7 is a planning bug:
   name shared symbols once, here.
-- Don't pre-write code in the task — describe the outcome, not the implementation.
+- Don't pre-write code in the task: describe the outcome, not the implementation.
 - Don't bundle "while we're here" work into a slice. That's scope creep; log it as a
   follow-up instead.
-- Don't slice to a target number — the count comes from the capabilities + the sizing
+- Don't slice to a target number: the count comes from the capabilities + the sizing
   rule (`slicing.md`), not a figure anyone named.

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

@@ -11,18 +11,18 @@ 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-polish — finish before review
+# $rite-polish: finish before review
 
 The "finish" phase. **Always** code-polishes; **and** runs UI normalize +
 design polish when the feature touches UI. Self-review the work to ship
 quality *before* handing it to `$rite-review`. The two-phase split (code,
-UI) lives in `reference/code.md` and `reference/ui.md` — read each on demand,
+UI) lives in `reference/code.md` and `reference/ui.md`: read each on demand,
 don't load both up front.
 
 ## Operating rules
@@ -30,7 +30,7 @@ don't load both up front.
 - **Functionality complete first.** Polish runs after `$rite-prove` (full
   feature proven).
 - Feature scope only.
-- For UI: **NEVER polish without normalizing first** — decoration on drift is
+- For UI: **NEVER polish without normalizing first**: decoration on drift is
   banned.
 
 ## Orchestration
@@ -42,7 +42,7 @@ don't load both up front.
    Then run `devrites-engine preamble` for deterministic workspace orientation.
 1. **Read** `state.md`, `touched-files.md`, and the `git diff` for the active
    workspace (or `$ARGUMENTS` if a target was given).
-2. **Detect UI scope** — UI is touched if the diff or `touched-files.md`
+2. **Detect UI scope:** UI is touched if the diff or `touched-files.md`
    contains any of: `.tsx`, `.jsx`, `.vue`, `.svelte`, `.html`, `.css`,
    `.scss`, `.sass`, `.less`, `.styl`, component dirs (`components/`,
    `pages/`, `routes/`, `app/`, `views/`, `screens/`), Storybook stories,
@@ -55,29 +55,29 @@ don't load both up front.
    `design-brief.md` if present (the UX/UI contract `devrites-ux-shape` shaped at spec and
    `devrites-frontend-craft` refined while building) so the polish honors the agreed
    direction + states. **Read the `## Visual Verdict` table in `browser-evidence.md` if present:
-   its `FAIL` and `PARTIAL` rows are the normalize/quality-bar worklist** — fix the root cause of
+   its `FAIL` and `PARTIAL` rows are the normalize/quality-bar worklist**: fix the root cause of
    each (a missing state, an off-token CTA, an anti-slop hit), don't decorate around it. Then run
    **Phase 3 (normalize)** → **Phase 4 (UI polish)**. Honor argument modes:
-   - `bolder | quieter | distill | harden` — passed to Phase 4 as the
+   - `bolder | quieter | distill | harden`: passed to Phase 4 as the
      emphasis dial.
-   - `normalize-only` — run Phase 3 and stop (no Phase 4).
-5. **Re-verify after any code edit** — polish edits code, so the proof from
+   - `normalize-only`: run Phase 3 and stop (no Phase 4).
+5. **Re-verify after any code edit:** polish edits code, so the proof from
    `$rite-prove` no longer post-dates it. Run the relevant fast checks (the
    targeted tests for the touched files + typecheck/lint; browser re-check if UI
    changed) and record a **`Re-verification:`** line in `polish-report.md`. A
    polish that changed code without a green re-verification isn't finished.
-6. **Aggregate output** — both phases append to the single `polish-report.md`.
+6. **Aggregate output:** both phases append to the single `polish-report.md`.
 
 ## Refinement modes
 
 When the user (or your own assessment) names a direction the UI should move,
-pass it through to Phase 4. Modes don't bypass normalize + quality-bar work —
+pass it through to Phase 4. Modes don't bypass normalize + quality-bar work:
 they shape the polish *after* the system is aligned. See `reference/ui.md` for
 the mode table.
 
 > **Mid-flight discipline.** When tempted to polish UI without normalize, cite
 > clean lint as proof of quality, skip Phase 2 on a backend diff, or delete a
-> Chesterton's Fence — see [anti-patterns](reference/anti-patterns.md).
+> Chesterton's Fence: see [anti-patterns](reference/anti-patterns.md).
 
 ## Output → `polish-report.md`
 

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

@@ -1,4 +1,4 @@
-# rite-polish — anti-patterns
+# rite-polish: anti-patterns
 
 Load this when standing a non-trivial polish decision, or when tempted to
 skip normalize, polish without Chesterton's Fence, or cite clean lint/build
@@ -12,11 +12,11 @@ Pack-wide rationalizations + red flags (incl. lint-pass-as-quality): see
 | Excuse | Rebuttal |
 |---|---|
 | "Tests pass; the feature is done." | Tests don't measure ship-quality, design drift, anti-slop, or backend polish. |
-| "UI looks fine to me." | Must align to the design system + meet CWV/WCAG 2.2 — not match a personal taste. |
-| "Code is simple enough; no need to audit." | Measure first. If there's no hotspot, that's fine — but record "no hotspots found", don't skip silently. |
-| "It's a small UI change; polish without normalize is fine." | **NO** — decoration on drift is banned. Phase 3 runs before Phase 4, always. |
-| "Backend looks OK; skip Phase 2." | If the diff touched BE, Phase 2 runs — error responses, logging hygiene, queries, anti-slop. |
-| "Fewer lines is simpler, so this is done." | The bar is the comprehension test, not line count: would a new reader understand it *faster* than the original? A cryptic one-liner fails it. Fewer-but-slower is churn — revert it. |
+| "UI looks fine to me." | Must align to the design system + meet CWV/WCAG 2.2, not match a personal taste. |
+| "Code is simple enough; no need to audit." | Measure first. If there's no hotspot, that's fine, but record "no hotspots found", don't skip silently. |
+| "It's a small UI change; polish without normalize is fine." | **NO**: decoration on drift is banned. Phase 3 runs before Phase 4, always. |
+| "Backend looks OK; skip Phase 2." | If the diff touched BE, Phase 2 runs: error responses, logging hygiene, queries, anti-slop. |
+| "Fewer lines is simpler, so this is done." | The bar is the comprehension test, not line count: would a new reader understand it *faster* than the original? A cryptic one-liner fails it. Fewer-but-slower is churn: revert it. |
 
 ## Red Flags
 
@@ -24,7 +24,7 @@ Pack-wide rationalizations + red flags (incl. lint-pass-as-quality): see
 - No browser evidence saved for a UI polish.
 - Code polish ran without naming a single technique (guard clauses, Extract Method, ...).
 - Backend was touched but `polish-report.md` shows no Phase 2 section.
-- A "simplification" that changes observable behavior — that's not behavior-preserving.
+- A "simplification" that changes observable behavior. That's not behavior-preserving.
 - Reading a Chesterton's Fence as "looks dead" and deleting without explaining what it guards.
-- Simplifying, reflowing, or "tidying" a block marked `devrites:keep` / `simplify-ignore` — the marker is an explicit fence; leave it in place.
+- Simplifying, reflowing, or "tidying" a block marked `devrites:keep` / `simplify-ignore`: the marker is an explicit fence; leave it in place.
 - Hand-editing a >500-line simplification that a codemod / AST transform should have applied uniformly.

package/pack/generated/codex/skills/rite-polish/reference/backend-polish.md

@@ -1,6 +1,6 @@
 # Backend polish (when backend touched)
 
-Runs as Phase 2 of `$rite-polish` when the feature touches server-side code — handlers /
+Runs as Phase 2 of `$rite-polish` when the feature touches server-side code: handlers /
 controllers / services / routes / models / migrations / queries / jobs / workers / auth /
 schemas. Polishes the **server side** to ship-quality before review, the way UI normalize
 + polish does for the client side.
@@ -17,17 +17,17 @@ schemas. Polishes the **server side** to ship-quality before review, the way UI
 
 ### Error handling (consistent + meaningful)
 - [ ] **Consistent error response shape** across endpoints (e.g. an RFC 7807 problem
-      document or the project's existing convention). One shape — not three.
+      document or the project's existing convention). One shape, not three.
 - [ ] **Correct HTTP / protocol status codes** (4xx for client errors, 5xx for server
       errors; not 200 with `{ error: ... }`).
 - [ ] **Custom error classes** (or equivalent) so callers can distinguish error kinds.
-- [ ] **Fail closed** on auth/permission/transaction errors — deny + roll back; never
+- [ ] **Fail closed** on auth/permission/transaction errors: deny + roll back; never
       default to allow or partial commit (`error-handling.md`, `security.md`).
-- [ ] **Narrow `catch`** — no blanket `catch (e) {}` swallows. If you catch, recover or
+- [ ] **Narrow `catch`**: no blanket `catch (e) {}` swallows. If you catch, recover or
       rethrow with context.
 
 ### Logging hygiene
-- [ ] **Structured logs** (key/value or JSON) with **context** — request id, user/actor
+- [ ] **Structured logs** (key/value or JSON) with **context**: request id, user/actor
       id, operation, duration.
 - [ ] Log the **events that matter**: failures, access violations, validation rejections,
       retries, auth events.
@@ -36,22 +36,22 @@ schemas. Polishes the **server side** to ship-quality before review, the way UI
 - [ ] No `console.log` / debug prints left in. No noisy "got here" lines.
 
 ### Data & queries
-- [ ] **No N+1** — fetch in batches / use joins or includes.
-- [ ] **No unbounded result sets** — pagination/limits where data can grow.
+- [ ] **No N+1**: fetch in batches / use joins or includes.
+- [ ] **No unbounded result sets**: pagination/limits where data can grow.
 - [ ] **Parameterized queries** only; never string-built SQL/shell/HTML.
 - [ ] **Indexes** exist for new query patterns (or recorded as a follow-up if the project
       adds them by migration).
-- [ ] **Transaction boundaries** are right — one logical write = one transaction; rollback
+- [ ] **Transaction boundaries** are right: one logical write = one transaction; rollback
       on error; no partial commits.
 - [ ] Don't return more fields than the caller needs.
 
 ### API contract
 - [ ] Response shape matches the contract the spec set (and what the UI / consumers
-      expect — match against `references/` if any).
+      expect: match against `references/` if any).
 - [ ] **Idempotency** where applicable (PUT/DELETE; retry-safe POSTs with idempotency
       keys).
 - [ ] **Pagination, sorting, filtering** consistent with neighboring endpoints.
-- [ ] **Validation at the boundary** — type/length/format/range on untrusted input;
+- [ ] **Validation at the boundary**: type/length/format/range on untrusted input;
       reject what doesn't match (see `security.md` three-tier).
 
 ### Performance (measure first)
@@ -67,14 +67,14 @@ schemas. Polishes the **server side** to ship-quality before review, the way UI
 - [ ] No leftover `TODO`s without an owner/issue.
 - [ ] **Migrations** are reversible where reasonable; destructive ones have rollback notes.
 
-### Anti-slop (code patterns — see `anti-ai-slop.md`)
+### Anti-slop (code patterns: see `anti-ai-slop.md`)
 - [ ] No over-defensive null/length checks layered redundantly.
 - [ ] No useless wrapper functions ("`function getUser(id) { return User.find(id); }`").
 - [ ] No generic AI naming (`process_data`, `handle_thing`, `do_it`).
 - [ ] No "robust" code that catches everything and hides bugs.
-- [ ] Didn't go **beyond the spec** — implemented what the spec asked, no extras.
+- [ ] Didn't go **beyond the spec**: implemented what the spec asked, no extras.
 
 ## Rules
 - Feature scope only. Don't refactor unrelated server code.
 - Re-prove after changes: targeted tests + a real request/response observation.
-- A polish change that breaks a test isn't behavior-preserving — revert and reconsider.
+- A polish change that breaks a test isn't behavior-preserving: revert and reconsider.

package/pack/generated/codex/skills/rite-polish/reference/browser-polish-evidence.md

@@ -6,14 +6,14 @@ in `polish-report.md`).
 
 ## Required when a browser can run
 - Screenshots of the polished UI at the target viewports (375 / 768 / 1280 as relevant).
-  **Open each screenshot and describe what's actually visible** — a path is not proof.
+  **Open each screenshot and describe what's visible**: a path is not proof.
 - All key interaction states captured or exercised: hover, focus, active, disabled,
   loading, empty, error, success.
-- Console clean (no errors/warnings) — captured.
-- No layout shift on load — observed.
+- Console clean (no errors/warnings): captured.
+- No layout shift on load: observed.
 - Reduced-motion behavior checked if motion was added.
 - **Design references**: if the spec saved references in `.devrites/work/<slug>/references/`,
-  compare the polished UI against them — does it match the agreed target? Note any diffs.
+  compare the polished UI against them: does it match the agreed target? Note any diffs.
 
 ## Before/after
 Where polish changed something visible, capture a **before/after** pair. The pair is the