devrites 3.0.7 → 3.2.0

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

@@ -11,19 +11,23 @@ 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.
-- Codex project hooks are installed in `.codex/hooks.json`. Review and trust them with `/hooks` before relying on hook enforcement.
+- **Invocation and dispatch are different:** invoke means run a skill in this context; dispatch means start a fresh agent with `spawn_agent`, await it, and reconcile its result. Never describe inline skill work as a dispatch.
+- For every DevRites specialist or writer dispatch, first call `spawn_agent` with the named `devrites-<role>` custom role. The matching project contract is `.codex/agents/devrites-<role>.toml`.
+- If `spawn_agent` is callable but a named read-only role is unavailable, use generic `explorer` only when the host proves that run has a runtime-enforced read-only sandbox. Tell it to read `.codex/agents/devrites-<role>.toml`, follow its `developer_instructions`, and execute the unchanged packet. A missing read-only custom role is not evidence that spawning is unavailable.
+- Never dispatch generic `worker` for `devrites-slice-wright` unless the host proves that worker run carries exact DevRites identity and the same `.wright-allowlist` enforcement as the named role. Codex reports a generic run as `agent_type=worker`, so the generated global hooks cannot prove that binding. Reject that unsafe rung and use the documented labelled inline wright path with `.reconcile-inline` plus the full reconcile gate.
+- If the host cannot prove the generic explorer is runtime read-only, reject that rung too. Only when no spawn primitive exists or a higher-priority policy rejects a safe spawn may the root run the documented discipline inline. Label it `independence: fallback`, never call it independent, and apply every fallback risk gate. An unbound generic wright or unconfined generic explorer is such a safety rejection, not evidence that no agents exist.
+- Wait for every required fresh-context dispatch before reconciling or advancing. A backgrounded or lost result is incomplete.
+- Codex project hooks are installed in `.codex/hooks.json`; declared-leaf hooks are scoped inside `.codex/agents/devrites-*.toml`. 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.
 
 
 # $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>`.
+Record 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
+> **Scope:** built-in `/verify` proves one change and `/run` launches the app.
+> `$rite-prove` covers a feature. 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
@@ -33,12 +37,13 @@ workspace first; if none, run `$rite-spec <feature>`.
 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
 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.)
+`$rite-build`; this phase proves the assembled feature as a whole.)
 
-**Never report a pass you didn't observe.** If a command couldn't run, say so and give exact manual steps.
+**Never report an unobserved pass.** If a command could not run, report that and give
+exact manual steps.
 
-**Re-runnable, scoped.** `$rite-prove` runs once when the full feature is assembled, but
-it can be **re-run scoped** afterwards: when `$rite-polish` or `$rite-review` edit code,
+**Scoped reruns are allowed.** `$rite-prove` runs once when the full feature is assembled.
+After `$rite-polish` or `$rite-review` edits code,
 the existing `evidence.md` no longer post-dates the change, so re-run `$rite-prove` over
 the affected criteria/routes to refresh proof before `$rite-seal`.
 
@@ -54,7 +59,7 @@ Pull these via `Read` when relevant:
   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 /
   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.
+  measure time-to-hello-world, and capture verbatim error text), rather than asserting it.
 - `definition-of-done.md`: standing Done bar: acceptance mapped, fresh proof, no open hard gates, scoped edits, rollback/docs where needed.
 
 
