devrites 3.2.28 → 4.0.0

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

@@ -1,30 +1,10 @@
 ---
 name: rite-polish
-description: Polish the active feature before review: code always, UI when touched. Use when the user says "polish this", "finish before review", "normalize the UI", or "make it bolder/quieter". Not for repo-wide refactors.
+description: Polish the active feature's code and any touched UI before review. Use for finish or normalization requests; not for repository-wide refactors.
 argument-hint: "[target | bolder | quieter | distill | harden | normalize-only]"
 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-polish: finish before review
 
 Polish code for every feature. When the feature touches UI, normalize and polish the
@@ -35,6 +15,9 @@ live in `reference/code.md` and `reference/ui.md`; read only the phase in scope.
 
 - **Functionality complete first.** Polish runs after `$rite-prove` (full
   feature proven).
+- Follow the shared
+  [`candidate-integrity.md`](../devrites-lib/reference/candidate-integrity.md).
+  Polish owns every candidate-affecting correction and durable rollup before Review.
 - Feature scope only.
 - For UI, **normalize before polishing**. Do not add decoration on top of drift.
 - **Root selects; wright edits.** The controlling chat assesses and reconciles, but every
@@ -49,9 +32,9 @@ live in `reference/code.md` and `reference/ui.md`; read only the phase in scope.
    per-phase rule files (`coding-style.md`, `error-handling.md`, …) load on demand
    from `reference/code.md` / `reference/ui.md` when their phase runs; for UI scope also read
    `.agents/skills/devrites-lib/reference/standards/browser-proof-checklist.md`.
