devrites 3.2.27 → 4.0.0

package/pack/generated/codex/skills/devrites-interview/SKILL.md

@@ -1,51 +1,31 @@
 ---
 name: devrites-interview
-description: Internal DevRites skill; DevRites agents invoke it explicitly, not by prompt match.
+description: Interview the user one question at a time to extract intent. Use when the user says "interview me", "I am not sure what I want", or the ask is underspecified. Not for casual clarification.
 user-invocable: false
-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.
-
-
 # devrites-interview: extract intent
 
 Resolve the difference between the request and the user's intent before writing a
 spec, plan, or code.
 
 ## Protocol
-- **State a confidence number.** Open with a one-line hypothesis of what the user wants and an
-  explicit **0-100%** confidence. Check the number against the next three questions you would ask:
-  if you cannot predict the user's answers, lower it. Below **~70%**, append the single unresolved
-  point so the user can answer it directly.
+- **Open with a working hypothesis.** State in one line what the user wants, then ask about the
+  highest-value unresolved human-owned material decision.
 - **One question per turn.** Multiple questions get one answered and the rest ignored.
-- **Attach your best guess** and its reason to every question:
-  > "I'm assuming export is CSV only (covers the stated use case). Right, or also XLSX?"
-  The user can then correct a concrete premise instead of answering an open-ended question.
+- **Attach an explicit recommendation** and its reason to every question:
+  > "I recommend CSV only because it covers the use case. Choose CSV, CSV + XLSX,
+  > or something else?"
+  This is a concrete candidate for the user's decision, not an assumption or confirmation.
 - **Highest-value question first:** order by how much the answer changes the build. A
   question that moves the data model or acceptance criteria beats a cosmetic one.
-- **Prioritize impact and limit blockers.** Order unknowns **scope > security/privacy > UX >
-  technical**. Ask at most **3 blocking questions** per pass, choosing only those that gate
-  the spec. Record the rest in `assumptions.md` with the best guess and reason. A reversible
-  detail is never blocking.
+- **Prioritize impact and bound each pass.** Order unknowns **scope > security/privacy > UX >
+  technical**. A pass MAY contain at most **3 questions** for cognitive load. After each pass,
+  rescan the decision tree and continue in later turns until every human-owned material decision
+  is explicitly selected or explicitly deferred by the user. A cap MUST NOT move a blocker to
+  `assumptions.md`. Own and log reversible, low-impact technical details instead of asking.
 - **Structured options** when the space is enumerable: present them as the standard ranked