@@ -63,6 +68,10 @@ Pull these via `Read` when relevant:
   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`).
+- **Runner observes; root records; wright fixes.** Use the file-backed fresh-context
+  contract in [`agents.md`](../devrites-lib/reference/standards/agents.md). The root owns
+  the evidence verdict and canonical writes. Every accepted source/test correction is one
+  bounded `devrites-slice-wright` packet, never an inline edit.
 
 ## Workflow
 0. Read `.agents/skills/devrites-lib/reference/standards/core.md` first (the always-on operating rules); pull the
@@ -75,23 +84,28 @@ Pull these via `Read` when relevant:
    [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:
+3. **Run proof in fresh context.** Freeze the candidate and dispatch
+   `devrites-proof-runner` with the exact commands, cwd, prerequisites, acceptance map,
+   and scratch boundary. Await and validate its observed full relevant test suite plus
+   **build / typecheck / lint** report. The runner writes no canonical evidence.
+4. **UI feature?** Include `design-brief.md`, `references.md`, routes, browser harness, and
+   allowed scratch path in the proof packet, then have the runner apply the browser proof ladder:
    [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
-   with target references, record deltas, fix/re-render, and do not pass with an unresolved
-   material mismatch.
+   with target references and record deltas. An unresolved material mismatch is a failed
+   result; the root handles any accepted correction at step 6 before re-rendering.
 5. **Map proof completely.** Follow
    [`reference/acceptance-proof.md`](reference/acceptance-proof.md) for acceptance/scenario
    coverage and the conditional critical-path, observability, developer-surface, and wiring
    branches. Completion: every criterion, planned interaction, and declared key link has a
    proof class plus passing evidence, or is recorded as a blocker.
 6. **On failure** → [failure-triage](reference/failure-triage.md) +
-   `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
+   `devrites-debug-recovery`. The root reconciles the reproduction. Send an accepted,
+   in-scope correction to the sole writer, `devrites-slice-wright`; then freeze the new
+   candidate and dispatch a fresh proof runner for affected checks. If a fix would exceed
+   scope, record a blocker.
+7. The root updates `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:
    see `devrites-lib/reference/workspace-artifact-schema.md`).
 

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

@@ -11,9 +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.
-- Codex project hooks are installed in `.codex/hooks.json`. Review and trust them with `/hooks` before relying on hook enforcement.
+- **Invocation and dispatch are different:** invoke means run a skill in this context; dispatch means start a fresh agent with `spawn_agent`, await it, and reconcile its result. Never describe inline skill work as a dispatch.
+- For every DevRites specialist or writer dispatch, first call `spawn_agent` with the named `devrites-<role>` custom role. The matching project contract is `.codex/agents/devrites-<role>.toml`.
+- If `spawn_agent` is callable but a named read-only role is unavailable, use generic `explorer` only when the host proves that run has a runtime-enforced read-only sandbox. Tell it to read `.codex/agents/devrites-<role>.toml`, follow its `developer_instructions`, and execute the unchanged packet. A missing read-only custom role is not evidence that spawning is unavailable.
+- Never dispatch generic `worker` for `devrites-slice-wright` unless the host proves that worker run carries exact DevRites identity and the same `.wright-allowlist` enforcement as the named role. Codex reports a generic run as `agent_type=worker`, so the generated global hooks cannot prove that binding. Reject that unsafe rung and use the documented labelled inline wright path with `.reconcile-inline` plus the full reconcile gate.
+- If the host cannot prove the generic explorer is runtime read-only, reject that rung too. Only when no spawn primitive exists or a higher-priority policy rejects a safe spawn may the root run the documented discipline inline. Label it `independence: fallback`, never call it independent, and apply every fallback risk gate. An unbound generic wright or unconfined generic explorer is such a safety rejection, not evidence that no agents exist.
+- Wait for every required fresh-context dispatch before reconciling or advancing. A backgrounded or lost result is incomplete.
+- Codex project hooks are installed in `.codex/hooks.json`; declared-leaf hooks are scoped inside `.codex/agents/devrites-*.toml`. 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.
 
 

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

@@ -12,24 +12,28 @@ 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.
-- Codex project hooks are installed in `.codex/hooks.json`. Review and trust them with `/hooks` before relying on hook enforcement.
+- **Invocation and dispatch are different:** invoke means run a skill in this context; dispatch means start a fresh agent with `spawn_agent`, await it, and reconcile its result. Never describe inline skill work as a dispatch.
+- For every DevRites specialist or writer dispatch, first call `spawn_agent` with the named `devrites-<role>` custom role. The matching project contract is `.codex/agents/devrites-<role>.toml`.
+- If `spawn_agent` is callable but a named read-only role is unavailable, use generic `explorer` only when the host proves that run has a runtime-enforced read-only sandbox. Tell it to read `.codex/agents/devrites-<role>.toml`, follow its `developer_instructions`, and execute the unchanged packet. A missing read-only custom role is not evidence that spawning is unavailable.
+- Never dispatch generic `worker` for `devrites-slice-wright` unless the host proves that worker run carries exact DevRites identity and the same `.wright-allowlist` enforcement as the named role. Codex reports a generic run as `agent_type=worker`, so the generated global hooks cannot prove that binding. Reject that unsafe rung and use the documented labelled inline wright path with `.reconcile-inline` plus the full reconcile gate.
+- If the host cannot prove the generic explorer is runtime read-only, reject that rung too. Only when no spawn primitive exists or a higher-priority policy rejects a safe spawn may the root run the documented discipline inline. Label it `independence: fallback`, never call it independent, and apply every fallback risk gate. An unbound generic wright or unconfined generic explorer is such a safety rejection, not evidence that no agents exist.
+- Wait for every required fresh-context dispatch before reconciling or advancing. A backgrounded or lost result is incomplete.
+- Codex project hooks are installed in `.codex/hooks.json`; declared-leaf hooks are scoped inside `.codex/agents/devrites-*.toml`. 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.
 
 
 # $rite-resolve: answer the human gate
 
-`$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**
+`$rite-resolve` resumes an **async** human gate: a checkpoint that already paused and
+**stopped the session** (an AFK blocking/escalating/irreversible queue, or a HITL pause
+left unanswered), plus `--batch`. When `$rite-build` asks a question **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
 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.
 
