devrites 3.2.28 → 4.0.0

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

@@ -1,17 +1,11 @@
 # `spec.md` template
 
-Write the product contract: WHAT users get, WHY it matters, how success is
-measured, and what is out of scope. Keep HOW in `plan.md`; put technical topology and
-diagrams in `architecture.md` / `flows.md`; put coverage in `traceability.md`.
+Contract WHAT users get, WHY, success, and scope. HOW belongs in `plan.md`,
+topology in `architecture.md`/`flows.md`, coverage in `traceability.md`.
 
-Rules:
-
-1. Mark unknowns with `[NEEDS CLARIFICATION: <question>]`; blocking unknowns
-   stop `$rite-clarify`.
-2. Use stable IDs: `REQ-001` for requirements and `AC-001` for acceptance.
-3. Link to source artifacts instead of duplicating them.
-4. Keep the file compact. If it exceeds the schema budget, add
-   `Budget override: <reason>`.
+Use `[NEEDS CLARIFICATION: <question>]` (blocking stops `$rite-clarify`) and
+stable `REQ-001`/`AC-001` IDs. Link, never duplicate, source artifacts. Over
+schema budget requires `Budget override: <reason>`.
 
 ```markdown
 # Spec: <Feature>
@@ -20,14 +14,25 @@ Status: Draft | Ready
 Created: <date>
 
 ## Problem
-What is broken, missing, or costly today.
+<What is broken, missing, or costly.>
 
 ## Goal
-One paragraph describing the user-visible outcome and why it matters.
+<User-visible outcome and why it matters.>
+
+Capability impact: <affected capability/ies and change | none — specific justification>
 
 ## Non-goals
 - <Explicitly out of scope.>
 
+## Existing behavior to preserve
+List affected observable public/security/data/operational outcomes that MUST
+survive; map preserving REQ/AC plus current test/runtime/contract/source evidence.
+No implementation detail. True greenfield: `none — no existing behavior in the affected scope`.
+
+| Existing outcome | Preserved by | Current evidence |
+| --- | --- | --- |
+| <outcome that must not regress> | REQ-001 / AC-001 | <current evidence> |
+
 ## Users / actors
 | Actor | Need |
 | --- | --- |
@@ -38,14 +43,12 @@ One paragraph describing the user-visible outcome and why it matters.
 - REQ-002: The system MUST NOT <prohibited behavior>.
 
 ## Acceptance criteria
-Each criterion is binary and evidence-backed; every item maps to at least one
-requirement and later to at least one slice in `traceability.md`.
+Binary/evidence-backed; each maps to a requirement and later a traceability slice.
 
-- [ ] AC-001: Given <state>, when <action>, then <observable outcome>. (REQ-001)
-- [ ] AC-002: Given <state>, when <action>, then <observable outcome>. (REQ-002)
+- [ ] AC-001: Given <state>, when <action>, then <outcome>. (REQ-001)
+- [ ] AC-002: Given <state>, when <action>, then <outcome>. (REQ-002)
 
-For behavioral or high-risk requirements, use the structured form below. Keep the
-`AC-###` ID inside the scenario so traceability remains machine-checkable.
+Behavioral/high-risk work uses this grammar, with the AC ID inside the scenario:
 
 ### Requirement: <name>
 The system SHALL <core observable behavior>.
@@ -54,49 +57,47 @@ The system SHALL <core observable behavior>.
 - [ ] AC-003: **WHEN** <trigger> **THEN** <observable outcome>. (REQ-001)
 
 ## Edge Coverage
-Deterministic boundary checklist for the requirements. Use `covered`, `backstop`,
-`dismissed`, or `unresolved`; every row targets an existing REQ/AC unless dismissed.
+Use `covered | backstop | dismissed | unresolved`; target an existing REQ/AC
+unless dismissed. `backstop` requires a named independent held-out,
+property/metamorphic, or direct behavioral check plus the wrong behavior it
+discriminates. If unavailable, use `unresolved`; presence/prose/self-judgment cannot pass.
 
 | Edge ID | Requirement/AC | Class | Status | Reason/backstop |
 | --- | --- | --- | --- | --- |
