devrites 5.7.2 → 5.9.0

package/engine/internal/parallel/select.go

@@ -0,0 +1,76 @@
+package parallel
+
+import (
+	"fmt"
+	"strings"
+)
+
+// SelectGreedy returns the largest plan-order pairwise-disjoint subset of ready
+// whose size is ≤ cap. ready must already be dependency-satisfied and in plan
+// order. cap is 1–MaxParallelSlices; 1 is a legal one-slice round, not a latch.
+func SelectGreedy(cap int, ready []SlicePaths, root string) ([]SlicePaths, error) {
+	if cap < 1 || cap > MaxParallelSlices {
+		return nil, fmt.Errorf("cap must be 1-%d (got %d)", MaxParallelSlices, cap)
+	}
+	normalized := make([]SlicePaths, 0, len(ready))
+	seen := make(map[string]struct{}, len(ready))
+	for i, item := range ready {
+		label := fmt.Sprintf("slice %d", i)
+		if item.ID != "" {
+			if err := validateSliceID(item.ID); err != nil {
+				return nil, fmt.Errorf("%s: %w", label, err)
+			}
+			label = fmt.Sprintf("slice %q", item.ID)
+		} else {
+			return nil, fmt.Errorf("%s: missing id", label)
+		}
+		if _, ok := seen[item.ID]; ok {
+			return nil, fmt.Errorf("duplicate slice id %q", item.ID)
+		}
+		seen[item.ID] = struct{}{}
+		paths, err := validateSlicePaths(item.Paths, label, root)
+		if err != nil {
+			return nil, err
+		}
+		normalized = append(normalized, SlicePaths{ID: item.ID, Paths: paths})
+	}
+
+	selected := make([]SlicePaths, 0, min(cap, len(normalized)))
+	for _, cand := range normalized {
+		if len(selected) >= cap {
+			break
+		}
+		if len(selected) == 0 {
+			selected = append(selected, cand)
+			continue
+		}
+		trial := append(append([]SlicePaths{}, selected...), cand)
+		if _, err := CheckPathDisjoint(trial, root); err != nil {
+			if strings.Contains(err.Error(), "overlap") {
+				continue
+			}
+			return nil, err
+		}
+		selected = trial
+	}
+	return selected, nil
+}
+
+func selectMode(n int) string {
+	switch {
+	case n <= 0:
+		return "none"
+	case n == 1:
+		return "serial"
+	default:
+		return "parallel"
+	}
+}
+
+func formatSelect(selected []SlicePaths) string {
+	ids := make([]string, len(selected))
+	for i, item := range selected {
+		ids[i] = item.ID
+	}
+	return fmt.Sprintf("select: n_eff=%d mode=%s slices=%s", len(selected), selectMode(len(selected)), strings.Join(ids, ","))
+}

package/engine/internal/parallel/select_test.go

