devrites 3.2.27 → 4.0.0

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

@@ -3,143 +3,129 @@ name: rite-prove
 description: Prove a completed feature with tests and the full test suite, build/typecheck/lint, end-to-end/browser evidence, screenshots, commands, and outputs for seal. Not for single-slice proof.
 argument-hint: "[feature-slug]"
 user-invocable: true
-required-agent-roles: devrites-proof-runner
 ---
 
-## Codex compatibility
-
-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.
-- Installed `.agents/` mirrors may be Git-ignored. If a repository-aware file tool refuses an ignored path, read it with a native filesystem command instead; a tool refusal is not a completed task.
-- For automatic Engram calls, omit optional `project` and `session_id` unless an exact value came from Engram or repository configuration. Never derive either from `task_name`, a run ID, directory name, or normalized slug. Call `mem_session_summary` without them by default; on `unknown_session` or `unknown_project`, retry once with both optional fields omitted. If auto-detection is ambiguous, ask the user instead of guessing.
-- Use the installed `devrites-engine` binary as the canonical runtime helper surface for orientation, gates, and state mutation.
-- **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.
-- On MultiAgent V2, call `spawn_agent` with the exact named `agent_type=devrites-<role>`, a unique `task_name`, and `fork_turns="none"`. A missing visible `agent_type` field is still V2—not capability loss, V1, or HITL—so send it anyway. If the named call rejects it, stop before any generic/default spawn. Codex loads the role TOML's `developer_instructions` natively; DevRites verifies the durable rollout, wait, completion, and delivered result.
-- Only after the runtime explicitly identifies MultiAgent V1, use generic `explorer` for a read-only role with `fork_turns="none"` and name exactly one `.codex/agents/devrites-<role>.toml` contract in the message. Trusted `.codex/hooks.json` injects that contract's exact `developer_instructions` and binds the child to the fail-closed reviewer read-only guard.
-- On explicitly identified MultiAgent V1, `devrites-slice-wright` uses generic `worker` with `fork_turns="none"` and the exact role TOML named in the message. Trusted `.codex/hooks.json` binds it to the active reconcile window and `.wright-allowlist`.
-- The invoked skill's `required-agent-roles` frontmatter arms the fail-closed Stop receipt. Every listed role must have a confirmed start, wait, and non-empty result in this turn.
-- If the required dispatch for the explicitly identified runtime is unavailable or rejected, stop for HITL. Never switch runtime lanes. Never execute a DevRites specialist role in the root context.
-- 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
 
-Record evidence for the **whole feature**. Read the active workspace first; if none,
-run `$rite-spec <feature>`.
+Prove the **whole feature**. Read the active workspace; if absent, run
+`$rite-spec <feature>`.
 
-> **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
-> `.devrites/work/<slug>/`. No DevRites workspace → use `/verify` or `/run` alone.
+> **Scope:** `/verify` proves one change; `/run` launches the app. `$rite-prove`
+> walks feature acceptance, relevant suite/build/typecheck/lint, and browser
+> proof, writing evidence under the active workspace. Without one, use
+> `/verify` or `/run`.
 
 ## 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
-complete, not after each slice. (Each slice already got its own targeted tests during
-`$rite-build`; this phase proves the assembled feature as a whole.)
+Read `tasks.md` + `state.md`. If any slice is pending, stop for `$rite-build`.
+This phase proves the assembled feature once, after per-slice tests.
 
 **Never report an unobserved pass.** If a command could not run, report that and give
 exact manual steps.
 
-**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`.
+After polish/review edits, rerun affected criteria/routes so evidence binds the
+changed candidate digest before 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.
+- `browser-proof-checklist.md`: required UI 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,
-  user flow): telemetry must be present **and observed to emit**, not assumed.
+- `observability.md`: runtime telemetry must be observed to emit.
 - `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,
   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.
+- `definition-of-done.md`: acceptance, proof, gates, scope, rollback/docs.
 
 
 ## Operating rules
 - Evidence over confidence. Feature scope only: fix within the feature or record a
   blocker; don't refactor unrelated code.
+- Apply `testing.md`'s positive, discriminating proof rule to every behavioral claim.
+  A green command without an executing assertion and decisive observed signal is unproven.
+- Follow the shared
+  [`candidate-integrity.md`](../devrites-lib/reference/candidate-integrity.md).
+  Prove owns proof binding, not manifest grammar or candidate hashing.
 - Spec Drift Guard applies: if tests/evidence reveal the spec is wrong, stop and handle
   drift (`rite-build/reference/spec-drift-guard.md`).
