devrites 6.1.0 → 6.1.2

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

@@ -1,10 +1,10 @@
 # Stop conditions: when autocomplete pauses
 
 On a real stop, write `state.md` as `awaiting_human` or `blocked`, persist the
-reason, and include one resume command only when an actual human/safety/access
-action can change it. Exhausted agent-owned recovery records terminal
-`Next step: none` and no runnable recovery command. `--ship` never bypasses a
-stop.
+reason, and include one resume command. Agent-owned recovery never ends the run:
+a spent strategy escalates and a fully escalated fingerprint parks while other
+work continues ([retry contract](../../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve)).
+`--ship` never bypasses a stop.
 
 Authority: `.pi/skills/devrites-lib/reference/standards/acceptance-preserving-reslice.md`.
 
@@ -24,8 +24,8 @@ Regardless of flags or AFK ceiling:
 - external-service contract change; or
 - filesystem destruction outside the workspace.
 
-Red proof cannot advance. Run bounded Debug Recovery; stop after proven
-exhaustion unless the remaining owner is human.
+Red proof cannot advance. Run bounded Debug Recovery and escalate spent
+strategies; a fully escalated fingerprint parks unless the remaining owner is human.
 
 ## Not stops: internal technical routing
 
@@ -36,13 +36,16 @@ agent-owned.
 
 Agent-owned backtracking is not a stop condition while the exact causal
 fingerprint has budget. Invoke the earlier phase, affected Vet, remediation, and
-proof; then resume the origin. Stop only after three no-progress corrections of
-that exact fingerprint or a real human/safety/access gate. Preserve reproduction,
-attempts, and dead ends; never offer `/rite-plan unblock` or another routine
-phase command. Reinvocation with unchanged evidence does not reset the cap.
-`unchanged` means the same fingerprint already has three recorded no-progress
-corrections. Closure is progress; a separately evidenced Critical/Important
-invariant starts its own cap and cannot extend the closed one.
+proof; then resume the origin. Three no-progress corrections of that exact
+fingerprint spend only its current strategy: escalate to the next correction
+class inline (shared root cause, boundary redesign, diagnostic amplification)
+with a fresh budget, never asking permission. After three escalations in this
+activation the fingerprint parks; finish all independent work, then stop once.
+Preserve reproduction, attempts, and dead ends; never offer `/rite-plan unblock`
+or another routine phase command. A new user-issued `/rite-autocomplete`
+reopens parked fingerprints with fresh escalation; wakes and compaction do not.
+Closure is progress; a separately evidenced Critical/Important invariant starts
+its own cap and cannot extend the closed one.
 
 Spent consumptive-action authorization is not technical-recovery exhaustion.
 It blocks another execution; retained new Critical/Important evidence still
@@ -52,11 +55,10 @@ authorization and never reuse old GO.
 Past evidence being irretrievable is not by itself terminal. If an in-scope
 trusted seam can uniquely discriminate the next failure, run diagnostic-
 amplification Plan repair and narrow Vet inline, then pause for fresh GO before
-one evidence-acquisition attempt. Use terminal none only when no safe in-scope
-seam exists, a real human/risk/scope gate owns it, or bounded recovery is
-exhausted.
+one evidence-acquisition attempt. Without a safe seam, escalate to the next
+class or park; only a real human/risk/scope gate stops for a human.
 
-<!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"classifier returns owner-busy, exhausted, or existing hard gate","action":"stop on exact WAIT_ACTIVE_OWNER, BLOCKED_EXHAUSTED, or BLOCKED_GATE result","return":"unchanged cursor plus fixed route-owned output"} -->
+<!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"classifier returns owner-busy, exhausted, or existing hard gate","action":"escalate BLOCKED_EXHAUSTED; on WAIT_ACTIVE_OWNER run independent work and recheck; stop on exact BLOCKED_GATE result","return":"unchanged cursor plus fixed route-owned output"} -->
 ## Other stop classes
 
 - **Gate severity:** escalating always stops. Blocking with a ranked recommended
@@ -83,10 +85,15 @@ exhausted.
   pre-existing remaining value, explicit flag, sentinel cap, or post-vet pending count
   does not stop. Zero with no pending slices is normal completion.
   Malformed flag stops before any write.