-| EDGE-001 | AC-001 | empty/error/permission/race/migration | covered | <test/evidence or rationale> |
+| EDGE-001 | AC-001 | empty/error/permission/race/migration | covered | <evidence/rationale> |
 
 ## Prohibitions (must-NOT)
-Only bespoke constraints; generic security/privacy canon stays in project standards.
-Use `resolved/test`, `resolved/judgment`, `dismissed`, or `unresolved`.
+Bespoke only; generic security/privacy stays in standards. Status:
+`resolved/test | resolved/judgment | dismissed | unresolved`.
 
 | Prohibition ID | Requirement/AC | Status | Test/evidence |
 | --- | --- | --- | --- |
 | PROH-001 | REQ-002 | resolved/test | <test/evidence link> |
 
 ## Edge cases
-- <Narrative notes for boundary cases not captured in the table.>
+- <Boundary note not captured above.>
 
 ## AI-SPEC annex
-- Required when the feature touches model calls, RAG, agents, evals, or LLM output: `ai-spec.md` from `ai-spec-template.md`.
+- Model/RAG/agent/eval/LLM-output scope: `ai-spec.md` from `ai-spec-template.md`.
 - Otherwise: not applicable.
 
 ## Measurable success
-- <Metric or observable proof that the feature worked.>
+- <Metric or observable proof.>
 
 ## Scope boundaries
-- Owns: <product surface or behavior>.
+- Owns: <surface/behavior>.
 - Does not own: <adjacent area>.
-- Placement summary: <one-line module/layer summary>; full technical map lives in `architecture.md`.
+- Placement summary: <module/layer>; full map in `architecture.md`.
 
 ## Coverage seed
-- Actors/journeys/components: <material surfaces discovered while authoring>.
-- States/data/contracts/integrations: <material boundaries discovered>.
-- Operations/proof surfaces: <configuration, observability, rollout/rollback, evidence constraints>.
+- Actors/journeys/components: <material surfaces>.
+- States/data/contracts/integrations: <material boundaries>.
+- Operations/proof: <config, observability, rollout/rollback, evidence constraints>.
 
 ## References
-- `brief.md` - request, objective, non-goals, success definition.
-- `architecture.md` - technical placement and integration points.
-- `flows.md` - diagrams when useful.
-- `decisions.md` - ADR-style product/technical decisions.
-- `decision-coverage.md` - topology scan and clarity verdict once `$rite-clarify` runs.
-- `traceability.md` - AC/REQ coverage once `$rite-define` runs.
-- `design-brief.md` - UI direction when UI is in scope.
+- `brief.md`: request/outcome/scope; `architecture.md`: placement/integration;
+  `flows.md`: diagrams; `decisions.md`: decisions; `decision-coverage.md`: Clarify
+  topology/verdict; `traceability.md`: Define coverage; `design-brief.md`: UI direction.
 
 ## Open questions
 | Question ID | Gate | Question | Impact |
@@ -104,14 +105,11 @@ Use `resolved/test`, `resolved/judgment`, `dismissed`, or `unresolved`.
 | Q-001 | blocking | [NEEDS CLARIFICATION: <question>] | AC-001 |
 
 ## Readiness gate
