devrites 5.10.2 → 5.12.0

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

@@ -0,0 +1,157 @@
+# The autocomplete loop: arm AFK, drive every phase
+
+Autocomplete sequences existing `/rite-*` workflows without pausing between
+routine phases. Acceptance-preserving Reslice authority is
+`.devin/skills/devrites-lib/reference/standards/acceptance-preserving-reslice.md`.
+
+<!-- BEGIN RESLICE ROUTE-TO-ACTION -->
+- `FOLD` → keep Plan repair/affected Vet internal; no stop solely for topology/count.
+- `GUARD_AND_REPAIR` → enter Spec Drift Guard/Clarify; pause only at an existing human-owned gate; resume Plan/Vet internally.
+- `BLOCKED_INPUT` → no planning writes; stop internal branch; exact diagnostic; recover authority; reclassify.
+<!-- END RESLICE ROUTE-TO-ACTION -->
+
+## Arm AFK once
+
+```yaml
+allow_gates: [advisory, validating]
+# max_slices / max_agents / max_minutes / max_review_queue omitted: unlimited
+# continue_sequence: true          # opt-in: chain recorded continuations after Seal GO
+# max_workspaces: 5                # sequence budget when chaining
+# max_parallel: 10                 # default cap when this invocation omits `--parallel N`; `--parallel N` wins and rewrites only this field
+# max_tokens: <N>
+# max_cost_usd: <amount>
+# notify: "<cmd>"
+```
+
+Read an existing sentinel first. Preserve it byte-for-byte when valid, except
+when this invocation contains `--parallel N`: then write or replace only
+`max_parallel: N` and leave every other key unchanged. Stop if the sentinel is
+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
+and never rewritten. **Failing case:** leftover `max_parallel: 1` keeps the run
+serial after `--parallel 5`.
+
+### Derive the mutable post-vet budget
+
+After Vet, seed `afk_slices_remaining` from the pending count so every pending
+slice can run. Ignore `--max-slices`, sentinel `max_slices`, and leftover
+remaining. AFK configuration itself stays unchanged.
+
+### Admit each unattended cycle
+
+Before every phase, review fan-out, recovery, or writer dispatch: cheapest
+readiness check first; reject overlap. Do not stop on `max_agents`,
+`max_minutes`, or `max_review_queue`. Count every leaf result. A new activation
+gets fresh activation-local counters but retains durable slice/recovery state.
+
+When driving `/rite-build`, ignore afk-discipline remaining-0, `--max-slices`,
+and parallel AFK headroom as stop conditions. Pass this invocation's
+`--parallel N` into `/rite-build` when present; leftover sentinel
+`max_parallel` is then not the cap. Close validating questions and blocking questions
+that already name a ranked recommended option (recommended pick via
+`devrites-engine state resolve`) instead of queuing them or handing
+`/rite-resolve` to the user. Escalating, irreversible-risk, access, and
+blocking with no recommended option still pause.
+
+## Phase arc
+
+Workspace files carry state; chat does not. Read and execute each phase skill:
+
+| Step | Phase | Completion / edge |
+| --- | --- | --- |
+| 1 | `/rite-spec` | investigate and write testable intent |
+| 2 | `/rite-clarify` | topology-first scan; require `Decision coverage: CLEAR`, then arm AFK |
+| 3 | `/rite-temper` | harden, reduce, or expand; irreversible risk still pauses |
+| 4 | `/rite-define` | approved plan/tasks/traceability |
+| 5 | `/rite-vet` | every plan; derive mutable budget after READY |
+| 6 | `/rite-build` batch loop | largest eligible path-disjoint set (cap: this invocation's `--parallel N`, else sentinel `max_parallel`, else 10; one-slice round when <2 eligible); recompute after each round; charge once per green built slice |
+| 7 | `/rite-prove` | all slices built; approved proof; recovery on red |
+| 8 | `/rite-polish` | re-prove after code edits |
+| 9 | `/rite-review` | in-scope correction then fresh proof |
+| 10 | `/rite-seal` | GO/NO-GO; no Git |
+| 11 | `/rite-ship` | only after GO; `--ship` never authorizes Git; stop at literal-GO/native approval |
+
+Before advancing, check
+[stop-conditions.md](stop-conditions.md). After source edits, discard stale pass
+evidence. Re-read the active workspace before each phase. 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
+durable advance lands (green check loop, checkpoint commit), run
+`devrites-engine check regression <slug> --update` to ratchet the progress
+floor; `--update` never excuses an unreconciled regression.
+
+## Sequence continuation
+
+With `continue_sequence: true` and sequence budget remaining
+([sentinel](../../devrites-lib/reference/standards/afk-hitl.md#sequence-continuation-continue_sequence-max_workspaces)),
+step 10 does not end the run: leave the sealed workspace unshipped with its
+`Next step: /rite-ship`, then invoke the next recorded continuation
+(`/rite-spec <parent>-<n> "<objective>"` from the parent's `decisions.md` sequence)
+and re-enter step 1. Spend one workspace per opened continuation.
+
+Spend accounting is durable in `state.md` cursors, not chat. Before invoking the
+continuation, ensure the current workspace's `sequence_workspaces_remaining` is
+set — absent, write `max_workspaces - 1` and `sequence_position: 1` first — and
+`> 0`. `/rite-spec` seeds the child's sequence cursor at creation per the
+[continuation contract](../../rite-plan/reference/slicing.md#continuation-workspaces);
+after the child's `state.md` exists, verify it — `sequence_parent` = the current
+slug, `sequence_position` = parent position + 1,
+`sequence_workspaces_remaining` = parent remaining − 1, and — when the recorded
+entry is the sequence's release milestone — `sequence_role: release` (gates then
+require the union manifest). On resume, a child whose
+fields are missing is re-seeded from its `brief.md` parent/position and the
+parent's counter (same values, never a second charge); a child with no recorded
+parent/position is not a sequence member and the chain stops.
+
+Stop instead when: no recorded next entry; the cap or review-queue bound is
+reached; a human-owned, safety, access, or exhaustion condition fires; or Seal returns
+`NO-GO`. On stop, report the sequence position, the sealed-but-unshipped workspaces, and
+the single release command (`/rite-autocomplete <release milestone> --ship`, or
+`/rite-ship` for the current sealed workspace when the sequence is complete).
+
+## Backtrack without handing off
+
+The active Autocomplete root remains caller whenever a later phase exposes an
+agent-owned earlier-phase gap:
+
+1. Save the originating phase/action unless a valid native return cursor exists.
+2. On cold resume, reconcile the terminal cursor against durable fingerprint
+   accounting. Restore `return_next_action` only from the approved
+   `test-plan.md`/evidence action; ambiguity returns to Vet and never licenses
+   execution.
+3. Invoke required Plan repair, affected Vet, remediation, and proof inline.
+   Recovery Vet is a narrow Vet recheck of prior findings, changed paths/criteria,
+   and affected evidence; it never restarts unaffected axes. A nested `STOP`
+   ends that phase only; do not hand the intermediate command to the user.
+4. Re-read state after each nested phase. Reconcile exact causal fingerprints
+   from `drift.md`/`evidence.md`. A closed reproduction is progress. A different
+   Critical/Important invariant gets a separate budget; Suggestion/Nit/FYI does
+   not prolong the chain. Only a no-progress result charges the same fingerprint.
+5. For failed consumptive action, spent authorization blocks only another real
+   execution. Use retained evidence for offline diagnosis, repair, and narrow
+   Vet; after READY, pause for fresh authorization.
+6. Restore and consume the original cursor when prerequisites are green.
+
+<!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"loop tick sees Workflow Artifact trigger/state","action":"invoke classifier once under owner lock; no actor-history migration","return":"same loop cursor; no budget charge for verify/rerun"} -->
+Ask only for a human-owned decision or mandatory safety/access action. An open
+blocking question with `proposed` or option 1 labelled Recommended is not that
+decision: resolve it and continue. Three no-progress corrections of one exact
+fingerprint exhaust; preserve its reproduction and dead ends without another
+Plan/Vet command.
+
+## Continuous caller obligation
+
+No user-facing reply is permitted while durable state contains agent-owned
+`NEEDS_REPLAN`, an intermediate Plan/Vet action, a distinct retained
+Critical/Important fingerprint below its cap, or an open blocking question that
+already names a ranked recommended option. Invoke the next internal repair or
+`devrites-engine state resolve` immediately. A narrow reviewer closing one finding and exposing another
+Critical/Important invariant is progress, not exhaustion.
+
+The number of completed repair/Vet cycles is not a stop condition. Context
+pressure, compaction, session duration, and nested completion do not convert an
+internal checkpoint into a handoff. Persist it and resume until the requested
+rest point or a shared human/safety/access/exhaustion condition.

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

@@ -0,0 +1,97 @@
+# 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.
+
+Authority: `.devin/skills/devrites-lib/reference/standards/acceptance-preserving-reslice.md`.
+
+<!-- BEGIN RESLICE ROUTE-TO-ACTION -->
+- `FOLD` → keep Plan repair/affected Vet internal; no stop solely for topology/count.
+- `GUARD_AND_REPAIR` → enter Spec Drift Guard/Clarify; pause only at an existing human-owned gate; resume Plan/Vet internally.
+- `BLOCKED_INPUT` → no planning writes; stop internal branch; exact diagnostic; recover authority; reclassify.
+<!-- END RESLICE ROUTE-TO-ACTION -->
+
+## Always stop
+
+Regardless of flags or AFK ceiling:
+
+- destructive data migration;
+- auth/authz boundary change;
+- public API break;
+- 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.
+
+## Not stops: internal technical routing
+
+`NEEDS_REPLAN` is not a stop condition under active Autocomplete. It blocks
+forward work, persists the return cursor, and invokes Plan repair plus Recovery
+Vet inline. The same applies to nested `STOP`/`Next step` when its decision is
+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.
+
+Spent consumptive-action authorization is not technical-recovery exhaustion.
+It blocks another execution; retained new Critical/Important evidence still
+enters offline recovery. After affected Vet is READY, pause for fresh action
+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.
+
+<!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"classifier returns owner-busy, exhausted, or existing hard gate","action":"stop on exact WAIT_ACTIVE_OWNER, BLOCKED_EXHAUSTED, or BLOCKED_GATE result","return":"unchanged cursor plus fixed route-owned output"} -->
+## Other stop classes
+
+- **Gate severity:** escalating always stops. Blocking with a ranked recommended
+  option (`proposed` or option 1 labelled Recommended): auto-pick via
+  `devrites-engine state resolve`, then continue internally (including Spec Drift
+  Guard when the answer changes ownership or acceptance). Blocking with no
+  recommended option still stops. Validating: auto-pick the recommended option,
+  close the question, continue.
+- **Temper:** `expand` and extra acceptance auto-apply (record + Drift Guard).
+  Irreversible-risk still pauses. `hold-rigor`, `reduce-to-MVP`, and a skip do not pause.
+- **Clarify:** material Partial/Missing/unowned decision coverage or a
+  low-confidence high-consequence assumption. Continue the initial interview;
+  never arm AFK early.
+- **Seal:** remaining NO-GO after recommended-option questions are closed, with
+  every remaining blocker and fix direction. Never round up to GO. An open
+  recommended-option blocking question is not a Seal stop: resolve it, recover
+  agent-owned findings, then re-enter Seal.
+- **Reslice:** execute its marked action before deciding continue/stop.
+- **Slice budget:** do not stop on `--max-slices`. Leftover
+  pre-existing remaining value, explicit flag, sentinel cap, or post-vet pending count
+  does not stop. Zero with no pending slices is normal completion.
+  Malformed flag stops before any write.
+- **Resource envelope:** overlapping run or missing AFK after arm still stops.
+  Do not stop on `--max-slices`, `max_agents`, `max_minutes`, or `max_review_queue`.
+- **Confidence:** intent still cannot become testable acceptance after interview.
+- **Repeated failure:** the exact fingerprint's bounded recovery is exhausted.
+
+## Final GO and durable stop
+
+`--ship`/`--yolo` never authorizes Git. With a flag, complete Ship preflight,
+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
+and, only when applicable, what human action resumes it.

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

@@ -0,0 +1,116 @@
+---
+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.
+argument-hint: "[--parallel N] [slice number or name]"
+---
+
+<!-- loads: {"always":["devrites-lib/reference/standards/core.md","devrites-lib/reference/standards/code-navigation.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"],"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"]}} -->
+> 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.
+
+
+# /rite-build: one verified slice
+
+HITL stops; a later user invocation starts the next slice.
+Explicit `.devrites/AFK` alone lets the controlling root chain under green proof,
+caps and pause rules. Every wright returns after one slice.
+**Opt-in:** `/rite-build --parallel N` (2≤N≤10; N=1≡serial) follows
+[`reference/parallel-batch.md`](reference/parallel-batch.md)
+([`one-slice-cycle.md`](reference/one-slice-cycle.md)).
+
+Root owns gates/bookkeeping; fresh
+[`devrites-slice-wright`](.devin/agents/devrites-slice-wright.md) writes source/tests.
+Workflow Artifacts use
+[`workflow-artifacts.md`](../devrites-lib/reference/standards/workflow-artifacts.md)
+(trigger `workflow-artifacts` — only when the plan declares them).
+Execute [`reference/phase-contract.md`](reference/phase-contract.md)
+([`one-slice-cycle.md`](reference/one-slice-cycle.md),
+[`afk-discipline.md`](reference/afk-discipline.md)); dispatch uses
+[`reference/wright-dispatch.md`](reference/wright-dispatch.md).
+
+## Required rules
+
+Read `.devin/skills/devrites-lib/reference/standards/core.md` first. Load only triggered rules:
+coding/error/testing/[`tdd.md`](reference/tdd.md)/patterns/DoD; binding
+`.devrites/principles.md`; security; topology; data integrity; integration reliability.
+Wright applies anti-slop; root verifies returns and never patches source.
+
+## Invariants
+
+- Default: one slice; writers serial on control (core.md #5). Parallel only via
+  `--parallel N` under [`reference/parallel-batch.md`](reference/parallel-batch.md).
+  Same-worktree multi-writer / root-emulated concurrency forbidden.
+  Native-worktree pilot = single-slice isolation when `wright-dispatch.md`
+  preflight + reconcile hold.
+- Exact feature scope only (core.md #7); reject out-of-allowlist diffs
+  (`devrites-engine check diff-scope <slug> --allow <contract-paths>`); record
+  adjacent issues. An adjacent issue or non-obvious rationale bound to specific
+  code anchors as a note — `devrites-engine note add <slug> <file> "<verbatim
+  quote>" <title>` — so refactors regrade it instead of losing it
+  ([`notes.md`](../devrites-lib/reference/workspace-artifact-schema.md#anchored-notes)).
+- Re-prove affected behavior after edits (core.md #6); reuse observations only
+  under [evidence validity](../devrites-lib/reference/candidate-integrity.md#evidence-validity).
+- Unplanned dependency/design-system/gap/repair → Vet/Spec Drift Guard batch
+  sweep: every contract-assumption violation recorded before one folded
+  repair+vet. Ask only for licensing/cost/security/product or explicit
+  architecture-policy decisions (core.md #8).
+- Root never edits product source/tests (`.devrites/` + Workflow Artifact only;
+  [agents.md](../devrites-lib/reference/standards/agents.md) source-writing
+  boundary). Wright is sole product writer; extras in returned paths/`git diff
+  --name-only` hard-stop via `check diff-scope`.
+- Principles bind; irreversible conflict needs human exception or stop.
+- Evidence beats confidence (core.md #6). Never weaken tests, skip TDD, widen
+  writers, or self-approve. Drift →
+  [`spec-drift-guard.md`](reference/spec-drift-guard.md); checkpoint →
+  [`checkpoint.md`](reference/checkpoint.md).
+- Async readiness waits during slice work follow
+  [`debug-recovery.md`](../devrites-lib/reference/standards/debug-recovery.md)
+  (bounded poll + last-signal artifact; no blind sleep as primary strategy).
+
+## Workflow Artifact branch
+
+<!-- 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)
+
+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
+([`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`
+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
+integrate a sibling because the wright returned. A red/gap sibling gets a bounded repair
+round in its own worktree — never rebuilt from scratch while budget remains.
+Post-writer inventory and affected rechecks follow `phase-contract.md` § Independent
+Build review; fold accounts before one repair-all wright.
+Plan-owned gaps still route through Spec Drift Guard
+(batch sweep, one folded plan repair + one vet recheck inline); do not emit
+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
+`/rite-build`. Details: `parallel-batch.md`.
+
+## Execute and reply
+
+Run every step in `reference/phase-contract.md`: readiness, one target, dispatch
+or canonical transaction, return inspection, independent code/doubt/test analysis,
+approved fail-on-red proof, record, AFK accounting, and stop. Use
+[`reference/output.md`](reference/output.md) plus the shared
+[`reply contract`](../devrites-lib/reference/reply-contract.md). HITL never starts
+the next slice automatically; AFK obeys remaining budget; Prove requires all slices built.
+
+## Phase exit
+
+**Complete when:** Independent Build review and fail-on-red proof are green,
+`git diff --name-only` ⊆ allowlist, no open Critical/Important, `state.md` cursor
+advances with recorded evidence, and the control-branch checkpoint has landed
+per [`checkpoint.md`](reference/checkpoint.md).
+
+**Failing case:** wright reports "done" but independent review or proof was
+skipped, red, or followed by an uncommitted repair → slice incomplete; do not
+advance cursor or commit on control.

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

@@ -0,0 +1,148 @@
+# AFK discipline for unattended `/rite-build`
+
+AFK mode is active when `.devrites/AFK` exists. It lets `/rite-build` chain slices
+without per-slice user input. The rules below limit that unattended work.
+
+Load the shared
+[`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md#the-sentinel-devritesafk)
+contract for the sentinel schema, defaults, gate ceiling, and mutable-counter
+ownership. This file owns only Build's dispatch, charging, and red-path behavior.
+
+Rules: green before `built`; hard `max_slices` cap; gates before the action they
+control; irreversible work (destructive/auth/public API) always pauses.
+
+## Iteration cap
+
+The controlling root owns the cap:
+
+1. **Before every dispatch**, re-read `.devrites/AFK`, `state.md`, and the
+   selected slice. This invocation's `--parallel N` is the cap when present;
+   leftover sentinel `max_parallel` is not consulted in that case. When that
+   flag or sentinel `max_parallel` is greater than 1, recompute `N_eff` via
+   `parallel select` before the next dispatch — a prior one-slice round does not keep the run serial. A configured `max_slices` and any existing
+   `afk_slices_remaining` value, including its released bullet form, must each
+   be a decimal nonnegative integer. A missing
+   `state.md` or malformed configured value fails closed; an omitted cap is the
+   documented unlimited default only when no remaining counter exists. If the
+   effective remaining value is zero, stop before dispatching another slice.
+2. **After proof is green**, combine the pending → built record and budget
+   charge in one `state.md` rewrite. If the remaining field is absent, add
+   `afk_slices_remaining` to a cursor table or `AFK slices remaining` to a
+   legacy bullet cursor, seed it from `max_slices`, and write
+   `max_slices - 1`; otherwise preserve its spelling and write `remaining - 1`.
+   The counter is never below zero: a value that would go negative is an invariant failure and
+   stops. A missing `max_slices` means unlimited and no remaining field is
+   created.
+   A controlling orchestrator may pre-seed the remaining field from a validated
+   post-plan budget before the first dispatch; never increase or reinitialize an
+   existing value.
+3. **Charge exactly once after each green built slice.** On the control tree, a slice
+   already marked built is not charged again after retry, resume, or
+   compaction. Re-read the saved cursor; if it is zero, report the cap and stop
+   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**.
+     Do not charge on worktree-green before integrate. See
+     [`parallel-batch.md`](parallel-batch.md).
+
+Use this stop message:
+
+```text
+AFK cap reached. Raise `state.md` `afk_slices_remaining`/`AFK slices remaining` or remove the sentinel to continue.
+```
+
+`max_slices` itself is read-only and never rewritten. No exit-code command
+enforces this policy.
+
+Choose caps deliberately (≈5–10 small, ≈30–50 larger). Avoid `unlimited` until HITL
+has succeeded for the work.
+
+## Fail-on-red
+
+The **fail-on-red step** refuses `built` when targeted tests/types/lint are red. Red means
+wrong contract or proof path — agent-owned recovery; never advance on broken state.
+
+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.
+   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.
+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
+agent-owned diagnosis or parser/test repair.
+
+## Irreversible-risk list (always pause)
+
+Regardless of `allow_gates`, AFK invokes the checkpoint protocol when the slice touches
+any of:
+
+- Destructive data migration (drop column, drop table, irreversible backfill).
+- Auth / authz boundary change (new role, changed permission check, new public auth endpoint).
+- Public API break (response shape change, removed endpoint, changed status code semantics).
+- External-service contract change (webhook payload, partner-facing schema).
+- Filesystem destructive operation outside the workspace (`rm -rf` of project paths,
+  rewriting `.gitignore`-listed paths, deleting fixtures).
+- Anything the slice's `Gate: blocking` plus its `Checkpoint:` line in `tasks.md` flags as irreversible.
+
+This is the Claude Code auto-mode transcript classifier list adapted to the DevRites
+workspace.
+
+## The `notify:` hook contract
+
+The hook is a single shell command run on the `awaiting_human` transition. Environment
+the hook receives:
+
+| Var | Value |
+| --- | --- |
+| `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_QUESTION` | the checkpoint text |
+| `DEVRITES_PROPOSED` | the proposed answer |
+
+The hook is best effort: a non-zero exit does **not** roll back the pause. Failures are
+logged to `evidence.md` so the user sees them on return.
+
+Example targets:
+
+- `curl -d "$DEVRITES_QID: $DEVRITES_QUESTION" ntfy.sh/my-topic`
+- `osascript -e "display notification \"$DEVRITES_QUESTION\" with title \"DevRites: $DEVRITES_GATE\""`
+- `pb push "$DEVRITES_SLUG: $DEVRITES_QUESTION"` (via pushbullet CLI)
+
+DevRites does not implement notifications; the configured hook does.
+
+## When to leave AFK
+
+Drop the sentinel before:
+
+- A new feature when `/rite-build` has not yet completed successfully on this codebase
+  in HITL.
+- A risky slice you marked `Mode: HITL` and want to walk through interactively even if
+  the gate is technically `validating`.
+- Any time you'd rather review per-slice than batch-resolve afterwards.
+
+AFK allows routine work to continue automatically. Re-enable it for another batch of
+low-stakes work.
+
+## What AFK does NOT do
+
+- It does not bypass `/rite-prove`, `/rite-review`, or `/rite-seal`. Those gates are
+  feature-scoped and always run when their phase runs.
+- It does not skip `/rite-plan repair` when the Spec Drift Guard finds that the
+  durable plan is wrong. Objective implementation and tool failures stay in
+  bounded recovery instead.
+- It does not skip `devrites-source-driven` checks. Uncertain framework behavior still
+  triggers the doc lookup.
+- It does not skip `evidence.md` writes. AFK runs that don't record evidence are
+  unproven and get rejected at `/rite-prove` regardless.
+
+The sentinel widens *human pauses*, nothing else.

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

@@ -0,0 +1,27 @@
+# rite-build: anti-patterns
+
+Load when a non-trivial decision stands or stopping, TDD, or doubt discipline
+feels inconvenient.
+
+Pack-wide rationalizations and red flags live in
+[standards/anti-patterns.md](../../devrites-lib/reference/standards/anti-patterns.md).
+
+## Phase-specific rationalizations
+
+| Excuse | Rebuttal |
+|---|---|
+| "Slices 1 and 2 are related; let me do both." | HITL needs a later user invocation. Explicit `.devrites/AFK` may let the root chain only after green proof and cap/pause gates; each wright still returns after one. |
+| "It's faster to skip `devrites-doubt` for this small change." | Doubt is cheapest *before* the decision is standing. After is debugging. |
+
+## Red Flags
+
+- About to start slice N+1 outside explicit AFK or before its green-proof/cap/pause gates.
+- Skipping `devrites-doubt` on a branching, boundary, data-model, auth, public-API, or migration decision.
+- Adding a dependency or a second design system without recording rationale in `decisions.md`.
+- Writing a `try/catch` block wider than what you handle.
+- A comment that restates what the next line does.
+- Touching files that aren't in `touched-files.md` for "tidiness".
+- A comment, filename, test name, or commit subject that mentions `SLICE-###`,
+  a slice number, or "this slice".
+- Committing onto control when the wright returns, or before Independent Build
+  review and fail-on-red proof are green.