devrites 7.2.6 → 7.2.7

package/pack/.claude/skills/rite-autocomplete/reference/stop-conditions.md

@@ -59,14 +59,13 @@ Without a safe seam, escalate or park; only a real human/risk/scope gate stops f
 ## Other stop classes
 
 - **Gate severity:** escalating always stops. Blocking with a ranked recommended
-  option (`proposed` or option 1 labelled Recommended): auto-pick via
-  `devrites-engine state resolve`, then continue internally (including Spec Drift
-  Guard when the answer changes ownership or acceptance). Exception: a question whose answer
-  would add acceptance or product scope is never auto-picked, even with a
-  recommended option; it stops for a human. Blocking with no
-  recommended option still stops. Validating: auto-pick the recommended option,
-  close the question, continue — except Seal's judgment-only acceptance question
-  (`slice: seal`), which only a human answers; it stops.
+  option (`proposed` or option 1 labelled Recommended) auto-picks via
+  `devrites-engine state resolve` and continues, Spec Drift Guard included when
+  the answer changes ownership or acceptance. Added acceptance or scope is never
+  auto-picked. No recommended option still stops. An avoidable principle conflict
+  complies: change the spec and resolve it. Re-read on entry. `continuation: clear`
+  with `awaiting_human` still folds resolved decisions. Do not report a stop from chat.
+  Validating auto-picks, except Seal `slice: seal`, which a human answers.
 - **Temper:** `expand` and extra acceptance stop: ask through `AskUserQuestion`, hold the
   fold, and continue only after a human resolves the qid (an ADR is not that answer).
   Irreversible-risk still pauses. `hold-rigor`, `reduce-to-MVP`, and a skip do not pause.

package/pack/.claude/skills/rite-build/reference/parallel-batch.md

@@ -27,16 +27,21 @@ N_eff = min(
   cap                  -- this invocation's --parallel N (wins over leftover sentinel max_parallel)
                        | else sentinel max_parallel | else 10 (autocomplete default)
   eligible set         -- dependency-satisfied pending slices, pairwise path-disjoint
-  AFK headroom         -- remaining max_slices, max_agents, max_minutes, review queue
+  AFK headroom         -- outside /rite-autocomplete only (max_slices, max_agents,
+                          max_minutes, review queue). Autocomplete ignores those;
+                          do not shrink this batch for them
   host capacity        -- concurrent worktree writers + the runtime isolation table
 )
 ```
 
 Select **greedily in plan order** with
 `devrites-engine parallel select --slug <slug> --cap N --from-plan`: ready set
-(dependencies `built`, minus running-lease slices), Writer allowlist
+(dependencies built — state.md checkbox, or an evidence.md heading that says that slice was checkpointed plus a `Checkpoint: <sha>` line — minus running-lease slices), Writer allowlist
 (else Files likely touched), plus manifest/lockfile when `External dependencies:`
-names a package (`none*`, existing, or no-new prose without a coordinate);
+names a package (module path, npm scope, backticked name, or a non-toolchain version).
+`context --phase build` with no `--slice` stays on `active_slice` unless AFK
+`max_parallel` is at least 2 or a lease is running; a HITL `--parallel N` run
+passes `--whole` so the other slices stay visible.
 `next` prints `eligible_now:`/`batch:`. `n_eff` counts new picks only.
 With a running lease, a single new pick still uses `parallel add`;
 `n_eff=0` with a running lease waits for siblings, not Prove. Without one:
@@ -76,10 +81,11 @@ snapshot directory, formatter sweep — and compare paths case-folded
 (`src/Api.ts` = `src/api.ts`); `--from-plan` adds the manifest/lockfile for a package.
 Slices colliding on either run serially; the rest
 stay eligible. Record `serial: <ids> — <surface>` in `evidence.md`. Under AFK
-with `max_parallel ≥ 2`, `dispatch open` refuses a first-round build wright wave
-narrower than the from-plan batch (printing batch and command) until the wave
-holds that batch or `serial:` names every skipped pick; repair rounds, lease
-siblings, and HITL runs are never refused. **Failing
+with `max_parallel ≥ 2`, `dispatch open` refuses a build wright wave narrower
+than the from-plan batch until that wave holds the other picks or `serial:`
+names each skipped one. Repairing a slice, or a slice already in the lease,
+does not waive them. A `serial:` reason that only says the skipped slice is
+repairing, already started, or in a wave does not count. HITL is never refused. **Failing
 case:** two slices each add a dependency, run in parallel, and integrate fails or
 lands a broken lockfile.
 
@@ -106,8 +112,11 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
    `pre-dispatch <id>` preflight row; a malformed contract or non-zero
    precondition is dropped from the batch and recorded as a gap, not dispatched.
 2. Write lease; freeze `B=HEAD`; `parallel create` worktrees.
-3. Dispatch ≤10 wrights in parallel (cwd=worktree; allowlist; prove `HEAD==B`;
-   one `--slice` per sibling on the wave). A linked worktree has no `.devrites`:
+3. Dispatch ≤10 wrights in parallel (cwd=worktree; allowlist; prove `HEAD==B`).
+   One wave, one role per sibling: `--role slice-wright.<SLICE-ID> --slice <SLICE-ID>`
+   for each. `start` every role before waiting on any. One shared `slice-wright`
+   role is refused: it has one handle, so the other slices never start.
+   A linked worktree has no `.devrites`:
    tell each wright to run `gates precheck` with `DEVRITES_ROOT=<control>/.devrites`.
 4. Inspect each returned path list, cumulative diff from `B`, transfer identity,
    and required result fields against the immutable contract. Reject malformed,
@@ -122,10 +131,11 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
    A recheck round is one dispatch per changed surface, not one per checklist: the
    recheck agent carries every open checklist (code, test, doubt) for that diff and
    answers each by name. Merging cuts dispatches; dropping a checklist does not.
-   Reviewer fan-out for a batch is itself batched under
-   [`parallel-dispatch.md`](../../devrites-lib/reference/parallel-dispatch.md#scale-limits)
-   (≈4 concurrent read-only reviewers, 8 only with disjoint paths), and `max_agents`
-   headroom bounds the batch size — one batch never assumes unbounded reviewers.
+   Reviewer fan-out does not shrink the writer batch. Reviewers queue at the
+   same cap as writers (10; see
+   [`parallel-dispatch.md`](../../devrites-lib/reference/parallel-dispatch.md#scale-limits)).
+   `max_agents` does not shrink it under autocomplete. Past that cap, queue a
+   second pass — a batch never assumes unbounded reviewers.
 5. Non-green siblings → **repair round** (below) in the same worktrees; lease
    stays `running` — no abort while repair budget remains. A green sibling →
    `parallel record-green`, then step 6 for it alone.

package/pack/.claude/skills/rite-build/reference/wright-dispatch.md

@@ -129,11 +129,11 @@ open findings move to the new slice owning their paths), or record
 `## <DRIFT-ID> — <SLICE-ID> reslice review` with why no smaller split exists and
 a spec trace of the slice's obligations (hardening no AC/INV/PROH requires moves to
 a sibling slice dependents do not need, still gated before Seal), and