-- [ ] No blocking `[NEEDS CLARIFICATION]` markers remain.
-- [ ] Requirements use `REQ-###` IDs.
-- [ ] Acceptance criteria use `AC-###` IDs and are independently provable.
-- [ ] Edge Coverage rows target existing REQ/AC IDs or carry a dismissal reason.
-- [ ] Prohibitions have resolved/dismissed status; `resolved/test` rows link test/evidence.
-- [ ] AI features have `ai-spec.md`; non-AI work states the annex is not applicable.
-- [ ] Non-goals and scope boundaries are explicit.
-- [ ] Architecture/flows/decisions are linked out instead of duplicated here.
-- [ ] UI work has `design-brief.md`; non-UI work states UI is out of scope.
-- [ ] Coverage seed names the material surfaces `$rite-clarify` must scan.
+- [ ] No blocking clarification; REQ/AC IDs are valid and ACs independently provable.
+- [ ] Existing affected behavior maps to preserving REQ/AC + current evidence, or uses the exact justified greenfield `none`.
+- [ ] Edge rows target REQ/AC or justify dismissal; every backstop names independent discriminating evidence, else `unresolved`.
+- [ ] Prohibitions resolve/dismiss; `resolved/test` links evidence.
+- [ ] AI has `ai-spec.md` and UI has `design-brief.md`; out-of-scope work states not applicable.
+- [ ] Non-goals/scope are explicit; capability impact is singular/specific and matches ledger deltas.
+- [ ] Architecture/flows/decisions are linked, not duplicated; Coverage seed names Clarify surfaces.
 ```

package/pack/generated/codex/skills/rite-spec/reference/state-workspace.md

@@ -11,7 +11,7 @@ Load that schema before creating or updating workspace artifacts.
   ACTIVE
   work/
     <feature-slug>/
-      README.md                  # compact workspace map (feature.md/index.md aliases supported)
+      README.md                  # compact workspace map
       brief.md
       spec.md
       architecture.md            # from $rite-define
@@ -26,7 +26,7 @@ Load that schema before creating or updating workspace artifacts.
       eng-review.md              # from $rite-vet
       test-plan.md               # from $rite-vet
       state.md
-      evidence.md                # from $rite-build or $rite-prove (proof.md alias supported)
+      evidence.md                # from $rite-build or $rite-prove
       browser-evidence.md        # UI only
       drift.md                   # drift only
       touched-files.md           # from $rite-build
@@ -38,14 +38,11 @@ Load that schema before creating or updating workspace artifacts.
     <feature-slug>/
 ```
 
-Backward compatibility: if an installed project already uses
-`.devrites/features/<slug>/`, keep reading and updating that workspace. New
-writer instructions should prefer `.devrites/work/<slug>/`; migration adds
-canonical files and preserves aliases rather than deleting old ones.
-
 ## Creation rules
 
