devrites 7.2.8 → 7.3.0

package/pack/generated/pi/skills/devrites-lib/reference/parallel-workspaces.md

@@ -0,0 +1,202 @@
+# One controller, multiple workspace sources
+
+> Root-only: not inlined in --role bundles. Every phase uses target binding below;
+> Autocomplete owns the global workflow. Standalone Build stays source-local.
+
+## Phase target binding
+
+For every lifecycle phase and cold handoff, resolve the existing explicit target
+or caller-supplied SOURCE slug first; use `.devrites/ACTIVE` only when neither is
+supplied. All workspace context, cursor, questions, artifact reads/writes, approval,
+candidate bindings and proof belong to that source. A missing source artifact
+routes its prerequisite; it never falls back to another workspace's artifacts.
+An explicit valid workspace does not require ACTIVE to name it or to exist.
+
+Carry that source through Spec → Clarify → Temper → Define/Plan → Vet and later
+Build/Converge/Prove/Polish/Review/Seal/Ship entrypoints. Use existing slug arguments
+where supported, including `context <source>` and `handoff <source> --resume`.
+For qid-only `state resolve` (including `--drop`/`--batch`), keep its existing argv
+and bind the call with `DEVRITES_ROOT=<absolute-control>/.devrites` and
+`DEVRITES_WORKSPACE=<absolute-control>/.devrites/work/<source>`. The override is a
+workspace path, not a slug. Apply this environment only to that invocation;
+neither a fabricated resolver slug argument nor process-global environment
+mutation is routing. Use the same source binding for nested recommended answers.
+
+Preparing or running an admitted future source preserves the ordered owner's
+ACTIVE and retained writer/controller. Ordinary standalone Spec still sets ACTIVE;
+explicit `--lookahead` still stops at planning/Vet and never becomes a Build root.
+Target binding changes neither phase approval nor Ship authority.
+
+## Authority and admission
+
+Resolve one controlling root and ordered lifecycle owner. `.devrites/ACTIVE` stays
+on that owner until normal sequence handoff; scheduling a future slice does not
+advance ACTIVE or create a second Build root. One repository-global lease owns
+control-tip mutations. Resume its controller, source identities and retained
+handles before admitting more work; status queried via ACTIVE/source reports the
+actual retained controller even after ordered handoff. Another retained
+controller is not bypassable; no extra cursor pointer is needed.
+
+The existing `--parallel N` is one global active-writer cap across all sources:
+explicit invocation value, else AFK `max_parallel`, else retained lease capacity
+on resume, else 10. Explicit 1 means one writer, not one writer per workspace.
+Review queues obey host capacity and existing reviewer caps separately; they never
+erase required specialist accounts.
+
+Discover only recorded forward sequence continuations through `sequence_parent`
+and the parent's recorded objectives. Honor `continue_sequence: false`, opening
+budget and human bounded requests. Charge each opening once; reuse prepared
+children and their cursor rather than re-specifying or charging them again.
+An unrelated directory or user-mentioned slug is not automatic enrollment.
+Respect workspace claims: a live lookahead owner retains its artifacts until
+release/terminal reconciliation. Root alone writes workspace artifacts; leaves
+never write `.devrites/**`.
+
+For each future slice, native Plan/Vet must have CURRENT approved readiness,
+a complete bound contract and explicit `Workspace dependencies` under
+[canonical slice grammar](workspace-artifact-schema.md#canonical-slice-grammar).
+Plan/Vet checks assumptions, consumed interfaces, shared runtime resources and
+independent slice proof. `none` is a native declaration, never an inference from
+path disjointness, local `Dependencies: none`, planning digests or a green branch.
+Only durably BUILT/integrated producer checkpoints satisfy qualified dependencies;
+validate each producer reference and graph, including safely archived predecessors.
+Cycles, unknown/malformed references and shared unisolated runtime withhold unsafe
+candidates. A waiting producer withholds only its consumers, not unrelated work.
+
+Missing declarations in legacy future plans need narrow Plan repair + affected
+Vet before early admission; existing local/standalone plans remain valid. Absent,
+incomplete, stale or human-blocked future work is a planning/repair/blocked
+opportunity, not a fatal pool failure. Retain every readiness reason: fixing stale
+bindings does not waive a coexisting human/access/safety gate. Re-Vet affected
+predecessor assumptions, then record current bindings; never auto-refresh a digest.
+
+## Recover avoidable serialization
+
+At native Plan/Vet, and when a full global scan leaves writer capacity unused,
+audit the remaining frontier before treating serialization as irreducible:
+
+1. Name what each edge consumes: product/interface, integration evidence, shared
+   writable path, runtime resource or explicit authority. Sequence/release order
+   alone is not a product dependency; current recorded prohibitions still bind.
+2. Recut unstarted work only where an accepted vertical capability is functional,
+   independently provable and rollbackable against an already real contract.
+   Keep producer edges on actual consumers and dependent integration/proof.
+   Consolidate hub edits in their real producer; worktrees alone do not isolate
+   shared files, databases, ports, credentials or measurement windows.
+3. Root routes a concrete opportunity through native Plan and the canonical
+   [Reslice classifier](standards/acceptance-preserving-reslice.md), preserving
+   every acceptance meaning, prohibition, semantic link and proof obligation.
+   Carry the blocked edge/resource and proposed independent cut into the drafter
+   packet. Invalidate readiness, obtain affected Vet, then reselect; a proposed
+   split or green branch is not admission authority.
+4. Freeze admissions to affected sources during repair. Preserve built and leased
+   slice identities/contracts; drain/reconcile affected workers before publishing
+   a repair that changes their inputs. Unrelated source planning/writers continue.
+5. Preserve human/safety/access/resource gates and explicit planning-only bounds.
+   Classify any authority change through its owning decision; never replace an
+   explicit prohibition with inferred permission or create placeholder slices.
+
+Completion: either admit a currently approved independent cut, or retain
+`Serial rationale: <consumed contract/resource/authority; next unblock event>`
+in affected `tasks.md` slice blocks only when normal Plan write authority permits; otherwise
+report the existing blocker without planning writes. Revisit after relevant
+inputs change, not merely because capacity remains unused. Target width never
+justifies extra architecture, acceptance loss, premature proof or repeatedly
+reslicing unchanged work.
+
+## Continuous global frontier
+
+At entry, each landing, planning/review return and before any wait or final reply:
+
+1. Re-read controller lease, per-source state/questions/readiness and authorized
+   sequence. Scan all stages, not only the owner's next local slice. While writers
+   run, root advances authorized Spec → Clarify → Temper → Define/Plan → Vet,
+   including narrow repair/re-Vet of prepared targets, under unchanged approval
+   and safety rules. Missing human authority blocks that target, not safe siblings.
+   If an explicit/AFK capacity change differs from retained capacity, reconcile it
+   before selection using `parallel add --root <repo> --slug <controller> --cap N --json -`
+   with stdin `[]`. This changes capacity only, not workers or a complete lease's
+   status. A decrease below active count refuses: pause admissions and drain to
+   the requested count, then retry; never cancel workers to meet a lower cap.
+   A pending landing is recovery, not free capacity: retry the exact recorded
+   integrate before admission; unrelated HEAD/ref movement remains blocked.
+2. Query the mixed pool in stable sequence order, controller first (the ordered
+   ACTIVE owner may now differ):
+   `devrites-engine parallel select --root <repo> --slug <controller> --from-plan --workspaces <controller,authorized-source,...> --cap N`.
+   `--workspaces` is an internal data-source parameter, not a user feature flag.
+   Read all notices and route repair/waits to their source. Existing running slots
+   and paths seed selection globally. Zero new picks with live writers means keep
+   planning/reviewing or wait, not Prove for those unfinished sources.
+3. Preflight selected slices against their SOURCE workspace with Build's normal
+   slice/readiness/precondition, exact-path and runtime-isolation gates. Early
+   foreign Build always uses isolated workers. For cap>1 on a capable host,
+   isolate even the first lone local writer, so later sources can refill. Persist
+   `--cap N` on create/add. With a retained lease, add even one pick; a complete
+   retained lease can reopen only at unchanged control tip. After cleanup,
+   create a new batch from current control. Never start another controller.
+   Unsupported isolation uses truthful serial owner dispatch and ordinary ordered
+   handoff, never early same-tree foreign Build or concurrent same-worktree writers.
+4. Launch every selected native writer before waiting on any; keep scheduling
+   planning and independent review while they run. Land each individually green
+   sibling through Build review/proof and `parallel integrate --slice <key>`;
+   refill immediately from the whole authorized pool. A red sibling repairs in
+   place and holds its slot/paths; it does not delay independent green landings.
+   Never satisfy a producer edge on writer return or green-but-unlanded work.
+   After worker-bound review/proof and source bookkeeping finish, prune only
+   verified clean integrated checkouts with `parallel prune --root <repo>
+   --slug <controller>`. Retain transfer refs/lease identities; dirty or ignored
+   data stays with its reported recovery path and does not justify forced deletion.
+
+## Identity, dispatch and proof
+
+Mixed JSON uses `{"slices":[{"id":"SLICE-001","paths":["src/child.go"],"workspace":"child"}]}`.
+Omitted workspace means controller; explicit controller normalizes to that lane.
+Lease targeting uses bare `SLICE-001` only for controller, `child/SLICE-001` for
+foreign sources. Duplicate local IDs across sources remain distinct typed keys.
+Use the lease's worktree/branch paths, not hand-built namespaces.
+
+Controller slug owns `parallel create/add/status/record-green/integrate/prune/cleanup`.
+SOURCE slug owns `context`, `packet`, `dispatch open/start/return`, slice checks,
+candidate freeze, proof, repair, evidence and bookkeeping. Open source-local waves
+with local roles `slice-wright.<SLICE-ID>` and local `--slice <SLICE-ID>`; no slash
+in a dispatch role. Start every source wave before first wait. Root explicitly
+supplies source slug, absolute worktree cwd, base and exact native profile to every
+writer/reviewer. Writer profile is `devrites-slice-wright`, never a suffixed or
+generic profile; reviewers use exact workflow-named `devrites-*` profiles in fresh
+read-only context. Labels/handles are not proof of native profile selection.
+Linked worktrees use `DEVRITES_ROOT=<control>/.devrites` for metadata, not source cwd.
+
+Run controller/global commands in a per-invocation environment without inherited
+worker `DEVRITES_WORKSPACE`; source calls use explicit source slug and control
+`DEVRITES_ROOT` in a source-bound environment, never another source's override.
+Never mutate process-global environment or ACTIVE to route a call.
+
+Freeze/review/prove each source slice in its own worktree/candidate window under
+Build's full required inventory, affected rechecks and repair rules. After landing,
+write `WIP(<source>):` with human summary, union only that source's paths into its
+manifest, persist checked BUILT/evidence and charge once there. Run source-local
+regression checks on resume and ratchet only after durable green advance. Neither
+controller bookkeeping nor sibling proof closes a child's acceptance.
+
+## Lifecycle closeout and Ship
+
+Prove/Polish/Review/Seal remain per workspace with fresh candidate bindings. Shared
+durable Polish outputs serialize; source changes invalidate affected evidence.
+Before any non-lease product correction, shared durable Polish write or control
+checkpoint, freeze new writer admissions, drain/reconcile retained writers, land
+safe green work and cleanup the lease. Preserve blocked work; never force-clean
+it merely to advance a phase. Perform phase-owned correction/proof/checkpoint,
+then resume the pool from new HEAD. Never accept unrelated commits as expected
+ControlTip or invent phase slices. Read-only frozen proof/review and planning-only
+`.devrites` repair may overlap writers; none may mutate the leased product/control tip.
+Normal ordered handoff reuses the same controller and prepared child cursor.
+Never archive controller/source while retained lease owns it; clean up owned
+workers first, preserving salvage and unknown outcomes.
+
+Early child WIPs can interleave with parent WIPs. Parent-only Ship must not absorb
+those commits as if parent alone were sealed. Deferred release waits for every
+participating sequence member's final proof/Review/Seal, uses engine-generated
+release union manifest and re-proves affected cross-workspace acceptance. Disclose
+all participating checkpoints in the exact Git plan, verify unchanged candidate
+and staged bytes, then require fresh literal `GO` plus native approval. Parallelism
+grants no push/tag/deploy authority and never broadens an earlier Ship approval.

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

@@ -118,18 +118,15 @@ candidate manifest to cover the whole recorded chain — run
   `/rite-autocomplete` recovers agent-owned Seal `NO-GO` per
   [stop-conditions.md](../../../rite-autocomplete/reference/stop-conditions.md), not a handoff.
 
-`max_parallel` is the unattended default batch cap only when this invocation does
-not contain `--parallel N`; `1` forces the serial cycle only in that default
-case. An exact `--parallel N` on `/rite-autocomplete` or `/rite-build` is the
-batch cap for this run: do not consult leftover sentinel `max_parallel`, and do
-not treat `max_parallel: 1` as serial. `/rite-autocomplete --parallel N` writes
-or replaces only that field so later ticks keep the cap; `/rite-build --parallel N`
-wins for that invocation without rewriting the sentinel. Never write `max_slices`
-from `--max-slices`. **Failing case:** `/rite-autocomplete --parallel 5` honors a
-leftover `max_parallel: 1` and stays serial.
-Unattended runs take the largest eligible set ≤ that 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)).
+`max_parallel` is the unattended default writer cap when this invocation omits
+`--parallel N`; explicit N wins and Autocomplete writes/replaces only that field.
+Build's explicit flag wins without rewriting the sentinel. Never write
+`max_slices` from `--max-slices`. Autocomplete uses one cap across all authorized
+sources, including explicit 1, under the shared root-only
+[`workspace controller`](../parallel-workspaces.md); standalone Build stays local.
+Unattended runs recompute after each landing and planning/review return, not only
+after a batch completes. **Failing case:** `/rite-autocomplete --parallel 5`
+honors leftover `max_parallel: 1`, or grants five writers per workspace.
 
 ## Unattended resource envelope
 

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