+- **Foreign writer:** a `live`/`expired` claim or `WAIT_ACTIVE_OWNER` held by
+  another session blocks only work on those paths; run independent work, re-check,
+  and stop only when nothing independent remains. `released`/`dead` claims are
+  reconciled per [§ Cancellation](../../devrites-lib/reference/parallel-dispatch.md#cancellation-and-terminal-reconciliation).
 - **Resource envelope:** overlapping run or missing AFK after arm still stops.
   Do not stop on `--max-slices`, `max_agents`, `max_minutes`, or `max_review_queue`.
 - **Confidence:** intent still cannot become testable acceptance after interview.
-- **Repeated failure:** the exact fingerprint's bounded recovery is exhausted.
+- **Repeated failure:** not a stop. Escalate; a fully escalated fingerprint parks,
+  and the run stops only once no independent work remains.
 - **Resolver failure:** `devrites-engine state resolve` not found, or nonzero exit.
   Never hand-edit `questions.md`/`state.md` in its place. Not found stops at once;
   nonzero allows one identical re-run (the fingerprint is command + exit code +
@@ -101,7 +108,7 @@ disclose the exact plan, and stop for literal `GO` plus native approval. Without
 one, stop at Seal GO with `/rite-ship`. Seal GO, AFK, prior approval, and flags
 never satisfy Ship approval.
 
-A cold-resumable stop records `state.md` status, exact reason, and either one
-human-owned resume action or `none — technical recovery exhausted`; the owning
-question/drift/seal entry explains it. The user-facing line says what stopped
+A cold-resumable stop records `state.md` status, exact reason, and one resume
+action: the human-owned action, or `/rite-autocomplete` to reopen parked
+fingerprints; the owning question/drift/seal entry explains it. The user-facing line says what stopped
 and, only when applicable, what human action resumes it.

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

@@ -75,15 +75,15 @@ Wright applies anti-slop; root verifies returns and never patches source. Refuse
 
 Omitted/`1` ≡ serial; `2`–`10` is a **cap** — the root runs the largest eligible
 path-disjoint set it can start now (`N_eff`), takes fewer when the cap cannot be
-filled, and recomputes after every completed round (serial slice or parallel
-integrate) until no pending slice remains
+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)).
-Unattended runs (`/rite-autocomplete`, `.devrites/AFK` `max_parallel`) repeat batches
-inside the same run; HITL stops after each batch. This invocation's `--parallel N`
+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
 that flag also writes or replaces only `max_parallel: N`. Non-integer/`N≤0`/`N>10` hard refuse.
-All-green (independent review + proof) then integrate as one local `WIP(<slug>):`
-commit per sibling onto the current control branch (never pushed). Do not
+Each sibling lands alone when its review + proof are green (`integrate --slice`):
+one local `WIP(<slug>):` commit onto the control branch (never pushed). Do not
 integrate a sibling because the wright returned. A red/gap sibling gets a bounded repair
 round in its own worktree — never rebuilt from scratch while budget remains.
 Post-writer inventory and affected rechecks follow `phase-contract.md` § Independent
@@ -94,7 +94,7 @@ 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 after integrate only. Running lease blocks another
+AFK charges per landed sibling only. Running lease blocks another
 `/rite-build`. Details: `parallel-batch.md`.
 
 ## Execute and reply

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

@@ -44,8 +44,8 @@ The controlling root owns the cap:
    before the next dispatch.
    - **Serial:** charge when fail-on-red is green and the built record is written
      (same rewrite as step 2).
-   - **Parallel `--parallel`:** charge only after **successful serial integrate**
-     — once per integrated green sibling. Abort / integrate-failed → charge **0**.
+   - **Parallel `--parallel`:** charge only after **successful integrate**
+     — once per landed green sibling. Abort / integrate-failed → charge **0**.
      Do not charge on worktree-green before integrate. See
      [`parallel-batch.md`](parallel-batch.md).
 
@@ -69,13 +69,16 @@ wrong contract or proof path — agent-owned recovery; never advance on broken s
 The fail-on-red path:
 
 1. Continue the same wright under `devrites-debug-recovery`, carrying exact output and dead
-   ends; cap writer + recovery at three no-progress attempts per exact causal fingerprint.
+   ends; cap writer + recovery at three no-progress attempts per exact causal fingerprint
+   and strategy.
    A correction that closes the reproduction is progress; a different evidenced
    Critical/Important invariant starts a separate fingerprint.
 2. Green → record the slice. Product-contract/irreversible ambiguity → write the genuine
    human gate. Missing human-only credential/permission → write a human-intervention gate.