-- **Root executes; runner validates; root records; wright fixes.** Use the file-backed
+- **Root executes; runner validates; root records; wright fixes.** Use the native
   fresh-context contract in
   [`agents.md`](../devrites-lib/reference/standards/agents.md). The root owns exact
   vetted gate execution, browser capability, the evidence verdict, and canonical
   writes. The proof runner is read-only and validates immutable logs/artifacts.
-  Every accepted source/test correction is one bounded `devrites-slice-wright`
-  packet, never an inline edit.
+  Every accepted source/test correction is one bounded
+  `devrites-slice-wright` task, never an inline edit.
+
+## Released-workspace refresh entry
+
+Only an admitted `$rite-upgrade` assessment that proves a released-format candidate
+defect may enter this branch. Normal Prove never reconstructs candidate scope.
+
+Before proof, require that the legacy touched-file scope, live diff, tasks, and traceability agree unambiguously on every candidate path and state. Missing, unknown, or
+ambiguous scope is a recorded gap and HITL stop; never guess from Git alone. When they
+agree, preserve unrelated `touched-files.md` content and refresh only its strict manifest
+from the currently observed project bytes under the workspace schema.
+
+Discard every old pass as proof. Run all current approved real proof from scratch under
+the positive, discriminating rules below, and establish the pre-proof and post-proof engine digest
+with `devrites-engine check candidate <slug>`. Require an identical digest,
+then write one fresh exact binding in `evidence.md` and in `browser-evidence.md` when it
+exists. Historical evidence cannot substitute for any current gate. A current proof
+failure is a blocker; this Upgrade admission never authorizes source or test changes.
 
 ## Workflow
-0. Read `.agents/skills/devrites-lib/reference/standards/core.md` first (the always-on operating rules); pull the
-   on-demand rules above when relevant.
-   Then run `devrites-engine preamble` for deterministic workspace orientation.
-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`.
+0. Read core, load relevant rules above, then resolve the active slug,
+   require its `state.md`, and read the cursor directly.
+1. **Confirm all slices built.** Read `spec.md`, `tasks.md`, `state.md`,
+   `test-plan.md`, and the full diff.
+   A missing `test-plan.md` returns to Vet; it never authorizes ad hoc proof.
 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. **Execute proof against a frozen candidate.** Freeze and hash the candidate.
-   The root runs only commands authorized byte-for-byte by `test-plan.md` and the
-   immutable proof packet, with exact cwd and prerequisites, capturing exit code,
-   decisive output, artifact hashes, and before/after candidate identity in secure
-   external scratch. Run the full relevant test suite plus **build / typecheck /
-   lint**. Reject synthesized or substituted commands and any source drift.
+   Discovery only supplies evidence. `test-plan.md` is the sole approved runtime
+   command list. If a discovered command is absent from it, do not run or
+   silently approve the command: return to the current Vet contract to add and
+   vet it, refresh readiness, then return to Prove.
+   **Completion:** exact commands are approved in `test-plan.md` or unavailable.
+3. **Execute proof against a frozen candidate.** Run
+   `devrites-engine check candidate <slug>` before any approved proof and retain
+   its exact digest. The root runs only commands declared by `test-plan.md`,
+   byte-for-byte, with exact cwd and prerequisites, capturing exit code and
+   decisive output in secure external scratch. Run the full relevant test suite
+   plus **build / typecheck / lint**. Then rerun the candidate check: require the
+   identical digest and no candidate-source mutation. Reject synthesized or
+   substituted commands, malformed manifests, zero-test/skipped/filtered results used as
+   behavioral proof, success inferred only from exit status, and any source drift. Static
+   gates prove only their named static criterion.
 4. **UI feature?** The root applies the browser proof ladder with
-   `design-brief.md`, `references.md`, packet-listed routes, browser harness, and
+   `design-brief.md`, `references.md`, the requested routes, browser harness, and
    allowed scratch path:
    [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 and record deltas. An unresolved material mismatch is a failed
    result; the root handles any accepted correction at step 7 before re-rendering.
-5. **Validate proof in fresh context.** Dispatch `devrites-proof-runner` with the
-   frozen candidate identity, exact approved command list, immutable root-produced
-   logs/screenshots/traces, acceptance map, and hashes. Await its non-empty
-   `agent-result/v1`; reject mismatched, missing, stale, or self-attested evidence.
-   The runner executes no command and writes no canonical evidence.
-6. **Map proof completely.** Follow
+5. **Validate proof in fresh context.** In parallel, dispatch the exact read-only
+   `devrites-proof-runner` on candidate identity, approved commands, immutable
+   root evidence, and acceptance map, and `devrites-spec-reviewer` on the same
+   candidate. Wait for both; reject missing/stale, invented-ID, label-only, or
+   self-attested evidence. Neither executes commands.
+6. **Map proof completely.** Reconcile both exact verdicts, then 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.
+   proof class plus positive, discriminating passing evidence, or is recorded as a blocker.
 7. **On failure** → [failure-triage](reference/failure-triage.md) +
    `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