-  **option set** (`standards/afk-hitl.md` → "Option set"): recommended **first**, labelled
+  **option set** ([`afk-hitl.md` → "Option set"](../devrites-lib/reference/standards/afk-hitl.md#option-set-how-every-gap-is-presented)): recommended **first**, labelled
   `(Recommended)`, each with a dimension-tagged rationale (`logic · infra · business ·
   architecture`, + `security`/`UX`/`risk` when in scope), plus the escape hatch. Render via
   `AskUserQuestion` when the harness has it:
@@ -55,20 +35,14 @@ spec, plan, or code.
   3. Something else — I'll describe it
   ```
 
-## Stop condition
-Stop **opening new questions** when any condition below holds. This does not transfer a
-material decision to the agent. Present that decision as a ranked option set even when
-high confidence makes it a one-pick confirmation.
-- **Confidence: the predict-three test.** At 95%, you should be able to predict the user's
-  reaction to the next three questions. If so, stop. If several rounds pass without that
-  confidence, name the missing premise instead of asking more narrow questions.
-- **Convergence:** the last 2-3 answers only rubber-stamped your guesses and didn't
-  move the spec.
-- **Soft cap:** after ~8 material questions, proceed with your best-guess answers logged
-  in `assumptions.md` rather than asking more (hard-stop sooner if the ask is small).
+## Completion condition
+Complete only when a topology and decision-tree rescan finds no unresolved human-owned
+material decision. Such a decision closes only through the user's option selection,
+free-form answer, or explicit deferral. A recommendation is not confirmation. If the user
+stops early, persist every visible blocker and MUST NOT claim readiness or advance.
 
-Ask fewer, deeper questions. If answers stop converging and the discussion circles one
-area, **reframe once** instead of asking another version of the same question.
+Ask fewer, deeper questions. If answers stop converging around one area, **reframe once**
+instead of asking another version of the same question.
 
 ## Want vs. should-want
 Users sometimes name the convention or best practice they think they should want instead
@@ -80,14 +54,14 @@ than designing to the generic one.
 ## What counts as a yes
 Approval requires an **explicit** yes. Treat these replies differently:
 - *"Whatever you think is best"* / *"you decide"*: **delegation, not approval.** Offer two
-  concrete options so the user chooses the substance.
+  concrete options so the user chooses the substance or explicitly defers it.
 - *"Sounds good"* / *"sure, let's go"*: confirm once for a material decision rather than
   treating a polite exit as approval.
 - **Silence:** not consent. State what is out of scope and get explicit approval for it.
 
 ## Don't ask
 - Things the codebase answers (read it first).
-- Reversible implementation details (decide, log as an assumption).
+- Reversible, low-impact technical details (decide and log as agent-owned assumptions).
 - Everything at once "to be thorough."
 
 ## When the ask is vague: map the decision tree first
@@ -105,21 +79,23 @@ protocol with the revised premise.
 When clarifying a written spec rather than extracting intent from scratch, first enumerate
 its actors, journeys/components, states, data boundaries, interfaces/integrations, and
 operational/proof surfaces. Scan every material surface against the caller's fixed taxonomy and mark
-**Clear / Partial / Missing** with evidence. Ask **≤5 prioritized decision packets per scan**,
-targeting Missing before Partial, one per turn with a best-guess attached. A packet may close
+**Clear / Partial / Missing** with evidence. Ask at most **3 prioritized decision packets per
+pass**, targeting Missing before Partial, one per turn with an explicit recommendation and reason.
+A packet may close
 several cells only when they share one owner and trade-off.
 
 **Integrate each answer into the relevant spec section** immediately. A Q&A log alone is
 insufficient.
 Append a dated **`## Clarifications`** block to `spec.md` with the question and resolution.
-Re-run the scan after answers. The general question caps control cognitive load; they never turn
-a material blocker into a silent assumption. Continue another scan while human-owned blockers
-remain, and stop only when every row is clear, agent-owned, not applicable, or explicitly
-deferred with a nonblocking reason, owner, and validation gate. Then re-score the affected
+Re-run the scan after each pass. Packet limits control cognitive load, never readiness. Continue
+later passes while human-owned blockers remain, and stop only when every row is clear, agent-owned,
+not applicable, or explicitly deferred by the user with a nonblocking reason, owner, and validation
+gate. Then re-score the affected
 `checklists/<domain>.md`.
 
 ## Output
 A short summary for the caller: objective in one sentence, confirmed decisions,
 open non-blocking items, and the recommended next step. If a workspace is active, write
-Q&A to `questions.md`, confirmed calls to `decisions.md`, standing guesses to
-`assumptions.md`. If not, just return the summary: don't create a workspace.
+Q&A to `questions.md`, confirmed calls to `decisions.md`, and only agent-owned reversible,
+low-impact technical details to `assumptions.md`. If not, return the summary without creating
+a workspace.

package/pack/generated/codex/skills/devrites-lib/SKILL.md

@@ -1,103 +1,55 @@
 ---
 name: devrites-lib
-description: Internal DevRites skill; DevRites agents invoke it explicitly, not by prompt match.
+description: Internal shared DevRites helper library. Documents cross-cutting engine commands and references; not a user workflow. Do not invoke directly.
 user-invocable: false
 disable-model-invocation: true
-required-agent-roles: none
 ---
 
-## Codex compatibility
+# devrites-lib: shared workflow contracts
 
-This is the Codex mirror of a DevRites skill. In Codex:
+Do **not** invoke this skill directly.
 
-- 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.
+## Ownership boundary
 
+- The host owns instruction loading, exact-agent dispatch, scheduling, waiting,
+  follow-up, results, and history. Skills state the role/result, never native
+  fields or dispatch receipts.
+- Dispatch every workflow-required role fresh. A missing role stops for HITL;
+  never skip, substitute, or perform its work in the root.
+- The root owns DevRites state/artifacts but never source/tests. Codex grants it
+  workspace permission only because children cannot elevate; writing follows
+  [`reference/standards/agents.md`](reference/standards/agents.md).
+- The engine owns the retained deterministic structure, atomic-write, install,
+  evidence-freshness, and safety primitives only.
 
-# devrites-lib: internal shared helpers (not a command)
+## Workspace orientation
 
-Do **not** run this skill directly. It lists shared references and control-plane
-operations. Skills call `devrites-engine <command>` from any workspace without a pack
-script path.
+Use the supplied slug or read `.devrites/ACTIVE`. Require its authoritative
+`state.md`; read it directly, then only needed phase artifacts. Never infer
+lifecycle state from chat or optional `README.md`.
 
-## Operations
+## Shared references
 
-These are selected `devrites-engine` contracts. Run `devrites-engine help` for the full list.
+- [`reference/standards/agents.md`](reference/standards/agents.md): native custom-agent roles,
+  immutable inputs, result contracts, and source-boundary review.
+- [`reference/candidate-integrity.md`](reference/candidate-integrity.md): the
+  content-bound candidate lifecycle from Build through Ship.
+- [`reference/reply-contract.md`](reference/reply-contract.md): compact user-facing
+  completion states. The host renders the response normally.
 
-**Read-only: orient / gate (never mutate the workspace):**
+## Deterministic engine surface
 
-- `devrites-engine preamble`: orientation digest for the active `.devrites/` feature:
-  prints `state.md`, the artifacts present, the run mode (HITL/AFK), and the
-  open-question tally by gate. Run first (step 0) by every workspace-operating
-  `rite-*` skill so the model orients deterministically instead of re-deriving
-  state from raw Markdown.
-- `devrites-engine progress`: progress footer and counterpart to the initial
-  `devrites-engine preamble`. Run it **last** in every lifecycle `rite-*` skill to render from
-  `state.md`, with zero model drift) the `── rite-<phase> ──` header rule, the **slice
-  meter** (`Slice 3/5  ██████░░░░  <last-built> ✓`, or `Slices 5/5  ██████████  ✅ ALL
-  BUILT` at completion), and the **flow ribbon** (`spec ✓ define ✓ build ◉ … ship ○`).
-  The meter answers "how many slices left"; the `✅ ALL BUILT` marker answers "is the
-  build done". The skill prints its own result, next step, and hygiene lines beneath
-  it. Read-only; silent (exit 0) when there is no active workspace. Not for the workspace-less
-  utilities (`$rite-prototype`, `$rite-zoom-out`, `$rite-pressure-test`, `$rite-handoff`,
-  the `$rite` menu). They have no phase/slice state to render.
-- `reference/reply-contract.md`: the shared user-facing completion reply contract. It
-  standardizes the compact chat lines printed below `devrites-engine progress` for success,
-  awaiting-human, stopped/blocked, GO, NO-GO, and shipped states. The chat reply is a
-  status summary; durable detail stays in the workspace artifacts.
-- `reference/model-tiers.md`: the dispatch-by-task-shape contract (extraction / generation /
-  ceiling). A skill names a **tier** by the shape of the work and never hardcodes a model name;
-  reviewers are ceiling on purpose. Carries the degradation rule for harnesses that cannot pick
-  models per agent. Loaded on demand by any skill that dispatches subagents.
-- `devrites-engine build-readiness`: build-readiness gate. Exits non-zero on `$rite-build`'s
-  step-0 stop conditions so they hold by exit code, not by prose the model must
-  remember: `2` no `Plan approved` (→ `$rite-define`), `3` `awaiting_human`
-  (→ `$rite-resolve`), `4` `blocked` (→ `$rite-plan`), `5` no workspace
-  (→ `$rite-spec`), `6` decision coverage missing/not CLEAR (→ `$rite-clarify`),
-  `7` implementation readiness missing/not READY (→ `$rite-vet`), `8` older or unknown
-  semantic readiness contract (→ `$rite-upgrade`), `0` ready.
-- `devrites-engine evidence-fresh`: evidence-freshness gate for `$rite-seal`. Exits `3`
-  when any file in `touched-files.md` is newer than `evidence.md` /
-  `browser-evidence.md` (stale proof = NO-GO until re-proven), `0` when fresh.
-- `devrites-engine check-acceptance`: executable acceptance gate. Compiles `spec.md`'s
-  acceptance IDs and exits `1` unless every one is checked (proven) in `seal.md`;
-  new workspaces use `AC-###`, while legacy archives may still carry old `[ACn]`
-  ids. Used by `$rite-seal` and by the outcome grader.
-- `devrites-engine spec-validate`: spec-grammar gate (the spec-side mirror of
-  `devrites-engine check-acceptance`). Lints `spec.md`'s structured `### Requirement:` / `#### Scenario:`
-  blocks (SHALL/MUST present, ≥1 scenario each, every scenario has WHEN + THEN, headers
-  unique). Exits `1` on a grammar violation, `0` when valid **or** when the spec uses the flat
-  `AC-###` flat-bullet form (no structured blocks: nothing to lint, never a failure). Used by
-  `$rite-spec`'s readiness gate; see [`standards/spec-grammar.md`](reference/standards/spec-grammar.md).
+The engine is limited to:
 
-**State mutators: write `state.md` / `questions.md` under one contract:**
+- `check readiness` for structure, `check candidate` for content-bound identity,
+  and `check seal` for structure plus exact artifact bindings; `secret-scan` and
+  `version` remain read-only helpers.
+- Atomic state: `state resolve` for answer/drop/batch and transactional
+  `state close`.
+- Offline, local `install`, `update`, and `uninstall`; their shell/npm callers
+  acquire the candidate bundle, source, and binary before invoking the engine.
 
-- `devrites-engine tick-afk`: decrement the AFK slice budget; exits `3` at 0 (forced HITL stop).
-- `devrites-engine resolve`: backs the `$rite-resolve` contract (answer / drop / batch).
-- `devrites-engine close-out`: archive the workspace + clear `ACTIVE` on `$rite-ship`.
-
-### Canonical footer
-
-Every lifecycle `rite-*` skill prints this as the **first lines of its output**, then its
-own compact fact lines below per [`reply-contract.md`](reference/reply-contract.md):
-
-```bash
-devrites-engine progress
-```
-
-**Unified entrypoint (tool-agnostic):**
-
-- `devrites-engine` is the shared CLI for agents, CI, and humans. The npm
-  `devrites` shim acquires it, owns install/update/uninstall bootstrap, and
-  proxies other commands.
+Exact native agents/checklists own semantics; the host filesystem owns ledger
+reads/preview/confirmed no-clobber writes, spec grammar re-reading, question-id
+allocation, clarify cursor edits, AFK accounting, recovery accounting, and
+read-only diagnostics. Repository scripts and CI own gates.

package/pack/generated/codex/skills/devrites-lib/reference/candidate-integrity.md

@@ -0,0 +1,51 @@
+# Candidate integrity
+
+This file owns the Build-to-Ship lifecycle for one content-bound candidate. The
+exact `touched-files.md` and binding grammar remain in
+[`workspace-artifact-schema.md`](workspace-artifact-schema.md); phase skills link
+here and state only their phase action.
+
+`devrites-engine check candidate <slug>` is the only candidate hash authority.
+Record its exact digest with this unindented standalone line:
+
+```text
+Candidate SHA-256: <64 lowercase hex>
+```
+
+The line appears exactly once in `evidence.md`, `review.md`, and `seal.md`, and
+exactly once in `browser-evidence.md` when that file exists. A missing,
+duplicate, malformed, or mismatched binding stops the lifecycle.
+
+## Lifecycle
+
+- **Build maintains** the authoritative manifest from each green slice's actual
+  scoped diff. It may change until Polish closes the candidate.
+- **Prove binds** approved real proof to one digest. Check the candidate before
+  commands and again after them; the digest must be identical and proof must not
+  mutate candidate sources. Record it in evidence and browser evidence when present.
+- **Polish closes** the candidate only after every code/UI correction, capability
+  fold, optional design-memory update, and durable ADR promotion. Update the
+  manifest for every such path; a digest change requires affected real re-proof
+  and refreshed evidence/browser bindings before Review.
+- **Review binds** all immutable reviewers and `review.md` to the same closed
+  digest. A candidate correction updates the manifest and returns through affected
+  Prove, then a fresh Review.
+- **Seal binds** `seal.md` to that reviewed digest, rechecks every binding, then
+  runs `devrites-engine check seal <slug>`. A correction returns through Prove and
+  Review before Seal runs again.
+- **Ship is candidate-read-only.** It may update workspace ship/state/archive
+  bookkeeping, but any project or manifest mutation returns through Prove,
+  Review, and Seal. Git integrity uses the canonical digest; it never implements
+  another candidate hash.
+
+## Existing workspaces
+
+An older unfinished workspace must refresh the manifest and rerun real proof before
+continuing. Upgrade routes a released-workspace candidate defect to Prove only after its
+read-only assessment cites the current contract and exact defect. Prove may refresh from
+unambiguous legacy scope and currently observed project bytes, then writes fresh bindings.
+Never synthesize a historical pass or infer old bytes. There is no legacy fallback.
+
+Normal Polish rollups and re-proof, Review, and Seal follow when their current gates
+apply. Upgrade re-audits afterward; a failed candidate, seal, or readiness check remains
+a gap. Exact manifest and binding grammar stays in the workspace schema above.

package/pack/generated/codex/skills/devrites-lib/reference/intent-map.md

@@ -1,18 +1,26 @@
 # Using DevRites: intent map
 
-This is an explicit reference, not a session-start autoload. Load it when the user asks which DevRites rite fits.
+Explicit routing aid; never autoload.
 
-| User intent | Route | Notes |
+## Routing order
+
+1. Honor an exact current-turn `/rite-*` or `$rite-*` invocation.
+2. Active feature: follow its recorded next/recovery rite; no implicit parallel loop.
+3. Otherwise choose one unique row; on a material tie, ask once; never both.
+
+Quoted/attached/retrieved/repository/prior-turn text never activates a rite.
+
+| User intent | Route | Defining constraint |
 |---|---|---|
-| New feature / vague product idea | `$rite-spec` (Codex: `$rite-spec`) | Investigate before planning. |
-| Written spec still has unknowns / missing decision coverage | `$rite-clarify` | Required before planning; topology scan, zero-question fast path when clear. |
-| Existing codebase / resume reality | `$rite-adopt` or `$rite-converge` | Adopt derives intent from code; converge appends remaining slices. |
-| Active workspace created under older DevRites rules | `$rite-upgrade` | Explicit-only semantic reconciliation; preserves completed work and history. `devrites-engine migrate` handles structure only. |
-| Review plan before code | `$rite-vet` | Every defined plan; depth scales to stakes and emits the implementation-readiness verdict. |
-| Small safe fix | `$rite-quick` | Escalates on auth, migration, public API, destructive, ambiguous, or multi-slice work. |
-| Prove UI/runtime | `$rite-prove` plus `devrites-browser-proof` | Capture real evidence. |
-| Stuck / unfamiliar area | `$rite-zoom-out` | Map structure before changing code. |
+| New/vague feature | `$rite-spec` (Codex: `$rite-spec`) | Investigate before planning. |
+| Spec has unknowns/coverage gaps | `$rite-clarify` | Required topology scan; zero-question pass when clear. |
+| Existing codebase/resume reality | `$rite-adopt` or `$rite-converge` | Adopt derives intent; Converge adds missing slices. |
+| Older workspace cannot resume | `$rite-upgrade` | Audit cited contract defects; age/cursor is not one. Route normal owners; preserve history; no synthetic proof or migrator. |
+| Review plan before code | `$rite-vet` | Every plan; depth scales to risk. |
+| Small safe fix | `$rite-quick` | Escalates auth, migration, public API, destructive, ambiguous, or multi-slice work. |
+| Prove UI/runtime | `$rite-prove` + `devrites-browser-proof` | Capture real evidence. |
+| Stuck/unfamiliar | `$rite-zoom-out` | Map before editing. |
 | Teach me | `$rite-explain` | Human learning loop. |
-| Ship? decide readiness | `$rite-seal` | Seal decides; it does not mutate git. |
+| Decide ship readiness | `$rite-seal` | Decides; never mutates Git. |
 | Execute ship after GO | `$rite-ship` | Requires GO/type-GO. |
-| Whole lifecycle unattended | `$rite-autocomplete` | Clean baseline + checkpoint mode; stops on hard gates. |
+| Unattended lifecycle | `$rite-autocomplete` | Clean baseline/checkpoints; hard gates stop. |

package/pack/generated/codex/skills/devrites-lib/reference/orchestration-profiles.md

@@ -0,0 +1,22 @@
+# Native execution profiles
+
+Profiles scale **change depth**, not orchestration machinery. The host discovers
+the exact project specialist named by a workflow, dispatches it in fresh context,
+waits for the result, validates the result shape, and reconciles the evidence.
+DevRites does not provide an engine broker, agent API version, tier protocol,
+receipt, polling loop, or fallback agent.
+
+| Profile | Use when | Depth |
+|---|---|---|
+| **Quick** | One small, reversible, unambiguous change | One bounded implementation pass and focused proof; escape to Standard as soon as the significance gate fails. |
+| **Standard** | Default feature work | Full required lifecycle, named independent passes, focused then feature-level proof. |
+| **Full** | Security, migration, public contracts, high blast radius, or explicit `--full` | Same phases and exact roles as Standard, with every applicable conditional axis, broader failure-mode proof, and stricter final review. |
+
+A profile never skips a workflow-named specialist, changes source-write
+ownership, relaxes a gate, or authorizes an irreversible action. Missing or
+incompatible exact roles stop for HITL; the root never substitutes a generic
+agent or performs the specialist's work inline.
+
+The complete 17-role catalog and source-writing boundary live in
+[`standards/agents.md`](standards/agents.md). Review-specific applicability
+lives in [`parallel-dispatch.md`](parallel-dispatch.md).

package/pack/generated/codex/skills/devrites-lib/reference/parallel-dispatch.md

@@ -1,117 +1,42 @@
-# Parallel review dispatch
+# Native review dispatch
 
-This file defines reviewer rosters for `$rite-review` and `$rite-seal`. The shared
-packet, result, capability ladder, concurrency limit, retry, and reconciliation rules live in
-[`standards/agents.md`](standards/agents.md); do not restate them here.
-
-All reviewers read the same **immutable candidate**, but no more than three run
-concurrently. For a larger panel, use awaited batches of at most three; after resource
-or process errors, reduce the batch or run serially. A batch boundary does not permit a
-write.
+Host dispatches; DevRites governs.
 
 ## Roster
 
-`$rite-seal` accounts for all seven roles. `$rite-review` runs the first two.
-Conditional triggers use the listed signals.
+Review: Spec/Code; Seal: all applicable roles.
 
 | Reviewer | Fires | Trigger |
 |---|---|---|
-| `devrites-spec-reviewer` | always | review Spec axis; seal may carry it forward only on the identical candidate |
-| `devrites-code-reviewer` | always | review Code-review axis; seal may carry it forward only on the identical candidate |
-| `devrites-test-analyst` | always at seal | completed feature |
-| `devrites-frontend-reviewer` | conditional | diff touches a component, template, stylesheet, story, route, screen, or design token |
-| `devrites-security-auditor` | conditional | input, auth/authz, data access/storage, external integration, permission, dependency, or secret |
-| `devrites-performance-reviewer` | conditional | spec has a performance budget, or diff adds a query, growing-set loop, render/hot-path work, or material payload |
-| `devrites-devex-reviewer` | conditional | public API, CLI, SDK/export, webhook, config/env, error message, docs, or getting-started path |
-
-Not in this roster: `devrites-simplifier-reviewer` (polish), `devrites-doubt-reviewer`
-(doubt), `devrites-strategy-reviewer` (temper), `devrites-plan-reviewer` (vet),
-`devrites-forge-judge` (build), and `devrites-retrospector` (ship).
-
-## Hit-rate gating
-
-Before conditionals, run:
-
-```bash
-devrites-engine reviewer-stats report
-```
-
-- `run`, `run (always-on)`, or `run (insurance — never gated)`: apply the roster.
-- `gate-candidate`: a conditional produced zero surviving findings in its last 10+
-  dispatches. Record a skip with `gated: zero surviving findings in <N> dispatches`.
-- `--full`: dispatch every triggered reviewer despite gating.
-
-Always-on reviewers and insurance reviewers (security and doubt) are never hit-rate
-gated. After reconciliation, record each dispatched reviewer's surviving
-Critical+Important count:
-
-```bash
-devrites-engine reviewer-stats record devrites-<x>-reviewer <count> <slug>
-```
-
-## Reviewer packet
-
-Create `agent-packet/v1` per `standards/agents.md`. In addition to the common fields:
-
-```yaml
-objective: Audit the active feature on <axis>; derive expected behavior independently.
-inputs:
-  - path: .devrites/work/<slug>/spec.md
-    purpose: acceptance contract
-  - path: .devrites/work/<slug>/touched-files.md
-    purpose: feature boundary
-  - path: <scratch_root>/candidate.diff
-    purpose: reviewed candidate
-scope:
-  in: [<axis-specific workspace paths>, <touched source/test paths>]
-  out: [author reasoning, sibling findings, unrelated repository debt]
-  allowed_repo_writes: []
-```
-
-Tell the role to apply its documented discipline and return `payload.type:
-review-findings`, one finding per line, labeled Critical / Important / Suggestion /
-Nit / FYI and anchored to `file:line` plus the spec criterion or observed command.
-The exact result `CANNOT-VERIFY: <requirement> — <why>` is never a pass.
-
-Before dispatching `devrites-devex-reviewer` in measured mode, the root runs the
-documented quickstart in an isolated clean checkout and adds immutable commands,
-timings, output, candidate identity, and log hashes to the packet. Before
-dispatching `devrites-performance-reviewer`, the root supplies the immutable diff
-and any already-authorized measurement artifacts. Reviewers validate these inputs;
-their read-only identity never executes quickstarts, builds, browser runs, or
-assignment-only shell setup.
-
-Dispatch rules:
-
-- Fresh-context dispatch through the capability ladder; one packet per reviewer.
-- No author context, sibling findings, severity coaching, or plan justification.
-- Feature scope is `touched-files.md` plus the frozen diff.
-- Await every required batch before any write or verdict. Never background/detach.
-
-## Account for every reviewer
-
-Log exact agent names as decisions are made:
-
-```bash
-devrites-engine footprint log <slug> reviewer devrites-<x>-reviewer
-devrites-engine footprint log <slug> skip devrites-<x>-reviewer
-devrites-engine footprint roster <slug>
-```
-
-`roster` rc=3 means an unaccounted reviewer: dispatch or record why it does not apply.
-rc=1 means an always-on skip; this is valid only for an unchanged-candidate
-carry-forward. A required reviewer that cannot be dispatched blocks the phase.
-
-## Reconciliation
-
-1. Preserve each valid report verbatim under `## <axis>` in `review.md`/`seal.md`.
-2. Surface contradictions explicitly; the root decides them.
-3. Keep the shared five-label scale. The simplifier's Suggestion/Nit/FYI subset is valid.
-4. Resolve every `CANNOT-VERIFY` before the gate or retain it as a gap.
-5. Add a deduped roll-up only after the verbatim record. Mark matching `file:line`
-   findings from two or more axes as consensus; do not hide lone findings.
-6. Apply the caller's gate; do not invent a composite score.
-
-Every panel reviewer runs at the ceiling or inherited tier. If the named role is
-unavailable, use the universal ladder. If no fresh-agent rung is available, stop for
-HITL; never execute the reviewer in the root context.
+| `devrites-spec-reviewer` | always | acceptance/scope |
+| `devrites-code-reviewer` | always | implementation correctness |
+| `devrites-test-analyst` | seal | completed feature |
+| `devrites-frontend-reviewer` | conditional | UI/route/screen/style/design-token change |
+| `devrites-security-auditor` | conditional | input/auth/data/permission/dependency/integration/secret |
+| `devrites-performance-reviewer` | conditional | performance budget or hot path/query/growing set |
+| `devrites-devex-reviewer` | conditional | public API/CLI/SDK/webhook/config/error/docs/onboarding |
+
+Also: `devrites-simplifier-reviewer`, `devrites-doubt-reviewer`,
+`devrites-strategy-reviewer`, `devrites-plan-reviewer`, or `devrites-retrospector`.
+
+## Dispatch contract
+
+1. Freeze one candidate; give each reviewer the same spec, paths, and diff.
+   Parallelize only when writes/state/locks/tool sessions/scarce resources
+   (ports/processes/quotas/FDs/browsers/MCP) are compatible. Frozen read-only
+   usually is; pressure requires batches or serial work.
+2. Ask for each exact named agent in fresh context; omit native syntax and
+   `agent_type`/`task_name`/`fork_turns` from the instruction.
+3. Wait for all applicable results before reconciling.
+4. Apply [`agents.md` § Result admission](standards/agents.md#result-admission)
+   and dedupe by evidence/root cause. Account for all seven in
+   `review.md`/`seal.md`: `Outcome:` plus admitted account, or
+   `Not-applicable: <inspected-scope reason>`. Spec/Code may cite unchanged
+   `review.md`; persist no dispatch telemetry.
+5. Missing profile, null/failure, or malformed output is a `gap`; never
+   infer approval or substitute inline review.
+
+On exhaustion/contention: stop spawning; collect running results; batch/serialize.
+Never restart/orphan the cohort or infer approval.
+
+Reviewers are read-only; accounts store evidence, never telemetry.