-3. Any other exhausted objective failure → set `Status: blocked`, preserve the reproduction,
-   set `Next step: none — technical recovery exhausted for <causal fingerprint>; requires new evidence or changed failure conditions`, and STOP without a qid or runnable phase command. Reinvocation with the unchanged fingerprint remains blocked and does not reset the cap.
+3. Any other spent strategy → escalate inline to the next correction class; after three
+   escalations park the fingerprint and build every slice that does not depend on it,
+   per the [retry contract](../../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve).
+   Never ask a qid or permission to retry; never hand back a routine phase command.
 4. Fire `notify:` only for an actual `awaiting_human` transition.
 
 AFK never starts the next slice while checks are red and never asks the human to approve

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

@@ -18,7 +18,7 @@ the orchestrator pauses for approval before landing it.
   and fail-on-red proof are green, with no open Critical/Important and no repair
   wright still in flight. Serial: git recipe below (skip empty index) or isolated
   FF of a matching `transfer_commit`. Parallel: `devrites-engine parallel
-  integrate --apply-to-control` (no second control `git commit`).
+  integrate --slice <id> --apply-to-control` (no second control `git commit`).
 - **Do not:** when a wright returns; before review/proof; with red/gap findings;
   fast-forward an isolated transfer onto control before those checks.
 

package/pack/generated/pi/skills/rite-build/reference/one-slice-cycle.md

@@ -28,7 +28,7 @@ RECORD    → orchestrator: after green verification, update state.md/evidence.m
             upsert the authoritative candidate manifest from the actual scoped diff
 (CHECKPOINT) → only now, with review+proof green: local WIP(<slug>): <imperative summary>
             on the control branch (no slice id) → checkpoint.md
-NEXT      → HITL root reports and stops. AFK with parallel cap>1: return to parallel-batch selection and run the new N_eff; otherwise repeat under afk-discipline.md
+NEXT      → HITL root reports and stops. AFK with parallel cap>1: return to parallel-batch selection to refill; otherwise repeat under afk-discipline.md
 ```
 
 ## Why the boundary matters

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

@@ -36,14 +36,14 @@ Select **greedily in plan order**: pass every currently dependency-ready pending
 `N_eff = 1` → one serial round; nothing pending → Prove. A cap that cannot be filled
 is normal: take fewer. Serial is this round's size, not the rest of the run.
 