+   in-scope correction to the sole writer, `devrites-slice-wright`; update the
+   manifest from its actual scoped diff, rerun affected real proof and both
+   candidate checks, then dispatch a fresh proof runner. If a fix would exceed
    scope, record a blocker.
-8. 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`).
+8. The root updates `evidence.md`, `browser-evidence.md` (when present),
+   `traceability.md`, and `state.md`. Record exactly one binding for the observed
+   digest in evidence and browser evidence. New proof goes to canonical
+   `evidence.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.
-
-## Output
-
-**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:
-```
-Done: feature proof complete for <slug>.
-Changed: evidence.md, browser-evidence.md <updated|n/a>, devex.md <updated|n/a>, state.md
-Evidence: acceptance <total>/<total> (judgment-only <n>); scenarios <total>/<total|n/a>; key links <n>/<n|none>; tests/build/lint/browser <pass summary>
-Open: none
-Next: $rite-polish
-Record: .devrites/work/<slug>/evidence.md
-↻ Hygiene: /clear before $rite-polish
-```
-If any check fails, a blocker remains, or a criterion is unproven, use the shared
-`Stopped / blocked` form and route `Fix:` to the failing check or `$rite-build`; do
-not recommend `$rite-polish`.

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

@@ -1,47 +1,51 @@
 # Acceptance proof
 
-Map every `spec.md` acceptance criterion to evidence and label its proof class:
-`test`, `command`, `browser`, or `judgment` with a one-line reason. Re-run the
-structured grammar gate before mapping scenarios:
+Map each `spec.md` criterion to `test | command | browser | judgment` evidence
+and one-line reason. Run `spec-grammar.md`'s Native grammar re-read on the saved
+spec before mapping; reopen after corrections. No parser/script may replace it.
 
-```bash
-devrites-engine spec-validate ".devrites/work/<slug>" --against .devrites/specs
-```
+Every structured WHEN/THEN scenario needs a passing asserting test. When
+`test-plan.md` exists, every acceptance/gap requirement, interactive element, and
+user flow needs a passing result. Missing coverage blocks.
 
-Each structured WHEN/THEN scenario needs a passing asserting test. If `test-plan.md`
-exists, every acceptance mapping, per-gap requirement, interactive element, and user
-flow needs a passing result. Missing coverage is an unproven blocker.
+Behavioral proof MUST be positive, discriminating, and observed under `testing.md`:
+assertion/output changes when behavior is absent or wrong. Skipped, focused,
+filtered, pending, zero-test, assertion-free, tautological, or unexecuted results
+do not count. Build/compile/typecheck/lint prove only their static criterion;
+discriminating shell assertions and golden/text comparisons may prove text/CLI.
 
-## Critical-path assertion strength
+## Backstop disposition
+
+A `backstop` passes only on its spec-named independent held-out,
+property/metamorphic, or direct behavioral check plus discriminating observed
+output. Presence, test names without results, author judgment, or an expectation
+copied from the same implementation logic fails.
 
-For regression-Critical, irreversible, and data-loss paths, fault-inject a small
-behavior break and confirm the covering test goes red, then revert. Use the existing
-mutation tool when present. Run:
+Undefined/unavailable signal: `cannot_verify`, evidence
+`insufficient_spec: <missing fact or evidence surface>`, then Spec Drift; never
+judgment or pass.
 
