devrites 3.0.4 → 3.0.6

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

@@ -11,19 +11,19 @@ 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-prove — prove the completed feature
+# $rite-prove: prove the completed feature
 
 Turn "I think it works" into recorded evidence for the **whole feature**. Read the active
 workspace first; if none, run `$rite-spec <feature>`.
 
 > **Differs from built-in `/verify` and `/run`:** those prove a single change /
-> launch the app. `$rite-prove` is feature-scoped — it walks `spec.md` acceptance
+> launch the app. `$rite-prove` is feature-scoped. It walks `spec.md` acceptance
 > criteria one-by-one, runs the full relevant test suite + build/typecheck/lint,
 > ascends the browser-proof ladder (step 4),
 > and writes `evidence.md` + `browser-evidence.md` keyed to the active
@@ -31,7 +31,7 @@ workspace first; if none, run `$rite-spec <feature>`.
 
 ## Gate: all slices must be built first
 Read `tasks.md` + `state.md`. **If ANY slice is still pending/unbuilt, STOP** and tell the
-user to finish it with `$rite-build` — `$rite-prove` runs once, when the full task is
+user to finish it with `$rite-build`: `$rite-prove` runs once, when the full task is
 complete, not after each slice. (Each slice already got its own targeted tests during
 `$rite-build`; this phase is the comprehensive proof of the assembled feature.)
 
@@ -44,22 +44,22 @@ the affected criteria/routes to refresh proof before `$rite-seal`.
 
 ## Rules consulted (read on demand from `.agents/skills/devrites-lib/reference/standards/`)
 Pull these via `Read` when relevant:
-- `testing.md` — pyramid, determinism, no-flake discipline.
-- `test-proof-checklist.md` — compact proof-quality gate for tests and recorded evidence.
-- `browser-proof-checklist.md` — for UI scope, the required browser states and Visual Verdict evidence.
-- `spec-grammar.md` — when the spec uses structured `### Requirement:` / `#### Scenario:`
+- `testing.md`: pyramid, determinism, no-flake discipline.
+- `test-proof-checklist.md`: compact proof-quality gate for tests and recorded evidence.
+- `browser-proof-checklist.md`: for UI scope, the required browser states and Visual Verdict evidence.
+- `spec-grammar.md`: when the spec uses structured `### Requirement:` / `#### Scenario:`
   blocks, each scenario (WHEN/THEN) is one observable behavior to walk and prove.