-**Re-batch automatically after every completed round** (parallel integrate+cleanup or
-a serial slice). Re-read `state.md`, pending slices, and the tree, then run
-`parallel select` again: finished work leaves the pending set, and satisfied
-dependencies unlock new slices. Under `.devrites/AFK` and `/rite-autocomplete` the
-repeat is the same run — HITL stops after each batch. `--parallel 5` with one eligible
-slice runs that one; when two to five then become eligible, the next round takes that
-many. **Failing case:** the run stays one-by-one after a serial round even though more
-slices are now eligible under the same cap.
+**Refill per landing; never wait for the batch.** Each sibling lands alone when
+green ([Lifecycle](#lifecycle) step 6). Then re-read `state.md`, pending slices, and
+the tree and run `parallel select --cap N --slug <slug>`: unlanded siblings hold
+their slots and paths, landed ones count as built, and only new picks print;
+`parallel add` starts each from the control tip and its wright dispatches at once.
+No lease → plain `select` + `create`. AFK/autocomplete is one run; HITL stops after
+each landing. **Failing case:** three siblings are green, one is repairing, and no
+new slice starts.
 
 ## Path-disjoint
 
@@ -109,22 +109,27 @@ Lease: `batch_id`, `created_at`, `base_sha`, `n`,
    headroom bounds the batch size — one batch never assumes unbounded reviewers.
 5. Non-green siblings → **repair round** (below) in the same worktrees; lease
    stays `running` — no abort while repair budget remains. A green sibling →
-   `parallel record-green`. No partial integrate. All green → integrate.
+   `parallel record-green`, then step 6 for it alone.
    A recoverable RED blocks integration but does not cancel independent safe running siblings.
    Expected test-first RED is not a terminal gate failure. Cancel only for a shared
    invalid foundation, safety/access failure, resource boundary, or explicit stop;
    preserve completed and in-progress recoverable work and classify each result.
-6. `parallel integrate --apply-to-control` **only after steps 4–5 are green**:
-   each `transfer_commit` descends from `B` and diffs path-exact vs
-   `B`; apply each in plan order as its own local `WIP(<slug>):` commit
-   (imperative summary, never a slice id). Staging branch, then FF. Conflict →
-   reset to `B`, `integrate-failed`; classify under repair rounds (siblings stay
-   in place). Never integrate because a wright returned.
-7. Success: FF control (the branch that held `HEAD` when the batch started —
-   often `main`/`master`, otherwise whatever the user was on) to the integrate
-   tip: N local commits, never pushed; union `touched-files.md`; update
-   state/evidence; AFK +1 per integrated sibling; optional `check candidate`.
-8. Cleanup runs only after `integrate` marks the lease `complete` — work
+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).
+   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 for that sibling; optional `check candidate`. Then
+   refill ([Dynamic selection](#dynamic-selection-and-re-batching)) and start the
+   feature gates on control
+   ([Proof tiers](phase-contract.md#proof-tiers)); the next landing waits for them
+   to pass, 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.
    Blocked/human-stopped batches keep lease, worktrees, branches — nothing is
    removed while the batch may resume. `parallel abort` + `cleanup --force`
@@ -182,18 +187,20 @@ Repair rejected work in place; never discard/rebuild while budget remains.
   exhaustion. Use plan path only if inventory proves the approach unsound.
 - Stop under the canonical retry/authority/resource conditions, or when evidence
   proves the approach unsound and no in-scope corrected decomposition exists.
-- Exhaustion is not abort: record one technical blocker (`Status: blocked`;
-  `Next step: none — technical recovery exhausted; requires new evidence or changed failure conditions`), preserve
-  lease/worktrees/branches, STOP — same fingerprint stays blocked on
-  reinvoke; new evidence resumes repair in place. Human-owned decisions use
-  the drift-guard question and wait.
+- A spent strategy is not abort: escalate per the canonical retry contract,
+  preserving lease/worktrees/branches; a fully escalated fingerprint parks and
+  the batch keeps its independent members. Repair resumes in place on
+  escalation or reinvocation. Human-owned decisions use the drift-guard
+  question and wait.
 
 ## Engine verbs
 
 ```text
-devrites-engine parallel select --cap <1-10> [--root <dir>] [<json-file>|-]
+devrites-engine parallel select --cap <1-10> [--root <dir>] [--slug <slug>] [<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 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
 devrites-engine parallel status --root <repo> --slug <slug>
 devrites-engine parallel lease-write|lease-read|lease-clear --root <repo> --slug <slug>

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

@@ -42,7 +42,8 @@ Spec Drift Guard still applies.
 6. **Prove.** Against the frozen pre-slice candidate inspect
    test hunks for deletion, skipping/focus, tautology, or weaker expectations.
    Wait for step 5's exact test-analyst account; missing/adverse criterion verdict is
-   Critical. Run only `test-plan.md` repository/CI commands, record output, recheck
+   Critical. Run only `test-plan.md` repository/CI commands ([tier](#proof-tiers)),
+   record output, recheck
    `git diff --name-only`. Missing/weakened/red/source-mutating proof cannot pass.
    Pre-existing/environment-specific claims need a predating same-command,
    same-environment baseline; otherwise unresolved.
@@ -67,6 +68,14 @@ Spec Drift Guard still applies.
 
 One contract builds one slice: preserve TDD, exact paths and independent judgment.
 
+## Proof tiers
+
+With a `test-plan.md` `## Feature gates` section, step 6 runs `Tests/proof` and every
+other row; feature gates run once per parallel landing, on control, while worktree
+wrights continue. The next landing and Prove wait for them; red is a fingerprint
+against slices landed since the last green run. Serial same-worktree mode, and plans
+without the section, run every row each round.
+
 ## Independent Build review
 
 After inspection, freeze full slice scope and cumulative baseline diff. Initial

package/pack/generated/pi/skills/rite-build/reference/spec-drift-guard.md

@@ -82,5 +82,6 @@ The detecting phase owns backtracking and the batch sweep. Save
 `return_phase`/`return_next_action`; consume nested Plan/Vet `STOP` internally, complete
 vetted acceptance-preserving remediation, then restore the cursor and failed step.
 Never hand the human an intermediate command. The shared three-attempt causal-fingerprint
-cap still applies: exhaustion produces one technical blocker, while a genuinely
-human-owned decision uses the question format below.
+cap still applies: a spent strategy escalates and a fully escalated fingerprint parks
+under the [retry contract](../../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve),
+while a genuinely human-owned decision uses the question format below.

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

@@ -144,8 +144,8 @@ TTL is crash recovery, not normal cleanup.
    **Do not land on control until review and proof are both green.** Isolated
    `transfer_commit` stays on the worker branch; same-worktree diffs stay
    uncommitted. Serial: [`checkpoint.md`](checkpoint.md), then host may remove the
-   worktree. Parallel: `record-green` only; land with `parallel integrate
-   --apply-to-control` after the batch; `parallel cleanup` removes worktrees.
+   worktree. Parallel: `record-green`, then `parallel integrate
+   --slice <id> --apply-to-control`; `parallel cleanup` removes worktrees.
 5. Reconcile returned reuse, conventions, principles, sources, assumptions,
    decisions, dead ends, follow-ups, gates, and touched files. Persist the
    relevant facts in canonical artifacts, not the wholesale report. A plan-gap

package/pack/generated/pi/skills/rite-define/SKILL.md

@@ -161,7 +161,7 @@ Pull these via `Read` when shaping the plan:
    meaning-changing mappings block. Then run
    `devrites-engine check task-graph <slug>`; a malformed dependency graph blocks
    before Vet rather than spending a reviewer context on invalid tasks. Resolve each
-   `ADVISORY size:` line now (split, or `Size rationale:`); it never blocks.
+   `ADVISORY size:`/`hub:` line now (split or seam slice, or a rationale); never blocking.
 7. **Readiness gate** (`plan-template.md`): require CLEAR coverage; complete acceptance,
    wiring, shared-contract proof, applicable outputs, and rollback; risk-first acyclic order;
    justified deviations; and every horizon item present, with blockers resolved, planning

package/pack/generated/pi/skills/rite-handoff/SKILL.md

@@ -74,7 +74,7 @@ themselves. The workspace is the canonical store; the handoff is the chat-only d
 6. **In-flight work.** Every dispatch wave opened or sealed without a return (`devrites-engine
    dispatch <slug> status`), running writer handle, held claim id plus paths (`devrites-engine
    claim list --all`), and consumptive action started, each `terminal: yes|unknown` (`yes` only with
-   an admitted return, release, or proof of stop). The live handle exists only in chat. Any
+   an admitted return, release, `dead` claim, or proof of stop). The live handle exists only in chat. Any
    `unknown` row makes item 1 a reconcile step (`dispatch <slug> status`, `parallel status`,
    `claim list --all`), never a writer command: otherwise the next session dispatches a second writer.
 7. **How to resume:** fixed boilerplate (see template below).

package/pack/generated/pi/skills/rite-plan/SKILL.md

@@ -177,7 +177,7 @@ Before classifying any Reslice, read `.pi/skills/devrites-lib/reference/standard
 
 When invoked inline by a controlling rite, return the completed Plan checkpoint
 to that caller so it can invoke Vet immediately. The phase boundary is not a
-user-facing stop unless a genuine HITL, safety/access, or exhausted-recovery
+user-facing stop unless a genuine HITL, safety/access, or parked-recovery
 condition was recorded.
 
 When invoked directly with no controlling caller and a planning artifact

package/pack/generated/pi/skills/rite-plan/reference/slicing.md

@@ -168,3 +168,8 @@ Order by dependency, but minimize coupling. A slice that needs three other slice
 is a smell: look for a thinner cut that stands alone. An edge exists only when this slice
 reads something the other produces: write it as `SLICE-001 (via <interface>)`. If you
 cannot name what crosses, drop the edge; a shallow, wide graph runs in parallel.
+
+Slices sharing a file never build side by side: put a hub file's shared edit
+(registry, command table, test harness) in one seam slice the others depend on.
+`check task-graph` prints the `schedule:` and `ADVISORY hub:` lines; inseparable
+writes get `Serial rationale: <why>`. Never merge slices or drop acceptance to widen it.

package/pack/generated/pi/skills/rite-prove/SKILL.md

@@ -37,8 +37,10 @@ TTHW, and exact signal-bearing errors; never assert DX (trigger `devex`).
   validates it. Only the bounded wright fixes product source/tests.
 - **Prove remains the controlling caller** during technical backtracking. Save
   its cursor; run Plan repair, Recovery Vet, remediation, and re-proof inline;
-  consume nested boundaries; resume the failed rung. Recovery exhausts after
-  three no-progress attempts on the exact same fingerprint. Closing one or exposing a distinct
+  consume nested boundaries; resume the failed rung. A strategy is spent after
+  three no-progress attempts on the exact same fingerprint; escalate it per the
+  [retry contract](../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve)
+  instead of stopping. Closing one or exposing a distinct
   Critical/Important invariant is progress, not a reason to hand work off.
 <!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"Prove consumes installed Workflow Artifact or CLEANED rerun","action":"VERIFY_EXISTING or admitted proof path ending PROVE_AND_RETURN","return":"saved Prove cursor; stop before real action"} -->
 ## Released-workspace refresh

package/pack/generated/pi/skills/rite-prove/reference/failure-triage.md

@@ -47,6 +47,7 @@ loop to `devrites-debug-recovery`.
 - Three no-progress attempts on the exact same causal fingerprint consume the
   shared recovery cap. A recheck that closes the reproduction is progress; a
   different evidenced Critical/Important invariant gets its own fingerprint.
-  Preserve the reproduction and dead ends, then stop once as a technical blocker.
+  Preserve the reproduction and dead ends, then escalate or park per the
+  [retry contract](../../devrites-lib/reference/standards/afk-hitl.md#retry-cap-no-progress-loops-and-self-resolve).
   Ask only when the remaining decision is human-owned.
 - A failure you can't fix in scope is a recorded **blocker**, not a silent skip.

package/pack/generated/pi/skills/rite-spec/reference/state-workspace.md

@@ -131,7 +131,7 @@ None.
 | slice_mode | none |
 | risk | none |
 | spec_gate | <passed <iso>; marker sweep: <n> files, <k> hits, <d> discarded — absent until /rite-spec passes> |
-| next_action | <single command + reason, or terminal: none — technical recovery exhausted for an unchanged causal fingerprint> |
+| next_action | <single command + reason; parked recovery names the invoking command> |
 | return_phase | <originating later phase; clarification or agent-owned technical backtracking only> |
 | return_next_action | <saved originating command> |
 | schema | 4 |
@@ -154,7 +154,7 @@ Before an active caller moves backward, it copies its current phase and
 non-empty action into the two return rows. Nested Plan, Vet, Build, and proof
 work preserves that valid cursor. Once the prerequisite chain is green, the
 controlling caller restores the saved phase/action and removes both rows in one
-rewrite. A real HITL or exhausted-recovery stop retains the cursor for cold
+rewrite. A real HITL or parked-recovery stop retains the cursor for cold
 resume. Never overwrite an existing valid return cursor, and preserve every
 unrelated Markdown byte. `/rite-clarify` applies its stricter native cursor protocol in `/rite-clarify`.
 

package/pack/generated/pi/skills/rite-vet/reference/artifacts.md

@@ -103,6 +103,14 @@ From /rite-vet on <iso>. Runner + conventions: <detected framework + command>.
 Link any disposable parser fixture. Preflight values are planning evidence, not post-build proof;
 Prove recaptures the observed command, candidate identity, and result.
 
+## Feature gates
+| Gate | Command | Cwd | Expected |
+|---|---|---|---|
+| <full suite / workspace lint / audit> | <exact command> | <path> | <exit/output> |
+
+Whole-repository rows only: Build runs them per landing
+([tiers](../../rite-build/reference/phase-contract.md#proof-tiers)), Prove on the final candidate.
+
 Commands in this durable artifact are portable repository commands: no RTK or local shell
 aliases, user-specific absolute paths, or temporary proof trees. Evidence records
 the command actually executed.

package/pack/generated/pi/skills/rite-vet/reference/review-axes.md

@@ -30,7 +30,7 @@ Before implementation review, check for work beyond the settled spec.
    (over-budget `tasks.md`/`plan.md` from slice or AC count) is a scope finding, not a
    `Budget override`: route to `/rite-plan course-correct` (`MVP cut`) with the
    continuation sequence named; do not vet the whole epic. An `ADVISORY size:`
-   slice without `Size rationale:` is a non-blocking Suggestion to split it.
+   or `hub:` line without its rationale is a non-blocking Suggestion to split or seam it.
 4. **Built-in check.** For each new pattern/infra/concurrency approach, invoke
    `devrites-source-driven` inline to verify current framework/runtime support and cite it. Custom
    work where a built-in suffices is a scope-reduction finding.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devrites",
-  "version": "6.1.0",
+  "version": "6.1.2",
   "description": "DevRites: a disciplined senior-engineer workflow pack for Claude Code, Codex, omp, pi, and Devin CLI",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://github.com/ViktorsBaikers/DevRites#readme",