-```bash
-devrites-engine test-integrity
-devrites-engine mutation-gate
-```
+## Critical-path assertion strength
 
-A test that stays green on broken code is unproven. Pure transforms also get a
-round-trip or metamorphic property check when applicable.
+For regression-Critical, irreversible, and data-loss paths, inject a small break,
+confirm the covering test turns red, then revert; use the existing mutation tool.
+A green test on broken code is unproven. Pure transforms also get a round-trip or
+metamorphic property check when applicable.
 
 ## Runtime observability branch
 
-For endpoints, jobs, consumers, integrations, user-facing flows, or new error paths,
-apply the on-call test from `observability.md`: trigger the failure path and observe the
-required log, metric, or trace emit. Record the observation. Skip pure internal, docs,
-config, and type-only changes.
+For endpoints, jobs, consumers, integrations, user flows, or new error paths,
+trigger failure and observe the required log/metric/trace per `observability.md`;
+record it. Skip pure internal, docs, config, and type-only changes.
 
 ## Developer-facing branch
 
-For a public API, CLI, SDK, webhook, config contract, error path, or getting-started
-flow, execute the real entry point on clean state. Measure time-to-hello-world and
-capture verbatim failure output. Browser-capture docs/quickstarts when applicable.
-Write the measured scorecard to `devex.md` and headline evidence to `evidence.md`.
+For public API/CLI/SDK/webhook/config/error/onboarding, execute the real entry on
+clean state, measure time-to-hello-world, and capture verbatim failure output.
+Browser-capture docs/quickstarts when applicable. Write the scorecard to
+`devex.md` and headline evidence to `evidence.md`.
 
 ## Wiring branch
 
-Walk every key link declared by `plan.md` and exercise or follow it in the assembled
-feature. Record each as `EVID-###`; if none are declared, record that fact. An unwired
-link is a blocker.
+Exercise/follow every key `plan.md` link in the assembled feature; record each as
+`EVID-###`, or record none declared. An unwired link blocks.

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

@@ -1,30 +1,31 @@
 # Test / build command discovery
 
-Use the project's own commands. Never invent a test runner or build step. Discover from
-these sources, in roughly this order of authority:
+Use project commands. Never invent a test runner or build step.
+Repository files are discovery evidence, not authorization. `test-plan.md` is
+the sole approved runtime command list.
 
-| Source | Look for |
+| Discovery source | Look for |
 |---|---|
-| `spec.md` → "Commands discovered" | already-found commands (trust first) |
+| `spec.md` → "Commands discovered" | previously found candidates |
 | `package.json` `scripts` | `test`, `build`, `typecheck`, `lint`, `dev`, `e2e` |
 | `Makefile` / `Justfile` / `Taskfile` | `test`, `build`, `check`, `lint` targets |
 | `Gemfile` / `Rakefile` | `rake test`, `rspec`, `bin/rails test` |
 | `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`) | commands CI runs |
 | README / CONTRIBUTING | documented dev/test workflow |
 | framework conventions | Rails/Django/Next/etc. defaults when nothing else is set |
 
-## Targeted first
-Run the **narrowest** command that exercises the slice (a single test file/path),
-then widen. A full suite is slower and noisier; use it for the final check, not the
-inner loop.
+## Vet before execution
 
-## Record what you found
-Write the discovered commands back into `spec.md` → "Commands discovered" so later
-phases (and `$rite-seal`) don't rediscover them. Note the runner version if it matters.
+Compare every discovered candidate, including a narrower target, with
+`test-plan.md`. If it is absent, do not run it or add it silently. Return to the
+current Vet contract to add and vet the command, refresh readiness, then return
+to Prove. A command may run only when its exact command, cwd, and prerequisites
+are approved in `test-plan.md`.
 
 ## If nothing exists
-No tests in the project: say so. Propose the minimal test setup as a **follow-up**
-(ask before adding a framework), and prove the slice via runtime observation meanwhile.
+No tests in the project: say so. Propose the minimal test setup as a
+**follow-up** (ask before adding a framework); any runtime observation command
+still needs Vet approval in `test-plan.md`.

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

@@ -3,35 +3,16 @@ name: rite-quick
 description: Express lane for a small reversible change: typo/copy/config, rate-limit constant, error message, local variable rename, feature flag, README link, one-file/function fix.
 argument-hint: "<what to change>"
 user-invocable: true