@@ -0,0 +1,95 @@
+package parallel
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestSelectGreedyOneThenMany(t *testing.T) {
+	t.Parallel()
+	round1, err := SelectGreedy(5, []SlicePaths{
+		{ID: "SLICE-001", Paths: []string{"src/a.go"}},
+	}, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(round1) != 1 || round1[0].ID != "SLICE-001" {
+		t.Fatalf("round1=%#v", round1)
+	}
+
+	round2, err := SelectGreedy(5, []SlicePaths{
+		{ID: "SLICE-002", Paths: []string{"src/b.go"}},
+		{ID: "SLICE-003", Paths: []string{"src/c.go"}},
+		{ID: "SLICE-004", Paths: []string{"src/d.go"}},
+		{ID: "SLICE-005", Paths: []string{"src/e.go"}},
+	}, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(round2) != 4 {
+		t.Fatalf("after a one-slice round, cap 5 with 4 ready must select 4, got %d (%#v)", len(round2), round2)
+	}
+}
+
+func TestSelectGreedySkipsOverlapKeepsCap(t *testing.T) {
+	t.Parallel()
+	got, err := SelectGreedy(5, []SlicePaths{
+		{ID: "SLICE-001", Paths: []string{"src/shared.go"}},
+		{ID: "SLICE-002", Paths: []string{"src/shared.go", "src/b.go"}},
+		{ID: "SLICE-003", Paths: []string{"src/c.go"}},
+	}, "")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got) != 2 || got[0].ID != "SLICE-001" || got[1].ID != "SLICE-003" {
+		t.Fatalf("got %#v", got)
+	}
+}
+
+func TestSelectGreedyRejectsBadCap(t *testing.T) {
+	t.Parallel()
+	if _, err := SelectGreedy(0, nil, ""); err == nil {
+		t.Fatal("cap 0 should fail")
+	}
+	if _, err := SelectGreedy(11, nil, ""); err == nil {
+		t.Fatal("cap 11 should fail")
+	}
+}
+
+func TestSelectCLIOneThenMany(t *testing.T) {
+	t.Parallel()
+	var stdout, stderr bytes.Buffer
+	in := strings.NewReader(`{"slices":[{"id":"SLICE-001","paths":["src/a.go"]}]}`)
+	code := Run("parallel", []string{"select", "--cap", "5", "-"}, in, &stdout, &stderr)
+	if code != ExitOK {
+		t.Fatalf("code=%d stderr=%s", code, stderr.String())
+	}
+	if got := stdout.String(); got != "select: n_eff=1 mode=serial slices=SLICE-001\n" {
+		t.Fatalf("round1 got %q", got)
+	}
+
+	stdout.Reset()
+	stderr.Reset()
+	in = strings.NewReader(`{"slices":[
+		{"id":"SLICE-002","paths":["src/b.go"]},
+		{"id":"SLICE-003","paths":["src/c.go"]},
+		{"id":"SLICE-004","paths":["src/d.go"]}
+	]}`)
+	code = Run("parallel", []string{"select", "--cap", "5", "-"}, in, &stdout, &stderr)
+	if code != ExitOK {
+		t.Fatalf("code=%d stderr=%s", code, stderr.String())
+	}
+	if got := stdout.String(); got != "select: n_eff=3 mode=parallel slices=SLICE-002,SLICE-003,SLICE-004\n" {
+		t.Fatalf("round2 got %q; must not stay n_eff=1", got)
+	}
+}
+
+func TestSelectCLIRequiresCap(t *testing.T) {
+	t.Parallel()
+	var stdout, stderr bytes.Buffer
+	code := Run("parallel", []string{"select", "-"}, strings.NewReader(`{"slices":[]}`), &stdout, &stderr)
+	if code != ExitUsage {
+		t.Fatalf("code=%d want %d stderr=%s", code, ExitUsage, stderr.String())
+	}
+}

package/pack/.claude/agents/devrites-slice-wright.md

@@ -31,16 +31,20 @@ the target stack's idiom. Never plan, choose scope, design, or perform independe
 8. **Isolated worktree transfer is explicit.** Only when the dispatch contract names
    `Isolation: native-worktree`, run `git rev-parse HEAD` as the first command and
    require exact equality with supplied `worktree_base` before reading or editing.
-   Mismatch returns a gap with no write. After green proof, create one local, unpushed
-   transfer commit. Never push, merge, rebase, or remove the worktree. Without that
-   exact mode, do not commit.
+   Mismatch returns a gap with no write. After writer-safe proof, create one local
+   unpushed **worktree-branch** transfer commit with the contract `WIP(<slug>):`
+   subject (no slice id) — transport only, not a control/primary commit. Never push,
+   merge, rebase, or remove the worktree. Without that exact mode, do not commit.
 
 ## The contract you receive
 The orchestrator supplies these inline or by path, relative to **Workspace root**:
 - **Slice:** id/name, goal, acceptance criteria, **scope boundary** (what it will and will
   **not** touch), mode (HITL/AFK + any budget).
 - **Isolation:** `same-worktree` or `native-worktree`; native mode also supplies the
-  exact committed `worktree_base` SHA and requires a local transfer commit.
+  exact committed `worktree_base` SHA and requires a local transfer commit whose
+  subject is the supplied `WIP(<slug>): <imperative summary>` (no slice id).
+  Same-worktree leaves the diff uncommitted; the orchestrator commits that subject
+  at RECORD.
 - **Targets:** the exact project-relative paths listed in the dispatch task,
   plus interfaces and signatures to match. Your return cannot widen this set.
 - **Context to read yourself:** the relevant owning sections of `spec.md`, `plan.md`, `decisions.md`, `assumptions.md`,
@@ -97,6 +101,8 @@ unclear boundary is underspecified: return `Escalation` without proceeding.
      `$devrites-source-driven` on Codex. Verify the fact in installed source,
      official documentation, or context7 for current upstream behavior, then include
      that source in the result. Never invent an API.
+   - **No process residue.** Do not put `SLICE-###`, slice numbers, or "this slice"
+     in product source, tests, comments, or filenames.
 4. **VERIFY (fail-on-red).** Run writer-safe tests/types/lint. Report required
    build/browser/E2E as `not-run` (root-owned, artifact-producing gates), and only
    when the exact command, cwd, and prerequisites already appear in the unchanged
@@ -118,9 +124,11 @@ unclear boundary is underspecified: return `Escalation` without proceeding.
    in-scope gaps together, rerun affected proof, and report remaining gaps. Self-check
    never replaces independent review; green tests do not prove all possible cases.
 5. **TRANSFER when isolated.** After green writer-safe proof, verify the diff again,
-   stage only exact task paths, and create one new local commit whose message names
-   the slice transfer. Record its SHA. If the commit fails or includes any extra
-   path, return the failure and preserve the worktree; never bypass hooks or amend.
+   stage only exact task paths, and create one new local commit on **this worktree
+   branch** with the contract `WIP(<slug>):` subject (no slice id). Record its SHA.
+   This is transport for later orchestrator landing — not a control/primary commit
+   and not "the slice is done". If the commit fails or includes any extra path,
+   return the failure and preserve the worktree; never bypass hooks or amend.
    In `same-worktree` mode skip this step and leave the approved diff uncommitted.
 6. **RETURN** the structured artifact (below) and stop.
 
@@ -197,8 +205,9 @@ human-owned choices. Never silently ship a known gap.
 ## Tools / read-write mode
 
 Write code/tests only at exact contract paths; no `.devrites/` bookkeeping. Only
-`native-worktree` permits staging and one local transfer commit of those paths.
-All other Git mutation and remote actions remain forbidden.
+`native-worktree` permits staging and one local transfer commit of those paths
+(contract `WIP(<slug>):` subject). All other Git mutation and remote actions
+remain forbidden.
 
 ## Composition
 

package/pack/.claude/settings.json

@@ -13,6 +13,7 @@
       "Bash(devrites-engine orient *)",
       "Bash(devrites-engine observe *)",
       "Bash(devrites-engine parallel status *)",
+      "Bash(devrites-engine parallel select *)",
       "Bash(devrites-engine parallel create *)",
       "Bash(devrites-engine parallel record-green *)",
       "Bash(devrites-engine parallel integrate *)",

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

@@ -110,8 +110,8 @@ candidate manifest to cover the whole recorded chain — run
   qualify; no recorded next entry, or the cap/review-queue bound reached, stops
   with the winning reason.
 - Milestones are **not** shipped: they stay sealed and unarchived in `.devrites/work/`
-  with `Next step: /rite-ship` preserved. Per-slice `WIP(<slug>)` checkpoints still
-  land locally ([checkpoint.md](../../../rite-build/reference/checkpoint.md)), so the tree
+  with `Next step: /rite-ship` preserved. Local `WIP(<slug>):` checkpoints still
+  land ([checkpoint.md](../../../rite-build/reference/checkpoint.md)), so the tree
   stays clean and crash-safe.
 - 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
@@ -120,7 +120,8 @@ candidate manifest to cover the whole recorded chain — run
   run exactly as without this field.
 
 `max_parallel` caps a Build batch for unattended runs; `1` forces the serial cycle.
-Unattended runs take the largest eligible set ≤ cap and recompute after every integrate
+Unattended runs take the largest eligible set ≤ cap and recompute after every completed
+round (serial slice or parallel integrate)
 ([parallel-batch.md § Dynamic selection and re-batching](../../../rite-build/reference/parallel-batch.md#dynamic-selection-and-re-batching));
 an explicit `/rite-build --parallel N` cap wins for that invocation.
 

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

@@ -9,7 +9,7 @@ user-invocable: true
 
 Run every phase after one clarification window. Irreversible-risk,
 blocking/escalating,<!-- pack-scan-ignore: negated statement: gates are NOT disabled -->
-NO-GO, resource, and human-owned gates still pause. Use the Standard native
+and NO-GO still pause. Use the Standard native
 profile by default and Full for high-risk scope or explicit `--full`; see
 [`orchestration-profiles.md`](../devrites-lib/reference/orchestration-profiles.md).
 
@@ -48,20 +48,19 @@ executable controller/harness/bundle bytes or a missing writer, read
 - Every exact causal fingerprint gets at most three no-progress corrections.
   Closing one is progress; a distinct Critical/Important invariant has its own
   budget. Lower severity cannot prolong recovery.
-- Enforce `--max-slices`, the AFK sentinel, review queue, and native
-  agent/token/cost/time limits before every phase or dispatch. Count failed,
-  malformed, and unavailable leaf calls. At the review cap, permit only work
-  that reduces the queue.
+- Do not stop on `--max-slices`, sentinel `max_slices`, `max_agents`,
+  `max_minutes`, or `max_review_queue`. Count failed, malformed, and
+  unavailable leaf calls.
 - Parse flags only from this invocation. `--ship`, `--yolo`, `--max-slices`,
   `--parallel`, `--full`, and `--cross-model` activate only as exact standalone
   tokens in `$ARGUMENTS`; examples or earlier messages can never arm them.
   `--max-slices` must occur once and be followed by a positive base-10 integer;
   `--parallel` must occur once and be followed by a base-10 integer in `1`–`10`.
   Missing, repeated, malformed, or conflicting values stop before any write.
-- Temper always runs after Clarify. Unattended mode auto-applies only
-  `hold-rigor` and `reduce-to-MVP`; any `expand` or added acceptance pauses.
+- Temper always runs after Clarify. Auto-apply the recommended mode, including
+  `expand` and extra acceptance; record the ADR and fold via Spec Drift Guard.
+  Irreversible-risk still pauses.
 - Vet every plan. Cross-model is off unless the current invocation arms it.
-  Never auto-grow accepted scope.
 
 ## Workflow
 
@@ -77,7 +76,7 @@ executable controller/harness/bundle bytes or a missing writer, read
    from chat. After compaction or a resumed session, read `.devrites/ACTIVE`, then
    the `state.md` cursor, `questions.md`, `decisions.md`, and `test-plan.md`/`evidence.md`.
    Normalize current arguments to idea, `ship_preflight: yes|no`,
-   `max_slices: N|default`, `parallel: N|default`, `profile: standard|full`,
+   `max_slices: unlimited`, `parallel: N|default`, `profile: standard|full`,
    and `cross_model: yes|no`.
    **Completion:** normalized state is unambiguous and no sentinel or workspace file has been written.
 2. **Specify and clarify.** Run `devrites-interview`, `/rite-spec`, and
@@ -85,7 +84,7 @@ executable controller/harness/bundle bytes or a missing writer, read
    AFK. **Completion:** `Decision coverage: CLEAR` is durable.
 3. **Arm AFK once.** Apply the loop's
    [one-write AFK contract](reference/loop.md#arm-afk-once): preserve valid
-   existing bytes or create the bounded advisory-only sentinel once; never
+   existing bytes or create the sentinel once (`allow_gates: [advisory, validating]`); never
    rewrite it after Vet. Preserve an existing sentinel byte-for-byte.
    **Completion:** a valid read-only AFK sentinel exists.
 4. **Drive phases.** Follow [the loop](reference/loop.md): `/rite-spec` →
@@ -94,15 +93,16 @@ executable controller/harness/bundle bytes or a missing writer, read
    `/rite-review` → `/rite-seal`. Read and execute each skill; durable files, not
    chat, carry state. Apply the mutable post-vet budget before first Build.
    Build runs the largest eligible path-disjoint batch (cap: `--parallel N`, else
-   sentinel `max_parallel`, else 10) and recomputes after every integrate until no
-   pending slice remains; serial only when fewer than two slices are eligible or the
-   host cannot isolate concurrent worktree writers.
+   sentinel `max_parallel`, else 10) and recomputes after every completed round until no
+   pending slice remains; a one-slice round is serial for that round only, then
+   selection runs again (host isolation still forces serial when concurrent writers
+   cannot be separated).
    **Completion:** loop reaches Seal GO or persists a valid stop before any later phase.
 5. **Apply stops.** At every gate use
    [stop-conditions.md](reference/stop-conditions.md). A `blocked` label alone is not a stop condition:
    route agent-owned red results through bounded recovery.
    Red gates block forward advancement and enter caller-owned recovery. Stop on
-   hard risk, human-owned blocking/escalating/NO-GO, resource exhaustion, or the
+   hard risk, human-owned blocking/escalating/NO-GO, or the
    exact fingerprint's proven exhaustion. Technical exhaustion records terminal
    `Next step: none`, never a routine phase command. **Completion:** no stop is active, or its cursor and reason are durable.
 6. **Seal boundary.** Without a ship flag, stop at Seal GO with `/rite-ship` —
@@ -115,8 +115,8 @@ executable controller/harness/bundle bytes or a missing writer, read
 
 ## Reply and resume
 
-HITL Build returns after one slice; explicit valid AFK may chain only green
-slices within every cap. One Autocomplete invocation owns all internal
+HITL Build returns after one slice; Autocomplete ignores `--max-slices` and
+keeps chaining pending slices. One Autocomplete invocation owns all internal
 backtracking. Context pressure, compaction, or a nested completion footer does
 not create a stop; persist and resume the cursor.
 
@@ -128,5 +128,5 @@ spec <done|stopped> · clarify <clear|stopped> · temper <done|stopped> · defin
 ```
 
 Final state is `Shipped`, `Stopped`, `Awaiting human`, `NO-GO`, or `GO`; do not
-write a narrative recap. Require a clean or accepted baseline, arm checkpoint
-mode, and never auto-pass a red gate.
+write a narrative recap. Require a clean or accepted baseline, land a local
+unpushed checkpoint after each green check, and never auto-pass a red gate.

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

@@ -36,6 +36,5 @@ not pick the option that's merely easiest to implement.
 
 ## When a choice is NOT autocomplete's to make
 
-Human-owned contract, data-model, security, and product choices are not discretionary.
-Use owning elicitation/safety gates and the topology marked action. Autocomplete
-answers *how*, never *what to build* beyond the settled interview.
+Human-owned blocking/escalating, irreversible-risk, and access stay human.
+Recommended temper `expand` auto-applies; do not invent product intent.

package/pack/.claude/skills/rite-autocomplete/reference/loop.md

@@ -13,11 +13,8 @@ routine phases. Acceptance-preserving Reslice authority is
 ## Arm AFK once
 
 ```yaml
-allow_gates: [advisory]
-max_slices: 10
-max_agents: 32
-max_minutes: 120
-max_review_queue: 8
+allow_gates: [advisory, validating]
+# max_slices / max_agents / max_minutes / max_review_queue omitted: unlimited
 # continue_sequence: true          # opt-in: chain recorded continuations after Seal GO
 # max_workspaces: 5                # sequence budget when chaining
 # max_parallel: 10                 # Build batch cap; 1 = serial (default: eligible, cap 10)
@@ -27,32 +24,28 @@ max_review_queue: 8
 ```
 
 Read an existing sentinel first. Preserve it byte-for-byte when valid; stop if
-its gate ceiling exceeds advisory, required envelope is malformed, or
-`max_slices` conflicts with the invocation. If absent, write it once after
-clarity, replacing the safe slice default only for explicit `--max-slices N`.
+malformed. Do not stop because it names `max_slices` / `max_agents` /
+`max_minutes` / `max_review_queue` or only `[advisory]`. If absent, write it
+once after clarity. Never write `max_slices` from `--max-slices`.
 It is read-only: never rewrite it after Vet or reset it on resume. Leftover
 `expires_at` is ignored and never rewritten.
 
 ### Derive the mutable post-vet budget
 
-After Vet, count pending slices and take the minimum of that count, explicit
-flag, and sentinel cap. Before first Build, seed absent state-owned
-`afk_slices_remaining`; retain the lower valid existing value and never increase
-or reinitialize it. AFK configuration itself stays unchanged.
+After Vet, seed `afk_slices_remaining` from the pending count so every pending
+slice can run. Ignore `--max-slices`, sentinel `max_slices`, and leftover
+remaining. AFK configuration itself stays unchanged.
 
 ### Admit each unattended cycle
 
-Before every phase, review fan-out, recovery, or writer dispatch, apply
-[`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md#unattended-resource-envelope): cheapest current-state/readiness
-check first; reject overlap; count unresolved review; check native
-agent/token/cost/time headroom. Count every leaf result. At the review cap, only
-reconciliation that reduces the queue may run. Any reached or unobservable
-bound stops before more work and persists the winning reason. A new activation
-gets fresh activation-local counters but retains durable slice/recovery state
-and recomputed queue.
+Before every phase, review fan-out, recovery, or writer dispatch: cheapest
+readiness check first; reject overlap. Do not stop on `max_agents`,
+`max_minutes`, or `max_review_queue`. Count every leaf result. A new activation
+gets fresh activation-local counters but retains durable slice/recovery state.
 
-`allow_gates: [advisory]` means validating gates pause now rather than becoming
-Seal NO-GO. Only explicit human configuration outside Autocomplete may widen it.
+When driving `/rite-build`, ignore afk-discipline remaining-0, `--max-slices`,
+and parallel AFK headroom. Close validating questions
+(recommended pick) instead of queuing them.
 
 ## Phase arc
 
@@ -62,17 +55,17 @@ Workspace files carry state; chat does not. Read and execute each phase skill:
 | --- | --- | --- |
 | 1 | `/rite-spec` | investigate and write testable intent |
 | 2 | `/rite-clarify` | topology-first scan; require `Decision coverage: CLEAR`, then arm AFK |
-| 3 | `/rite-temper` | harden or reduce; expansion and irreversible risk pause |
+| 3 | `/rite-temper` | harden, reduce, or expand; irreversible risk still pauses |
 | 4 | `/rite-define` | approved plan/tasks/traceability |
 | 5 | `/rite-vet` | every plan; derive mutable budget after READY |
-| 6 | `/rite-build` batch loop | largest eligible path-disjoint set (cap 10; serial when <2 eligible); recompute after each integrate; charge once per green built slice |
+| 6 | `/rite-build` batch loop | largest eligible path-disjoint set (cap 10; one-slice round when <2 eligible); recompute after each round; charge once per green built slice |
 | 7 | `/rite-prove` | all slices built; approved proof; recovery on red |
 | 8 | `/rite-polish` | re-prove after code edits |
 | 9 | `/rite-review` | in-scope correction then fresh proof |
 | 10 | `/rite-seal` | GO/NO-GO; no Git |
 | 11 | `/rite-ship` | only after GO; `--ship` never authorizes Git; stop at literal-GO/native approval |
 
-Before advancing, check resource admission and
+Before advancing, check
 [stop-conditions.md](stop-conditions.md). After source edits, discard stale pass
 evidence. Re-read the active workspace before each phase.
 

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

@@ -59,22 +59,21 @@ exhausted.
 <!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"classifier returns owner-busy, exhausted, or existing hard gate","action":"stop on exact WAIT_ACTIVE_OWNER, BLOCKED_EXHAUSTED, or BLOCKED_GATE result","return":"unchanged cursor plus fixed route-owned output"} -->
 ## Other stop classes
 
-- **Gate severity:** blocking or escalating gate; any open validating question.
-- **Temper:** any `expand` or added acceptance criterion. `hold-rigor`,
-  `reduce-to-MVP`, and a justified skip do not pause.
+- **Gate severity:** blocking or escalating gate. Validating: auto-pick the
+  recommended option, close the question, continue.
+- **Temper:** `expand` and extra acceptance auto-apply (record + Drift Guard).
+  Irreversible-risk still pauses. `hold-rigor`, `reduce-to-MVP`, and a skip do not pause.
 - **Clarify:** material Partial/Missing/unowned decision coverage or a
   low-confidence high-consequence assumption. Continue the initial interview;
   never arm AFK early.
 - **Seal:** NO-GO, with every blocker and fix direction. Never round up to GO.
 - **Reslice:** execute its marked action before deciding continue/stop.
-- **Slice budget:** any validated root-owned remaining value of zero stops before the next dispatch
-  when slices remain; malformed state also stops. Report whether the winning
-  bound was the pre-existing remaining value, explicit flag, sentinel cap, or post-vet pending count.
-  Zero with no pending slices is normal completion and proceeds to Prove.
-- **Resource envelope:** missing/malformed AFK, overlapping run,
-  exhausted/unobservable declared agent/token/cost/time headroom, or review queue
-  above cap. At cap, only queue-reducing reconciliation may run. Persist winning
-  bound and observed usage; a new activation does not reset durable budgets.
+- **Slice budget:** do not stop on `--max-slices`. Leftover
+  pre-existing remaining value, explicit flag, sentinel cap, or post-vet pending count
+  does not stop. Zero with no pending slices is normal completion.
+  Malformed flag stops before any write.
+- **Resource envelope:** overlapping run or missing AFK after arm still stops.
+  Do not stop on `--max-slices`, `max_agents`, `max_minutes`, or `max_review_queue`.
 - **Confidence:** intent still cannot become testable acceptance after interview.
 - **Repeated failure:** the exact fingerprint's bounded recovery is exhausted.
 

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

@@ -60,12 +60,15 @@ Wright applies anti-slop; root verifies returns and never patches source.
 
 Omitted/`1` ≡ serial; `2`–`10` is a **cap** — the root runs the largest eligible
 path-disjoint set it can start now (`N_eff`), takes fewer when the cap cannot be
-filled, and recomputes after every integrate until no pending slice remains
+filled, and recomputes after every completed round (serial slice or parallel
+integrate) until no pending slice remains
 ([`parallel-batch.md` § Dynamic selection](reference/parallel-batch.md#dynamic-selection-and-re-batching)).
 Unattended runs (`/rite-autocomplete`, `.devrites/AFK` `max_parallel`) repeat batches
 inside the same run; HITL stops after each batch. Non-integer/`N≤0`/`N>10` hard refuse.
-All-green serial integrate; a red/gap sibling gets a bounded repair round in
-its own worktree — never rebuilt from scratch while budget remains.
+All-green (independent review + proof) then integrate as one local `WIP(<slug>):`
+commit per sibling onto the current control branch (never pushed). Do not
+integrate a sibling because the wright returned. A red/gap sibling gets a bounded repair
+round in its own worktree — never rebuilt from scratch while budget remains.
 Post-writer inventory and affected rechecks follow `phase-contract.md` § Independent
 Build review; fold accounts before one repair-all wright.
 Plan-owned gaps still route through Spec Drift Guard
@@ -88,9 +91,11 @@ the next slice automatically; AFK obeys remaining budget; Prove requires all sli
 
 ## Phase exit
 
-**Complete when:** the dispatched wright returns green proof for the slice,
-`git diff --name-only` ⊆ allowlist, independent test analysis admits no Critical
-gap, and `state.md` cursor advances with recorded evidence paths.
+**Complete when:** Independent Build review and fail-on-red proof are green,
+`git diff --name-only` ⊆ allowlist, no open Critical/Important, `state.md` cursor
+advances with recorded evidence, and the control-branch checkpoint has landed
+per [`checkpoint.md`](reference/checkpoint.md).
 
-**Failing case:** wright reports "done" but proof command was not executed or
-failed → slice incomplete; do not advance cursor.
+**Failing case:** wright reports "done" but independent review or proof was
+skipped, red, or followed by an uncommitted repair → slice incomplete; do not
+advance cursor or commit on control.

package/pack/.claude/skills/rite-build/reference/afk-discipline.md

@@ -16,7 +16,9 @@ control; irreversible work (destructive/auth/public API) always pauses.
 The controlling root owns the cap:
 
 1. **Before every dispatch**, re-read `.devrites/AFK`, `state.md`, and the
-   selected slice. A configured `max_slices` and any existing
+   selected slice. When `--parallel N` or sentinel `max_parallel` is greater than
+   1, recompute `N_eff` via `parallel select` before the next dispatch — a prior
+   one-slice round does not keep the run serial. A configured `max_slices` and any existing
    `afk_slices_remaining` value, including its released bullet form, must each
    be a decimal nonnegative integer. A missing
    `state.md` or malformed configured value fails closed; an omitted cap is the

package/pack/.claude/skills/rite-build/reference/anti-patterns.md

@@ -21,3 +21,7 @@ Pack-wide rationalizations and red flags live in
 - Writing a `try/catch` block wider than what you handle.
 - A comment that restates what the next line does.
 - Touching files that aren't in `touched-files.md` for "tidiness".
+- A comment, filename, test name, or commit subject that mentions `SLICE-###`,
+  a slice number, or "this slice".
+- Committing onto control when the wright returns, or before Independent Build
+  review and fail-on-red proof are green.

package/pack/.claude/skills/rite-build/reference/checkpoint.md

@@ -1,28 +1,46 @@
-# Checkpoint: proven slices land as local WIP commits
+# Checkpoint: land local WIP only after the check loop is green
 
-A slice's source never stays uncommitted after its gates are green: at RECORD
-the orchestrator commits the proven slice as a local `WIP`, so the working
-tree stays clean and the work survives a crash or compaction.
+The wright does not commit onto the control/primary branch. Independent review
+and fail-on-red proof run first; a red or gap finding dispatches another wright.
+Only when that loop is green does the orchestrator land the local unpushed
+`WIP(<slug>):` commit. Same rule for `/rite-build`, `/rite-prove`, `/rite-polish`,
+`/rite-review`, and `/rite-autocomplete`. Never push. `.devrites/CHECKPOINT` is
+not a gate.
 
-## The checkpoint commit: orchestrator, at RECORD, after gates are green
-A checkpoint records a **proven** slice only after its gates are green. Stage the exact
-slice-owned candidate paths from the manifest, passing each literal path separately.
+## When (and when not)
+
+- **Do:** after Independent Build review (or the phase's independent validators)
+  and fail-on-red proof are green, with no open Critical/Important and no repair
+  wright still in flight. Serial: git recipe below (skip empty index) or isolated
+  FF of a matching `transfer_commit`. Parallel: `devrites-engine parallel
+  integrate --apply-to-control` (no second control `git commit`).
+- **Do not:** when a wright returns; before review/proof; with red/gap findings;
+  fast-forward an isolated transfer onto control before those checks.
+
+A native-worktree `transfer_commit` is transport on the worker branch only.
+
+## The commit
+Stage the exact candidate paths from the manifest, each as its own argv.
 Never stage `touched-files.md`, a directory, glob, unrelated path, or user change.
-Verify the staged set, then commit locally with a `[devrites-context]` body:
+Verify the staged set, then commit locally.
+
+Subject: `WIP(<slug>):` plus an imperative summary of the change (from the
+goal). Never a slice id, `SLICE-###`, a slice number, or "this slice"
+(`WIP(admin-report): add CSV export for usage rows`, not `SLICE-003` or
+`complete slice 3`). Product source, tests, comments, and filenames omit the
+same marks; they stay in `.devrites/` only.
 
 ```bash
-git commit -m "WIP(<slug>): <slice>" -m "$(cat <<'BODY'
+git commit -m "WIP(<slug>): <imperative summary>" -m "$(cat <<'BODY'
 [devrites-context]
-decisions: <one-line delta this slice added to decisions.md>
-remaining: <pending slices — count or names>
-dead-ends: <approaches ruled out this slice, if any>
+decisions: <one-line delta this work added to decisions.md>
+remaining: <pending count>
+dead-ends: <approaches ruled out, if any>
 BODY
 )"
 ```
 
-When host reconciliation already landed the isolated transfer commit, nothing
-is staged and the step no-ops. **Local-only:** never push a checkpoint or let
-scratch work trigger CI.
+**Local-only:** never push or let scratch work trigger CI.
 
 ## Restore
 After a crash, a fresh session may read the last `WIP(<slug>)` body as crash context.
@@ -36,9 +54,3 @@ WIP commits are scratch and never reach shared history. `/rite-ship` folds them
 one atomic feature commit before the Conventional-Commit ladder: see the collapse step in
 [git-ship.md](../../rite-ship/reference/git-ship.md). Result: one clean commit, bisect
 stays green.
-
-## Autocomplete
-Checkpoints are unconditional; `/rite-autocomplete` needs no sentinel arming.
-Each wright returns after one slice; HITL stops, while explicit `.devrites/AFK`
-lets the controlling Build root chain another green slice only under its cap
-and pause rules.