@@ -72,7 +72,7 @@ Only that bounded writer may edit its exact project-relative source/test paths;
 workspace writes, scope widening, or second writer. Root remains source/test nonwriter.
 This exception grants no additional tools, permissions, phase, agent-launch, or Git authority.
 
-Isolated-worktree pilot only under [`wright-dispatch.md`](../../../rite-build/reference/wright-dispatch.md#isolated-writer-worktree-pilot): one writer, committed/clean baseline, non-submodule parent, exact transfer commit, candidate reconciliation — never parallel writers nor weaker exact-path admission. Root may materialize only exact Vet-ready workflow-artifact paths per [`workflow-artifacts.md`](workflow-artifacts.md) — not a writer dispatch or candidate mutation.
+Isolated-worktree pilot follows [`wright-dispatch.md`](../../../rite-build/reference/wright-dispatch.md#isolated-writer-worktree-pilot); sanctioned parallel work follows [`parallel-batch.md`](../../../rite-build/reference/parallel-batch.md) and Autocomplete's shared [`workspace controller`](../parallel-workspaces.md), never same-tree co-writers or weaker exact-path admission. Root may materialize only exact Vet-ready workflow-artifact paths per [`workflow-artifacts.md`](workflow-artifacts.md) — not a writer dispatch or candidate mutation.
 
 Each job gets objective/exclusions, exact paths/immutable candidate, rubric/result shape, a **stop condition** (when to return), and the exact result shape; a dispatch missing them is malformed and re-issued. Briefs MUST NOT seed verdict/severity cap/conclusion/suppression. Results state status/scope, outcome, commands/escalation; wright adds paths, changed files, gates, stood decisions; results never widen scope.
 

package/pack/generated/pi/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/pi/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/pi/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/pi/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 --skills-root .pi/skills <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/pi/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/pi/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/pi/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 --skills-root .pi/skills <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/pi/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/pi/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