-required-agent-roles: none
 ---
 
-## Codex compatibility
-
-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.
-- Installed `.agents/` mirrors may be Git-ignored. If a repository-aware file tool refuses an ignored path, read it with a native filesystem command instead; a tool refusal is not a completed task.
-- For automatic Engram calls, omit optional `project` and `session_id` unless an exact value came from Engram or repository configuration. Never derive either from `task_name`, a run ID, directory name, or normalized slug. Call `mem_session_summary` without them by default; on `unknown_session` or `unknown_project`, retry once with both optional fields omitted. If auto-detection is ambiguous, ask the user instead of guessing.
-- Use the installed `devrites-engine` binary as the canonical runtime helper surface for orientation, gates, and state mutation.
-- **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.
-- On MultiAgent V2, call `spawn_agent` with the exact named `agent_type=devrites-<role>`, a unique `task_name`, and `fork_turns="none"`. A missing visible `agent_type` field is still V2—not capability loss, V1, or HITL—so send it anyway. If the named call rejects it, stop before any generic/default spawn. Codex loads the role TOML's `developer_instructions` natively; DevRites verifies the durable rollout, wait, completion, and delivered result.
-- Only after the runtime explicitly identifies MultiAgent V1, use generic `explorer` for a read-only role with `fork_turns="none"` and name exactly one `.codex/agents/devrites-<role>.toml` contract in the message. Trusted `.codex/hooks.json` injects that contract's exact `developer_instructions` and binds the child to the fail-closed reviewer read-only guard.
-- On explicitly identified MultiAgent V1, `devrites-slice-wright` uses generic `worker` with `fork_turns="none"` and the exact role TOML named in the message. Trusted `.codex/hooks.json` binds it to the active reconcile window and `.wright-allowlist`.
-- The invoked skill's `required-agent-roles` frontmatter arms the fail-closed Stop receipt. Every listed role must have a confirmed start, wait, and non-empty result in this turn.
-- If the required dispatch for the explicitly identified runtime is unavailable or rejected, stop for HITL. Never switch runtime lanes. Never execute a DevRites specialist role in the root context.
-- 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-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
 discipline that matters (idiom, TDD, evidence, escape-to-full-lifecycle) and drops the
 artifacts that don't, in a **single pass**. Senior-engineer "right step, right time" made
-executable, not advisory.
+executable, not advisory. This lane uses the **Quick** depth profile from
+[`devrites-lib/reference/orchestration-profiles.md`](../devrites-lib/reference/orchestration-profiles.md).
 
 ## The significance gate (the whole safety story)
 
@@ -62,8 +43,9 @@ Load this lane's conditional standards when 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.
+0. **Orient.** Read `core.md`. If a `.devrites/` workspace is active, read its
+   `state.md` directly; `$rite-quick` does **not** require
+   a workspace 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
    know it works), and the **scope boundary** (what you will NOT touch). This is the entire
@@ -91,21 +73,6 @@ decision surfaces, scope grows past the boundary, or you hit an irreversible-ris
 **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.
 
-## Output
-Run `devrites-engine progress` when a workspace is active; otherwise skip it. Then use the
-shared completion reply contract
-([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md)).
-Default success shape:
-```
-Done: quick change complete — <one line>.
-Changed: <files touched>
-Evidence: tests <cmd -> pass>; assertion check <real asserts saw red | n/a>; boundary held yes
-Open: <none | non-blocking follow-up | tracked workspace needs ship>
-Next: <single recommended command>
-Record: <commit/PR path | .devrites/work/<slug>/evidence.md | not applicable>
-↻ Hygiene: /clear after commit
-```
-
 If the quick boundary does not hold or an escalation remains, use `Stopped / blocked`
 and route to the full lifecycle; do not render `Done`.
 

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

@@ -4,35 +4,15 @@ description: User-invoked resume verb for answering, dropping, or batch-resolvin
 argument-hint: "<qid> \"<answer>\"  |  --drop <qid> [\"<reason>\"]  |  --batch <path-to-yaml>"
 user-invocable: true
 disable-model-invocation: true
-required-agent-roles: none
 ---
 