-- Slug is kebab-case and comes from the objective.
+- Create or reuse the slug exactly under the canonical schema's
+  [Slug identity](../../devrites-lib/reference/workspace-artifact-schema.md#slug-identity)
+  contract.
 - `$rite-spec` creates the workspace map, `brief.md`, `spec.md`, `decisions.md`,
   `assumptions.md`, `questions.md`, `state.md`, optional `references.md` /
   `references/`, and optional `design-brief.md` for UI.
@@ -57,8 +54,9 @@ canonical files and preserves aliases rather than deleting old ones.
   empty placeholders; absence means the phase has not produced that artifact.
 - Each artifact starts with a summary and links to deeper source files instead of
   copying their content.
-- Use stable IDs: `REQ-001`, `AC-001`, `SLICE-001`, `DEC-001`, `Q-001`,
-  `DRIFT-001`, `EVID-001`.
+- Use stable IDs: `REQ-001`, `AC-001`, `EDGE-001`, `PROH-001`, `SLICE-001`,
+  `DEC-001`, `ASM-001`, `DRIFT-001`, `EVID-001`; apply the canonical schema's
+  append-only ID contract. Queued questions use `q-YYYY-MM-DD-NNN` below.
 
 ## README.md template
 
@@ -114,7 +112,7 @@ None.
 Only present when status is awaiting_human.
 | Key | Value |
 | --- | --- |
-| question_id | Q-001 |
+| question_id | q-YYYY-MM-DD-NNN |
 | gate | blocking |
 | blocking_slices | SLICE-001 |
 ```
@@ -122,12 +120,23 @@ Only present when status is awaiting_human.
 `state.md` is a compact cursor, not a history file. Put proof in `evidence.md`,
 decisions in `decisions.md`, assumptions in `assumptions.md`, and drift in
 `drift.md`. Omit both `return_*` rows outside a later-phase `$rite-clarify`
-retrofit; `devrites-engine clarify-return` owns their atomic lifecycle.
+retrofit. The controlling root follows `$rite-clarify`'s native cursor protocol:
+save both fields before later-phase entry, restore and remove both only after a
+contract-neutral CLEAR verdict, and preserve every unrelated Markdown byte.
+
+`afk_slices_remaining` is mutable runtime state, not `.devrites/AFK`
+configuration. Only the controlling root writes it under the shared
+[`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md#the-sentinel-devritesafk)
+contract and Build's
+[`afk-discipline.md`](../../rite-build/reference/afk-discipline.md#iteration-cap).
+Ordinary workspace creation preserves the field without initializing,
+increasing, renaming, or deleting it. Released bullet workspaces spell it `AFK
+slices remaining`; preserve that presentation rather than migrating it.
 
 ## questions.md entry format
 
 ```markdown
-## Q-001
+## q-YYYY-MM-DD-NNN
 status: open | answered | dropped
 slice: spec | plan | SLICE-001
 gate: advisory | validating | blocking | escalating
@@ -143,6 +152,12 @@ impact: <affected AC/REQ/slice IDs>
 ```
 
 No open blocking/escalating question may remain before define/build/prove gates.
+For a new entry, scan every `## q-YYYY-MM-DD-NNN` header for the current date,
+choose one above the highest suffix (or `001` when none exist), advancing until
+it is unused, then re-read
+`questions.md` immediately before the append and recompute. If the candidate is
+no longer unused, retry the scan; never reserve or derive it with an engine
+command.
 
 ## brief.md template
 

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

@@ -4,124 +4,47 @@ description: User-invoked read-only active-feature report: phase, active slice,
 argument-hint: "[feature-slug]"
 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-status: active feature status
 
-Read-only. Report where the active feature stands. **Do not run any phase.**
-
-## Load state
-
-Run the shared DevRites preamble plus the machine snapshot (default slug = `.devrites/ACTIVE`):
-
-```bash
-devrites-engine preamble [feature-slug]
-devrites-engine snapshot [feature-slug]
-```
-
-The preamble is the human-readable orientation digest: it prints `state.md`, artifacts
-present, run mode, and open-question counts. The snapshot is the canonical
-cross-harness machine contract: phase, section completeness, current slice,
-evidence/drift/review freshness, capability readiness, and **both** host-specific
-next-command forms under `nextCommands` (`claude` = `/rite-*`, `codex` = `$rite-*`).
-Use the command form for the current host; do not invent or hardcode one.
-The `!`-prefix dynamic-context-injection idiom is **not** used here so the skill
-stays portable across harnesses; the `devrites` binary is the cross-harness mechanism.
-
-## What to output
-
-If no workspace: tell the user to run `$rite-spec <feature>` to start. Stop.
+Read-only. Report the active workspace; do not run a phase or write files.
 
-Otherwise summarize from the loaded state, concisely:
+## Load
 
-1. **Feature** + one-line objective (from `brief.md`).
-2. **Phase**, **active slice** + its slice mode (from `state.md`). **Run mode**
-   (`afk` / `hitl`) is derived from `.devrites/AFK` presence (the preamble
-   already does this), not from a `state.md` field: present = `afk`, absent = `hitl`.
-3. **Status:** `running` / `awaiting_human` / `blocked` / `done`. If
-   `awaiting_human`, render the `Awaiting human` block from `state.md` (qid, gate,
-   question, proposed, raised_at, blocking_slices) and instruct
-   `$rite-resolve <qid> "<answer>"`.
-4. **Next action:** the single recommended next command from `snapshot.nextCommands`
-   for the current host.
-5. **Evidence:** what's proven vs unproven (from `evidence.md` /
-   `browser-evidence.md`).
-6. **Open questions:** count by gate (from `questions.md`:
-   `n open: x blocking · y validating · z advisory`) + the blocking qids by id and one-line question.
-7. **Unresolved drift** (`drift.md`).
-8. **Risks** (from `state.md` / `spec.md`); if `.devrites/principles.md` exists, note the count
-   of declared invariants and flag any exception in its register that is past its review/removal
-   trigger (a stale exception is a standing risk). Omit if there's no principles file.
-9. **Ready for handoff?:** see section below.
+Use the supplied slug or `.devrites/ACTIVE`; require its authoritative
+`state.md` and read the cursor directly. Read question, evidence, and risk
+artifacts only as needed. Never infer lifecycle state from `README.md` or chat.
 
-Flag anything blocking: unresolved drift, failing evidence, `Status: awaiting_human`,
-or open questions that change product behavior. End with the recommended next command
-and nothing else.
+If no workspace exists, recommend `$rite-spec <feature>` and stop.
 
-## Ready for handoff?
+## Report
 
-After the summary items (1-8), render the handoff readiness section (item 9 above) last:
-the canonical output order is: progress footer → summary items 1-8 → handoff readiness.
-A fresh agent
-or a future session should be able to pick the work up from the workspace
-**alone**, with zero chat context. Check:
+1. feature and one-line objective;
+2. phase, run mode, and active slice;
+3. status from `state.md`;
+4. the single `Next step` recorded in `state.md`;
+5. proven versus unproven evidence;
+6. open questions by gate, including the exact resolving command when awaiting
+   a human;
+7. unresolved drift and material risks;
+8. handoff readiness.
 
-- [ ] `state.md` has a **single** next-action command (not a list of options).
-- [ ] `questions.md` lists every unresolved question raised in this or any
-      prior session.
-- [ ] `decisions.md` records the rationale for any non-obvious choice
-      ("why this, not the obvious alternative").
-- [ ] `assumptions.md` lists every load-bearing assumption that wasn't
-      confirmed by code or by the user.
-- [ ] `drift.md` shows current resolution status for every drift event
-      (open / asked-user / repaired).
-- [ ] `evidence.md` is current for the active phase (no claims without
-      recorded commands + output).
+A workspace is handoff-ready when it records one next action, all unresolved
+questions, non-obvious decisions, load-bearing assumptions, current drift
+status, and evidence for its claims. If chat contains missing durable context,
+recommend `$rite-handoff` before the lifecycle command.
 
-If any item above fails, suggest `$rite-handoff` to compact chat-only
-context into the workspace before the session ends.
+Do not derive a command from host identity or invent one from phase names. Read
+the persisted `Next step`.
 
-## Gotchas
-- Read-only: never advance a phase or write to the workspace; that's the phase skills' job.
-- Report from the `.devrites/` files, not chat memory (it's gone after `/clear`).
-- Give the single next command, not a menu of options: an ambiguous next-action fails the handoff check.
+## Output
 
-## Output format
-
-**Progress first**: `$rite-status` *is* the status meter: render it by running
-`devrites-engine progress`. Then use the shared completion reply contract
-([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md))
-as a read-only status variant:
-```
-Done: status read for <slug>; phase <phase> and active slice <slice|n/a>.
-Changed: workspace only
-Evidence: <current proof summary | not applicable yet>
-Open: <none | questions n | drift n | blockers n | handoff gaps n>
-Next: <single recommended command>
-Record: .devrites/work/<slug>/state.md
-↻ Hygiene: <handoff ready | $rite-handoff before /clear>
+```text
+Feature: <slug> — <objective>
+Phase: <phase>; slice: <slice|n/a>; mode: <HITL|AFK>; status: <status>
+Evidence: <fresh/proven summary | gaps>
+Open: <questions/drift/blockers | none>
+Handoff: <ready | missing durable context>
+Next: <single persisted command>
 ```
-
-If gaps exist, the recommended next command is to **persist them first** (see
-`.agents/skills/devrites-lib/reference/standards/core.md`. "Persistence before stopping"). Only then
-move to the phase's next action.

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

@@ -3,35 +3,17 @@ name: rite-temper
 description: Temper a readied spec before planning. Use when the user says "temper this", "strategy review", "pre-mortem the spec", or asks if we are over/under-building. Not for code review or final seal.
 argument-hint: "[feature-slug] [--mode expand|selective|hold|reduce]"
 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-temper: review scope and risk before planning
 
 Review a readied spec for outcome ambition, scope, pre-mortem risks, and unnecessary
 solution surface. Fold accepted decisions into the canonical contract before
 `$rite-define`. This step is optional for small work and skips low-stakes specs, but
 `$rite-autocomplete` always invokes it. **Read the active workspace first**; if there
-is no readied `spec.md`, tell the user to run `$rite-spec`.
+is no readied `spec.md`, tell the user to run `$rite-spec`. Review depth follows
+[`devrites-lib/reference/orchestration-profiles.md`](../devrites-lib/reference/orchestration-profiles.md);
+the required exact strategy reviewer never changes with profile.
 
 ## Rules consulted (read on demand from `.agents/skills/devrites-lib/reference/standards/`)
 Pull on demand: `patterns.md` +
@@ -60,8 +42,8 @@ that needs more than the default pre-mortem) selected by the section's risk).
   failure that reopens the readiness gate.
 
 ## Workflow
-0. **Read `.agents/skills/devrites-lib/reference/standards/core.md`**, then run
-   `devrites-engine preamble` for deterministic workspace orientation.
+0. **Read `.agents/skills/devrites-lib/reference/standards/core.md`**, then
+   resolve the active slug, require its `state.md`, and read the cursor directly.
    Then read the workspace: `spec.md`, `decision-coverage.md` (+ `decisions.md`,
    `assumptions.md`, `design-brief.md` if UI), `state.md`. Require `Spec gate: passed`: else
    STOP → `$rite-spec`. Require `Decision coverage: CLEAR`: else STOP →
@@ -118,44 +100,24 @@ that needs more than the default pre-mortem) selected by the section's risk).
    After any edit to `brief.md`, `spec.md`, `decisions.md`, `assumptions.md`, or
    `questions.md`, re-scan the affected coverage rows, assumption audit, residual uncertainty,
    and closed gates. Partial/Missing, an unowned material assumption, or an open
-   blocking/escalating question routes `$rite-clarify`/HITL; never refresh past it. Only after the
-   matrix is re-closed, run `devrites-engine readiness-digest coverage <slug>` and replace the
-   complete `Coverage inputs SHA-256` line in `decision-coverage.md`.
+   blocking/escalating question routes `$rite-clarify`/HITL. Only after the
+   matrix is re-closed may the phase advance.
    Update `state.md`: `Phase: temper`,
    `Next step: $rite-define`; on a blocking pause (expand / irreversible / a dimension still below
    bar) write the `Awaiting human` block + `Status: awaiting_human` before stopping.
-7. **Adversarial verification loop:** dispatch [`devrites-strategy-reviewer`](.codex/agents/devrites-strategy-reviewer.toml)
-   through the file-backed fresh-context contract in
+7. **Adversarial verification loop:** ask the exact
+   [`devrites-strategy-reviewer`](.codex/agents/devrites-strategy-reviewer.toml)
+   through the native fresh-context contract in
    [`agents.md`](../devrites-lib/reference/standards/agents.md), with **only** the hardened
    spec + rubric: no authoring reasoning. Resolve
    actionable findings by editing `spec.md`/`strategy.md`, re-dispatch; **cap ≤3 iterations**. A
    dimension still below bar after 3 is classified by decision ownership: a product/scope/risk
    choice becomes a blocking question; an objective spec defect stays blocked with the exact
    required edit and routes to `$rite-spec`, not `$rite-resolve`. Irreversible-risk findings
-   always pause. Use the shared capability ladder; if no fresh-agent rung is available,
-   stop for HITL. After an accepted edit to a
-   coverage-bound input, repeat step 6's revalidation and digest refresh before handoff.
+   always pause. If the named agent is unavailable, stop for HITL. After an accepted edit to a
+   coverage-bound input, repeat step 6's native coverage revalidation before handoff.
 8. **STOP.** Report the mode, the scope deltas, and the floor verdict; recommend `$rite-define`.
 
 > **Mid-flight discipline.** Do not replace the interactive review with `strategy.md`,
 > expand implementation surface without need, grow scope outside the Drift Guard, or score
 > before citing evidence. See [`reference/anti-patterns.md`](reference/anti-patterns.md).
-
-## 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: spec tempered for <slug>; mode <expand|selective|hold-rigor|reduce-to-MVP|skipped-low-stakes>.
-Changed: strategy.md, spec.md, decisions.md, assumptions.md
-Evidence: dimension floor <band>; reviewer loop <n>; spec readiness + decision coverage re-checked pass
-Open: <none | n deferred non-goals>
-Next: $rite-define
-Record: .devrites/work/<slug>/strategy.md
-↻ Hygiene: /clear before $rite-define
-```
-If readiness is blocked, use the shared `Stopped / blocked` form and route `Fix:`
-to `$rite-clarify` for an uncovered decision surface or `$rite-spec` for an objective
-spec defect; do not recommend `$rite-define`.
-**DO NOT plan, slice, or write code here**. That's `$rite-define` and `$rite-build`.