-It is **deliberately small**: one verb, one source of truth (`questions.md`), one cursor
-(`state.md`). The full AFK / HITL contract lives in
+It has one verb, one source of truth (`questions.md`), and one cursor (`state.md`). The
+full AFK / HITL contract lives in
 [`afk-hitl.md`](../devrites-lib/reference/standards/afk-hitl.md).
 
 ## Rules consulted (read on demand from `.agents/skills/devrites-lib/reference/standards/`)
@@ -57,9 +61,9 @@ Pull these via `Read` when shaping the resolve:
   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
-  test?", "go implement X"), don't record a human answer that punts the agent's own job back to it:
+  human must answer is a genuine decision (a scope / design / risk call only the human can make),
+  not a task the agent can do. If a question is really agent-doable ("should I write the
+  test?", "go implement X"), do not record a human answer that returns the agent's work 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.
 
@@ -79,9 +83,10 @@ Pull these via `Read` when shaping the resolve:
    `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).
-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`.
+3. **Apply explicit consent.** Supplying `<qid> "<answer>"`, `--drop`, or `--batch` is the
+   user's explicit consent for this local workspace mutation. Echo the qid, answer/drop,
+   and slice being unblocked, then continue immediately; do not ask the user to confirm the
+   command they just typed.
 4. **Mutate.** Run `devrites-engine resolve` with the same
    arguments. The script:
    - flips the qid's `status` to `answered` / `dropped` and stamps `answered_at` + `answer`;

package/pack/generated/codex/skills/rite-resolve/reference/answer-protocol.md

@@ -6,6 +6,9 @@ shapes, the batch file format, and the rules the underlying `devrites-engine res
 
 ## Three input shapes
 
+Each form is an explicit local mutation command. Supplying it is the confirmation; the
+skill applies it once after validation and reports the result instead of asking for `y` again.
+
 ### 1. Single answer
 
 ```

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

@@ -11,21 +11,25 @@ This is the Codex mirror of a DevRites skill. In Codex:
 
 - Load DevRites engineering standards from `.agents/skills/devrites-lib/reference/standards/`. Read `.agents/skills/devrites-lib/reference/standards/core.md` before workflow work, then load the other `.agents/skills/devrites-lib/reference/standards/*.md` files exactly when this skill asks for them.
 - Use the installed `devrites-engine` binary as the canonical runtime helper surface for orientation, gates, and state mutation.
-- When this skill asks for a DevRites specialist or writer agent, **explicitly** spawn the matching Codex custom agent from `.codex/agents/devrites-*.toml` through Codex subagents (`spawn_agent`), then wait for its result and reconcile it as the skill instructs. Do not do the review inline just because the instruction to spawn is embedded here: Codex under-fires embedded spawn/skill instructions (openai/codex #23496), so treat the spawn as required, not optional.
-- The independence of a fresh-context subagent is the point. If Codex genuinely cannot spawn subagents in the current surface, run the documented inline fallback and **label the result an inline fallback, not an independent review**: an inline pass shares the calling context and is weaker evidence.
-- Codex project hooks are installed in `.codex/hooks.json`. Review and trust them with `/hooks` before relying on hook enforcement.
+- **Invocation and dispatch are different:** invoke means run a skill in this context; dispatch means start a fresh agent with `spawn_agent`, await it, and reconcile its result. Never describe inline skill work as a dispatch.
+- For every DevRites specialist or writer dispatch, first call `spawn_agent` with the named `devrites-<role>` custom role. The matching project contract is `.codex/agents/devrites-<role>.toml`.
+- If `spawn_agent` is callable but a named read-only role is unavailable, use generic `explorer` only when the host proves that run has a runtime-enforced read-only sandbox. Tell it to read `.codex/agents/devrites-<role>.toml`, follow its `developer_instructions`, and execute the unchanged packet. A missing read-only custom role is not evidence that spawning is unavailable.
+- Never dispatch generic `worker` for `devrites-slice-wright` unless the host proves that worker run carries exact DevRites identity and the same `.wright-allowlist` enforcement as the named role. Codex reports a generic run as `agent_type=worker`, so the generated global hooks cannot prove that binding. Reject that unsafe rung and use the documented labelled inline wright path with `.reconcile-inline` plus the full reconcile gate.
+- If the host cannot prove the generic explorer is runtime read-only, reject that rung too. Only when no spawn primitive exists or a higher-priority policy rejects a safe spawn may the root run the documented discipline inline. Label it `independence: fallback`, never call it independent, and apply every fallback risk gate. An unbound generic wright or unconfined generic explorer is such a safety rejection, not evidence that no agents exist.
+- Wait for every required fresh-context dispatch before reconciling or advancing. A backgrounded or lost result is incomplete.
+- Codex project hooks are installed in `.codex/hooks.json`; declared-leaf hooks are scoped inside `.codex/agents/devrites-*.toml`. 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.
 
 
 # $rite-review: feature-scoped review
 
-Senior review of the **active feature scope only**. **Read the active workspace first**;
-if none, tell the user to run `$rite-spec <feature>`.
+Review the **active feature scope only**. **Read the active workspace first**; if none,
+tell the user to run `$rite-spec <feature>`.
 
-> **Differs from built-in `/code-review` in:** `/code-review` is a generic
-> diff review with no workspace context. `$rite-review` reads
+> **Scope:** `/code-review` is a generic diff review with no workspace context.
+> `$rite-review` reads
 > `.devrites/work/<slug>/spec.md` first, runs Spec ↔ Code-review axes as
-> parallel subagents (see [`parallel-dispatch.md`](../devrites-lib/reference/parallel-dispatch.md)), and gates feeding
+> parallel fresh-context reviewers (see [`parallel-dispatch.md`](../devrites-lib/reference/parallel-dispatch.md)), and gates feeding
 > into `$rite-seal`. Use `/code-review` for a one-off diff; use
 > `$rite-review` for a DevRites feature where the spec is the contract.
 
@@ -34,7 +38,7 @@ Pull these via `Read` when the diff demands them:
 - `code-review.md`: small PRs, severity labels, tests-first review focus.
 - `review-checklist.md`: compact pass/fail sweep before reporting the verdict.
 - `principles.md`: declared project invariants (`.devrites/principles.md`); a diff that violates one with no recorded exception is a Critical, blocking finding.
-- `testing.md`: confirm the tests prove the spec, not just pass.
+- `testing.md`: confirm that passing tests actually prove the spec.
 - `agents.md`: when to fan out to which review subagent.
 - `security.md`: when input / auth / data / integrations / secrets are in scope.
 - `security-checklist.md`: for the same security-sensitive scope, the compact trust-boundary sweep.
@@ -44,10 +48,14 @@ Pull these via `Read` when the diff demands them:
 - **Feature scope only.** Review touched files + the diff. **NO whole-project refactors,
   NO drive-by cleanup.** DO NOT delete suspected dead code outside this feature without
   asking. Spec Drift Guard applies.
-- **Reviews the finished product.** `$rite-polish` has already done **code simplification**
-  + UI normalize/polish. Review judges; if it reveals a real complexity issue polish
-  missed, flag it as a finding: don't re-run a simplification sweep here.
-- Findings are labeled (below). Re-prove after any change you make.
+- **Review the finished product.** `$rite-polish` has already simplified code and
+  normalized or polished UI. If review finds a remaining complexity issue, record it as
+  a finding rather than rerunning a simplification pass.
+- Findings are labeled (below). Re-prove after any accepted correction.
+- **Reviewers judge; root reconciles; wright fixes.** Follow
+  [`agents.md`](../devrites-lib/reference/standards/agents.md). The root owns the verdict and
+  canonical writes; every accepted source/test correction routes to
+  `devrites-slice-wright`.
 
 ## Workflow
 0. Read `.agents/skills/devrites-lib/reference/standards/core.md` first (the always-on operating rules); pull the
@@ -64,13 +72,14 @@ Pull these via `Read` when the diff demands them:
 2. **Review tests first:** do they prove the acceptance criteria? Missing,
    weak, or wrong tests are the first findings.
    **Completion:** every acceptance criterion maps to a proven test or a labeled finding.
-3. **Spec ↔ Code-review split (parallel sub-agents, fresh context).** A change can pass
+3. **Review spec and code separately in parallel.** A change can pass
    one axis and fail the other: code that follows every project standard but
    implements the wrong thing (Code-review pass, Spec fail), or code that does exactly
    what the spec asked but breaks project conventions (Spec pass, Code-review fail).
-   Running them serially in one context lets one mask the other. So:
-   - Dispatch **two** read-only reviewers in **parallel** via the `Task` tool, each
-     with its own narrow brief and no cross-pollination:
+   Separate contexts prevent one axis from masking the other:
+   - Freeze the candidate and fresh-context dispatch **two** read-only reviewers in
+     parallel, each with its own `agent-packet/v1`, narrow brief, and no
+     cross-pollination:
      - **Spec axis** → `devrites-spec-reviewer`: "Apply your documented discipline on
        the active feature workspace + diff. Report (a) criteria the spec asked for that
        are missing or partial, (b) behaviour in the diff the spec did not ask for
@@ -113,15 +122,20 @@ Pull these via `Read` when the diff demands them:
 6. **Performance:** apply `devrites-audit perf`
    ([performance-review](reference/performance-review.md)) only when performance is
    relevant or a regression risk is visible (measure first).
-7. Apply only in-scope fixes; **run verification after changes** (`$rite-prove` logic).
-8. Update `review.md`, `evidence.md`, and `state.md`.
-9. **Guard against the silent reviewer.** After `review.md` is written, run:
+7. Reconcile and accept only in-scope fixes. Consolidate them into one bounded wright
+   correction packet; never edit source in the reviewing context. Freeze the new candidate
+   and **run affected verification after changes** (`$rite-prove` logic), then perform at
+   most one narrow recheck of affected findings.
+8. The root updates `review.md`, `evidence.md`, and `state.md`.
+   **Completion:** the records name the reviewed candidate identity and every accepted
+   correction has affected proof plus its narrow recheck.
+9. **Require an account from every reviewer.** After `review.md` is written, run:
    ```bash
    devrites-engine review-integrity
    devrites-engine review-fingerprints --write
    ```
-   Exit 1 means an adversarial axis reported nothing and justified nothing: a suspected
-   rubber-stamp. Re-run that axis or add its `No-findings:` justification; do not carry a silent
+   Exit 1 means an adversarial axis reported neither findings nor a justification. Re-run
+   that axis or add its `No-findings:` justification; do not carry a silent
    axis into `$rite-seal` (where it surfaces as an Important).
 
 ## Finding labels
@@ -131,13 +145,13 @@ Pull these via `Read` when the diff demands them:
 - **Nit:** trivial/style.
 - **FYI:** context, no action implied.
 
-**Action decoration (orthogonal to severity).** Also tag each finding with how to act on it:
+**Action tag (separate from severity).** Tag each finding with how to act on it:
 `blocking` (fix before seal), `non-blocking` (fix when convenient), or `if-minor` (fix only if the
 change is already small: a pure noise-economics lever). Only a **`blocking` Critical** gates the
 seal; a `non-blocking` / `if-minor` finding is recorded, not a stop.
 
-## Confidence + signal-to-noise
-Borrow `$rite-vet`'s discipline so review stays **trusted, not noisy**: a reviewer that posts
+## Confidence and signal-to-noise
+Apply `$rite-vet`'s confidence rules. A reviewer that posts
 18 comments per PR teaches the team to ignore every one (below ~10% false-positive rate devs
 investigate each finding; past ~30% they label the tool noisy and skip it):
 - **Confidence-band each finding** (1-10) and state the band. A low-confidence finding (≤4)
@@ -145,21 +159,20 @@ investigate each finding; past ~30% they label the tool noisy and skip it):
   (low-confidence): n` line, never raised as Critical/Important.
 - **Verify before you escalate.** Every Critical/Important quotes the spec line or cites the
   `file:line` that proves it: no unverified blockers.
-- **Budget the noise.** Roll up trivia ("N style nits") into a single line; tooling already
+- **Limit low-value comments.** Roll up trivia ("N style nits") into a single line; tooling already
   catches style. Review's job is correctness + spec fidelity, not a lint dump.
 - **A silent axis is suspicious, not clean.** An adversarial axis that raises nothing must earn
   it: end its `## Spec` / `## Code review` section with a **`No-findings:`** line naming the
   passes it ran (missing/partial/incorrect for spec; edge cases, error paths, the riskiest
   decision, a changed behavior whose test may not cover it for code) and why each came back
-  empty. This is the mirror of confidence-banding: banding kills the false positive, this catches
-  the false negative ([`code-review.md` § Zero findings is suspicious](../devrites-lib/reference/standards/code-review.md)).
+  empty. Confidence bands suppress false positives; this requirement catches silent false
+  negatives ([`code-review.md` § Zero findings is suspicious](../devrites-lib/reference/standards/code-review.md)).
 
 ## Severity orientation (labels, not score)
 
 After labeling, summarize findings as `Critical / Important / Suggestion / Nit /
-FYI` counts. There is no composite number — `$rite-seal` gates on
-`Critical == 0` and on acceptance + drift. Inventing a number invites gaming;
-the labels do the work.
+FYI` counts. There is no composite number. `$rite-seal` gates on
+`Critical == 0` and on acceptance plus drift. Do not invent a composite score.
 
 > **Mid-flight discipline.** When tempted to demote a Critical, hide a finding, fix without re-verification, or wander out of scope: see [`anti-patterns`](reference/anti-patterns.md). Load it the moment you reach for the excuse.
 

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

@@ -11,9 +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.
-- Codex project hooks are installed in `.codex/hooks.json`. Review and trust them with `/hooks` before relying on hook enforcement.
+- **Invocation and dispatch are different:** invoke means run a skill in this context; dispatch means start a fresh agent with `spawn_agent`, await it, and reconcile its result. Never describe inline skill work as a dispatch.
+- For every DevRites specialist or writer dispatch, first call `spawn_agent` with the named `devrites-<role>` custom role. The matching project contract is `.codex/agents/devrites-<role>.toml`.
+- If `spawn_agent` is callable but a named read-only role is unavailable, use generic `explorer` only when the host proves that run has a runtime-enforced read-only sandbox. Tell it to read `.codex/agents/devrites-<role>.toml`, follow its `developer_instructions`, and execute the unchanged packet. A missing read-only custom role is not evidence that spawning is unavailable.
+- Never dispatch generic `worker` for `devrites-slice-wright` unless the host proves that worker run carries exact DevRites identity and the same `.wright-allowlist` enforcement as the named role. Codex reports a generic run as `agent_type=worker`, so the generated global hooks cannot prove that binding. Reject that unsafe rung and use the documented labelled inline wright path with `.reconcile-inline` plus the full reconcile gate.
+- If the host cannot prove the generic explorer is runtime read-only, reject that rung too. Only when no spawn primitive exists or a higher-priority policy rejects a safe spawn may the root run the documented discipline inline. Label it `independence: fallback`, never call it independent, and apply every fallback risk gate. An unbound generic wright or unconfined generic explorer is such a safety rejection, not evidence that no agents exist.
+- Wait for every required fresh-context dispatch before reconciling or advancing. A backgrounded or lost result is incomplete.
+- Codex project hooks are installed in `.codex/hooks.json`; declared-leaf hooks are scoped inside `.codex/agents/devrites-*.toml`. 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.
 
 

package/pack/generated/codex/skills/rite-seal/reference/phase-contract.md

@@ -1,36 +1,5 @@
 # rite-seal phase contract
 
-## Execution spine
-
-Run the engine gates at these moments:
-
-```bash
-devrites-engine preamble
-
-devrites-engine spec-validate .devrites/work/<slug>; echo "spec-validate rc=$?"
-devrites-engine check-acceptance .devrites/work/<slug>; echo "check-acceptance rc=$?"
-devrites-engine evidence-fresh <slug>; echo "evidence-fresh rc=$?"
-devrites-engine doubt-coverage <slug>; echo "doubt-coverage rc=$?"
-
-devrites-engine footprint log <slug> reviewer devrites-<x>-reviewer
-devrites-engine footprint log <slug> skip devrites-<x>-reviewer
-devrites-engine footprint roster <slug>; echo "roster rc=$?"
-devrites-engine review-integrity <slug>; echo "review-integrity rc=$?"
-devrites-engine review-fingerprints --write <slug>
-
-devrites-engine footprint render <slug>
-devrites-engine learnings add "<slug>" "<dismissed-as-intentional class or dead-end>" dismiss
-devrites-engine health record <0..10> "<GO|NO-GO evidence summary>" --note "<top blocker or green proof>"
-devrites-engine timeline log completed --skill rite-seal --slug <slug> --outcome "<go|no-go>" --decision "<verdict>"
-
-devrites-engine progress
-```
-
-Conditional calls still obey the detailed rules below: reviewer and skip
-footprints must account for the whole roster; learnings run only on GO; progress
-is rendered before the final response from [`output.md`](output.md). Seal decides
-only; `$rite-ship` owns irreversible git/publish/deploy actions.
-
 1. **Run the shared orientation preamble:** it prints `state.md`, the artifacts present,
    the run mode (HITL/AFK), and the open-question tally by gate, so you orient deterministically
    instead of re-deriving state from raw Markdown:
@@ -80,50 +49,20 @@ only; `$rite-ship` owns irreversible git/publish/deploy actions.
      verdicts by hand).
    Either way, walk the `## Decisions stood` ledger yourself: severity rides the unverified
    **decision**, never the exit code alone.
-5. Check **security, data, migration, rollback** risk:
-   [risk-and-rollback](risk-and-rollback.md). If `strategy.md` exists (from
-   `$rite-temper`), confirm its **top pre-mortem risks are mitigated** in the diff/evidence and
-   that no **Non-goal / deferred item crept into the diff** (scope creep): either is a finding
-   (an unmitigated top risk or smuggled-in out-of-scope work).
-   - **Principles** (`principles.md`): score the final diff against each declared invariant in
-     `.devrites/principles.md`. A violation with no matching, human-approved exception in the
-     register is a **Critical** finding and a NO-GO; an exception that is stale (past its review
-     trigger) or wider than its stated scope is itself a finding. No file / no principles → skip.
-   - **Observability** (`observability.md`): if the diff added a runtime surface (endpoint,
-     job, integration, user flow, error path), a feature shipping with no way to debug it in
-     prod is an **Important** finding, not a pass: `evidence.md` should show telemetry observed
-     to emit (`$rite-prove` step 5b).
-   - **Developer experience** (`developer-experience.md`): if the diff ships a developer-facing
-     surface, reconcile `devex.md` (the `$rite-vet` predicted scorecard vs the `$rite-prove`
-     measured one: the boomerang). A broken public dev contract (a documented command that errors,
-     a getting-started flow that can't complete) or an unexplained measured DX regression is
-     **Important**. **Critical** on a frozen public surface (`principles.md`). No surface → skip.
-   - **Removal / migration** (`deprecation.md`): if the diff deletes or migrates code, an API,
-     or data, confirm it followed expand→contract, proved the old path unused before removing it,
-     and carries a rollback for every destructive step. A surprise deletion or a one-shot
-     breaking migration is a finding (and trips the irreversible-risk gate, `afk-hitl.md`).
+5. Check **security, data, migration, rollback**, strategy scope, principles,
+   observability, developer experience, and removal using
+   [risk-and-rollback](risk-and-rollback.md) and the named standards. Unmitigated top risks,
+   scope creep, missing runtime diagnostics, broken developer contracts, or unsafe removals
+   are findings. An unexcepted declared-principle violation is Critical and NO-GO.
 6. Check **frontend polish** if UI is involved (states, a11y, responsive, design-system,
    browser evidence).
-7. **Independent review:** seal is the final gate, not a re-run of `$rite-review`.
-   It **always re-spawns** the axes `$rite-review` did not cover: `devrites-test-analyst`,
-   `devrites-security-auditor`, `devrites-performance-reviewer`, and
-   `devrites-frontend-reviewer` (UI). It **only re-runs the Spec and Code-review axes**
-   (`devrites-spec-reviewer`, `devrites-code-reviewer`) when the diff changed since
-   `$rite-review` ran (compare against `review.md`); if the diff is unchanged, carry
-   review's verdicts on those axes forward rather than re-litigating them.
-   If subagents are available, fan out **in parallel** (one `Task` block, multiple tool
-   calls) to the **roster**: the seven reviewers and their checkable triggers are the single
-   source in [`parallel-dispatch.md`](../../devrites-lib/reference/parallel-dispatch.md) (dispatch
-   shape + reconciliation there too; `.agents/skills/devrites-lib/reference/standards/agents.md`. "Run independent reviewers in
-   parallel"). Dispatch every always-on reviewer and every conditional whose trigger the diff
-   meets; `devrites-devex-reviewer` runs in **measure mode**: grade the measured DX scorecard
-   and reconcile the boomerang against the `$rite-vet` prediction. Give each the workspace path +
-   diff *without the author's reasoning*. If subagents are unavailable, run the equivalent
-   reviews sequentially yourself and flag each as a fallback.
-   The reviewer **AGENTS** here (fresh context, no author reasoning) are the seal
-   GATE; `devrites-audit` is the inline single-axis pass run during build/polish.
-   The two paths are intentional, not divergent: the inline audit catches issues
-   early; the fresh-context agents are the independent gate before ship.
+7. **Independent review:** apply the complete roster, triggers, dispatch shape, and
+   reconciliation from
+   [`parallel-dispatch.md`](../../devrites-lib/reference/parallel-dispatch.md). Await
+   fresh-context batches of at most three and give reviewers only the workspace path plus
+   immutable diff, without author reasoning. Use named role → safely enforced generic fresh
+   agent → labelled inline; inline output is never independent. Carry Spec/Code verdicts only
+   for an unchanged post-review diff; rerun the other applicable axes.
    **Footprint: account for the whole roster.** For each reviewer you dispatch, append
    `devrites-engine footprint log <slug> reviewer devrites-<x>-reviewer` (the reviewer's **exact agent name**:
    the roster gate matches on it, so a freehand label like `spec` will read as unaccounted); for
@@ -131,13 +70,12 @@ only; `$rite-ship` owns irreversible git/publish/deploy actions.
    `devrites-engine footprint log <slug> skip devrites-<x>-reviewer` and note the one-line reason in `seal.md`.
    A conditional reviewer that does not apply is a *recorded skip*, never a silent omission: step 7b
    proves the roster complete before the verdict.
-7a. **Reconcile findings: confidence over volume.** Band each reviewer finding by confidence
+7a. **Reconcile findings by confidence.** Band each reviewer finding by confidence
    (1-10); a low-confidence (≤4) finding that can't be verified against the diff is **suppressed**
    to a `Suppressed (low-confidence): n` line, not a blocker. Every Critical/Important must cite
    the `file:line` (or spec line) that proves it. Surface genuine cross-reviewer disagreement
    **explicitly** rather than averaging it away, and don't let a pile of low-confidence nits
-   inflate the verdict: the gate is `Critical == 0` + acceptance + drift, not "few findings".
-   (A seal that fires noise teaches the next one to be ignored.)
+   inflate the verdict. The gate is `Critical == 0` + acceptance + drift, not "few findings".
 7b. **Account for the roster: no reviewer silently skipped.** Before the verdict, prove every
    roster reviewer carries a decision (dispatched or skip-recorded in step 7's footprint):
    ```bash
@@ -158,7 +96,7 @@ only; `$rite-ship` owns irreversible git/publish/deploy actions.
    ```
    - **rc=1:** an axis in `review.md` is silent (no finding, no justification): **Important** on the
      review's completeness. Re-run that axis or record its `No-findings:` account, then re-seal.
-   - **rc=0:** every axis has findings or a justified clean bill; proceed. (No `review.md`, or a
+   - **rc=0:** every axis has findings or a justified no-findings result; proceed. (No `review.md`, or a
      freeform one, is a clean pass: the gate keys on per-axis sections.)
    Then write stable finding IDs for learning and recurring-dismissal correlation:
    ```bash
@@ -178,20 +116,10 @@ only; `$rite-ship` owns irreversible git/publish/deploy actions.
      "acceptance": "<proven>/<total>", "test_integrity": "ok | weakened", "mutation": "<score | n/a>",
      "blockers": ["<one line each, empty on GO>"] }
    ```
-9. **On GO only: record proven conventions** to the local ledger
-   (`.devrites/conventions.md`) so later slices stop re-deriving this project's idioms:
-   the durable, *evidence-proven* commands / idioms / placement / gotchas this feature
-   established. Evidence-gated like the seal itself; the band is earned, not guessed; the
-   step degrades gracefully when unavailable. Full contract + command:
-   [conventions-ledger](conventions-ledger.md). (Skip entirely on NO-GO.)
-9a. **On GO only: auto-capture learnings** (`.devrites/learnings.md`). Learning is automatic, not a
-   command anyone must remember: append this feature's durable signal so the **next** feature's
-   review starts warmer: (a) any reviewer finding the gate **dismissed as intentional here** (a
-   "don't re-flag X in this project" class, tag `dismiss`); (b) a recurring correction or dead-end
-   worth not repeating (tag `note`). The review skills load this ledger **before** they fan out, so a
-   dismissed-finding class stops recurring. It is an untrusted prior: live code always overrides
-   (`.agents/skills/devrites-lib/reference/standards/security.md`). Promotion of a recurring lesson to a *project rule* stays the
-   human's call (`$rite-learn`: propose, don't impose). Skip on NO-GO.
+9. **On GO only:** record evidence-proven conventions through
+   [conventions-ledger](conventions-ledger.md).
+9a. **On GO only:** append durable dismissed-finding or dead-end learnings as untrusted
+   priors. Promotion to a project rule remains human-owned.
    ```bash
    devrites-engine learnings add "<slug>" "<dismissed-as-intentional class or dead-end>" dismiss
    ```
@@ -200,7 +128,14 @@ only; `$rite-ship` owns irreversible git/publish/deploy actions.
     lower for NO-GO or unresolved blockers.
     ```bash
     devrites-engine health record <0..10> "<GO|NO-GO evidence summary>" --note "<top blocker or green proof>"
-    devrites-engine timeline log completed --skill rite-seal --slug <slug> --outcome "<go|no-go>" --decision "<verdict>"
+    devrites-engine timeline log run-finished \
+      --slug <slug> \
+      --outcome "<passed|blocked>" \
+      --execution-mode named \
+      --guard-strength n/a \
+      --reason-id "<DRV-GATE-SEAL-PASSED on GO; otherwise the blocking DRV-* reason>" \
+      --host "<claude|codex>" \
+      --evidence .devrites/work/<slug>/seal.md
     ```
 
 ## `seal.md` template

package/pack/generated/codex/skills/rite-seal/reference/risk-and-rollback.md

@@ -25,6 +25,19 @@ For each risky step, state how to back it out:
 - A new external dependency with no failure handling is at least **Important**.
 - Record the chosen rollback path in `seal.md` → "Rollback / Recovery".
 
+## Fresh-context fallback weighting
+
+An inline final-rung review is useful signal but **not independent evidence**:
+
+- Record `independence: fallback` and a roster skip reason; never log it as a dispatched
+  reviewer or a clean fresh-context pass.
+- Preserve its findings at their normal severity. A clean inline result still leaves an
+  **Important assurance gap** and cannot silently satisfy a required axis.
+- Seal remains NO-GO until that axis runs through a fresh-context spawn, or the human
+  explicitly accepts the reduced assurance in `seal.md`. AFK never auto-accepts it.
+- Security or irreversible-risk scope has no reduced-assurance override: unavailable
+  independent review remains NO-GO.
+
 ## Destructive operations
 Confirm any destructive step with the user before shipping. Verify backups exist where
 relevant. Never treat an irreversible action as routine.