-   Then run `devrites-engine preamble` for deterministic workspace orientation.
-1. **Read** `state.md`, `touched-files.md`, and the `git diff` for the active
-   workspace (or `$ARGUMENTS` if a target was given).
+   Then read the explicit or active workspace's `state.md` directly.
+1. **Read** `state.md`, `touched-files.md`, the current candidate digest, and the
+   `git diff` for the active workspace (or `$ARGUMENTS` if a target was given).
 2. **Detect UI scope:** UI is touched if the diff or `touched-files.md`
    contains any of: `.tsx`, `.jsx`, `.vue`, `.svelte`, `.html`, `.css`,
    `.scss`, `.sass`, `.less`, `.styl`, component dirs (`components/`,
@@ -74,13 +57,18 @@ live in `reference/code.md` and `reference/ui.md`; read only the phase in scope.
    - `bolder | quieter | distill | harden`: passed to Phase 4 as the
      emphasis dial.
    - `normalize-only`: assess Phase 3 and stop (no Phase 4).
-5. **Re-verify after any code edit:** a wright correction invalidates prior proof, so
-   `$rite-prove` no longer post-dates it. Dispatch `devrites-proof-runner` for the affected
-   fast checks (the
-   targeted tests for the touched files + typecheck/lint; browser re-check if UI
-   changed) and record a **`Re-verification:`** line in `polish-report.md`. A
-   polish that changed code without a green re-verification isn't finished.
-6. **Aggregate output:** both phases append to the single `polish-report.md`.
+5. **Finish durable rollups before Review.** Apply the capability
+   [`ledger`](reference/ledger.md) when requirements changed, the optional UI
+   [`design memory`](reference/design-memory.md), and durable
+   [`ADR promotion`](reference/adr-promotion.md). Add every changed project path
+   to the candidate manifest; none of these writes waits for Ship.
+6. **Re-prove and close.** After all accepted code/UI corrections and rollups,
+   run `devrites-engine check candidate <slug>`. Any digest change requires
+   affected real re-proof using the approved commands, fresh proof-runner
+   validation, refreshed evidence/browser bindings, and an updated candidate
+   manifest. Record a **`Re-verification:`** line in `polish-report.md`. Close
+   the candidate for Review only after these checks are green.
+7. **Aggregate output:** both phases append to the single `polish-report.md`.
 
 ## Refinement modes
 
@@ -93,19 +81,4 @@ quality bar; they apply after the system is aligned. See `reference/ui.md`.
 
 ## Output → `polish-report.md`
 
-Write the detailed report to `polish-report.md`. In chat, run `devrites-engine progress` first,
-then use the shared completion reply contract
-([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md)).
-Default success shape:
-```
-Done: polished <slug | target>; code/backend/UI phases <ran|n/a>.
-Changed: polish-report.md, <files touched | workspace only>, browser-evidence.md <updated|n/a>
-Evidence: re-verification <cmd -> pass | n/a>; browser <summary | n/a>
-Open: <none | non-blocking design follow-ups>
-Next: $rite-review
-Record: .devrites/work/<slug>/polish-report.md
-↻ Hygiene: /clear before $rite-review
-```
-If a design decision remains unresolved or polish invalidated proof, use `Awaiting human`
-or `Stopped / blocked` and route to the decision or `$rite-prove`; do not recommend
-`$rite-review`.
+Write the detailed report to `polish-report.md`.

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

@@ -0,0 +1,11 @@
+# ADR promotion
+
+Promote only durable architecture or interface decisions from `decisions.md`; slice-local
+calls remain in the archived workspace. Do this during Polish before Review. If the
+project has no `docs/adr/`, ask before creating that convention.
+
+Write the next append-only `docs/adr/ADR-NNN.md` with Context, Decision, Status
+`accepted`, and Consequences. Never rewrite an accepted ADR; supersede it with a new ADR
+that links the old one. Add every promoted ADR to the authoritative candidate
+manifest, run affected real re-proof, and refresh evidence/browser bindings before
+Review. Ship performs no ADR promotion.

package/pack/{.claude/skills/rite-ship → generated/codex/skills/rite-polish}/reference/design-memory.md

@@ -1,18 +1,18 @@
 # Design memory: record proven design rules in `DESIGN.md`
 
-This optional `/rite-ship` step applies only to UI features. Feature design decisions
+This optional `$rite-polish` step applies only to UI features. Feature design decisions
 live in `design-brief.md` and archive with the workspace. With the user's approval,
 copy proven, reusable design rules into the project-level `DESIGN.md` for later
 features.
 
 `devrites-ux-shape` §1 and
 `devrites-frontend-craft/reference/design-references.md` read `DESIGN.md` when present.
-This step writes that file from sealed feature evidence.
+This step writes that file from real feature evidence before Review.
 
 ## When it runs
 - **UI features only.** No UI in the diff → skip silently.
-- **At ship, GO sealed, after the git plan, before type-GO** (step 2a), so the user sees
-  the full staged change set (code + `DESIGN.md`) under the single type-GO that ships it.
+- **During Polish, after initial proof and before candidate closure.** Any update
+  enters the candidate manifest and is proved and reviewed with the feature.
 - **Opt in and confirm.** A project-wide artifact is outside feature scope
   (`standards/core.md` rule 7), so never write it silently. Present a ranked option set
   (see [`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md), "Option set");
@@ -23,25 +23,28 @@ This step writes that file from sealed feature evidence.
   it only adds evidence-proven entries.
 
 ## Inputs (proven only)
+
+Entries are **proven, not aspirational**.
 - `design-brief.md`: direction, color strategy, **calibration** (density / motion), key
   states, named anchors, and the per-slice **Build-time refinements**.
-- The **final diff** and `touched-files.md`: the tokens, components, and states that
-  shipped. Record only what the diff proves, not everything the brief intended.
+- The **closed candidate diff** and `touched-files.md`: the tokens, components,
+  and states the candidate proves. Record only what the diff proves, not
+  everything the brief intended.
 - Existing `DESIGN.md` if present: the merge target.
 
 ## What to record
-Record only reusable rules established by the shipped, proven feature. Exclude choices
+Record only reusable rules established by the proved candidate. Exclude choices
 that apply only to this feature.
 - **Tokens introduced + used:** new color roles / spacing steps / type steps / elevation
-  / radius that shipped and are reusable. Names and values, mirrored from the code.
+  / radius proved in the candidate and reusable. Names and values, mirrored from the code.
 - **Color strategy and calibration baseline:** the strategy (Restrained / Committed / …) and
   established density / motion; record a deviation as a deviation, not a new
   default.
 - **Type & spacing scales** in actual use; **motion** classes + easing; **materiality**
   (elevation set, hairline usage, glass / texture policy).
 - **Component behaviors:** for each shared component established or extended by the
-  feature, record its shipped states and interaction model.
-- **Named-anchor lineage:** the anchors used by shipped features.
+  feature, record its proved states and interaction model.
+- **Named-anchor lineage:** the anchors used by proved features.
 - **Anti-slop exceptions:** any banned default the project *intentionally* uses (with the
   why), so build / polish don't "correct" a deliberate choice.
 
@@ -54,20 +57,20 @@ that apply only to this feature.
 - **Attribute and keep it short.** Tag each new entry with the feature slug. Future
   specs read this file, so use concise entries.
 
-## How it commits
-`DESIGN.md` is a tracked project artifact and ships **in the feature commit**:
+## How it enters the candidate
+`DESIGN.md` is a tracked project artifact:
 1. Write / update `<project-root>/DESIGN.md` from the template below.
-2. **Append `DESIGN.md` to `touched-files.md`** so the existing commit scope (SKILL
-   steps 2 and 4) stages it under the same type-GO. Do not create a second commit.
-3. Note the rollup in `ship.md` (what was added, or "design-memory: skipped by user").
+2. Add `DESIGN.md` to the authoritative candidate manifest.
+3. Run affected real re-proof, refresh evidence/browser digest bindings, and
+   include the result in Review. Ship performs no design-memory write.
 
 ## `DESIGN.md` template (project-level, stack-agnostic)
 ```markdown
 # DESIGN.md — <project> design memory
 
-> Rolled up from shipped features by `/rite-ship` (design memory). Read by
+> Rolled up from proven features by `$rite-polish` (design memory). Read by
 > `devrites-ux-shape` and `devrites-frontend-craft` as the inherited system. Evidence-only:
-> every entry shipped and was proven. Edit through a feature's ship, not by hand.
+> every entry was proven. Edit through a feature's polish, not by hand.
 
 ## Register & direction
 Default register per surface (brand / product) and the scene-derived direction the product
@@ -94,7 +97,7 @@ Classes in use, easing, `prefers-reduced-motion` handling.
 Elevation token set, hairline usage, glass policy, texture / asset approach.
 
 ## Components (proven behaviors)
-| Component | States shipped | Interaction model | First proven by |
+| Component | States proven | Interaction model | First proven by |
 |---|---|---|---|
 | <name> | default/hover/focus/loading/empty/error/… | inline / navigated / modal · feedback | <slug> |
 
@@ -108,8 +111,7 @@ Banned defaults this project *intentionally* uses, with the why (so build/polish
 ## NEVER (design memory)
 - Never roll up unattended on first creation: a new persistent project artifact is a
   confirmed step, never an AFK silent write.
-- Never write an entry the feature didn't *prove* shipped: no aspirational tokens.
+- Never write an entry the feature did not prove: no aspirational tokens.
 - Never overwrite or silently reconcile a conflicting existing entry: surface it.
 - Never persist a feature-only one-off as if it were the project default.
-- Never add `DESIGN.md` to the commit without appending it to `touched-files.md` first
-  (it would fall outside the ship's commit scope).
+- Never leave `DESIGN.md` outside the candidate manifest or defer it until Ship.

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

@@ -0,0 +1,62 @@
+# Capability ledger
+
+`.devrites/specs/<capability>/spec.md` is the canonical ledger of proven capability
+`### Requirement:` blocks across feature archival.
+Host filesystem I/O; no engine command.
+
+## Fold semantics
+
+A feature spec may group deltas under capability-tagged H2s (`## ADDED
+Requirements — capability: <c>`, `MODIFIED`, or `REMOVED`); see
+[`spec-grammar.md`](../../devrites-lib/reference/standards/spec-grammar.md).
+
+| Delta | Rule |
+|---|---|
+| ADDED | Append an absent block. Identical existing content is a no-op; the same header with different content conflicts. |
+| MODIFIED | Replace the named block in full. Equal content is a no-op; an absent target conflicts. |
+| REMOVED | Delete the named block. An absent target is a no-op; preview deletion if the capability becomes empty. |
+
+Match exact `### Requirement:` headers. Rename = REMOVED + ADDED. Flat specs
+seed the slug capability as all-ADDED.
+
+For MODIFIED, compare the complete current requirement block to its full replacement.
+It MUST preserve
+every existing scenario and normative or source-grounded claim unless an exact accepted `DEC-###`
+explicitly names its replacement or removal and rationale. For MODIFIED or REMOVED,
+reconciliation MUST account for load-bearing adjacent notes,
+examples, and comments whose meaning depends on changed text. Ambiguous ownership blocks
+reconciliation: preserve and show the content for an explicit decision; MUST NOT silently
+relocate or drop it. An unexplained omission is a blocking conflict,
+not cleanup or simplification.
+
+## Native preview/write workflow
+
+Run during Polish before Review so ledger edits enter the proved candidate.
+
+1. **Read.** Read the feature spec and only affected ledger specs. Reject a
+   capability escaping `.devrites/specs`, symlink/special file, duplicate header,
+   or malformed delta.
+2. **Preview, do not write.** Show exact target paths; every delta with before/after
+   header; full requirement order; and changed files. Apply the table to current
+   bytes and the preservation rule to MODIFIED and REMOVED. Conflicts stop.
+3. **Check feature grammar.** Apply `spec-grammar.md`'s Native grammar re-read
+   checklist to the saved feature spec. Any miss stops. Step 2's native comparison owns delta reconciliation; an
+   already-applied empty preview remains a no-op.
+4. **Confirm.** Name exact paths and deltas. A later Seal or Ship approval does
+   not confirm this write. Skip only when no capability contract exists.
+5. **Write safely.** Use `git check-ignore` and `git status` to prove targets will
+   be tracked; surface a needed ignore carve-out. Immediately re-read and refuse
+   bytes changed since preview. Touch only `.devrites/specs/`, preserve unrelated
+   bytes/order, and apply only previewed replacements or empty-file deletion.
+6. **Verify.** Re-read targets; require unrelated blocks byte-identical and the
+   same preview empty. Apply the same Native grammar re-read checklist to each
+   resulting capability spec.
+   Add changed paths to the authoritative candidate manifest, run affected real
+   re-proof, and refresh evidence/browser digest bindings before Review.
+
+Skip all six steps for a refactor/chore with no requirements.
+
+## Reading in Spec and Adopt
+
+List ledger specs with the host filesystem and read only touched capabilities.
+Classify against current file content, never memory.

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

@@ -1,66 +1,43 @@
 ---
 name: rite-pov
-description: Project-grounded verdict for adopting, switching, rejecting, or revisiting a named external technology, library, platform, CVE, or pattern. Use when deciding whether this project should commit to an outside option.
+description: Project-grounded verdict for adopting, switching, rejecting, or revisiting a named external technology, library, platform, CVE, or pattern.
 argument-hint: "[candidate/link/question]"
 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-pov: project-grounded external verdict
 
-Decide whether **this project** should adopt, trial, hold, reject, or ignore a named outside candidate. Chat verdict first; durable record only when the user asks or the decision changes an active feature.
-
-## Rules consulted
-Step 0: Read `.agents/skills/devrites-lib/reference/standards/core.md`. Pull `source-driven`, `security`, or `deprecation` standards only when the candidate touches those risks.
-
-## Operating rules
-- Verdict only after two floors clear: one verified project fact and one verified external source.
-- Named candidate only. If the user asks "what should we use?" over an open field, route to `$rite-pressure-test` or `$rite-spec` to surface criteria first.
-- Reversibility sizes rigor: two-way config/dependency < bounded internal migration < public/security/legal/data decision.
+Decide whether this project should adopt, trial, hold, reject, or ignore one
+named outside candidate.
 
 ## Workflow
-1. **Frame.** Parse `$ARGUMENTS` into candidate, intent (`adopt|switch|compare|CVE/deprecation impact|second opinion`), and reversibility tier. If intent is ambiguous, ask one blocking question before research.
-   **Completion:** candidate, decision intent, and reversibility tier are explicit.
-2. **Project floor.** Verify at least one concrete project fact: incumbent dependency/call site, current absence plus integration point, prior ADR/decision, or affected surface. Use `devrites-engine profile get`; on `MISS`, run `devrites-engine profile refresh` once, then inspect candidate-specific files fresh. Completion: at least one `file:line` or local doc pointer is in notes, or the verdict is `Hold: project floor missing`.
-3. **External floor.** Read primary docs/advisory/release notes/source for the candidate. Prefer official sources; web summaries are supporting only. Completion: at least one dated source URL/title is in notes, or the verdict is `Hold: external floor missing`.
-4. **Compare.** Weigh fit, migration cost, reversibility, project principles, security/licensing/deprecation risk, and simpler alternatives already present.
-   **Completion:** every comparison dimension has project evidence or an explicit unknown.
-5. **Verdict.** Return exactly one grade: `Adopt`, `Trial`, `Hold`, `Reject`, or `Not-our-problem`. Include next step: `$rite-spec`, `$rite-define`, spike, `$rite-learn` record, or done.
-6. **Optional record.** If the user asks to persist, append the decision to the active workspace `decisions.md`; if no active workspace, suggest an ADR. A persisted `Reject` also lands in the cross-feature ledger so ideation skills stop re-proposing it: `devrites-engine learnings add <slug> "<candidate> — <why rejected>" rejected-direction`.
+
+1. Frame the candidate, decision intent, and reversibility tier. Route an
+   open-ended market search to `$rite-pressure-test` or `$rite-spec`.
+2. Inspect the live repository for at least one concrete project fact: an
+   incumbent dependency/call site, integration seam, relevant ADR/decision, or
+   confirmed absence. No profile cache.
+3. Verify the external claim from current primary documentation, source,
+   advisory, or release notes.
+4. Compare fit, existing alternatives, migration cost, reversibility, project
+   principles, security, licensing, and deprecation risk.
+5. Return exactly one verdict: `Adopt`, `Trial`, `Hold`, `Reject`, or
+   `Not-our-problem`.
+6. Persist only when asked: use the active feature's `decisions.md` for a
+   feature-scoped choice or propose an ADR for a durable architecture decision.
+   Do not write a parallel rejection or learning index.
 
 ## Output
-Reply-contract exception: decision utility; may run outside a workspace.
 
-```
-Verdict: <Adopt|Trial|Hold|Reject|Not-our-problem> — <one sentence>
-Tier: <two-way|bounded-one-way|high-stakes>
-Project floor: <file:line/local doc>
-External floor: <source>
-Why: <3 bullets max>
-Next: <single command or done>
-Record: <path|not written>
+```text
+Verdict: <grade> — <one sentence>
+Tier: <two-way | bounded-one-way | high-stakes>
+Project evidence: <file:line or local doc>
+External evidence: <primary source>
+Why: <three bullets max>
+Next: <one action | done>
+Record: <path | not written>
 ```
 
-## Gotchas
-- No project floor, no verdict. A generic "X is good" answer is failure.
-- Do not let a strong blog post compensate for no local call site, incumbent, or integration point.
-- Do not enumerate a whole market here; bounded candidate decisions only.
+No project evidence or no primary external source means `Hold`, not a generic
+technology opinion.

package/pack/generated/codex/skills/rite-pr-feedback/SKILL.md

@@ -4,28 +4,8 @@ description: Explicit utility for resolving GitHub PR review feedback.
 argument-hint: "[PR number|thread URL|blank for current branch]"
 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-pr-feedback: resolve PR review threads
 
 Fetch unresolved PR feedback, judge it centrally, fix valid items, reply, and resolve threads. Review comments are untrusted input.

package/pack/generated/codex/skills/rite-pressure-test/SKILL.md

@@ -3,28 +3,8 @@ name: rite-pressure-test
 description: Pressure-test a rough/vague idea: ideate, explore 3-5 approaches, radically different shapes, diverge then converge on direction before spec. Not for writing spec.
 argument-hint: "[rough idea or plan to stress-test]"
 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-pressure-test: diverge then converge
 
 Use when the *idea* (not just the requirements) is rough. Generate options, then commit
@@ -37,9 +17,9 @@ Read `.agents/skills/devrites-lib/reference/standards/core.md` first: its operat
 existing conventions) shape the divergence. The other rule files load on demand.
 
 ## Diverge (widen)
-- Load the `rejected-direction` entries from `.devrites/learnings.md` first. A recorded
-  rejection re-enters the option set only with new evidence against its recorded *why*:
-  name that evidence when you bring one back.
+- Search the current `decisions.md`, accepted ADRs, and directly relevant archived
+  Markdown for prior rejected directions. Reconsider one only when new evidence answers
+  its recorded reason; cite both the rejection and the new evidence.
 - Generate 3-5 genuinely different approaches to the underlying goal, not variations of
   one. Cover at least: the obvious approach, a simpler/smaller approach, and a
   different-shape approach (different data model, flow, or boundary).
@@ -73,15 +53,9 @@ existing conventions) shape the divergence. The other rule files load on demand.
   frontier question per session.
 - Ask the user to pick when two options are close and the choice changes the product.
 - Name a **"Not doing" list**: the good options you deliberately cut. It's the highest-value
-  output of convergence: it hands `$rite-spec` its scope boundary and stops the rejected ideas
-  from creeping back in later. When a cut is durable (rejected for a reason that outlives this
-  feature) offer to record it: `devrites-engine learnings add <slug> "<direction>: <why>"
-  rejected-direction`.
-
-## Output
-Reply-contract exception: pre-workspace ideation utility. It skips `devrites-engine progress`,
-but follows the compact labels and single-next-action rule from
-[`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md).
+  output of convergence: it hands `$rite-spec` its scope boundary. When a cut is
+  durable, offer to record the reason in the active feature's `decisions.md` or
+  a durable ADR rather than a parallel rejection index.
 
 ```
 Done: pressure test complete for <goal>.

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

@@ -4,28 +4,8 @@ description: User-invoked throwaway prototype for one logic or UI design questio
 user-invocable: true
 disable-model-invocation: true
 argument-hint: "[the question the prototype is answering]"
-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-prototype: answer one question with throwaway code
 
 A prototype is throwaway code for exactly one question. Choose its shape from that
@@ -110,11 +90,6 @@ calling phase. The prototype itself does **not** ship.
 
 ## Output
 
-Reply-contract exception: scoped prototype detour. Run `devrites-engine progress` only when
-an active workspace exists; otherwise skip it. Use the compact labels from the shared
-completion reply contract
-([`devrites-lib/reference/reply-contract.md`](../devrites-lib/reference/reply-contract.md)).
-
 ```
 Done: prototype answered <question>.
 Changed: <prototype path | deleted after absorption>; decisions.md or NOTES.md