-- `performance.md` — measure first when perf is in scope.
-- `observability.md` — when the change has a runtime surface (endpoint, job, integration,
+- `performance.md`: measure first when perf is in scope.
+- `observability.md`: when the change has a runtime surface (endpoint, job, integration,
   user flow): telemetry must be present **and observed to emit**, not assumed.
-- `developer-experience.md` — when the change ships a developer-facing surface (API / CLI / SDK /
+- `developer-experience.md`: when the change ships a developer-facing surface (API / CLI / SDK /
   webhook / config / error messages / getting-started): **measure** the DX scorecard (run the flow,
   time time-to-hello-world, capture the verbatim error text), don't assert it.
-- `definition-of-done.md` — standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
+- `definition-of-done.md`: standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
 
 
 ## Operating rules
-- Evidence over confidence. Feature scope only — fix within the feature or record a
+- Evidence over confidence. Feature scope only: fix within the feature or record a
   blocker; don't refactor unrelated code.
 - Spec Drift Guard applies: if tests/evidence reveal the spec is wrong, stop and handle
   drift (`rite-build/reference/spec-drift-guard.md`).
@@ -71,13 +71,13 @@ Pull these via `Read` when relevant:
 1. **Confirm the gate** (all slices built). Read `spec.md` (acceptance criteria +
    "Commands discovered"), `tasks.md`, `state.md`, `test-plan.md` if present (the vetted
    coverage target from `$rite-vet`), and the full `git diff`.
-2. **Discover commands** if not recorded —
+2. **Discover commands** if not recorded:
    [test-command-discovery](reference/test-command-discovery.md): README, package
    scripts, Makefile, CI configs, Gemfile/Rakefile, pyproject, go.mod, Cargo.toml.
    **Completion:** exact runnable test/build/typecheck/lint commands are recorded or explicitly unavailable.
 3. **Run the full relevant test suite** for the feature (not a single slice), then the
    relevant **build / typecheck / lint**.
-4. **UI feature?** Read `design-brief.md` + `references.md`, then run the browser proof ladder over the feature's routes —
+4. **UI feature?** Read `design-brief.md` + `references.md`, then run the browser proof ladder over the feature's routes:
    [proof-ladder](reference/proof-ladder.md) + [browser-proof](reference/browser-proof.md)
    (`devrites-browser-proof`): routes, viewports, screenshots (opened + described),
    console, network, interaction paths, and the brief's proof targets. Compare screenshots
@@ -92,14 +92,14 @@ Pull these via `Read` when relevant:
    `devrites-debug-recovery`. Reproduce → isolate → fix within scope → re-run; if a fix
    would exceed scope, record a blocker.
 7. Update `evidence.md`, `browser-evidence.md` (if UI), `traceability.md`, and
-   `state.md`. New proof goes to `evidence.md` (`proof.md` is a read-only alias —
+   `state.md`. New proof goes to `evidence.md` (`proof.md` is a read-only alias:
    see `devrites-lib/reference/workspace-artifact-schema.md`).
 
-> **Mid-flight discipline.** When tempted to claim an un-observed pass, skip a rung of the browser-proof ladder, or proceed with slices pending — see [`anti-patterns`](reference/anti-patterns.md). Load it the moment you reach for the excuse.
+> **Mid-flight discipline.** When tempted to claim an un-observed pass, skip a rung of the browser-proof ladder, or proceed with slices pending: 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-prove/reference/anti-patterns.md

@@ -1,4 +1,4 @@
-# rite-prove — anti-patterns
+# rite-prove: anti-patterns
 
 Load this when standing a non-trivial proof decision, or when tempted to
 report a pass you didn't observe, skip a rung of the browser-proof ladder,
@@ -14,12 +14,12 @@ see [standards/anti-patterns.md](../../devrites-lib/reference/standards/anti-pat
 | "Tests passed during build; that's enough." | Build = per-slice sanity check. Prove = whole-feature suite + build/typecheck/lint + browser. |
 | "Browser proof is overkill for this UI change." | If it's UI and a browser can run, the ladder applies. If you can't, document which rung and why. |
 | "Failure is in pre-existing code, not in this feature." | Still surfaces as a blocker. Feature scope = fix in scope or record + halt. |
-| "Some slices are still pending but the rest can be proved." | No — `$rite-prove` runs once, when every slice is built. Otherwise you're proving a partial system. |
+| "Some slices are still pending but the rest can be proved." | No: `$rite-prove` runs once, when every slice is built. Otherwise you're proving a partial system. |
 
 ## Red Flags
 
-- Reporting "pass" for a command you didn't actually run.
-- Skipping browser-proof rungs 1–3 because rung 4 (project E2E) was easier.
+- Reporting "pass" for a command you didn't run.
+- Skipping browser-proof rungs 1-3 because rung 4 (project E2E) was easier.
 - An acceptance criterion left "unproven" without a corresponding blocker note.
 - Tests recorded green but the diff shows the test file wasn't touched (stale run).
 - About to write `evidence.md` without command + output.

package/pack/generated/codex/skills/rite-prove/reference/browser-proof.md

@@ -1,4 +1,4 @@
-# Browser proof — evidence schema
+# Browser proof: evidence schema
 
 What `browser-evidence.md` must capture for a UI slice. Delegates to
 `devrites-browser-proof`; this is the record contract.
@@ -33,7 +33,7 @@ What `browser-evidence.md` must capture for a UI slice. Delegates to
 ```
 
 ## Rules
-- Open every screenshot path and describe it — never assert from the filename.
+- Open every screenshot path and describe it: never assert from the filename.
 - Read `design-brief.md` + `references.md` first. Compare fidelity only with references
   classified **target**; check constraints as rules and never pixel-match inspiration.
 - Render every proof target named by the brief/slice. At minimum check a small (375) and a

package/pack/generated/codex/skills/rite-prove/reference/failure-triage.md

@@ -4,21 +4,21 @@ When a test/build/runtime/browser check fails, triage before fixing. Delegates t
 loop to `devrites-debug-recovery`.
 
 ## Triage ladder
-1. **Reproduce** — run the failing command again; capture the exact error (quote it).
+1. **Reproduce:** run the failing command again; capture the exact error (quote it).
 2. **Classify** the failure:
    - test is right, code is wrong → fix the code (in scope).
    - test is wrong/outdated → that may be **spec drift** (acceptance criteria wrong).
    - environment/setup (missing dep, wrong node/ruby) → fix setup or record blocker.
    - flaky (passes on re-run, timing/order) → note it; don't paper over with retries.
    - external dependency down → record blocker; don't fake the result.
-3. **Isolate** — minimize to the smallest failing case; bisect the diff if needed.
-4. **Fix within scope** — the current slice/feature only. If the fix reaches outside
+3. **Isolate:** minimize to the smallest failing case; bisect the diff if needed.
+4. **Fix within scope:** the current slice/feature only. If the fix reaches outside
    scope, stop and record a blocker in `state.md` (then `$rite-plan unblock`).
 5. **Re-run** the same command; confirm green; record both attempts in `evidence.md`.
 
 ## Rules
 - Quote the real error text; don't paraphrase it away.
-- Don't loosen/delete a failing assertion to get green — investigate whether it's drift.
+- Don't loosen/delete a failing assertion to get green: investigate whether it's drift.
 - Don't add blanket retries/sleeps to hide flakiness.
 - Three failed fix attempts on the same root cause → escalate: `devrites-debug-recovery`
   for a hypothesis-driven pass, or ask the user.

package/pack/generated/codex/skills/rite-prove/reference/proof-ladder.md

@@ -1,21 +1,21 @@
 # Proof ladder
 
 Prefer real runtime evidence. For UI/browser work, try tools top-down and record which
-rung you used. Detect, don't install — browser tooling setup is the user's call.
+rung you used. Detect, don't install: browser tooling setup is the user's call.
 
 1. **Playwright MCP** (preferred when configured)
    - Detect: the Playwright MCP `browser_*` tools are available (e.g. `browser_navigate`).
      Capabilities: navigation, accessibility-tree snapshots, screenshots, ref-based
      clicks/typing, console messages, network requests, `browser_evaluate`. Drives a
      Playwright-managed browser; detect, don't install.
-2. **Chrome DevTools MCP** (when configured — pairs with Playwright MCP for Lighthouse, the
-   perf trace, and deeper DOM) — screenshots, DOM, console, network, performance,
+2. **Chrome DevTools MCP** (when configured). Pair it with Playwright MCP for Lighthouse, the
+   perf trace, deeper DOM inspection, screenshots, console, network, performance, and the
    accessibility tree.
-3. **Claude Code `/run` and `/verify`** (if available) — launch and observe the app;
+3. **Claude Code `/run` and `/verify`** (if available): launch and observe the app;
    prefer a project-specific run/verify skill if one exists.
-4. **Project-native E2E** (only if already present) — Playwright, Cypress, Capybara,
+4. **Project-native E2E** (only if already present). Playwright, Cypress, Capybara,
    Selenium. Use the project's existing commands; don't add a new framework.
-5. **Manual fallback** — no tooling available: record the limitation and write exact
+5. **Manual fallback:** no tooling available: record the limitation and write exact
    manual steps (route, action, expected result).
 
 ## Non-UI scope

package/pack/generated/codex/skills/rite-prove/reference/test-command-discovery.md

@@ -12,7 +12,7 @@ these sources, in roughly this order of authority:
 | `pyproject.toml` / `tox.ini` / `noxfile.py` | `pytest`, `tox`, `nox` |
 | `go.mod` | `go test ./...`, `go build ./...`, `go vet` |
 | `Cargo.toml` | `cargo test`, `cargo build`, `cargo clippy` |
-| CI configs (`.github/workflows`, `.gitlab-ci.yml`, `circleci`) | the exact commands CI runs — the source of truth for "green" |
+| CI configs (`.github/workflows`, `.gitlab-ci.yml`, `circleci`) | the exact commands CI runs: the source of truth for "green" |
 | README / CONTRIBUTING | documented dev/test workflow |
 | framework conventions | Rails/Django/Next/etc. defaults when nothing else is set |
 

package/pack/generated/codex/skills/rite-quick/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-quick — express lane for small changes
+# $rite-quick: express lane for small changes
 
 The full DevRites lifecycle is right for real features; it is **ceremony** for a typo, a
 copy tweak, a one-function fix, or a small config change. `$rite-quick` keeps the
@@ -27,39 +27,39 @@ executable, not advisory.
 
 ## The significance gate (the whole safety story)
 
-**Run this first. If ANY of these holds, STOP and route to `$rite-spec` — do NOT use the
+**Run this first. If ANY of these holds, STOP and route to `$rite-spec`. Do NOT use the
 express lane:**
 - Touches **auth / authz**, a **data migration**, a **public API contract**, or any
-  **destructive / data-loss** path (the irreversible-risk list — `standards/afk-hitl.md`).
+  **destructive / data-loss** path in the irreversible-risk list. See `standards/afk-hitl.md`.
 - Spans **more than one vertical slice**, or more than a couple of files of real logic.
-- **Ambiguous scope** — you'd have to guess what "done" means, or the ask hides a design
+- **Ambiguous scope:** you'd have to guess what "done" means, or the ask hides a design
   decision (data model, new dependency, second design system).
 - Security-sensitive input handling, or a measurable performance-critical path.
 - Would **break a declared project principle** (`.devrites/principles.md`) with no recorded,
-  human-approved exception — the express lane never relaxes a project gate; a needed exception is
+  human-approved exception: the express lane never relaxes a project gate; a needed exception is
   a deliberate human decision, so route it to `$rite-spec`.
 
 If none hold, the change is small + reversible + unambiguous → proceed. **When in doubt,
-escalate** — the cost of the full lifecycle on a small change is minutes; the cost of the
+escalate**: the cost of the full lifecycle on a small change is minutes; the cost of the
 express lane on a risky one is the failure mode the lifecycle exists to prevent.
 
 ## Rules consulted
 Load this lane's conditional standards when needed:
-- `coding-style.md` — naming, guard clauses, reuse-first.
-- `testing.md` — TDD, **completeness** (every touched behavior/element asserted) +
+- `coding-style.md`: naming, guard clauses, reuse-first.
+- `testing.md`: TDD, **completeness** (every touched behavior/element asserted) +
   **assertion strength** (no tautological tests; see it fail first), scaled to the change.
-- `error-handling.md` / `security.md` — only if the change touches input/errors.
-- `principles.md` — when `.devrites/principles.md` exists; a change that breaks an invariant is a gate, not a quick fix.
-- `definition-of-done.md` — standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
+- `error-handling.md` / `security.md`: only if the change touches input/errors.
+- `principles.md`: when `.devrites/principles.md` exists; a change that breaks an invariant is a gate, not a quick fix.
+- `definition-of-done.md`: standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
 
 
 ## Workflow
 0. **Orient.** Read `core.md`. If a `.devrites/` workspace is active, run the preamble to
    see it; `$rite-quick` does **not** require one and does **not** create the full tree.
 1. **Significance gate** (above). Fail → STOP, tell the user to run `$rite-spec <feature>`.
-2. **One-line contract.** Restate in 1–3 lines: the change, its **acceptance** (how you'll
+2. **One-line contract.** Restate in 1-3 lines: the change, its **acceptance** (how you'll
    know it works), and the **scope boundary** (what you will NOT touch). This is the entire
-   "spec + plan" for a quick change — keep it in the chat; optionally drop a `brief.md` +
+   "spec + plan" for a quick change: keep it in the chat; optionally drop a `brief.md` +
    `evidence.md` under `.devrites/work/<slug>/` if the user wants a record. This is the
    `$rite-frame` FRAME move: if the acceptance won't reduce to a check that could be *false*,
    the ask is ambiguous → escalate per the significance gate. Its AUDIT pass is the diff
@@ -71,15 +71,15 @@ Load this lane's conditional standards when needed:
 4. **Prove (scoped).** Run the **targeted** tests + typecheck / lint for what changed (not
    the whole suite) → green. Record the command + output. A tautological test that can't
    fail is not proof.
-5. **Review-lite + ship.** Self-review the diff (correctness, scope, idiom, and — if
-   `.devrites/principles.md` exists — no declared invariant broken; this is `$rite-frame`'s AUDIT
-   pass — one pass, no subagent fan-out). Show the diff, then on the user's confirm commit it
-   (Conventional Commits, atomic) — or hand to `$rite-ship` if a workspace is active. **Never push
+5. **Review-lite + ship.** Self-review the diff for correctness, scope, and idiom. If
+   `.devrites/principles.md` exists, confirm that no declared invariant is broken. This is
+   `$rite-frame`'s AUDIT pass: one pass, no subagent fan-out. Show the diff, then on the user's confirm commit it
+   (Conventional Commits, atomic), or hand to `$rite-ship` if a workspace is active. **Never push
    without the user asking.**
 
-## Escalation (mid-flight) — the Spec Drift Guard still applies
-If the "small" change turns out to be not small — a second slice appears, a real design
-decision surfaces, scope grows past the boundary, or you hit an irreversible-risk item —
+## Escalation (mid-flight): the Spec Drift Guard still applies
+If the "small" change turns out to be not small: a second slice appears, a real design
+decision surfaces, scope grows past the boundary, or you hit an irreversible-risk item:
 **STOP, say so, and route to `$rite-spec` / `$rite-define`**. Don't quietly grow a quick
 fix into an unreviewed feature; that's the exact drift the lifecycle guards against.
 
@@ -101,5 +101,5 @@ Record: <commit/PR path | .devrites/work/<slug>/evidence.md | not applicable>
 If the quick boundary does not hold or an escalation remains, use `Stopped / blocked`
 and route to the full lifecycle; do not render `Done`.
 
-**DO NOT** use this lane to dodge the gate — the express lane is for changes that are
-*actually* small, not for shipping risky work faster.
+**DO NOT** use this lane to dodge the gate: the express lane is for changes that are
+genuinely small, not for shipping risky work faster.

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

@@ -12,19 +12,19 @@ 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-resolve — answer the human gate
+# $rite-resolve: answer the human gate
 
-`$rite-resolve` is the canonical resume verb for **async** human gates — a checkpoint that
+`$rite-resolve` is the canonical resume verb for **async** human gates: a checkpoint that
 already paused and **stopped the session** (an AFK blocking/escalating/irreversible queue, or a
 HITL pause the human walked away from), plus `--batch`. When `$rite-build` asks a gap **inline**
 via `AskUserQuestion` and the human is present, that pick resolves the gate **in place** through
-the same `devrites-engine resolve` writer — you don't type `$rite-resolve` for it. For the async case this
+the same `devrites-engine resolve` writer. You don't type `$rite-resolve` for it. For the async case this
 skill takes the human's answer (or `--drop` / `--batch`), writes it to `questions.md`, updates
 `state.md` (clears `Awaiting human`, sets `Status: running`), and recommends the next command.
 
@@ -36,8 +36,8 @@ It is **deliberately small**: one verb, one source of truth (`questions.md`), on
 
 Pull these via `Read` when shaping the resolve:
 
-- `afk-hitl.md` — gate taxonomy, `questions.md` schema, AFK exception rules.
-- `documentation.md` — record decisions and rationale where the answer changes scope.
+- `afk-hitl.md`: gate taxonomy, `questions.md` schema, AFK exception rules.
+- `documentation.md`: record decisions and rationale where the answer changes scope.
 
 ## Operating rules
 
@@ -49,16 +49,16 @@ Pull these via `Read` when shaping the resolve:
   `dropped`, refuse with the existing answer; ask the user to open a new qid that
   references the old one (the file is the audit trail).
 - **If the answer materially changes scope, architecture, or acceptance**, route it
-  through the Spec Drift Guard (`$rite-plan repair`) **after** writing the answer — do
+  through the Spec Drift Guard (`$rite-plan repair`) **after** writing the answer: do
   not modify `spec.md` / `plan.md` inside this skill.
 - **The script is the source of truth.** Always invoke
-  `devrites-engine resolve` — it keeps `questions.md` + `state.md` consistent and emits the
+  `devrites-engine resolve`. It keeps `questions.md` + `state.md` consistent and emits the
   next-action recommendation. The one `state.md` field this skill may write by hand is the
   unblocked slice's `Slice mode` (step 4, the named exception); everything else goes through
   the script, never by hand.
 - **Human gates are for human-only decisions, not the agent's work.** A `questions.md` entry the
-  human must answer is a genuine *decision* (a scope / design / risk call only the human can make)
-  — not a task the agent can do itself. If a question is really agent-doable ("should I write the
+  human must answer is a genuine *decision* (a scope / design / risk call only the human can make).
+  Not a task the agent can do itself. If a question is really agent-doable ("should I write the
   test?", "go implement X"), don't record a human answer that punts the agent's own job back to it:
   flag the mis-tag and route it to the right skill (`$rite-build`, `$rite-plan unblock`,
   `devrites-debug-recovery`). The human resolves decisions; the agent does the work.
@@ -69,16 +69,16 @@ Pull these via `Read` when shaping the resolve:
    touching the workspace.
    Then run `devrites-engine preamble` for deterministic workspace orientation.
 1. **Parse arguments.** `$ARGUMENTS` is one of:
-   - `<qid> "<answer>"` — answer the single open question.
-   - `--drop <qid>` (optional `"<reason>"`) — mark the question `dropped`; record
+   - `<qid> "<answer>"`: answer the single open question.
+   - `--drop <qid>` (optional `"<reason>"`): mark the question `dropped`; record
      the reason inline.
-   - `--batch <path-to-yaml>` — bulk resolve, one entry per qid (see
+   - `--batch <path-to-yaml>`: bulk resolve, one entry per qid (see
      [`reference/answer-protocol.md`](reference/answer-protocol.md) for the batch
      format).
 2. **Load context.** Read `state.md`, `questions.md`, and the relevant slice from
    `tasks.md`. Confirm the qid is `status: open`. If `state.md` `Status` is not
    `awaiting_human` and the question's `gate` is `blocking`, surface the inconsistency
-   before proceeding (don't auto-repair — flag it).
+   before proceeding (don't auto-repair: flag it).
 3. **Render preview.** Echo the qid, the question, the proposed answer (if any), the
    user's answer, and which slice unblocks. Stop here and ask `confirm? (y/N)` **unless**
    the answer was provided non-interactively via `--batch`.
@@ -97,17 +97,17 @@ Pull these via `Read` when shaping the resolve:
    recommend `$rite-plan repair`. Otherwise → recommend the slice's natural next action
    (typically `$rite-build` for the slice that was awaiting).
    **Completion:** the resolved state contains exactly one next command.
-6. **STOP.** This skill does not run `$rite-build` itself — the user re-enters the
+6. **STOP.** This skill does not run `$rite-build` itself: the user re-enters the
    workflow explicitly.
 
 > **Mid-flight discipline.** Don't edit `spec.md` / `plan.md` to "incorporate" the
-> answer — that's `$rite-plan repair`. Don't silently retry a build after the answer
-> lands — the user types the next command. Don't merge two open questions into one
-> answered entry — each question is independently auditable.
+> answer. That's `$rite-plan repair`. Don't silently retry a build after the answer
+> lands: the user types the next command. Don't merge two open questions into one
+> answered entry: each question is independently auditable.
 
 ## 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-resolve/reference/answer-protocol.md

@@ -1,4 +1,4 @@
-# Answer protocol — how `$rite-resolve` mutates the workspace
+# Answer protocol: how `$rite-resolve` mutates the workspace
 
 `$rite-resolve` is the single canonical writer for `questions.md` `status` flips and
 `state.md` `Awaiting human` clearance. This file is the reference for the three input
@@ -22,7 +22,7 @@ $rite-resolve q-2026-05-28-001 "composite index — single key is fine for now,
 $rite-resolve --drop q-2026-05-28-002 "merged into q-...-003 after we narrowed the scope"
 ```
 
-- A drop is **not** an answer — it removes the question from the active queue without
+- A drop is **not** an answer. It removes the question from the active queue without
   recording a decision. Use it when the question is obsolete, a duplicate, or absorbed
   by a re-plan.
 - The reason is an optional single trailing string, **strongly recommended** for the
@@ -45,7 +45,7 @@ q-2026-05-28-002: clinician sign-off required at runtime, not at plan time
 ```
 
 - One qid per line. The first colon is the separator; the rest of the line is the value.
-- Order matters only for `state.md` clearance — the script processes top-to-bottom and
+- Order matters only for `state.md` clearance: the script processes top-to-bottom and
   flushes `Awaiting human` after each match.
 - Errors abort the batch at the first failing line so partial state is small and
   diagnosable. (Re-run after fixing the offending line; already-applied lines refuse to
@@ -54,7 +54,7 @@ q-2026-05-28-002: clinician sign-off required at runtime, not at plan time
 ## Never overwrite
 
 A qid that is already `answered` or `dropped` refuses to be re-resolved. The audit trail
-is the file — you do not edit history. If the original answer was wrong:
+is the file. You do not edit history. If the original answer was wrong:
 
 1. Open a new qid (the agent will, during the next `$rite-build` if the bad answer
    re-surfaces; or you write it manually).
@@ -76,7 +76,7 @@ Both terminals stamp `answered_at: <iso>` and write the answer/reason to `answer
 
 ## `state.md` clearance rules
 
-`state.md`'s `Awaiting human` block is **single-question by default** — `$rite-build`
+`state.md`'s `Awaiting human` block is **single-question by default**: `$rite-build`
 writes one block at a time and pauses. When `$rite-resolve` matches the block's qid:
 
 - the entire `Awaiting human` block is removed (header + fields);
@@ -88,7 +88,7 @@ qid (drift between the two files), `$rite-resolve` flags the inconsistency and r
 to silently fix it. Use `$rite-plan repair` to reconcile.
 
 If the answer materially changes spec/plan, **do not** edit `spec.md` or `plan.md` inside
-`$rite-resolve` — that's `$rite-plan repair`'s job. The skill's post-resolve hand-off
+`$rite-resolve`. That's `$rite-plan repair`'s job. The skill's post-resolve hand-off
 recommends `$rite-plan repair` whenever the answer touches acceptance criteria, scope,
 or architecture.
 
@@ -101,7 +101,7 @@ If a future evolution lets `$rite-build` queue multiple questions per pause, the
 - leave the rest of the list intact;
 - flip `Status: running` only when the list is empty.
 
-This shape is reserved — current `$rite-build` writes one question per pause.
+This shape is reserved: current `$rite-build` writes one question per pause.
 
 ## Why no auto-`$rite-build` after resolve