-## Codex compatibility
-
-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.
-- Installed `.agents/` mirrors may be Git-ignored. If a repository-aware file tool refuses an ignored path, read it with a native filesystem command instead; a tool refusal is not a completed task.
-- For automatic Engram calls, omit optional `project` and `session_id` unless an exact value came from Engram or repository configuration. Never derive either from `task_name`, a run ID, directory name, or normalized slug. Call `mem_session_summary` without them by default; on `unknown_session` or `unknown_project`, retry once with both optional fields omitted. If auto-detection is ambiguous, ask the user instead of guessing.
-- Use the installed `devrites-engine` binary as the canonical runtime helper surface for orientation, gates, and state mutation.
-- **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.
-- On MultiAgent V2, call `spawn_agent` with the exact named `agent_type=devrites-<role>`, a unique `task_name`, and `fork_turns="none"`. A missing visible `agent_type` field is still V2—not capability loss, V1, or HITL—so send it anyway. If the named call rejects it, stop before any generic/default spawn. Codex loads the role TOML's `developer_instructions` natively; DevRites verifies the durable rollout, wait, completion, and delivered result.
-- Only after the runtime explicitly identifies MultiAgent V1, use generic `explorer` for a read-only role with `fork_turns="none"` and name exactly one `.codex/agents/devrites-<role>.toml` contract in the message. Trusted `.codex/hooks.json` injects that contract's exact `developer_instructions` and binds the child to the fail-closed reviewer read-only guard.
-- On explicitly identified MultiAgent V1, `devrites-slice-wright` uses generic `worker` with `fork_turns="none"` and the exact role TOML named in the message. Trusted `.codex/hooks.json` binds it to the active reconcile window and `.wright-allowlist`.
-- The invoked skill's `required-agent-roles` frontmatter arms the fail-closed Stop receipt. Every listed role must have a confirmed start, wait, and non-empty result in this turn.
-- If the required dispatch for the explicitly identified runtime is unavailable or rejected, stop for HITL. Never switch runtime lanes. Never execute a DevRites specialist role in the root context.
-- 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` 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
+the `devrites-engine state 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.
 
@@ -60,7 +40,7 @@ Pull these via `Read` when shaping the resolve:
   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 state 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.
@@ -75,7 +55,7 @@ Pull these via `Read` when shaping the resolve:
 
 0. **Read `.agents/skills/devrites-lib/reference/standards/core.md`** (operating rules + persistence discipline) before
    touching the workspace.
-   Then run `devrites-engine preamble` for deterministic workspace orientation.
+   Then read the explicit or active workspace's `state.md` directly.
 1. **Parse arguments.** `$ARGUMENTS` is one of:
    - `<qid> "<answer>"`: answer the single open question.
    - `--drop <qid>` (optional `"<reason>"`): mark the question `dropped`; record
@@ -91,8 +71,7 @@ Pull these via `Read` when shaping the resolve:
    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:
+4. **Mutate.** Run `devrites-engine state resolve` with those arguments. It:
    - flips the qid's `status` to `answered` / `dropped` and stamps `answered_at` + `answer`;
    - if the qid is in `state.md`'s `Awaiting human` block (single-question pause), clears
      that block and sets `Status: running`;
@@ -113,18 +92,3 @@ Pull these via `Read` when shaping the resolve:
 > 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
-([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md)).
-Default success shape:
-```
-Done: resolved <qid> for <gate> at <slice/phase>.
-Changed: questions.md, state.md, decisions.md <updated|n/a>
-Evidence: not applicable; answer persisted before resume
-Open: <none | remaining questions | plan repair needed>
-Next: <single recommended command>
-Record: .devrites/work/<slug>/questions.md
-↻ Hygiene: no /clear needed; the answer is persisted
-```

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

@@ -2,7 +2,7 @@
 
 `$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
-shapes, the batch file format, and the rules the underlying `devrites-engine resolve` obeys.
+shapes, the batch file format, and the `devrites-engine state resolve` rules.
 
 ## Three input shapes
 
@@ -30,7 +30,7 @@ $rite-resolve --drop q-2026-05-28-002 "merged into q-...-003 after we narrowed t
   by a re-plan.
 - The reason is an optional single trailing string, **strongly recommended** for the
   audit trail. "obsolete" / "duplicate" / "absorbed by Slice N" are sufficient; if omitted,
-  `devrites-engine resolve` records the reason as `dropped`.
+  `devrites-engine state resolve` records it as `dropped`.
 
 ### 3. Batch