devrites 7.1.1 → 7.1.2

package/pack/generated/claude/skills/rite-temper/reference/scope-modes.md

@@ -1,7 +1,6 @@
 # Scope modes + the two passes
 
-The heart of `/rite-temper`: two ordered passes (heat, then quench), converging on exactly
-one scope mode. Ambition is a **generative** move followed by a **required convergence**: the
+`/rite-temper`: two ordered passes (heat, then quench), converging on one scope mode. Ambition is a **generative** move followed by a **required convergence**: the
 divergence is never the spec; the converged sweet spot is.
 
 ## Pass 1: FORWARD (heat: raise ambition on the outcome)
@@ -41,11 +40,11 @@ Mode selection is the first convergence move. Record the chosen mode + rationale
 | **REDUCE-TO-MVP** | Over-scoped: second-system bloat, ~all must-haves, gold-plating | Hammer scope to the Minimum Usable Subset; move the rest to Non-goals with one-line reasons + revisit notes | Strongest YAGNI alignment. Cutting acceptance is **still a spec change**: record it via the Guard, never a silent trim |
 
 ## Bound ambition by reversibility
-The bigger the bet, the more it must be reversible. Irreversible-risk areas (auth, migrations,
-public API, data model) get the **opposite** of ambition: maximum conservatism, explicit
-rollback, and they **always pause** regardless of mode (the [`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md) irreversible-risk
-list is honored verbatim). Size big bets so that if the whole thing vanished tomorrow, you'd be
-fine.
+Bigger bets need more reversibility. Auth, migrations, public API, and data-model
+changes need maximum conservatism, full review, and explicit rollback.
+Pause only for actual [canonical irreversible-risk items](../../devrites-lib/reference/standards/afk-hitl.md#irreversible-risk-list-always-pause)
+or unresolved human-owned decisions, not an already-approved reversible internal
+data-model change. Size bets to tolerate their disappearance tomorrow.
 
 ## Effort foresight (frame it now, not "later")
 While choosing scope, surface the late-stage questions early: *"What will surprise us at

package/pack/generated/claude/skills/rite-upgrade/SKILL.md

@@ -99,8 +99,13 @@ references, and only current phase contracts needed for the observed gap.
    - a missing/malformed strict manifest, missing/malformed/mismatched evidence binding,
      a browser-binding defect when that file exists, or current candidate-check failure
      → `/rite-prove`;
-   - candidate-affecting capability-ledger, `DESIGN.md`, or ADR rollups still deferred by
-     an old Ship-era workspace → `/rite-polish`;
+   - required candidate-affecting capability-ledger, `DESIGN.md`, or ADR rollups still
+     deferred by an old Ship-era workspace → `gap`: no admitted route. STOP with an
+     explicit `/rite-polish` handoff for separate user authorization; never invoke
+     those rollup writes inside Upgrade. After authorization outside Upgrade, normal
+     affected Prove → Review → Seal applies;
+   - workspace-only Polish refresh → `/rite-polish` only when its exact paths remain
+     within the admitted gate artifacts and no candidate-affecting rollup is required;
    - a missing, stale, or mismatched review binding → `/rite-review`;
    - a missing, stale, or mismatched seal binding or failed Seal gate → `/rite-seal`.
 

package/pack/generated/claude/skills/rite-vet/SKILL.md

@@ -11,10 +11,10 @@ user-invocable: true
 
 # /rite-vet: review the plan before build
 
-Vet every plan's scope, architecture, quality, proof, performance, failures and writer
-safety. Fold cited technical findings; design Build tests. Temper owns product;
-Vet owns implementation; current `$ARGUMENTS` (`--full`) feeds the depth triggers in
-`reference/depth.md`; profiles never remove the exact plan-reviewer gate
+Vet each plan: scope, architecture, quality, proof, performance, failures, writer
+safety. Fold cited technical findings; design Build tests. Temper owns product,
+Vet implementation. Current `$ARGUMENTS` (`--full`) feeds `reference/depth.md`
+triggers; profiles never remove the exact plan-reviewer gate
 ([orchestration-profiles.md](../devrites-lib/reference/orchestration-profiles.md)).
 
 ## Rules
@@ -41,21 +41,23 @@ plan declares a root-authored executable workflow file, read
 
 ## Invariants
 
-- Review implementation, not ambition. Challenge creep, complexity, proof, and
-  risk without changing accepted product scope.
-- Root owns decisions/writes/readiness; reviewers judge without route policy.
-  Cite findings/confidence; suppress
-  unverified or confidence ≤4 findings under `review-axes.md`.
-  Lens arrows in `eng-lenses.md` are heuristics; band findings only under the
-  four `review-axes.md` names.
-- Auth, migration, public API, and data-model changes use maximum caution and the
-  irreversible-risk stop. Project principles never become trade-offs.
+- Review implementation, not ambition. Challenge creep/complexity/proof/risk
+  without changing accepted product scope.
+- Root owns decisions/writes/readiness; reviewers judge, not route. Cite
+  findings/confidence; suppress unverified or confidence ≤4 findings per
+  `review-axes.md`. `eng-lenses.md` arrows are heuristics; use only the four
+  `review-axes.md` band names.
+- Auth, migration, public API, and data-model changes need maximum caution,
+  full review, and explicit rollback. Pause only for
+  [canonical irreversible-risk items](../devrites-lib/reference/standards/afk-hitl.md#irreversible-risk-list-always-pause)
+  or unresolved human-owned decisions, not an already-approved reversible internal
+  data-model change. Project principles never become trade-offs.
 - **Governance-protected paths** (`.devrites/**`, pack skill/agent trees,
-  `NOTICE.md` generator regions, CI/hook config named in repo docs) require explicit
-  human approval before plan slices may edit them. A slice touching a protected path
-  without approval → Vet **NEEDS CLARIFICATION**.
-- Use the lowest axis band; never average or round thin to ready. Search before
-  asking and resolve reversible technical choices. Ask only human-owned choices.
+  `NOTICE.md` generator regions, documented CI/hook config) require explicit
+  human approval before plan slices edit them; absent approval → Vet
+  **NEEDS CLARIFICATION**.
+- Use lowest axis band; never average/round thin to ready. Search; resolve
+  reversible technical choices; ask only human-owned.
 - Preserve a valid technical return cursor. Agent-owned `NEEDS REPLAN` returns
   internally to its caller, not to the human; on a direct invocation there is
   no caller, so Vet becomes it — save a return cursor
@@ -76,18 +78,16 @@ plan declares a root-authored executable workflow file, read
    assumptions, and state. Require approved Plan and `Decision coverage: CLEAR`;
    otherwise stop for Define or Clarify. Check placement (`get_architecture`),
    blast radius (`trace_path`), and reuse (`search_graph`) per [`code-navigation.md`](../devrites-lib/reference/standards/code-navigation.md).
-1. **Select depth.** Apply `reference/depth.md` exactly; never skip. Every initial
-   pass records an engineering verdict and test-plan coverage. A valid Recovery
-   recheck retains prior depth and enters 1b.
-1a. **Independent initial pass.** Freeze candidate and dispatch the exact fresh
-   read-only plan reviewer — plus developer-experience reviewer for developer
-   surfaces (trigger `devex`) and the current strategy reviewer after significant
-   Temper — in
-   parallel under `../devrites-lib/reference/parallel-dispatch.md`; they are
-   independent read-only passes on one frozen candidate. Missing
-   required account blocks. Run root steps 2–4, including step 3's preflight
-   commands, on the same frozen candidate while the wave is out; reconcile the
-   accounts when they return.
+1. **Select depth.** Apply `reference/depth.md` exactly; never skip. Initial passes
+   record engineering verdict and test-plan coverage. Valid Recovery rechecks
+   retain prior depth; enter 1b.
+1a. **Independent initial pass.** Freeze candidate; dispatch exact fresh read-only
+   plan reviewer, plus developer-experience reviewer for developer surfaces
+   (trigger `devex`) and current strategy reviewer after significant Temper, in
+   parallel under `../devrites-lib/reference/parallel-dispatch.md`: independent
+   read-only passes on one frozen candidate. Missing required account blocks.
+   Meanwhile run root steps 2–4, including step 3 preflight commands, on that
+   candidate; reconcile returned accounts.
 1b. **Recovery recheck.** Require valid return cursor, accepted prior finding,
    exact fingerprint/reproduction, repaired candidate identity, changed
    paths/criteria, affected drift/evidence, and the recorded delta self-check.
@@ -118,14 +118,13 @@ plan declares a root-authored executable workflow file, read
    Do not fall through to steps 2–7. Retain evidenced unchanged coverage; changed
    global contract/uncertain impact requires full applicable review. Reopen historical
    findings only for affected invariants/dependencies.
-2. **Challenge scope.** Apply review-axes §0 and search accepted decisions.
+2. **Challenge scope.** Apply review-axes §0; search accepted decisions.
    Harden to the smallest contract-complete plan, using marked topology action.
    Then verify bidirectional ID-and-meaning traceability across spec/plan/
    tasks/test-plan/traceability, acceptance, terms, principles, anti-slop,
    and conventions; every slice and test-plan row maps to a live requirement
-   and vice versa. Critical gaps and
-   unexcepted principle breaches block; record the challenge result in `eng-review.md`
-   §2 (Scope challenge) after recheck.
+   and vice versa. Critical gaps/unexcepted principle breaches block. Record
+   rechecked result in `eng-review.md` §2 (Scope challenge).
 3. **Preflight Build entry.** Under `reference/artifacts.md`, verify exact
    command/cwd/tool/version/prerequisite; output filters must preserve upstream
    failure. Verify dependencies from authoritative source plus nearest manifest.

package/pack/generated/codex/agents/devrites-upgrade-planner.toml

@@ -37,7 +37,10 @@ rules cannot fail.
 - `repairable`: each defect is neutral, preservation-safe, and owned by Clarify,
   Plan repair, Converge, Vet, Prove, Polish, Review, or Seal.
 - `unsupported`: cursor/topology is unofficial; propose no rewrite.
-- `gap`: evidence/contracts are insufficient. Missing input or unverifiable current rules produce `gap`, never `current` or `repairable`.
+- `gap`: evidence/contracts are insufficient or the required delta has no admitted
+  preservation-safe route. Missing input or unverifiable current rules produce `gap`,
+  never `current` or `repairable`. Required candidate-affecting rollup writes also
+  produce `gap`.
 
 ## Rules
 
@@ -51,9 +54,14 @@ rules cannot fail.
   slices beyond the feature ceiling to Plan course-correct (`MVP cut` + named
   continuation sequence); built slices and their evidence stay.
 - For released post-Build work, route a strict-manifest, evidence/browser-binding, or
-  candidate-check defect to Prove; an old Ship-era candidate rollup to Polish; a
-  review-binding defect to Review; and a seal-binding or Seal-gate defect to Seal.
-  Include only applicable owners, ordered Prove, Polish, Review, Seal. Never infer scope
+  candidate-check defect to Prove; a workspace-only Polish refresh to Polish only
+  within Upgrade's admitted gate artifacts; a review-binding defect to Review; and a
+  seal-binding or Seal-gate defect to Seal. Required candidate-affecting capability-ledger,
+  `DESIGN.md`, or ADR rollups are outside admission: return `gap` with an explicit
+  `$rite-polish` handoff for separate user authorization, no writable paths and no admitted route.
+  Never recommend invoking those writes inside Upgrade. After authorization
+  outside Upgrade, normal affected Prove → Review → Seal applies.
+  Include only applicable admitted owners, ordered Prove, Polish, Review, Seal. Never infer scope
   or treat an old pass as current proof. A Prove repair is admissible only when legacy
   scope inputs are present and agree unambiguously; ambiguous candidate scope produces
   `gap` with no route.

package/pack/generated/codex/skills/devrites-debug-recovery/SKILL.md

@@ -53,6 +53,21 @@ has no clear next move. Optional slug selects the active workspace; defaults to
    gone, hypothesis recorded. Classify the failure.
    See [cleanup-and-classify.md](reference/cleanup-and-classify.md).
 
+## Caller-owned records and routing
+
+The controlling root accepts and persists all recovery records in `decisions.md`,
+`evidence.md`, and `## Dead ends` before the next admission/attempt. This rule governs
+all loaded recovery steps, including cleanup and regression instructions. A leaf
+returns the complete class/rationale, proposed routing, hypothesis/probe, baseline,
+exact failure/evidence, causal fingerprint, attempt number and failed idea/dead ends,
+and human predicate in its existing result fields (`gates`, `dead_ends`,
+`follow_ups`, or `Escalation` as applicable); no new result schema is required.
+A leaf never writes `.devrites/**`, changes phase, invokes agents, or commits through
+recovery. Only the controlling root routes to owning rites and supplies later attempts
+with accepted records. Product/test edits remain inside the caller's exact allowed
+paths; recovery never widens them. Commit/PR wording is a returned proposal for the
+authorized owner, not authority to commit.
+
 ## Hard rules
 
 - Quote exact signal-bearing error text with typed redactions (not paraphrase); apply
@@ -79,8 +94,9 @@ has no clear next move. Optional slug selects the active workspace; defaults to
 <!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"durable active failure or ambiguous admitted state","action":"OFFLINE_RECOVERY; correct offline, re-preflight, narrow Vet, retry only under cap","return":"saved caller or exact Plan/Vet route"} -->
 - **Classify before routing** with
   [cleanup-and-classify.md](reference/cleanup-and-classify.md).
-- **Durably record class and rationale** in `decisions.md` and the applicable
-  `evidence.md` or `## Dead ends` entry.
+- **Durably record class and rationale** through [Caller-owned records and routing](#caller-owned-records-and-routing):
+  root persists `decisions.md` and the applicable `evidence.md` or `## Dead ends`
+  entry; leaves return the full payload for root acceptance.
 - **One causal fingerprint, counted by the caller.** Normalize the root cause as
   `<affected boundary>: <failed invariant/failure mechanism>` and bind its minimal
   reproduction plus decisive signal rather than hashing symptom text.
@@ -98,5 +114,6 @@ has no clear next move. Optional slug selects the active workspace; defaults to
   human-only access becomes a human gate; otherwise return the spent strategy and
   reproduction to the caller, which escalates or parks per the
   [retry contract](../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve);
-  never request attempt four of the same strategy. While budget remains, coupled failure requiring behavior change routes
-  `$rite-plan repair` inline; behavior-neutral rerouting uses `unblock` inline.
+  never request attempt four of the same strategy. While budget remains, the controlling
+  root routes coupled failure requiring behavior change to `$rite-plan repair` inline;
+  behavior-neutral rerouting uses `unblock` inline. Leaves return proposed routes only.

package/pack/generated/codex/skills/devrites-debug-recovery/reference/cleanup-and-classify.md

@@ -1,5 +1,10 @@
 # Cleanup + classify
 
+All recording and routing below follows
+[`SKILL.md` § Caller-owned records and routing](../SKILL.md#caller-owned-records-and-routing):
+root accepts/persists the full payload and owns transitions; leaves return proposals
+and evidence only, never workspace writes, agent launches, or commits.
+
 ## Classify one causal fingerprint
 
 Fingerprint the diagnosis, not its symptom. Reuse it until evidence disproves it; then
@@ -19,8 +24,9 @@ required before the next consumptive execution pause. Fresh authorization never
 pauses offline diagnosis or correction from retained evidence; never ask for a
 blind retry.
 
-Record class/routing in `decisions.md` and each failed attempt in `evidence.md`
-or `## Dead ends`. Apply the causal-fingerprint and three-attempt rules in
+Root records class/routing in `decisions.md` and each failed attempt in `evidence.md`
+or `## Dead ends`; leaves return the complete record for root acceptance/persistence
+before the next admission. Apply the causal-fingerprint and three-attempt rules in
 [`SKILL.md`](../SKILL.md) Hard rules; record baseline, exact failure,
 hypothesis/probe, attempt number, and any human predicate.
 
@@ -31,4 +37,5 @@ hypothesis/probe, attempt number, and any human predicate.
 - [ ] Regression test passes (or absence of seam is documented).
 - [ ] All `[DEBUG-...]` instrumentation removed (`grep` the prefix).
 - [ ] Throwaway harnesses deleted (or moved to a clearly marked debug location).
-- [ ] The correct hypothesis is stated in `evidence.md` + the commit/PR message: next debugger learns.
+- [ ] Root persists the correct hypothesis in `evidence.md`; leaves return it plus
+      proposed commit/PR wording for the authorized owner, without committing.

package/pack/generated/codex/skills/devrites-debug-recovery/reference/regression-test.md

@@ -10,10 +10,13 @@ confidence.
 
 ## No correct seam? That itself is the finding
 
-Note it in `evidence.md` and append a follow-up in the active feature's
-`decisions.md` (or run `$rite-plan repair` if the spec is affected): the
-codebase architecture is preventing this class of failure from being locked
-down. Frame it as a *deepening opportunity* ("this module needs a seam at <X>
+Follow [`SKILL.md` § Caller-owned records and routing](../SKILL.md#caller-owned-records-and-routing):
+root notes it in `evidence.md` and appends a follow-up in the active feature's
+`decisions.md` (or routes `$rite-plan repair` if the spec is affected). A leaf
+returns the complete finding, evidence, and proposed route for root acceptance and
+persistence; it never writes the workspace or invokes the rite. The codebase
+architecture is preventing this class of failure from being locked down. Frame it as
+a *deepening opportunity* ("this module needs a seam at <X>
 so this failure can be regression-tested") so the next `$rite-plan` repair or
 architecture cleanup pass has a concrete target.
 

package/pack/generated/codex/skills/devrites-lib/reference/reply-contract.md

@@ -1,8 +1,7 @@
 # DevRites completion reply contract
 
-Use the host's normal response. Do not run a progress renderer, emit session
-telemetry, assign a health score, or repeat state already visible in the durable
-artifact.
+Use normal host responses. No progress renderer, session telemetry, health score,
+or repetition of durable artifact state.
 
 Keep the reply compact and evidence-backed:
 
@@ -21,16 +20,17 @@ Next: <one recommended action>
 Record: <primary durable artifact path>
 ```
 
-`Changed:` is the complete write set, not a highlight reel: every file written
-or edited this turn — workspace artifact and project source alike — appears
-there or inside one named grouped entry, so a reviewer can `git diff` exactly
-those paths. `Record:` then names the single durable artifact a later session
-reads first.
+`Changed:` lists every file written/edited this turn (workspace and source),
+individually or in one named group, so reviewers can `git diff` those paths.
+`Record:` names the single durable artifact the next session reads first.
 
-Mid-flight replies — the turns between completion states — obey the same economy:
+Active `$rite-autocomplete` consumes green checkpoints/`next_action` internally.
+Continue execution or tool progress; never end with a text-only final reply between green phases.
 
-- **Restate position.** The reader cannot hold "step 3 of 5" between turns; name it
-  (`step N of M` / `state: <where things stand>`) rather than asking them to remember.
+Standalone HITL mid-flight replies follow the same economy:
+
+- **Restate position** (`step N of M` / `state: <where things stand>`); do not rely
+  on the reader remembering it between turns.
 - **One next action, doable now.** `Next:` names one concrete action completable in
   under two minutes — a command, a file to open, a yes/no decision. "Want me to
   continue?" is a stall, not an action.

package/pack/generated/codex/skills/devrites-lib/reference/standards/afk-hitl.md

@@ -4,11 +4,8 @@
 
 > Applies when: any rite/devrites skill that can pause for a human or run unattended; irreversible-risk list, budgets, recovery accounting.
 
-Defines two modes for `rite-*`/`devrites-*` skills that may pause; main
-callers are `$rite-build`, `$rite-status`, `$rite-resolve`, and
-`devrites-doubt`.
-
-The contract uses one sentinel, one queue, and one resume verb.
+Two pause modes for `rite-*`/`devrites-*`, chiefly `$rite-build`, `$rite-status`,
+`$rite-resolve`, `devrites-doubt`: one sentinel, queue, resume verb.
 
 ## Contents
 
@@ -46,15 +43,15 @@ The contract uses one sentinel, one queue, and one resume verb.
   ceiling (and every irreversible-risk item) pause and queue a `questions.md` entry for
   `$rite-resolve`.
 
-`.devrites/AFK` presence is authoritative for run mode; gate-deciding skills re-read
-it at decision time. There is no `state.md` run-mode field to drift out of sync.
+`.devrites/AFK` presence owns run mode; gate-deciding skills re-read it at decision
+time. No `state.md` run-mode field can drift out of sync.
 
 ## The sentinel: `.devrites/AFK`
 
 Presence = AFK active. The file body is optional YAML:
 
 ```yaml
-max_slices: 10                       # whole-workspace writer budget; seeds state.md remaining count
+max_slices: 10 # whole-workspace writer budget; seeds state.md remaining count
 max_agents: 32                       # native agent dispatches in one host activation
 max_minutes: 120                     # min; $rite-autocomplete: not a ceiling
 max_review_queue: 8                  # unresolved review/gate items admitted before fan-out stops
@@ -64,55 +61,52 @@ notify: 'curl -fsS -m 10 -d "$DEVRITES_QID: $DEVRITES_QUESTION" ntfy.sh/my-topic
 allow_gates: [advisory, validating]  # gate severities AFK auto-handles (auto-picks the recommended option)
 continue_sequence: true              # after Seal GO, open the next recorded continuation
 max_workspaces: 5                    # workspaces one armed sequence may open
-max_parallel: 10                     # unattended default cap; `--parallel N` on this invocation wins and may rewrite only this field
+max_parallel: 10 # unattended default cap; `--parallel N` on this invocation wins and may rewrite only this field
 ```
 
-The file is **read-only config**: never rewritten in place, except `$rite-autocomplete --parallel N` writes or replaces only `max_parallel: N`. `max_slices` is the initial
-budget; the mutable remaining count is the `state.md` cursor
-`afk_slices_remaining` (`AFK slices remaining: <n>` in the released bullet
-form), owned by the controlling root. Recognize either spelling and preserve
-the existing table or bullet presentation. Before dispatch, a configured
-`max_slices` and any existing remaining value must be decimal nonnegative
-integers; malformed or negative values fail closed. The pending → built state transition spends
+The file is **read-only config**: never rewritten in place, except `$rite-autocomplete --parallel N` writes or replaces only `max_parallel: N`.
+
+Outside active `$rite-autocomplete`, the following slice-budget rules apply:
+`max_slices` seeds root-owned `state.md` cursor `afk_slices_remaining`
+(released bullet alias: `AFK slices remaining: <n>`). Accept either spelling;
+preserve table/bullet presentation. Before dispatch, require configured
+`max_slices` and existing remaining values to be decimal nonnegative integers;
+malformed or negative values fail closed. The pending → built state transition spends
 exactly one slice: on the first green slice write `max_slices - 1`, otherwise
 write `remaining - 1`, never below zero. Re-reading an already built slice does
 not spend again. At zero, stop before the next dispatch.
 
-An orchestrator that can derive a stricter budget only after planning may pre-seed
-`afk_slices_remaining` in `state.md` before the first dispatch instead of rewriting the
-sentinel. It uses the minimum of pending work and every configured/explicit cap. An
-existing counter may be lowered but never increased or reinitialized. Once present, that state
-counter is the effective remaining budget even when the read-only sentinel omits
-`max_slices`.
+A stricter post-planning budget may pre-seed `afk_slices_remaining` before first
+dispatch, not rewrite the sentinel: use the minimum of pending work and all
+configured/explicit caps. An existing counter may be lowered but never increased or reinitialized.
+It remains effective even if the sentinel omits `max_slices`. Under active `$rite-autocomplete`, skip these slice-cap checks,
+charges, zero stops, and minimum-cap seeding; use its
+[post-Vet budget](../../../rite-autocomplete/reference/loop.md#derive-the-mutable-post-vet-budget).
 
 ### Sequence continuation (`continue_sequence`, `max_workspaces`)
 
-`continue_sequence: true` lets one armed run open the next **recorded** continuation
-after a `Seal GO` instead of stopping. Under `$rite-autocomplete`, absent means on, even
-in an existing sentinel; `false` opts out. `max_workspaces` (default 5) is the
-sequence budget (nonnegative decimal, fail closed): spend one when a new workspace is
-opened, never when resuming the current one. `max_slices` stays **per workspace** —
-each new workspace's `state.md` seeds its own `afk_slices_remaining`.
+`continue_sequence: true` opens the next **recorded** continuation after Seal GO.
+Under `$rite-autocomplete`, absent means on, even in existing sentinels; `false` opts out.
+`max_workspaces` (default 5): nonnegative decimal sequence budget, fail closed;
+charge new workspaces only, never resumes. `max_slices`/`afk_slices_remaining` stay **per workspace** outside active
+`$rite-autocomplete`, which uses its post-Vet pending count.
 
 The chain lives in root-owned `state.md` cursor fields, not in chat:
 `sequence_parent` (the immediately preceding workspace slug), `sequence_position`
 (1-based ordinal), `sequence_workspaces_remaining` (slots the chain may still
 open after this workspace), and — on the release milestone only —
-`sequence_role: release`. Seeding is exactly-once because the values are
-derived, not remembered: a continuation's fields are computed from its recorded
-parent and the parent's counter at creation, and a resumed run that finds a
-continuation workspace missing the fields re-derives the same values from its
-`brief.md` parent/position plus the parent's counter — never a second charge. A
-workspace without a recorded parent/position is not a sequence member; the
-counter only decreases, malformed values fail closed, and `0` opens nothing.
+`sequence_role: release`. Seed exactly once from the recorded parent and its counter at creation.
+On resume, re-derive missing continuation fields from its `brief.md` parent/position
+and parent counter — same values, never a second charge. No recorded parent/position means no sequence membership. Counter only decreases;
+malformed values fail closed; `0` opens nothing.
 `sequence_role: release` makes `check candidate` and `check seal` require the
 candidate manifest to cover the whole recorded chain — run
 `devrites-engine state merge-manifest <slug>` before Prove.
 
 - Only continuations recorded in the parent's `decisions.md` sequence
   ([slicing.md § Continuation workspaces](../../../rite-plan/reference/slicing.md#continuation-workspaces))
-  qualify; no recorded next entry, or the cap/review-queue bound reached, stops
-  with the winning reason.
+  qualify; no next entry or exhausted `max_workspaces` stops with that reason. The review-queue bound applies only outside active
+  `$rite-autocomplete`.
 - Milestones are **not** shipped: they stay sealed and unarchived in `.devrites/work/`
   with `Next step: $rite-ship` preserved. Local `WIP(<slug>):` checkpoints still
   land ([checkpoint.md](../../../rite-build/reference/checkpoint.md)), so the tree
@@ -120,8 +114,9 @@ candidate manifest to cover the whole recorded chain — run
 - Git stays human-gated. The release ship is one disclosed plan, one literal `GO`, and
   one native approval; it collapses the sequence's `WIP` commits into the single
   release commit and may archive the sealed predecessors.
-- Every human-owned, safety, access, exhaustion, and `NO-GO` condition still stops the
-  run exactly as without this field.
+- Human-owned, safety, access, and exhaustion stops remain. Active
+  `$rite-autocomplete` recovers agent-owned Seal `NO-GO` per
+  [stop-conditions.md](../../../rite-autocomplete/reference/stop-conditions.md), not a handoff.
 
 `max_parallel` is the unattended default batch cap only when this invocation does
 not contain `--parallel N`; `1` forces the serial cycle only in that default
@@ -145,28 +140,30 @@ Existing sentinels that declare writer admission but miss/malform these fail clo
 state-owned slice counter. A leftover `expires_at` is ignored and never rewritten.
 Read-only watchers use equivalent native caps from [`loop-operations.md`](loop-operations.md).
 
+Outside active `$rite-autocomplete`, the following dispatch/queue limits apply:
 `max_agents` counts every leaf in the native activation, including failures and
 parallel branches; do not add dispatch telemetry to `.devrites/`. `max_review_queue`
 counts open validating questions plus unresolved admitted Critical/Important findings.
-Above it stop; at it run only reconciliation that reduces the queue. Optional
-`max_tokens`/`max_cost_usd` lower enforceable native caps; if declared but unobservable, stop.
+Above it stop; at it run only reconciliation that reduces the queue.
+
+Optional `max_tokens`/`max_cost_usd` lower native caps in all unattended modes; if declared but unobservable, stop.
 `$rite-autocomplete` deliberately ignores `max_slices`, `max_agents`, `max_minutes` and
 `max_review_queue` ([stop-conditions.md](../../../rite-autocomplete/reference/stop-conditions.md));
-there they are not a ceiling.
+not ceilings there.
 
 Numeric limits are nonnegative decimals. Before costly checks, fan-out, or writing,
-run cheap readiness, reject overlap, count queue, and confirm agent/time/token/cost
-headroom; re-check after every result. Never start one call that can exceed remaining
-headroom. Agent/time/token/cost counters are per native activation and start fresh only
-for a genuinely new activation. Slices, recovery attempts, and current
-review queue remain durable/recomputed across wakes. Persist each activation stop and
-checkpoint before notification.
+run cheap readiness and reject overlap. Outside active `$rite-autocomplete`, count
+queue and confirm agent/time headroom; under Autocomplete those ignored limits
+never block admission. In both cases confirm declared token/cost and native safety
+headroom; re-check after every result. Never start a call that can exceed an
+applicable remaining limit. Agent/time/token/cost counters are per native activation and start fresh only
+for a new activation. Slice/recovery state and review queue remain durable/recomputed across wakes.
+Persist stops/checkpoints before notification.
 
-New sentinels write no `expires_at` and no notification/token/cost cap.
-Post-Vet pending count may lower slices. Existing files
-never receive missing defaults implicitly.
+New sentinels omit `expires_at` and notification/token/cost caps. Post-Vet pending
+count may lower standalone slices. Never add missing defaults to existing files.
 
-To leave AFK, delete the file. The next skill invocation reverts to HITL.
+Delete the file to restore HITL on the next invocation.
 
 ## The four gates
 
@@ -223,10 +220,9 @@ keep the **rejected options in `questions.md`**.
 
 ## Decision ownership: search before asking
 
-A gate is human only when its remaining choice is human-owned. First search live code,
-project/decision docs, and authoritative dependency sources; make and record reversible
-implementation/test choices. Ask only about product, scope, acceptance, architecture policy,
-irreversible risk, or human-only access/action.
+First search live code, project/decision docs, and authoritative dependency sources;
+make and record reversible implementation/test choices. Ask only human-owned
+product, scope, acceptance, architecture-policy, irreversible-risk, or access/action choices.
 
 Objective test/build/tool failure runs bounded `devrites-debug-recovery`; fix it, or escalate and
 park it under the [retry contract](#retry-cap-no-progress-loops-and-self-resolve). Never ask

package/pack/generated/codex/skills/devrites-lib/reference/standards/agents.md

@@ -10,7 +10,10 @@ Follow DevRites policy and [`depth profiles`](../orchestration-profiles.md).
 - Root owns scope, questions/decisions/results, `.devrites/**`, phase transitions — not product source/tests; vetted executable workflow artifacts follow [`workflow-artifacts.md`](workflow-artifacts.md).
 - Every named role runs; unavailable → HITL, never skip/substitute.
 <!-- /root-only -->
-- Only bounded wright writes product source/tests; others inspect an immutable candidate.
+- Among lifecycle `devrites-*` specialists, only bounded wright writes product
+  source/tests; others inspect an immutable candidate. The independent `$rite-fast`
+  lane instead uses only its existing `fast-builder` as writer under its own roster;
+  never substitute a lifecycle role. Root remains source/test nonwriter.
 - Leaves never invoke agents, ask humans, change phase, push, install/deploy, migrate live data, or act irreversibly; they return evidence/proposals for root acceptance. Sole exception: one local unpushed transfer commit by an eligible native-worktree `devrites-slice-wright` — transport, not shipping authority or a checkpoint.
 
 <!-- root-only -->
@@ -56,8 +59,15 @@ Workflow-named skills (e.g. devrites-source-driven) are invoked inline in the ro
 
 ## Source-writing boundary
 
+Among lifecycle `devrites-*` specialists only (independent Fast exception below):
 Claude grants only wright `acceptEdits`; Codex root is workspace-capable (children cannot elevate). Wright alone `:workspace`; others `:read-only`. Wright gets the smallest exact project-relative source/test list — no directories/globs, traversal, or `.devrites/**`; no scope widening; root rejects `git diff --name-only` extras. Never patch product source/tests in root, bypass/substitute wright, accept drift, or recreate a dispatch bridge.
 
+Independent Fast exception: `$rite-fast` uses its existing `fast-builder` write-capable
+profile, not a `devrites-*` substitute, under the exact Fast roster and lane contract.
+Only that bounded writer may edit its exact project-relative source/test paths; no
+workspace writes, scope widening, or second writer. Root remains source/test nonwriter.
+This exception grants no additional tools, permissions, phase, agent-launch, or Git authority.
+
 Isolated-worktree pilot only under [`wright-dispatch.md`](../../../rite-build/reference/wright-dispatch.md#isolated-writer-worktree-pilot): one writer, committed/clean baseline, non-submodule parent, exact transfer commit, candidate reconciliation — never parallel writers nor weaker exact-path admission. Root may materialize only exact Vet-ready workflow-artifact paths per [`workflow-artifacts.md`](workflow-artifacts.md) — not a writer dispatch or candidate mutation.
 
 Each job gets objective/exclusions, exact paths/immutable candidate, rubric/result shape, a **stop condition** (when to return), and the exact result shape; a dispatch missing them is malformed and re-issued. Briefs MUST NOT seed verdict/severity cap/conclusion/suppression. Results state status/scope, outcome, commands/escalation; wright adds paths, changed files, gates, stood decisions; results never widen scope.