-reopen with `--reslice-review <DRIFT-ID>`. Use
-at most one writer across all linked worktrees for this workspace. Never run two
-writers in one worktree, run isolated and same-worktree writers concurrently, or
-substitute a generic agent. Opt-in `/rite-build --parallel N` fans out only under
-[`parallel-batch.md`](parallel-batch.md).
+reopen with `--reslice-review <DRIFT-ID>`. Same-worktree stays one writer.
+Never run two writers in one worktree, mix isolated and same-worktree writers,
+or substitute a generic agent. Opt-in `/rite-build --parallel N` is the
+exception: one wright per worktree, each its own `slice-wright.<SLICE-ID>` role
+on one wave ([`parallel-batch.md`](parallel-batch.md)).
 
 The `return` that completes the wave releases its claim; `dispatch abandon --release`
 releases it on any other host-confirmed terminal path (a stop, a launch refused with no

package/pack/.claude/skills/rite-spec/SKILL.md

@@ -117,8 +117,8 @@ load a routed standard to discover required behavior, not to prescribe implement
    and [`interview-patterns.md`](reference/interview-patterns.md) for a vague ask. Every
    material dimension is resolved by a human pick or explicitly deferred as non-blocking;
    only genuinely reversible, low-impact details go to `assumptions.md`. A paper-only
-   uncertainty may take one scoped `/rite-prototype` detour. A declared-principle conflict
-   remains blocking until the human approves a recorded, scoped exception.
+   uncertainty may take one scoped `/rite-prototype` detour. A principle conflict
+   complies by changing the spec. Only an unavoidable violation blocks for a human.
 4a. **Build-interruption forecast.** Search first, then list and close foreseeable human needs:
    product/acceptance ambiguity, irreversible/external approval, or human-only access. Record
    owned prerequisites. Keep a build checkpoint only for unavailable pre-code evidence or a

package/pack/.claude/skills/rite-temper/SKILL.md

@@ -123,12 +123,11 @@ the spec applicability map triggers that risk family.
    [`devrites-strategy-reviewer`](../../agents/devrites-strategy-reviewer.md)
    through the native fresh-context contract in
    [`agents.md`](../devrites-lib/reference/standards/agents.md), with **only** its `--role strategy-reviewer` read-set
-   (hardened spec, `strategy.md`, claim-check artifacts) + rubric, no authoring reasoning. Fold technical findings into one correction;
-   exact strategy reviewer rechecks open findings and affected coverage/regressions under
+   (hardened spec, `strategy.md`, claim-check artifacts) + rubric, no authoring reasoning. Fold findings once and recheck them under
    [the canonical retry contract](../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve):
-   Product/scope choices and unapproved irreversible risk remain human gates;
-   technical exhaustion preserves blocker/reproduction.
-   If the named agent is unavailable, stop for HITL. After an accepted edit to a
+   Product/scope and unapproved irreversible risk stay human gates;
+   exhaustion keeps the blocker.
+   If the named agent is unavailable, stop for HITL. Except `sequence_lookahead: yes` and no spawn tool: record the review pending, stay `running`, continue Define. Not access. After an accepted edit to a
    coverage-bound input, repeat step 6's native coverage revalidation before handoff.
 8. **STOP.** Report the mode, the scope deltas, and the floor verdict; recommend `/rite-define`.
 

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

@@ -169,9 +169,9 @@ named in the re-dispatch contract; changes outside task paths stop for the human
 
 ## Scale limits
 
-The role table bounds rosters. Use roughly four concurrent read-only reviewers,
-counting children any leaf spawned; eight only with disjoint paths/resources.
-Refuse unbounded swarms and role substitution: sharpen scope or use a bounded second pass when coverage is missing.
+The role table bounds rosters. Use up to ten concurrent read-only reviewers,
+the same cap as a writer batch, counting children any leaf spawned.
+Refuse a larger swarm and role substitution: sharpen scope or use a bounded second pass when coverage is missing.
 Overlapping reviewers increase duplicate findings and reconciliation work.
 
 ## Children are tools, not peers

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

@@ -8,7 +8,7 @@ Follow DevRites policy and [`depth profiles`](../orchestration-profiles.md).
 
 <!-- root-only -->
 - 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.
+- Every named role runs; unavailable → HITL, never skip/substitute. `sequence_lookahead: yes` with no spawn tool defers the role, records the gap, and keeps planning. Not gate `access`, not a verdict. Admit the role before Build.
 <!-- /root-only -->
 - Among lifecycle `devrites-*` specialists, only bounded wright writes product
   source/tests; others inspect an immutable candidate. The independent `/rite-fast`
@@ -145,11 +145,8 @@ Basis: <files read · commands run to reach this finding>
   asks for is a Suggestion, however plausible. The `when` must also be reachable:
   a hostile actor enters only through a trust boundary the feature really has
   (users, network, external systems, untrusted files). A trigger that needs one it
-  never faces — the code under test forging its own evidence, a tampering second
-  user on a single-owner dev host, a swapped remote daemon under a local dev tool —
-  is a Suggestion too. So is an environment state the feature's declared
-  environment does not have (a mount option, kernel setting or daemon location
-  absent from the target host): guard against it only when the spec names it.
+  never faces — forged test evidence, a second user on a single-owner host, or a swapped local daemon —
+  is a Suggestion too. So is an undeclared host setting (mount, kernel, daemon path): guard it only when the spec names it.
   A finding never pulls a deferred slice's scope forward.
 - **`no-findings`:** `No-findings:` names checks and inspected evidence. Bare
   pass, empty list, or “looks good” is malformed.

package/pack/generated/claude/skills/devrites-lib/reference/standards/principles.md

@@ -47,10 +47,9 @@ unaudited.
 
 ## Gate
 
-At plan, build, review, and seal, compare the proposed or actual change with each
-in-scope principle. An unexcepted violation is a Critical finding and blocks the
-phase. A missing or empty principles file passes silently.
+At plan, build, review, and seal, compare the change with each in-scope principle.
+An unexcepted violation is Critical and blocks. A missing or empty file passes.
 
-Adding, changing, retiring, or excepting a principle is a deliberate human-owned
-decision recorded in the file's governance history. Agents may propose wording;
-they do not ratify it.
+Adding, changing, retiring, or excepting a principle is human-owned. Date it in
+the governance history. Agents do not ratify it. Comply by changing the spec.
+Ask for an exception only when the objective cannot be met without the violation.

package/pack/generated/claude/skills/rite-autocomplete/reference/decision-policy.md

@@ -41,4 +41,6 @@ recommended option stay human. A blocking question that already names option 1
 `(Recommended)` or `proposed:` is autocomplete's to resolve: pick that option
 via `devrites-engine state resolve` and continue. Recommended temper
 `expand` and extra acceptance are never auto-picked: they stop for a human through
-`AskUserQuestion`; do not invent product intent.
+`AskUserQuestion`; do not invent product intent. A principle
+conflict complies by changing the spec. Except a principle when the
+objective cannot be met without the violation.

package/pack/generated/claude/skills/rite-autocomplete/reference/lookahead.md

@@ -2,49 +2,32 @@
 
 > Root-only: not inlined in --role bundles.
 
-A second session plans the next sequence continuation while the active
-workspace builds, so the child's Spec → Vet overlaps its predecessor's
-Build → Seal. The main loop later resumes the planned child instead of
-specifying it again.
+Plans the next continuation while the active workspace builds. Spec → Vet
+overlaps the predecessor's Build → Seal.
 
 ## Start and target
 
-The operator starts the second host session with `/rite-autocomplete
---lookahead` once the `.devrites/ACTIVE` workspace is in Build or later. The
-agent never launches a session itself. The target is the next recorded
-continuation after the active workspace: the entry
-[sequence continuation](loop.md#sequence-continuation) would open. Stop with
-nothing to do when the active workspace is before Build, no entry remains,
-`continue_sequence: false`, or the sequence budget is spent.
+Start `/rite-autocomplete --lookahead` once `.devrites/ACTIVE` is in Build or later. The agent never launches a session. Target: the next continuation
+([sequence continuation](loop.md#sequence-continuation)). Stop when that workspace
+is before Build, no entry remains, `continue_sequence: false`, or the budget is spent.
 
 ## Lease
 
-Before any write, take the workspace lease:
+Before any write:
 `devrites-engine claim add --session lookahead-<target> --ttl 240 --workspace <target> --reason lookahead`.
-Exit 3 means another session holds the target: stop. Re-add the lease with the
-same session at each phase start, and release it with `devrites-engine claim
-release` on every stop. A crashed session's lease reads `dead` and frees itself.
+Exit 3: held, stop. Re-add the same session each phase. Release with `devrites-engine claim release` on stop. A `dead` lease frees itself.
 
 ## Rules
 
-- Never read or write `.devrites/ACTIVE`. Pass the target slug explicitly to every
-  skill and engine command, including `/rite-spec <target> "<objective>"` and
-  `devrites-engine handoff <target> --resume`.
+- Never read or write `.devrites/ACTIVE`. Pass the slug to `/rite-spec <target> "<objective>"` and `devrites-engine handoff <target> --resume`.
 - After the workspace exists, run `devrites-engine state set <target> sequence_lookahead=yes`.
-- Run Spec → Clarify → Temper → Define → Plan → Vet as the main loop does.
-  Define and Plan read the predecessor's current tree and plan. Record an
-  assumption for each predecessor interface the plan relies on.
-- At Vet, beside the readiness binding, record exactly one line
-  `Predecessor readiness: <active-slug> <digest>` in `eng-review.md`. `<digest>`
-  is the hex that `devrites-engine check readiness --emit-binding <active-slug>`
-  prints. When the predecessor later changes its planning inputs, the child's
-  readiness check blocks with `DRV-GATE-READINESS-STALE` and the main loop
-  re-vets the child before Build.
-- Never Build, never write product source or tests, never commit, and never
-  arm or rewrite `.devrites/AFK`. Owner questions go to the target's
-  `questions.md` and stop the lookahead.
-- Stop at Vet `READY` with `next_action: build after predecessor Seal GO`, at a
-  human gate, or when the target's lease is lost.
-
-**Failing case:** the lookahead passes Vet and starts Build while the
-predecessor is still sealing, so two root sessions write one tree.
+- Run Spec → Clarify → Temper → Define → Plan → Vet. Define and Plan read the predecessor tree and plan. Record one assumption per predecessor interface used.
+- At Vet record `Predecessor readiness: <active-slug> <digest>` in `eng-review.md` (the `--emit-binding` hex). A later planning change blocks `DRV-GATE-READINESS-STALE`; re-vet before Build.
+- Predecessor still in Build or later forbids only Build, product source, tests, commits, and `.devrites/AFK`. It does not skip Define, Plan, or Vet, and is not `awaiting_human`. Acceptance, scope, and irreversible risk still stop.
+- No spawn tool is not gate `access` or `awaiting_human`. Root writes Define and Plan. No Vet `READY` until those roles are admitted; else stop `running`, `next_action: /rite-vet`.
+- On every entry, re-read `state.md` and `questions.md`. Do not report a stop from chat. `continuation: clear` with `awaiting_human` is not done: fold resolved decisions into the spec, then continue. An except-principle or change-the-spec question complies: change the spec and resolve it. Ask only when the approved objective cannot comply.
+- Stop at Vet `READY` with `next_action: build after predecessor Seal GO`, at a real human gate, or when the lease is lost.
+
+**Failing case:** Vet then Build while the predecessor is still sealing, so two sessions write one tree. Or Define, Plan, and Vet skipped because the predecessor is still Build, or a missing strategy-reviewer spawn recorded as gate `access`.
+
+**Failing case:** stops to except a principle the spec can avoid.

package/pack/generated/claude/skills/rite-autocomplete/reference/stop-conditions.md

@@ -61,14 +61,13 @@ Without a safe seam, escalate or park; only a real human/risk/scope gate stops f
 ## Other stop classes
 
 - **Gate severity:** escalating always stops. Blocking with a ranked recommended
-  option (`proposed` or option 1 labelled Recommended): auto-pick via
-  `devrites-engine state resolve`, then continue internally (including Spec Drift
-  Guard when the answer changes ownership or acceptance). Exception: a question whose answer
-  would add acceptance or product scope is never auto-picked, even with a
-  recommended option; it stops for a human. Blocking with no
-  recommended option still stops. Validating: auto-pick the recommended option,
-  close the question, continue — except Seal's judgment-only acceptance question
-  (`slice: seal`), which only a human answers; it stops.
+  option (`proposed` or option 1 labelled Recommended) auto-picks via
+  `devrites-engine state resolve` and continues, Spec Drift Guard included when
+  the answer changes ownership or acceptance. Added acceptance or scope is never
+  auto-picked. No recommended option still stops. An avoidable principle conflict
+  complies: change the spec and resolve it. Re-read on entry. `continuation: clear`
+  with `awaiting_human` still folds resolved decisions. Do not report a stop from chat.
+  Validating auto-picks, except Seal `slice: seal`, which a human answers.
 - **Temper:** `expand` and extra acceptance stop: ask through `AskUserQuestion`, hold the
   fold, and continue only after a human resolves the qid (an ADR is not that answer).
   Irreversible-risk still pauses. `hold-rigor`, `reduce-to-MVP`, and a skip do not pause.

package/pack/generated/claude/skills/rite-build/reference/parallel-batch.md

@@ -27,16 +27,21 @@ N_eff = min(
   cap                  -- this invocation's --parallel N (wins over leftover sentinel max_parallel)
                        | else sentinel max_parallel | else 10 (autocomplete default)
   eligible set         -- dependency-satisfied pending slices, pairwise path-disjoint
-  AFK headroom         -- remaining max_slices, max_agents, max_minutes, review queue
+  AFK headroom         -- outside /rite-autocomplete only (max_slices, max_agents,
+                          max_minutes, review queue). Autocomplete ignores those;
+                          do not shrink this batch for them
   host capacity        -- concurrent worktree writers + the runtime isolation table
 )
 ```
 
 Select **greedily in plan order** with
 `devrites-engine parallel select --slug <slug> --cap N --from-plan`: ready set
-(dependencies `built`, minus running-lease slices), Writer allowlist
+(dependencies built — state.md checkbox, or an evidence.md heading that says that slice was checkpointed plus a `Checkpoint: <sha>` line — minus running-lease slices), Writer allowlist
 (else Files likely touched), plus manifest/lockfile when `External dependencies:`
-names a package (`none*`, existing, or no-new prose without a coordinate);
+names a package (module path, npm scope, backticked name, or a non-toolchain version).
+`context --phase build` with no `--slice` stays on `active_slice` unless AFK
+`max_parallel` is at least 2 or a lease is running; a HITL `--parallel N` run
+passes `--whole` so the other slices stay visible.
 `next` prints `eligible_now:`/`batch:`. `n_eff` counts new picks only.
 With a running lease, a single new pick still uses `parallel add`;
 `n_eff=0` with a running lease waits for siblings, not Prove. Without one:
@@ -76,10 +81,11 @@ snapshot directory, formatter sweep — and compare paths case-folded
 (`src/Api.ts` = `src/api.ts`); `--from-plan` adds the manifest/lockfile for a package.
 Slices colliding on either run serially; the rest
 stay eligible. Record `serial: <ids> — <surface>` in `evidence.md`. Under AFK
-with `max_parallel ≥ 2`, `dispatch open` refuses a first-round build wright wave
-narrower than the from-plan batch (printing batch and command) until the wave
-holds that batch or `serial:` names every skipped pick; repair rounds, lease
-siblings, and HITL runs are never refused. **Failing
+with `max_parallel ≥ 2`, `dispatch open` refuses a build wright wave narrower
+than the from-plan batch until that wave holds the other picks or `serial:`
+names each skipped one. Repairing a slice, or a slice already in the lease,
+does not waive them. A `serial:` reason that only says the skipped slice is
+repairing, already started, or in a wave does not count. HITL is never refused. **Failing
 case:** two slices each add a dependency, run in parallel, and integrate fails or
 lands a broken lockfile.
 
@@ -106,8 +112,11 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
    `pre-dispatch <id>` preflight row; a malformed contract or non-zero
    precondition is dropped from the batch and recorded as a gap, not dispatched.
 2. Write lease; freeze `B=HEAD`; `parallel create` worktrees.
-3. Dispatch ≤10 wrights in parallel (cwd=worktree; allowlist; prove `HEAD==B`;
-   one `--slice` per sibling on the wave). A linked worktree has no `.devrites`:
+3. Dispatch ≤10 wrights in parallel (cwd=worktree; allowlist; prove `HEAD==B`).
+   One wave, one role per sibling: `--role slice-wright.<SLICE-ID> --slice <SLICE-ID>`
+   for each. `start` every role before waiting on any. One shared `slice-wright`
+   role is refused: it has one handle, so the other slices never start.
+   A linked worktree has no `.devrites`:
    tell each wright to run `gates precheck` with `DEVRITES_ROOT=<control>/.devrites`.
 4. Inspect each returned path list, cumulative diff from `B`, transfer identity,
    and required result fields against the immutable contract. Reject malformed,
@@ -122,10 +131,11 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
    A recheck round is one dispatch per changed surface, not one per checklist: the
    recheck agent carries every open checklist (code, test, doubt) for that diff and
    answers each by name. Merging cuts dispatches; dropping a checklist does not.
-   Reviewer fan-out for a batch is itself batched under
-   [`parallel-dispatch.md`](../../devrites-lib/reference/parallel-dispatch.md#scale-limits)
-   (≈4 concurrent read-only reviewers, 8 only with disjoint paths), and `max_agents`
-   headroom bounds the batch size — one batch never assumes unbounded reviewers.
+   Reviewer fan-out does not shrink the writer batch. Reviewers queue at the
+   same cap as writers (10; see
+   [`parallel-dispatch.md`](../../devrites-lib/reference/parallel-dispatch.md#scale-limits)).
+   `max_agents` does not shrink it under autocomplete. Past that cap, queue a
+   second pass — a batch never assumes unbounded reviewers.
 5. Non-green siblings → **repair round** (below) in the same worktrees; lease
    stays `running` — no abort while repair budget remains. A green sibling →
    `parallel record-green`, then step 6 for it alone.

package/pack/generated/claude/skills/rite-build/reference/wright-dispatch.md

@@ -129,11 +129,11 @@ open findings move to the new slice owning their paths), or record
 `## <DRIFT-ID> — <SLICE-ID> reslice review` with why no smaller split exists and
 a spec trace of the slice's obligations (hardening no AC/INV/PROH requires moves to
 a sibling slice dependents do not need, still gated before Seal), and
-reopen with `--reslice-review <DRIFT-ID>`. Use
-at most one writer across all linked worktrees for this workspace. Never run two
-writers in one worktree, run isolated and same-worktree writers concurrently, or
-substitute a generic agent. Opt-in `/rite-build --parallel N` fans out only under
-[`parallel-batch.md`](parallel-batch.md).
+reopen with `--reslice-review <DRIFT-ID>`. Same-worktree stays one writer.
+Never run two writers in one worktree, mix isolated and same-worktree writers,
+or substitute a generic agent. Opt-in `/rite-build --parallel N` is the
+exception: one wright per worktree, each its own `slice-wright.<SLICE-ID>` role
+on one wave ([`parallel-batch.md`](parallel-batch.md)).
 
 The `return` that completes the wave releases its claim; `dispatch abandon --release`
 releases it on any other host-confirmed terminal path (a stop, a launch refused with no

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

@@ -117,8 +117,8 @@ load a routed standard to discover required behavior, not to prescribe implement
    and [`interview-patterns.md`](reference/interview-patterns.md) for a vague ask. Every
    material dimension is resolved by a human pick or explicitly deferred as non-blocking;
    only genuinely reversible, low-impact details go to `assumptions.md`. A paper-only
-   uncertainty may take one scoped `/rite-prototype` detour. A declared-principle conflict
-   remains blocking until the human approves a recorded, scoped exception.
+   uncertainty may take one scoped `/rite-prototype` detour. A principle conflict
+   complies by changing the spec. Only an unavoidable violation blocks for a human.
 4a. **Build-interruption forecast.** Search first, then list and close foreseeable human needs:
    product/acceptance ambiguity, irreversible/external approval, or human-only access. Record
    owned prerequisites. Keep a build checkpoint only for unavailable pre-code evidence or a

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

@@ -123,12 +123,11 @@ the spec applicability map triggers that risk family.
    [`devrites-strategy-reviewer`](../../agents/devrites-strategy-reviewer.md)
    through the native fresh-context contract in
    [`agents.md`](../devrites-lib/reference/standards/agents.md), with **only** its `--role strategy-reviewer` read-set
-   (hardened spec, `strategy.md`, claim-check artifacts) + rubric, no authoring reasoning. Fold technical findings into one correction;
-   exact strategy reviewer rechecks open findings and affected coverage/regressions under
+   (hardened spec, `strategy.md`, claim-check artifacts) + rubric, no authoring reasoning. Fold findings once and recheck them under
    [the canonical retry contract](../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve):
-   Product/scope choices and unapproved irreversible risk remain human gates;
-   technical exhaustion preserves blocker/reproduction.
-   If the named agent is unavailable, stop for HITL. After an accepted edit to a
+   Product/scope and unapproved irreversible risk stay human gates;
+   exhaustion keeps the blocker.
+   If the named agent is unavailable, stop for HITL. Except `sequence_lookahead: yes` and no spawn tool: record the review pending, stay `running`, continue Define. Not access. After an accepted edit to a
    coverage-bound input, repeat step 6's native coverage revalidation before handoff.
 8. **STOP.** Report the mode, the scope deltas, and the floor verdict; recommend `/rite-define`.
 

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

@@ -169,9 +169,9 @@ named in the re-dispatch contract; changes outside task paths stop for the human
 
 ## Scale limits
 
-The role table bounds rosters. Use roughly four concurrent read-only reviewers,
-counting children any leaf spawned; eight only with disjoint paths/resources.
-Refuse unbounded swarms and role substitution: sharpen scope or use a bounded second pass when coverage is missing.
+The role table bounds rosters. Use up to ten concurrent read-only reviewers,
+the same cap as a writer batch, counting children any leaf spawned.
+Refuse a larger swarm and role substitution: sharpen scope or use a bounded second pass when coverage is missing.
 Overlapping reviewers increase duplicate findings and reconciliation work.
 
 ## Children are tools, not peers

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

@@ -8,7 +8,7 @@ Follow DevRites policy and [`depth profiles`](../orchestration-profiles.md).
 
 <!-- root-only -->
 - 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.
+- Every named role runs; unavailable → HITL, never skip/substitute. `sequence_lookahead: yes` with no spawn tool defers the role, records the gap, and keeps planning. Not gate `access`, not a verdict. Admit the role before Build.
 <!-- /root-only -->
 - Among lifecycle `devrites-*` specialists, only bounded wright writes product
   source/tests; others inspect an immutable candidate. The independent `$rite-fast`
@@ -145,11 +145,8 @@ Basis: <files read · commands run to reach this finding>
   asks for is a Suggestion, however plausible. The `when` must also be reachable:
   a hostile actor enters only through a trust boundary the feature really has
   (users, network, external systems, untrusted files). A trigger that needs one it
-  never faces — the code under test forging its own evidence, a tampering second
-  user on a single-owner dev host, a swapped remote daemon under a local dev tool —
-  is a Suggestion too. So is an environment state the feature's declared
-  environment does not have (a mount option, kernel setting or daemon location
-  absent from the target host): guard against it only when the spec names it.
+  never faces — forged test evidence, a second user on a single-owner host, or a swapped local daemon —
+  is a Suggestion too. So is an undeclared host setting (mount, kernel, daemon path): guard it only when the spec names it.
   A finding never pulls a deferred slice's scope forward.
 - **`no-findings`:** `No-findings:` names checks and inspected evidence. Bare
   pass, empty list, or “looks good” is malformed.

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

@@ -47,10 +47,9 @@ unaudited.
 
 ## Gate
 
-At plan, build, review, and seal, compare the proposed or actual change with each
-in-scope principle. An unexcepted violation is a Critical finding and blocks the
-phase. A missing or empty principles file passes silently.
+At plan, build, review, and seal, compare the change with each in-scope principle.
+An unexcepted violation is Critical and blocks. A missing or empty file passes.
 
-Adding, changing, retiring, or excepting a principle is a deliberate human-owned
-decision recorded in the file's governance history. Agents may propose wording;
-they do not ratify it.
+Adding, changing, retiring, or excepting a principle is human-owned. Date it in
+the governance history. Agents do not ratify it. Comply by changing the spec.
+Ask for an exception only when the objective cannot be met without the violation.

package/pack/generated/codex/skills/rite-autocomplete/reference/decision-policy.md

@@ -41,4 +41,6 @@ recommended option stay human. A blocking question that already names option 1
 `(Recommended)` or `proposed:` is autocomplete's to resolve: pick that option
 via `devrites-engine state resolve` and continue. Recommended temper
 `expand` and extra acceptance are never auto-picked: they stop for a human through
-`AskUserQuestion`; do not invent product intent.
+`AskUserQuestion`; do not invent product intent. A principle
+conflict complies by changing the spec. Except a principle when the
+objective cannot be met without the violation.

package/pack/generated/codex/skills/rite-autocomplete/reference/lookahead.md

@@ -2,49 +2,32 @@
 
 > Root-only: not inlined in --role bundles.
 
-A second session plans the next sequence continuation while the active
-workspace builds, so the child's Spec → Vet overlaps its predecessor's
-Build → Seal. The main loop later resumes the planned child instead of
-specifying it again.
+Plans the next continuation while the active workspace builds. Spec → Vet
+overlaps the predecessor's Build → Seal.
 
 ## Start and target
 
-The operator starts the second host session with `$rite-autocomplete
---lookahead` once the `.devrites/ACTIVE` workspace is in Build or later. The
-agent never launches a session itself. The target is the next recorded
-continuation after the active workspace: the entry
-[sequence continuation](loop.md#sequence-continuation) would open. Stop with
-nothing to do when the active workspace is before Build, no entry remains,
-`continue_sequence: false`, or the sequence budget is spent.
+Start `$rite-autocomplete --lookahead` once `.devrites/ACTIVE` is in Build or later. The agent never launches a session. Target: the next continuation
+([sequence continuation](loop.md#sequence-continuation)). Stop when that workspace
+is before Build, no entry remains, `continue_sequence: false`, or the budget is spent.
 
 ## Lease
 
-Before any write, take the workspace lease:
+Before any write:
 `devrites-engine claim add --session lookahead-<target> --ttl 240 --workspace <target> --reason lookahead`.
-Exit 3 means another session holds the target: stop. Re-add the lease with the
-same session at each phase start, and release it with `devrites-engine claim
-release` on every stop. A crashed session's lease reads `dead` and frees itself.
+Exit 3: held, stop. Re-add the same session each phase. Release with `devrites-engine claim release` on stop. A `dead` lease frees itself.
 
 ## Rules
 
-- Never read or write `.devrites/ACTIVE`. Pass the target slug explicitly to every
-  skill and engine command, including `$rite-spec <target> "<objective>"` and
-  `devrites-engine handoff <target> --resume`.
+- Never read or write `.devrites/ACTIVE`. Pass the slug to `$rite-spec <target> "<objective>"` and `devrites-engine handoff <target> --resume`.
 - After the workspace exists, run `devrites-engine state set <target> sequence_lookahead=yes`.
-- Run Spec → Clarify → Temper → Define → Plan → Vet as the main loop does.
-  Define and Plan read the predecessor's current tree and plan. Record an
-  assumption for each predecessor interface the plan relies on.
-- At Vet, beside the readiness binding, record exactly one line
-  `Predecessor readiness: <active-slug> <digest>` in `eng-review.md`. `<digest>`
-  is the hex that `devrites-engine check readiness --emit-binding <active-slug>`
-  prints. When the predecessor later changes its planning inputs, the child's
-  readiness check blocks with `DRV-GATE-READINESS-STALE` and the main loop
-  re-vets the child before Build.
-- Never Build, never write product source or tests, never commit, and never
-  arm or rewrite `.devrites/AFK`. Owner questions go to the target's
-  `questions.md` and stop the lookahead.
-- Stop at Vet `READY` with `next_action: build after predecessor Seal GO`, at a
-  human gate, or when the target's lease is lost.
-
-**Failing case:** the lookahead passes Vet and starts Build while the
-predecessor is still sealing, so two root sessions write one tree.
+- Run Spec → Clarify → Temper → Define → Plan → Vet. Define and Plan read the predecessor tree and plan. Record one assumption per predecessor interface used.
+- At Vet record `Predecessor readiness: <active-slug> <digest>` in `eng-review.md` (the `--emit-binding` hex). A later planning change blocks `DRV-GATE-READINESS-STALE`; re-vet before Build.
+- Predecessor still in Build or later forbids only Build, product source, tests, commits, and `.devrites/AFK`. It does not skip Define, Plan, or Vet, and is not `awaiting_human`. Acceptance, scope, and irreversible risk still stop.
+- No spawn tool is not gate `access` or `awaiting_human`. Root writes Define and Plan. No Vet `READY` until those roles are admitted; else stop `running`, `next_action: $rite-vet`.
+- On every entry, re-read `state.md` and `questions.md`. Do not report a stop from chat. `continuation: clear` with `awaiting_human` is not done: fold resolved decisions into the spec, then continue. An except-principle or change-the-spec question complies: change the spec and resolve it. Ask only when the approved objective cannot comply.
+- Stop at Vet `READY` with `next_action: build after predecessor Seal GO`, at a real human gate, or when the lease is lost.
+
+**Failing case:** Vet then Build while the predecessor is still sealing, so two sessions write one tree. Or Define, Plan, and Vet skipped because the predecessor is still Build, or a missing strategy-reviewer spawn recorded as gate `access`.
+
+**Failing case:** stops to except a principle the spec can avoid.