devrites 7.2.8 → 7.3.0

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

@@ -47,7 +47,7 @@ Required review rosters and final proof remain. Preserve protected history uncha
 a compact current view references originals without omitting active requirements.
 
 **Compaction fallback:** after compaction or a resumed session, always run
-`devrites-engine handoff [slug] --resume` first (slug from `.devrites/ACTIVE`) — one
+`devrites-engine handoff <source> --resume` first for the selected source per [phase target binding](../parallel-workspaces.md#phase-target-binding) — one
 deterministic resume record reduced from durable artifacts (cursor, `awaiting_human`,
 open `questions.md` gates, the `gates.md` reduction with unmet/stale ids,
 `decisions.md` dead ends, in-flight dispatch waves, and the read-next order over

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

@@ -65,11 +65,18 @@ their optional `Run at` cell, writing the same transcripts.
 Execution contract: the command runs through the platform shell in the named
 directory with a bounded timeout; pass requires exit 0 **and** output matching
 EXPECT. Without `--transcripts`, output is captured but never persisted, only its
-digest. `--transcripts` writes one file per executed or reused gate under
-`references/gates/<gate-id>/`. Each file holds the command, cwd, attempt, times,
-exit, EXPECT verdict, the candidate digest read before and after the run, and the
-output with known credential shapes masked and capped at 1 MiB. Its
-`OUTPUT_SHA256` equals the ledger evidence digest.
+digest. `--transcripts` atomically writes a private v2 executed record under
+`references/gates/<gate-id>/`, or returns a verified original record for reuse
+without rewriting its historical candidate labels. Metadata and output mask
+known credential shapes; output is capped at 1 MiB. `DEFINITION_SHA256` binds the
+oracle, `OUTPUT_SHA256`/`OUTPUT_BYTES` describe original output, and the final
+`TRANSCRIPT_SHA256` hashes all preceding record bytes for drift detection.
+Do not rehash redacted/truncated output as though it were original output.
+Reuse requires a complete passing executed origin matching current definition,
+output identity and declared inputs, plus current command approval. Missing,
+corrupt, legacy v1 or reuse-only records rerun only affected approved checks;
+missing approval blocks even when an old checkbox remains met. A record checksum
+detects drift; it is not a signature or proof of honest execution.
 
 After Vet READY the runnable set is fixed: converting a runnable gate to manual,
 loosening EXPECT, changing CHECK or CWD, adding or narrowing INPUTS, or removing
@@ -115,10 +122,12 @@ devrites-engine gates attest <slug> <id> <note>   record human evidence on a man
 devrites-engine gates abandon <slug> <id> <why>   record a terminal ABANDON handoff
 ```
 
-Run/reverify hold the feature lock, re-read the ledger before writeback, and
-discard a result whose gate definition moved mid-run. Reverify is the
-suspicion-killer: when any doubt exists about prior passes, rerun it rather
-than trusting recorded evidence.
+Run/reverify serialize execution, origin lookup and transcript publication under
+the gates lock; the feature lock is held only for input acquisition and ledger
+writeback. Results whose gate definition moved are discarded. Unchanged declared
+inputs may reuse proof even under reverify; a reused result is never execution.
+If non-file prerequisites changed or proof is doubtful, invalidate affected
+automatic evidence through the single-writer protocol before approved rerun.
 
 ## Oracle quality (`gates lint`)
 

package/pack/generated/claude/skills/devrites-lib/reference/workspace-artifact-schema.md

@@ -223,6 +223,7 @@ SLA: <15m | 4h | 24h | none>
 Checkpoint: <question + why it needs unavailable pre-code evidence or action-time approval | none>
 Dependencies: <SLICE-### (via <interface it consumes>) list | none>
 depends_on: [<SLICE-### IDs>]
+Workspace dependencies: <none | comma-separated <workspace-slug>/SLICE-### producer refs>
 Consumes / Produces: <interfaces read and exposed>
 Known-Gotchas: <ordering hazards and framework footguns | none>
 Prior-slice learnings: <constraints learned earlier | none>
@@ -245,6 +246,15 @@ Done condition: <checkable, exhaustive completion criterion>
 
 `depends_on` is the machine-readable mirror of `Dependencies`; keep the sets
 identical and cycle-free. Each dependency names what crosses it (`check task-graph` advises).
+`Workspace dependencies` records cross-workspace producer prerequisites, separate
+from local `Dependencies`/`depends_on`. Define/Plan writes it after native interface,
+assumption, runtime-resource and proof-independence review; Vet approves the current
+bound declaration. `none` is explicit, not inferred from paths or local edges.
+Only durably BUILT/integrated producer checkpoints satisfy refs, including valid
+archived predecessors; unknown/malformed refs or cycles withhold unsafe work.
+Missing field on a legacy future plan requires narrow Plan/Vet repair before
+early admission, not rejection of existing local/standalone execution. The global
+controller procedure lives only in [`parallel-workspaces.md`](parallel-workspaces.md).
 Define and `/rite-plan` repair write `Prior-slice learnings`, folding Build's
 `decisions.md` carry-forward constraints; Build never edits `tasks.md`. `Gate`, `SLA`, and `Checkpoint` are required for HITL
 slices; use `none` when they do not apply. Complexity above 3 triggers reslicing

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

@@ -5,7 +5,7 @@ argument-hint: "[idea] [--ship|--yolo] [--max-slices N] [--parallel N] [--full]
 user-invocable: true
 ---
 
-<!-- loads: {"always":["devrites-lib/reference/standards/core.md","devrites-lib/reference/standards/afk-hitl.md","devrites-lib/reference/standards/one-shot-actions.md","devrites-lib/reference/orchestration-profiles.md","devrites-lib/reference/standards/acceptance-preserving-reslice.md","rite-autocomplete/reference/decision-policy.md","rite-autocomplete/reference/loop.md","rite-autocomplete/reference/stop-conditions.md"],"triggers":{"workflow-artifacts":["devrites-lib/reference/standards/workflow-artifacts.md"],"lookahead":["rite-autocomplete/reference/lookahead.md"]},"workspace":["state.md","spec.md","plan.md","tasks.md","questions.md","decisions.md","drift.md","evidence.md","test-plan.md"],"rootOnly":["devrites-lib/reference/standards/afk-hitl.md","devrites-lib/reference/orchestration-profiles.md","devrites-lib/reference/standards/workflow-artifacts.md","rite-autocomplete/reference/lookahead.md"]} -->
+<!-- loads: {"always":["devrites-lib/reference/standards/core.md","devrites-lib/reference/standards/afk-hitl.md","devrites-lib/reference/standards/one-shot-actions.md","devrites-lib/reference/orchestration-profiles.md","devrites-lib/reference/parallel-workspaces.md","devrites-lib/reference/standards/acceptance-preserving-reslice.md","rite-autocomplete/reference/decision-policy.md","rite-autocomplete/reference/loop.md","rite-autocomplete/reference/stop-conditions.md"],"triggers":{"workflow-artifacts":["devrites-lib/reference/standards/workflow-artifacts.md"],"lookahead":["rite-autocomplete/reference/lookahead.md"]},"workspace":["state.md","spec.md","plan.md","tasks.md","questions.md","decisions.md","drift.md","evidence.md","test-plan.md"],"rootOnly":["devrites-lib/reference/standards/afk-hitl.md","devrites-lib/reference/orchestration-profiles.md","devrites-lib/reference/parallel-workspaces.md","devrites-lib/reference/standards/workflow-artifacts.md","rite-autocomplete/reference/lookahead.md"]} -->
 > Read-set manifest: `devrites-engine context <slug> --phase autocomplete` bundles every file named below into one deduplicated read. Trigger names map to the conditional rules in the sections that follow.
 
 
@@ -86,7 +86,7 @@ With `--lookahead` (trigger `lookahead`), follow
 [`lookahead.md`](reference/lookahead.md) instead of the steps below: plan the
 next sequence continuation through Vet in a second session, then stop.
 
-1. **Orient and parse.** Resolve the explicit or active slug; when a workspace exists,
+1. **Orient and parse.** Resolve source per [phase target binding](../devrites-lib/reference/parallel-workspaces.md#phase-target-binding); when a workspace exists,
    require its `state.md` and read its cursor; a fresh idea starts empty at step 2.
    Before honoring `blocked` with terminal `next_action`,
    reconcile retained consumptive evidence and fingerprint attempts from
@@ -96,7 +96,7 @@ next sequence continuation through Vet in a second session, then stop.
    Reconstruct a missing return cursor only from
    the current phase and exact approved action in `test-plan.md`/evidence, never
    from chat. After compaction or a resumed session, always run `devrites-engine
-   handoff <slug> --resume` first (slug from `.devrites/ACTIVE`) and open only the
+   handoff <source> --resume` first for that selected source and open only the
    `read_next` artifacts it names, per [`context-hygiene.md`](../devrites-lib/reference/standards/context-hygiene.md) § Compaction fallback.
    Normalize current arguments to idea, `ship_preflight: yes|no`,
    `max_slices: unlimited`, `parallel: N|default`, `profile: standard|full`,
@@ -118,13 +118,16 @@ next sequence continuation through Vet in a second session, then stop.
    `/rite-build` batch loop → `/rite-prove` → `/rite-polish` →
    `/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 uses `parallel select --from-plan` (cap: explicit `--parallel N`, else
-   sentinel `max_parallel`, else 10), refilling per landing until none pending;
-   a one-slice round is serial for that round only; reselect afterward. Host
-   isolation may force serial. If `--parallel N` is explicit,
-   pass it into `/rite-build` and ignore leftover sentinel `max_parallel`.
-   Otherwise pass the resolved sentinel/default cap into `/rite-build` as
-   `--parallel N`, never bare `/rite-build`.
+   Execute [`parallel-workspaces.md`](../devrites-lib/reference/parallel-workspaces.md):
+   continuously scan the authorized recorded sequence across stages, preparing
+   and re-Vetting future targets while writers run. Build queries the global
+   pool with `parallel select --from-plan --slug <controller> --workspaces
+   <controller,authorized-source,...> --cap N`; N is explicit `--parallel N`, else
+   sentinel `max_parallel`, else 10 — one global writer cap, including explicit 1.
+   Always pass resolved `--parallel N` to Build. Cap>1 uses an isolated first
+   writer even when initially alone; refill globally per landing and planning/
+   review return. Unsupported host stays serial. No local ready slice is not
+   completion while authorized planning, repair/re-Vet or independent work remains.
    **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:

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

@@ -19,15 +19,15 @@ Exit 3: held, stop. Re-add the same session each phase. Release with `devrites-e
 
 ## Rules
 
-- Never read or write `.devrites/ACTIVE`. Pass the slug to `/rite-spec <target> "<objective>"` and `devrites-engine handoff <target> --resume`.
+- Preserve the ordered owner's `.devrites/ACTIVE`; bind every phase and handoff to the target per shared [phase target binding](../../devrites-lib/reference/parallel-workspaces.md#phase-target-binding).
 - After the workspace exists, run `devrites-engine state set <target> sequence_lookahead=yes`.
 - 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.
+- This explicit second session stays planning-only: no Build, product source/tests, commits or `.devrites/AFK` writes, even after predecessor Seal. Main controller may later consume the prepared target under [`parallel-workspaces.md`](../../devrites-lib/reference/parallel-workspaces.md); its sanctioned isolated Build is not a second same-tree writer. 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.
+- Stop at Vet `READY` with `next_action: /rite-build <target>` as a cursor for the main controller (not permission for this lookahead session to Build), at a real human gate, or when the lease is lost. Release the planning claim so the main controller can recheck/admit it.
 
-**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:** lookahead session starts Build; main controller is blanket-blocked until predecessor Seal despite current native independent admission; or Define/Plan/Vet are skipped because predecessor is still Build. Missing strategy-reviewer spawn is not gate `access`.
 
 **Failing case:** stops to except a principle the spec can avoid.

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

@@ -16,7 +16,7 @@ allow_gates: [advisory, validating]
 # max_slices / max_agents / max_minutes / max_review_queue omitted: unlimited
 # continue_sequence: false         # opt out; default chains after Seal GO
 # max_workspaces: 5                # sequence budget when chaining
-# max_parallel: 10                 # default cap when this invocation omits `--parallel N`; `--parallel N` wins and rewrites only this field
+# max_parallel: 10                 # fresh-run default; preserve retained lease capacity on cold resume; explicit `--parallel N` rewrites only this field
 # max_tokens: <N>
 # max_cost_usd: <amount>
 # notify: "<cmd>"
@@ -28,7 +28,10 @@ when this invocation contains `--parallel N`: then write or replace only
 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, and include `max_parallel: N` when that flag is present.
-Never write `max_slices` from `--max-slices`. It is otherwise read-only: never rewrite it after Vet or reset it on resume. Leftover `expires_at` is ignored
+Without the flag, seed a newly created sentinel from retained global lease capacity
+when present; otherwise use fresh-run default 10. Never replace a valid existing
+sentinel's capacity from lease/default. Never write `max_slices` from `--max-slices`.
+It is otherwise read-only: never rewrite it after Vet or reset it on resume. Leftover `expires_at` is ignored
 and never rewritten. **Failing case:** leftover `max_parallel: 1` keeps the run
 serial after `--parallel 5`.
 
@@ -64,7 +67,7 @@ Workspace files, not chat, carry state. Read/execute each phase skill:
 | 3 | `/rite-temper` | harden or reduce; `expand` and extra acceptance stop for a human; 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: this invocation's `--parallel N`, else sentinel `max_parallel`, else 10; serial if <2 eligible); refill per landing; charge once per landed slice |
+| 6 | `/rite-build` global frontier | execute [shared controller workflow](../../devrites-lib/reference/parallel-workspaces.md); scan authorized stages and repair/re-Vet while writers run, refill per landing under one global cap; charge each source once per landed slice |
 | 7 | `/rite-prove` | all slices built except deferred (`Satisfies: none`); approved proof; recovery on red |
 | 8 | `/rite-polish` | re-prove after code edits |
 | 9 | `/rite-review` | in-scope correction then fresh proof |
@@ -72,7 +75,7 @@ Workspace files, not chat, carry state. Read/execute each phase skill:
 | 11 | `/rite-ship` | only after GO; `--ship` never authorizes Git; stop at literal-GO/native approval |
 
 Check [stop-conditions.md](stop-conditions.md) before advancing. Discard stale
-pass evidence after source edits. Re-read active workspace before each phase. On a cold resume or
+pass evidence after source edits. Re-read the selected source before each phase per [phase target binding](../../devrites-lib/reference/parallel-workspaces.md#phase-target-binding). On a cold resume or
 new activation, run `devrites-engine check regression <slug>`: `BLOCKED` names a
 durable fact lost since the last checkpoint — restore or route it through its
 owning phase before continuing; `unproven` does not block. After each phase's
@@ -89,11 +92,12 @@ step 10 does not end the run: leave the sealed workspace unshipped with its
 (`/rite-spec <parent>-<n> "<objective>"` from the parent's `decisions.md` sequence)
 and re-enter step 1. Spend one workspace per opened continuation.
 
-For a child already planned by [lookahead](lookahead.md), do not re-specify.
-Wait while `devrites-engine claim check --workspace <child>` exits 3 (live
-lookahead), then set `.devrites/ACTIVE` to the child and resume its cursor at
-step 1. A predecessor replan since its Vet blocks child readiness with
-`DRV-GATE-READINESS-STALE`; route to `/rite-vet` before Build.
+For an already prepared child, do not re-specify. Follow
+[`parallel-workspaces.md`](../../devrites-lib/reference/parallel-workspaces.md)
+while the owner is still running: honor claims, repair/re-Vet stale readiness,
+and admit only explicitly independent/dependency-satisfied isolated work.
+ACTIVE changes to the child only at normal ordered handoff after the owner Seal;
+resume its durable cursor without a second controller or another opening charge.
 
 Before invoking a continuation, require durable `state.md`
 `sequence_workspaces_remaining > 0`; if absent, first write

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

@@ -1,11 +1,11 @@
 ---
 name: rite-build
-description: Build the next approved vertical slice with evidence. HITL one-slice default; AFK/autocomplete chain serially or in eligible path-disjoint batches (dynamic size, cap 10); `--parallel N` caps a batch.
+description: Build the next approved vertical slice with evidence. HITL one-slice default; AFK/autocomplete refill eligible isolated work under --parallel N, one global writer cap under Autocomplete.
 argument-hint: "[--parallel N] [slice number or name]"
 user-invocable: true
 ---
 
-<!-- loads: {"always":["devrites-lib/reference/standards/core.md","devrites-lib/reference/standards/code-navigation.md","devrites-lib/reference/standards/code-index.md","devrites-lib/reference/standards/agents.md","rite-build/reference/phase-contract.md","rite-build/reference/one-slice-cycle.md","rite-build/reference/wright-dispatch.md","rite-build/reference/checkpoint.md","rite-build/reference/spec-drift-guard.md","rite-build/reference/output.md","rite-build/reference/anti-patterns.md"],"rootOnly":["devrites-lib/reference/standards/code-index.md","rite-build/reference/phase-contract.md","rite-build/reference/wright-dispatch.md","rite-build/reference/checkpoint.md","rite-build/reference/output.md","rite-build/reference/afk-discipline.md","rite-build/reference/checkpoint-protocol.md","rite-build/reference/parallel-batch.md","devrites-lib/reference/standards/afk-hitl.md","devrites-lib/reference/standards/workflow-artifacts.md"],"triggers":{"afk":["rite-build/reference/afk-discipline.md","devrites-lib/reference/standards/afk-hitl.md","rite-build/reference/checkpoint-protocol.md"],"applicability":["devrites-lib/reference/standards/repository-topology.md","devrites-lib/reference/standards/data-integrity.md","devrites-lib/reference/standards/integration-reliability.md"],"coding":["devrites-lib/reference/standards/coding-style.md"],"debug-recovery":["devrites-lib/reference/standards/debug-recovery.md"],"dod":["devrites-lib/reference/standards/definition-of-done.md"],"errors":["devrites-lib/reference/standards/error-handling.md"],"frontend":["rite-build/reference/frontend-trigger.md"],"parallel":["rite-build/reference/parallel-batch.md"],"patterns":["devrites-lib/reference/standards/patterns.md"],"principles":["devrites-lib/reference/standards/principles.md"],"security":["devrites-lib/reference/standards/security.md"],"tdd":["rite-build/reference/tdd.md","devrites-lib/reference/standards/testing.md"],"workflow-artifacts":["devrites-lib/reference/standards/workflow-artifacts.md"]},"workspace":["brief.md","spec.md","state.md","decisions.md","assumptions.md","questions.md","decision-coverage.md","architecture.md","plan.md","tasks.md","traceability.md","eng-review.md","test-plan.md","gates.md","strategy.md"],"workspaceByRole":{"code-reviewer":["spec.md","plan.md","tasks.md","test-plan.md","architecture.md","decisions.md","state.md"],"doubt-reviewer":["spec.md","plan.md","tasks.md","state.md","decisions.md"],"slice-wright":["brief.md","spec.md","architecture.md","plan.md","tasks.md","test-plan.md","state.md","decisions.md","assumptions.md","questions.md"],"test-analyst":["spec.md","tasks.md","test-plan.md","state.md"]}} -->
+<!-- loads: {"always":["devrites-lib/reference/parallel-workspaces.md","devrites-lib/reference/standards/core.md","devrites-lib/reference/standards/code-navigation.md","devrites-lib/reference/standards/code-index.md","devrites-lib/reference/standards/agents.md","rite-build/reference/phase-contract.md","rite-build/reference/one-slice-cycle.md","rite-build/reference/wright-dispatch.md","rite-build/reference/checkpoint.md","rite-build/reference/spec-drift-guard.md","rite-build/reference/output.md","rite-build/reference/anti-patterns.md"],"rootOnly":["devrites-lib/reference/standards/code-index.md","devrites-lib/reference/parallel-workspaces.md","rite-build/reference/phase-contract.md","rite-build/reference/wright-dispatch.md","rite-build/reference/checkpoint.md","rite-build/reference/output.md","rite-build/reference/afk-discipline.md","rite-build/reference/checkpoint-protocol.md","rite-build/reference/parallel-batch.md","devrites-lib/reference/standards/afk-hitl.md","devrites-lib/reference/standards/workflow-artifacts.md"],"triggers":{"afk":["rite-build/reference/afk-discipline.md","devrites-lib/reference/standards/afk-hitl.md","rite-build/reference/checkpoint-protocol.md"],"applicability":["devrites-lib/reference/standards/repository-topology.md","devrites-lib/reference/standards/data-integrity.md","devrites-lib/reference/standards/integration-reliability.md"],"coding":["devrites-lib/reference/standards/coding-style.md"],"debug-recovery":["devrites-lib/reference/standards/debug-recovery.md"],"dod":["devrites-lib/reference/standards/definition-of-done.md"],"errors":["devrites-lib/reference/standards/error-handling.md"],"frontend":["rite-build/reference/frontend-trigger.md"],"parallel":["rite-build/reference/parallel-batch.md","devrites-lib/reference/parallel-workspaces.md"],"patterns":["devrites-lib/reference/standards/patterns.md"],"principles":["devrites-lib/reference/standards/principles.md"],"security":["devrites-lib/reference/standards/security.md"],"tdd":["rite-build/reference/tdd.md","devrites-lib/reference/standards/testing.md"],"workflow-artifacts":["devrites-lib/reference/standards/workflow-artifacts.md"]},"workspace":["brief.md","spec.md","state.md","decisions.md","assumptions.md","questions.md","decision-coverage.md","architecture.md","plan.md","tasks.md","traceability.md","eng-review.md","test-plan.md","gates.md","strategy.md"],"workspaceByRole":{"code-reviewer":["spec.md","plan.md","tasks.md","test-plan.md","architecture.md","decisions.md","state.md"],"doubt-reviewer":["spec.md","plan.md","tasks.md","state.md","decisions.md"],"slice-wright":["brief.md","spec.md","architecture.md","plan.md","tasks.md","test-plan.md","state.md","decisions.md","assumptions.md","questions.md"],"test-analyst":["spec.md","tasks.md","test-plan.md","state.md"]}} -->
 > Read-set manifest: `devrites-engine context <slug> --phase build` bundles every file named below into one deduplicated read. Trigger names map to the conditional rules in the sections that follow.
 
 
@@ -80,12 +80,14 @@ Wright applies anti-slop; root verifies returns and never patches source. Refuse
 <!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"Vet-ready admitted bytes require root authorship outside product wright","action":"ROOT_TRANSACTION; root writes only admitted .devrites/** targets","return":"saved Build slice cursor; wright product allowlist unchanged"} -->
 ## `--parallel N` (opt-in)
 
-HITL default/explicit `1` ≡ serial; AFK inherits cap.
-`2`–`10` is a **cap** — the root runs an eligible
-path-disjoint set it can start now (`N_eff`, from `parallel select --from-plan`), takes fewer when the cap cannot be
-filled, and refills a slot per landing (serial slice or one sibling) until
-no pending slice remains
-([`parallel-batch.md` § Dynamic selection](reference/parallel-batch.md#dynamic-selection-and-re-batching)).
+Standalone HITL default/explicit `1` ≡ serial; AFK inherits cap. Under
+Autocomplete, read and execute shared root-only
+[`parallel-workspaces.md`](../devrites-lib/reference/parallel-workspaces.md)
+(trigger `parallel`, including global cap 1): controller/source routing,
+authorized pool, isolated first writer and continuous repair/re-Vet/refill.
+Standalone Build remains local. `2`–`10` is a cap, not a quota; eligible
+path-disjoint work refills after each landing
+([`parallel-batch.md`](reference/parallel-batch.md#dynamic-selection-and-re-batching)).
 Unattended runs (`/rite-autocomplete`, `.devrites/AFK` `max_parallel`) refill
 inside the same run; HITL stops after each landing. This invocation's `--parallel N`
 is the cap: leftover sentinel `max_parallel` is not consulted. Autocomplete with
@@ -102,8 +104,9 @@ a human `Fix`. Exhausted repair blocks and preserves everything;
 `cleanup --force` salvages slice branches before removing worktrees —
 human-gated to abandon a batch, orchestrator-emitted only as the salvage
 step of an automatic frozen-lease re-batch.
-AFK charges per landed sibling only. Running lease blocks another
-`/rite-build`. Details: `parallel-batch.md`.
+AFK charges per landed sibling only. A retained lease resumes through its
+controller; it blocks a competing Build root, not controller-owned source dispatch.
+Details: `parallel-batch.md`.
 
 ## Execute and reply
 

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

@@ -110,7 +110,7 @@ the hook receives:
 | `DEVRITES_QID` | the new qid (e.g. `q-2026-05-28-001`) |
 | `DEVRITES_GATE` | `advisory` / `validating` / `blocking` / `escalating` |
 | `DEVRITES_SLICE` | `<N — name>` |
-| `DEVRITES_SLUG` | active feature slug |
+| `DEVRITES_SLUG` | source feature slug |
 | `DEVRITES_QUESTION` | the checkpoint text |
 | `DEVRITES_PROPOSED` | the proposed answer |
 

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

@@ -70,7 +70,7 @@ After a crash, a fresh session may read the last `WIP(<slug>)` body as crash con
 Authoritative state remains in `.devrites/`: validate the body against that workspace;
 never reconstruct or advance state from the commit body. Reload per
 [`context-hygiene.md`](../../devrites-lib/reference/standards/context-hygiene.md)
-(`.devrites/ACTIVE`, `state.md`, `questions.md`, `decisions.md`, `test-plan.md`/`evidence.md`).
+(source-local `state.md`, `questions.md`, `decisions.md`, `test-plan.md`/`evidence.md`).
 
 ## Collapse at ship
 WIP commits are scratch and never reach shared history. `/rite-ship` folds them into the

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

@@ -4,6 +4,12 @@
 
 Opt-in only. Default `/rite-build` stays [`one-slice-cycle.md`](one-slice-cycle.md).
 
+Autocomplete first executes shared
+[`parallel-workspaces.md`](../../devrites-lib/reference/parallel-workspaces.md):
+it owns global admission, authorized source discovery and controller routing.
+The local selection below applies to standalone Build; mixed selection uses
+that reference and then this same per-slice review/repair/integration lifecycle.
+
 ## Entry
 
 | Input | Behavior |
@@ -14,8 +20,9 @@ Opt-in only. Default `/rite-build` stays [`one-slice-cycle.md`](one-slice-cycle.
 | Autocomplete `--parallel N` | N is the cap for this run; leftover sentinel `max_parallel` is ignored, then `/rite-autocomplete` writes or replaces only `max_parallel: N` |
 | Autocomplete, no flag | Same path, cap from sentinel `max_parallel` else 10; serial only when ineligible |
 
-AFK caps `N`. Charge green siblings once after integrate; abort /
-integrate-failed → **0**. `parallel create` refuses while a lease exists.
+AFK caps `N`. Charge each green sibling once after its successful landing;
+rejected/unlanded work charges zero, without undoing prior landed accounting.
+`parallel create` refuses another retained repository controller.
 Reconcile retained repair-round artifacts by exact causal fingerprint before honoring a stored blocked status/verdict. Blocked status, round count, or distinct finding alone cannot stop cold resume: establish missing or stale review coverage under step 4; repair unless a stop condition remains evidenced.
 
 ## Dynamic selection and re-batching
@@ -45,8 +52,10 @@ 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:
-≥2 → parallel batch, 1 → serial, none pending → Prove.
-Serial is this round only; a cap need not be filled.
+≥2 → parallel batch, 1 → standalone serial; Autocomplete cap>1 on a capable
+host instead isolates that first writer for global refill. No pending work
+returns to the caller's next phase; no ready local work does not exhaust its
+authorized global frontier. A cap need not be filled.
 
 **Refill per landing; never wait for the batch.** Each sibling lands alone when
 green ([Lifecycle](#lifecycle) step 6). Re-read state, pending slices, and the
@@ -91,33 +100,36 @@ lands a broken lockfile.
 
 ## Control vs workers
 
-Control owns `.devrites/work/<slug>/` (lease + bookkeeping).
-Workers: `.scratch/parallel-wt/<batch>/<slice>/` on
-`devrites/parallel/<slug>/<batch>/<slice>` @ base `B`. Wrights never write
-`.devrites/**`.
+Control owns the controller lease; source workspaces own their bookkeeping.
+Use returned worker `worktree_path`/`branch`: controller-local siblings retain
+`<batch>/<slice>`, foreign siblings use `<batch>/_workspaces/<source>/<slice>`.
+Workers never write `.devrites/**`.
 
-Lease: `batch_id`, `created_at`, `base_sha`, `n`,
-`status` (`running|aborted|integrate-failed|complete`), `control_pid_or_session`,
-`slices[]` (`id`, `paths`, `worktree_path`, `branch`, `wright_status`,
-`transfer_commit`).
+Lease includes `batch_id`, `created_at`, `base_sha`, `capacity`, `n`, `status`,
+`control_pid_or_session` and `slices[]` (`id`, optional `workspace`, `paths`,
+`worktree_path`, `branch`, `wright_status`, `transfer_commit`). Omitted workspace
+means controller; CLI lease `--slice` uses source-qualified foreign keys.
 
 ## Lifecycle
 
 1. Orient/gate; parse the cap; compute `N_eff` and select the eligible set
    ([Dynamic selection and re-batching](#dynamic-selection-and-re-batching)) —
-   `parallel select --slug <slug> --cap N --from-plan` (ready set, write paths,
-   and pairwise disjointness are inside that verb).
+   local `parallel select --slug <slug> --cap N --from-plan`, or Autocomplete's
+   authorized mixed-source query from the shared controller reference.
    Preflight each selected slice with `devrites-engine check slice <slug>
    <id>`, plus `check preconditions <slug> --slice <id>` when it has a
    `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 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`.
+2. Write lease with `parallel create --cap N`; freeze `B=HEAD`; create isolated
+   worktrees, including Autocomplete's first lone writer at cap>1.
+3. Dispatch ≤N active wrights globally (absolute cwd=returned worktree; exact
+   `devrites-slice-wright` native profile; source slug; allowlist; prove `HEAD==B`).
+   Source-local waves use one role per sibling:
+   `--role slice-wright.<SLICE-ID> --slice <SLICE-ID>`.
+   `start` every selected role across sources before waiting on any.
+   Shared `slice-wright` role is refused: one handle cannot track siblings.
+   Linked worktrees run source checks with `DEVRITES_ROOT=<control>/.devrites`;
+   source overrides never leak into controller lease mutations.
 4. Inspect each returned path list, cumulative diff from `B`, transfer identity,
    and required result fields against the immutable contract. Reject malformed,
    stale, or out-of-scope work. Freeze and probe the sibling in its worktree:
@@ -145,21 +157,30 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
    preserve completed and in-progress recoverable work and classify each result.
 6. `parallel integrate --slice <id> --apply-to-control` **only after its steps
    4–5 are green**: `transfer_commit` descends from the sibling's base and diffs
-   path-exact vs it; apply as its own local `WIP(<slug>):` commit
-   (imperative summary, never a slice id). Staging branch, then FF; the engine
-   refuses (never rewinds) if anything but this lease moved control. Conflict →
-   `integrate-failed`; classify under repair rounds (siblings stay in place).
+   path-exact vs it; apply as its own local `WIP(<source-slug>):` commit
+   (imperative summary, never a slice id). Staging branch, durable exact landing
+   intent, then FF; retry the same operation after interrupted persistence.
+   The engine reconciles only that recorded landing and refuses unrelated
+   HEAD/ref movement. Conflict → `integrate-failed`; classify under repair rounds
+   (siblings stay in place).
    Never integrate because a wright returned.
 7. Each landing: FF control (the branch that held `HEAD` when the batch started —
    often `main`/`master`, otherwise whatever the user was on) by one local commit,
-   never pushed; union that sibling's paths into `touched-files.md`; update
-   state/evidence; AFK +1; optional `check candidate`. Land every green sibling,
-   refill ([Dynamic selection](#dynamic-selection-and-re-batching)), then run the
-   feature gates once for the train
-   ([Proof tiers](phase-contract.md#proof-tiers)); the next train waits, the
-   refilled wrights do not.
-8. Cleanup runs only after the last landing marks the lease `complete` — work
-   landed in control, so `parallel cleanup` removes worktrees/branches.
+   never pushed; union only that sibling's paths into SOURCE `touched-files.md`;
+   update its checked BUILT state/evidence and regression floor; AFK +1 once.
+   Once every worker-bound reviewer/proof handle is terminal and source bookkeeping
+   is durable, run `parallel prune --root <repo> --slug <controller>` to release
+   clean integrated checkouts before refilling. It keeps transfer branches, proof
+   identities, lease rows and pending siblings. A dirty, ignored-data-bearing,
+   switched or unknown checkout stays untouched; record its recovery path and
+   continue safe independent work, never force-delete it to reclaim a slot.
+   Land every independently green sibling and refill globally immediately
+   ([Dynamic selection](#dynamic-selection-and-re-batching)), then run source-owned
+   feature gates for the train ([Proof tiers](phase-contract.md#proof-tiers));
+   refilled wrights do not wait for unrelated source proof.
+8. Whole cleanup runs only after the last landing marks the lease `complete`.
+   `parallel cleanup` removes verified disposable checkouts/branches; late edits,
+   ignored/untracked data and extra commits stay with reported recovery paths.
    Blocked/human-stopped batches keep lease, worktrees, branches — nothing is
    removed while the batch may resume. `parallel abort` + `cleanup --force`
    abandons the batch — the explicit human discard path; the single
@@ -225,9 +246,9 @@ Repair rejected work in place; never discard/rebuild while budget remains.
 ## Engine verbs
 
 ```text
-devrites-engine parallel select --cap <1-10> [--root <dir>] [--slug <slug>] [--from-plan | <json-file>|-]
-devrites-engine parallel create --root <repo> --slug <slug> --batch <id> --base <B> --json <file>|-
-devrites-engine parallel add --root <repo> --slug <slug> --json <file>|-
+devrites-engine parallel select --cap <1-10> [--root <dir>] [--slug <controller>] [--from-plan [--workspaces <controller,authorized-source,...>] | <json-file>|-]
+devrites-engine parallel create --root <repo> --slug <controller> --batch <id> --base <B> --cap <N> --json <file>|-
+devrites-engine parallel add --root <repo> --slug <controller> --cap <N> --json <file>|-
 devrites-engine parallel record-green --root <repo> --slug <slug> --slice <id> --commit <sha>
 devrites-engine parallel integrate --root <repo> --slug <slug> --slice <id> --apply-to-control
 devrites-engine parallel integrate --root <repo> --slug <slug> --apply-to-control

package/pack/generated/claude/skills/rite-build/reference/phase-contract.md

@@ -4,11 +4,13 @@
 
 Apply [`one-slice-cycle.md`](one-slice-cycle.md) and
 [`candidate-integrity.md`](../../devrites-lib/reference/candidate-integrity.md).
-Opt-in `--parallel N` replaces steps 2–8 with [`parallel-batch.md`](parallel-batch.md);
+`--parallel N` uses [`parallel-batch.md`](parallel-batch.md) for steps 2–8;
+Autocomplete also executes the shared
+[`workspace controller`](../../devrites-lib/reference/parallel-workspaces.md).
 Spec Drift Guard still applies.
 
-1. **Gate.** Read core, `.devrites/ACTIVE`, then `devrites-engine orient <slug>`
-   (`devrites-engine next <slug>` prints the minimal remaining path) and the
+1. **Gate.** Read core and ordered ACTIVE owner; use explicit SOURCE slug for
+   `devrites-engine orient <slug>` (`next <slug>` prints its minimal path) and the
    Build read-next in
    [`workspace-artifact-schema.md`](../../devrites-lib/reference/workspace-artifact-schema.md#read-next-by-phase):
    the selected slice via `devrites-engine observe slice <slug> <SLICE-ID>`, not whole
@@ -16,8 +18,9 @@ Spec Drift Guard still applies.
    `Implementation readiness: READY`, current `Readiness inputs SHA-256`, exact
    required accounts, ID/meaning traceability and green proof preflight.
    Run `devrites-engine check readiness <slug>`; any miss/nonzero blocks.
-   Non-empty `orient` `inflight_waves` is reconciled first: `dispatch return` each
-   role whose account is in hand, else `dispatch abandon --reason` and re-dispatch.
+   Non-empty `orient` `inflight_waves` is reconciled first: record accounts in
+   hand; retain running/unknown writer handles, claims and lease slots. Read-only
+   stale waves follow terminal reconciliation before re-dispatch, not blind abandon.
 2. **Select.** Pick the lowest pending slice whose `depends_on` are all built, using
    `orient` `task_graph.slices` plus the `state.md` built list — never by scanning
    `tasks.md`; then `observe slice` it. Restate its goal, ACs, exclusions and exact paths. Include

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

@@ -46,10 +46,10 @@ only per [`checkpoint.md`](checkpoint.md).
 
 Conflict, extra/missing commit, moved base, or cleanup failure is `gap`/STOP:
 preserve the worktree and commit. Without explicit reconciliation, use same-worktree serial.
-Parallel isolated-writer worktrees remain forbidden until this serial pilot measures
-transfer, conflict, proof, and review outcomes on both hosts; opt-in `/rite-build --parallel N`
-(2≤N≤10) path-disjoint fan-out is the only sanctioned parallel mode. Same-worktree multi-writer / root-emulated
-worktrees stay forbidden.
+Parallel isolated writers use only [`parallel-batch.md`](parallel-batch.md) and,
+under Autocomplete, the shared
+[`workspace controller`](../../devrites-lib/reference/parallel-workspaces.md).
+Same-worktree multi-writer / root-emulated worktrees stay forbidden.
 
 ## Prepare
 
@@ -131,9 +131,9 @@ a spec trace of the slice's obligations (hardening no AC/INV/PROH requires moves
 a sibling slice dependents do not need, still gated before Seal), and
 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)).
+or substitute a generic agent. Sanctioned parallel dispatch uses one exact
+wright per worktree, source-local `slice-wright.<SLICE-ID>` roles and starts
+all selected sources before first wait ([`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-clarify/SKILL.md

@@ -5,7 +5,7 @@ argument-hint: "[feature-slug]"
 user-invocable: true
 ---
 
-<!-- loads: {"always":["devrites-lib/reference/standards/core.md","devrites-lib/reference/standards/code-navigation.md","devrites-lib/reference/standards/code-index.md","devrites-lib/reference/standards/afk-hitl.md","rite-clarify/reference/decision-coverage.md","rite-clarify/reference/anti-patterns.md"],"triggers":{"agents":["devrites-lib/reference/standards/agents.md"]},"workspace":["brief.md","spec.md","state.md","decisions.md","assumptions.md","questions.md","decision-coverage.md"],"workspaceByRole":{"evidence-scout":["brief.md","spec.md","state.md","questions.md"]},"rootOnly":["devrites-lib/reference/standards/code-index.md","devrites-lib/reference/standards/afk-hitl.md"]} -->
+<!-- loads: {"always":["devrites-lib/reference/parallel-workspaces.md","devrites-lib/reference/standards/core.md","devrites-lib/reference/standards/code-navigation.md","devrites-lib/reference/standards/code-index.md","devrites-lib/reference/standards/afk-hitl.md","rite-clarify/reference/decision-coverage.md","rite-clarify/reference/anti-patterns.md"],"triggers":{"agents":["devrites-lib/reference/standards/agents.md"]},"workspace":["brief.md","spec.md","state.md","decisions.md","assumptions.md","questions.md","decision-coverage.md"],"workspaceByRole":{"evidence-scout":["brief.md","spec.md","state.md","questions.md"]},"rootOnly":["devrites-lib/reference/parallel-workspaces.md","devrites-lib/reference/standards/code-index.md","devrites-lib/reference/standards/afk-hitl.md"]} -->
 > Read-set manifest: `devrites-engine context <slug> --phase clarify` bundles every file named below into one deduplicated read. Trigger names map to the conditional rules in the sections that follow.
 
 
@@ -40,7 +40,7 @@ dispatch uses
 
 ## Workflow
 
-1. **Orient.** Read `.devrites/ACTIVE`, `state.md`, and `spec.md`. Require
+1. **Orient.** Resolve source per [phase target binding](../devrites-lib/reference/parallel-workspaces.md#phase-target-binding), then read its `state.md` and `spec.md`. Require
    `state.md` `spec_gate: passed` (legacy `Spec gate: passed` line accepted); otherwise stop at `/rite-spec`. Apply the native cursor
    protocol below before changing workspace artifacts.
 2. **Enumerate the topology.** From the spec, live code, contracts, references,

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

@@ -5,7 +5,7 @@ argument-hint: "[feature-slug]"
 user-invocable: true
 ---
 
-<!-- loads: {"always":["devrites-lib/reference/standards/core.md","devrites-lib/reference/standards/code-navigation.md","devrites-lib/reference/standards/code-index.md","devrites-lib/reference/standards/spec-grammar.md","devrites-lib/reference/standards/agents.md","devrites-lib/reference/standards/tooling.md","devrites-lib/reference/standards/testing.md","rite-converge/reference/convergence-assessment.md","rite-converge/reference/anti-patterns.md","rite-build/reference/spec-drift-guard.md"],"triggers":{"applicability":["devrites-lib/reference/standards/repository-topology.md","devrites-lib/reference/standards/data-integrity.md","devrites-lib/reference/standards/integration-reliability.md"],"principles":["devrites-lib/reference/standards/principles.md"],"workflow-artifacts":["devrites-lib/reference/workspace-artifact-schema.md"]},"workspace":["brief.md","spec.md","state.md","decisions.md","assumptions.md","questions.md","decision-coverage.md","architecture.md","plan.md","tasks.md","traceability.md","eng-review.md","test-plan.md","gates.md","evidence.md"],"workspaceByRole":{"evidence-scout":["spec.md","plan.md","tasks.md","state.md","evidence.md"]},"rootOnly":["devrites-lib/reference/standards/code-index.md","devrites-lib/reference/standards/tooling.md"]} -->
+<!-- loads: {"always":["devrites-lib/reference/parallel-workspaces.md","devrites-lib/reference/standards/core.md","devrites-lib/reference/standards/code-navigation.md","devrites-lib/reference/standards/code-index.md","devrites-lib/reference/standards/spec-grammar.md","devrites-lib/reference/standards/agents.md","devrites-lib/reference/standards/tooling.md","devrites-lib/reference/standards/testing.md","rite-converge/reference/convergence-assessment.md","rite-converge/reference/anti-patterns.md","rite-build/reference/spec-drift-guard.md"],"triggers":{"applicability":["devrites-lib/reference/standards/repository-topology.md","devrites-lib/reference/standards/data-integrity.md","devrites-lib/reference/standards/integration-reliability.md"],"principles":["devrites-lib/reference/standards/principles.md"],"workflow-artifacts":["devrites-lib/reference/workspace-artifact-schema.md"]},"workspace":["brief.md","spec.md","state.md","decisions.md","assumptions.md","questions.md","decision-coverage.md","architecture.md","plan.md","tasks.md","traceability.md","eng-review.md","test-plan.md","gates.md","evidence.md"],"workspaceByRole":{"evidence-scout":["spec.md","plan.md","tasks.md","state.md","evidence.md"]},"rootOnly":["devrites-lib/reference/parallel-workspaces.md","devrites-lib/reference/standards/code-index.md","devrites-lib/reference/standards/tooling.md"]} -->
 > Read-set manifest: `devrites-engine context <slug> --phase converge` bundles every file named below into one deduplicated read. Trigger names map to the conditional rules in the sections that follow.
 
 
@@ -16,7 +16,7 @@ Read `spec.md`, `plan.md`, and `tasks.md` as the **sole source of intent** (with
 implements, and **append every unmet piece as a new traceable `SLICE-###`** at the
 bottom of `tasks.md` so `/rite-build` can finish it. Use this for a resumed half-built
 feature, an adopted codebase that drifted from its derived spec, or a build that stalled
-mid-slice. **Read the active
+mid-slice. **Read the selected source
 workspace first**; if there's no `spec.md`/`plan.md`/`tasks.md`, tell the user which
 prerequisite skill to run.
 
@@ -74,9 +74,9 @@ Pull on demand:
 ## Workflow
 
 0. **Read `.claude/skills/devrites-lib/reference/standards/core.md`** first (the always-on
-   operating rules), then resolve the active slug, require its `state.md`, and
+   operating rules), then resolve source per [phase target binding](../devrites-lib/reference/parallel-workspaces.md#phase-target-binding), require its `state.md`, and
    read the cursor directly.
-1. **Confirm the gate.** Require `spec.md` + `plan.md` + `tasks.md` in the active workspace. If
+1. **Confirm the gate.** Require `spec.md` + `plan.md` + `tasks.md` in that source workspace. If
    any is missing, **STOP** and name the prerequisite (`/rite-spec` for a missing spec,
    `/rite-define` for a missing plan/tasks, `/rite-adopt` to onboard existing code). Do not
    produce partial output.