devrites 4.1.0 → 4.2.0

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

@@ -7,161 +7,113 @@ user-invocable: true
 
 # $rite-autocomplete: full lifecycle, unattended
 
-Runs every phase unattended after initial clarification. Irreversible-risk,
+Run every phase after one clarification window. Irreversible-risk,
 blocking/escalating,<!-- pack-scan-ignore: negated statement: gates are NOT disabled -->
-and NO-GO gates still pause. Use the **Standard** native execution profile by
-default and **Full** for high-risk scope or explicit `--full`; profiles are defined in
-[`devrites-lib/reference/orchestration-profiles.md`](../devrites-lib/reference/orchestration-profiles.md).
+NO-GO, resource, and human-owned gates still pause. Use the Standard native
+profile by default and Full for high-risk scope or explicit `--full`; see
+[`orchestration-profiles.md`](../devrites-lib/reference/orchestration-profiles.md).
 
-## Rules consulted (read on demand from `.agents/skills/devrites-lib/reference/standards/`)
-**Step 0:** Read `.agents/skills/devrites-lib/reference/standards/core.md` and `.agents/skills/devrites-lib/reference/standards/afk-hitl.md` first.
-When the cursor or approved plan contains a consumptive action, also read
-`.agents/skills/devrites-lib/reference/standards/one-shot-actions.md` before any
-stop/continue or execution decision.
-When a blocked cursor names missing executable controller/harness/bundle bytes or
-a missing writer under the active feature workspace, read
-`.agents/skills/devrites-lib/reference/standards/workflow-artifacts.md` before honoring
-the terminal cursor or its recovery count.
+## Required rules
 
-## Operating rules
-- **Use one initial human window.** Run spec and topology-first clarify; arm AFK
-  only after `Decision coverage: CLEAR`. Record later discretionary calls
-  ([decision policy](reference/decision-policy.md)).
-- **Safety gates are not bypassable.** Irreversible risk, blocking/escalating,
-  open validating gates, and unexcepted principle violations pause. `--ship` /
-  `--yolo` never authorizes Git; it reaches only the exact-plan literal-GO and
-  native-approval boundary. Red checks run bounded recovery, then block unless
-  the remaining decision is human-owned.
-- **Keep routine backtracking internal.** Always follow agent-owned backward edges
-  through repair, Vet, bounded implementation correction, and re-proof inside
-  the active run. A nested phase `STOP` or intermediate `Next step` is not a
-  user handoff; pause only on the shared real stop conditions.
+Read `devrites-lib/reference/standards/core.md` and `afk-hitl.md` first. Read
+`one-shot-actions.md` before any stop/continue or execution decision involving a
+consumptive action. Before honoring a terminal cursor that names missing
+executable controller/harness/bundle bytes or a missing writer, read
+`workflow-artifacts.md`. Before classifying any Reslice, read `.agents/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 -->
+
+## Invariants
+
+- Use one initial human window: Spec, topology-first Clarify, and
+  `Decision coverage: CLEAR`. Only then arm AFK. Record later reversible choices
+  under [decision policy](reference/decision-policy.md).
+- Safety is not bypassable. `--ship`/`--yolo` reaches only the exact-plan
+  literal-GO and native-approval boundary; it never authorizes Git.
 - **Treat technical readiness as routing, not completion.** `NEEDS_REPLAN` is a backward edge
-  to Plan repair and narrow Vet; `NEEDS_CLARIFICATION` is likewise internal when
-  decision coverage can be resolved from existing authority. Neither state may
-  end Autocomplete unless its underlying fingerprint is actually exhausted or a
-  human/safety/access decision is required.
-- **Do not confuse an action budget with recovery exhaustion.** After a failed
-  consumptive action, zero remaining real attempts blocks only another execution.
-  New retained Critical/Important evidence starts offline repair and narrow Vet
-  inside this Autocomplete invocation. Stop for a fresh GO only after that repair
-  changes the failure condition and Vet is READY.
-- **Admit work under the AFK resource envelope.** Vet may split/add slices.
-  `--max-slices N` replaces the safe new-sentinel default of 10; post-Vet pending
-  count may lower it. Before every phase or leaf dispatch, also enforce expiry,
-  review-backlog, and native agent/token/cost/time limits from `afk-hitl.md`.
-- **Parse flags only from this invocation.** `--ship`, `--yolo`, `--max-slices`,
-  `--full`, and `--cross-model` are active only when their exact standalone tokens
-  occur in `$ARGUMENTS`; their presence in this skill, examples, or earlier messages
-  can never arm them. `--max-slices` must occur once and be followed by a positive
-  base-10 integer; missing, repeated, malformed, or conflicting values stop before
-  any sentinel or workspace write.
-- **Record discretionary choices.** Use the specialist/reviewer recommendation
-  and rationale; never choose arbitrarily.
-- **Strategic review runs, but never auto-grows scope.** After `$rite-clarify`, run `$rite-temper`
-  (significance-gated; it skips low-stakes specs in one line). Unattended it auto-applies only
-  `hold-rigor` + `reduce-to-MVP` (these never grow acceptance); **any `expand` is a blocking
-  pause**, and irreversible-risk findings always pause. Autocomplete hardens and may *prune* the
-  spec on its own; it never *expands* the build's scope without the human.
-- **Engineering review runs on every plan, but never auto-grows scope.** After `$rite-define`,
-  run `$rite-vet` on **every** feature (depth scales: a light pass on simple plans, full rigor on
-  big/risky; never skipped). Unattended it auto-applies only *hardening* findings: added test
-  requirements, error-handling / failure-mode coverage, tightened scope, reuse-over-rebuild,
-  dependency-order fixes (these never grow acceptance); acceptance-preserving
-  reslicing or remediation remains agent-owned. **Any finding that grows product
-  scope or changes acceptance is a blocking pause**, and irreversible-risk findings always
-  pause. Cross-model is off unless `--cross-model` was armed.
+  to Plan repair and narrow Vet. `NEEDS_REPLAN` cold resume follows a valid
+  technical return cursor before forward work or any reply. Clarification is
+  likewise internal when current authority resolves it.
+- Always follow agent-owned backward edges through repair, affected Vet,
+  correction, and proof. A nested `STOP`/`Next step` is not a user handoff.
+  Pause only for a shared human/safety/access/exhaustion condition.
+- **Do not confuse an action budget with recovery exhaustion.** Spent action
+  authority blocks another real execution, not offline correction of retained
+  Critical/Important evidence. Stop for fresh GO only after changed conditions
+  and READY Vet.
+- Every exact causal fingerprint gets at most three no-progress corrections.
+  Closing one is progress; a distinct Critical/Important invariant has its own
+  budget. Lower severity cannot prolong recovery.
+- Enforce `--max-slices`, the AFK sentinel, expiry, review queue, and native
+  agent/token/cost/time limits before every phase or dispatch. Count failed,
+  malformed, and unavailable leaf calls. At the review cap, permit only work
+  that reduces the queue.
+- Parse flags only from this invocation. `--ship`, `--yolo`, `--max-slices`,
+  `--full`, and `--cross-model` activate only as exact standalone tokens in
+  `$ARGUMENTS`; examples or earlier messages can never arm them. `--max-slices`
+  must occur once and be followed by a positive base-10 integer; missing, repeated, malformed, or conflicting values stop before any write.
+- Temper always runs after Clarify. Unattended mode auto-applies only
+  `hold-rigor` and `reduce-to-MVP`; any `expand` or added acceptance pauses.
+- Vet every plan. Cross-model is off unless the current invocation arms it.
+  Never auto-grow accepted scope.
 
 ## Workflow
-1. **Orient + parse args.** Resolve the explicit or active slug, require its
-   `state.md`, and read the cursor directly. Before honoring `blocked` with a
-   terminal `next_action`, reconcile retained consumptive-action artifacts and
-   per-fingerprint attempts from `drift.md` / `evidence.md`. A distinct retained
-   fingerprint below its no-progress cap reopens caller-owned offline recovery;
-   a stale pre-ownership workflow-artifact writer stop reopens under
-   `workflow-artifacts.md` when no controlling-root materialization attempt exists.
-   A `NEEDS_REPLAN` cold resume with a valid technical return cursor immediately
-   invokes Plan repair and Recovery Vet before selecting a forward phase or
-   emitting any reply.
-   That materialization runs directly as non-consumptive prerequisite recovery,
-   even with no pending product slice or AFK budget; it does not re-ask an answered
-   human gate.
-   reconstruct any missing return cursor only from the current phase plus the
-   exact approved action in `test-plan.md` / evidence, never from chat or guesswork.
-   The idea + flags: `--ship` / `--yolo` (continue through ship preflight, then stop
-   for literal-GO and native approval), `--max-slices N` (optional explicit cap;
-   a newly created sentinel defaults to 10 and post-Vet pending count may lower it).
-   Parse only the current `$ARGUMENTS`; normalize the result to the idea,
-   `ship_preflight: yes|no`, `max_slices: N|default`, `profile: standard|full`, and
-   `cross_model: yes|no`.
-   **Completion:** that normalized state is unambiguous and no sentinel or workspace
-   file has been written.
-2. **Specify and clarify up front.** Use `devrites-interview`, `$rite-spec`, and
-   `$rite-clarify` as one interactive window. Clear specs ask zero questions; Partial/Missing
-   coverage never arms AFK. **Completion:** `decision-coverage.md` records `CLEAR`.
-3. **Arm AFK after clarity.** Require `Decision coverage: CLEAR`, then apply the
-   loop's [one-write AFK contract](reference/loop.md#arm-afk-once): preserve a valid
-   existing sentinel byte-for-byte or create an advisory-only sentinel once with
-   bounded slices, agents, wall time, review queue, and four-hour absolute expiry;
-   never rewrite it after Vet or reset it on resume. Also `touch .devrites/CHECKPOINT`:
-   unattended runs use
-   checkpoint mode so each proven slice is committed locally as a crash-survivable
-   `WIP` ([rite-build/reference/checkpoint.md](../rite-build/reference/checkpoint.md));
-   `$rite-ship` collapses them into the one feature commit. **Completion:** AFK config is
-   valid and advisory-only, any pre-existing bytes are unchanged, and the checkpoint
-   sentinel exists.
-4. **Drive the phases** ([reference/loop.md](reference/loop.md)). The canonical arc is
-   `$rite-spec` → **`$rite-clarify`** → **`$rite-temper`** → `$rite-define` →
-   **`$rite-vet`** → `$rite-build` (repeat until all slices
-   built; root charges the AFK budget once per green built slice) → `$rite-prove`
-   → `$rite-polish` → `$rite-review` → `$rite-seal`.
-   Read each `SKILL.md` and execute it; workspace files carry state, not chat.
-   Follow the loop's backward-edge contract whenever a later phase discovers an
-   agent-owned earlier-phase gap; keep the original return cursor until that
-   phase resumes.
-   Immediately after `$rite-vet` and before the first Build dispatch, apply the loop's
-   [mutable post-vet budget](reference/loop.md#derive-the-mutable-post-vet-budget)
-   contract, then apply resource admission before every phase and native dispatch.
-   **Completion:** the loop reaches Seal GO, or a stop condition is persisted
-   before any later phase runs; the cursor names the last completed phase and the
-   effective remaining budget.
-5. **Apply stop conditions at every gate** ([reference/stop-conditions.md](reference/stop-conditions.md)):
-   first route an agent-owned red technical result through the loop's bounded
-   recovery; its `blocked` label alone is not a stop condition. After that, on
-   hard-risk / human-owned blocking / escalating / NO-GO / slice, agent, token,
-   cost, time, review-queue, or expiry exhaustion / still-low-confidence → write
-   `state.md` (`Status`, `Next step`), surface *why*, and **STOP**.
-   Exhausted agent-owned technical recovery uses the terminal `Next step: none`
-   marker and never hands the user `$rite-plan unblock` or another routine
-   phase command.
-   **Completion:** either no stop condition is active, or the stopped cursor and reason
-   are durable and no later phase has been invoked.
-6. **Seal GO → ship boundary.** With `--ship` / `--yolo`, proceed through
-   `$rite-ship` preflight, disclose the exact Git plan, then stop for the human's
-   literal `GO` and any native host approval. Without the flag, stop at seal GO with
-   `$rite-ship` as the resume command. **Completion:** the no-flag path has performed no
-   Ship work; the flagged path has disclosed the exact plan and performed no Git action
-   before fresh literal `GO` plus native approval.
 
-> **Mid-flight discipline.** Stop rather than auto-passing a blocking gate, answering a
-> human-owned material question, or continuing past red tests.
+1. **Orient and parse.** Resolve the explicit or active slug, require `state.md`,
+   and read its cursor. Before honoring `blocked` with terminal `next_action`,
+   reconcile retained consumptive evidence and fingerprint attempts from
+   `drift.md`/`evidence.md`; a retained fingerprint below its cap resumes offline
+   recovery.
+<!-- workflow-artifact-adapter: {"module":"devrites-lib/reference/standards/workflow-artifacts.md","entry":"lifecycle cursor encounters admitted set or resumable journal","action":"invoke classifier; execute returned route internally","return":"saved phase/action; zero intermediate reply"} -->
+   Reconstruct a missing return cursor only from
+   the current phase and exact approved action in `test-plan.md`/evidence, never
+   from chat. Normalize current arguments to idea, `ship_preflight: yes|no`,
+   `max_slices: N|default`, `profile: standard|full`, and `cross_model: yes|no`.
+   **Completion:** normalized state is unambiguous and no sentinel or workspace file has been written.
+2. **Specify and clarify.** Run `devrites-interview`, `$rite-spec`, and
+   `$rite-clarify` as one window. Partial/Missing material coverage never arms
+   AFK. **Completion:** `Decision coverage: CLEAR` is durable.
+3. **Arm AFK once.** Apply the loop's
+   [one-write AFK contract](reference/loop.md#arm-afk-once): preserve valid
+   existing bytes or create the bounded advisory-only sentinel once; never
+   rewrite it after Vet. Preserve an existing sentinel byte-for-byte. Touch
+   `.devrites/CHECKPOINT` so proven slices get local crash-survivable WIP
+   checkpoints for Ship to collapse. **Completion:** valid read-only AFK and checkpoint sentinels exist.
+4. **Drive phases.** Follow [the loop](reference/loop.md): `$rite-spec` →
+   `$rite-clarify` → `$rite-temper` → `$rite-define` → `$rite-vet` →
+   `$rite-build` × pending slices → `$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.
+   **Completion:** loop reaches Seal GO or persists a valid stop before any later phase.
+5. **Apply stops.** At every gate use
+   [stop-conditions.md](reference/stop-conditions.md). A `blocked` label alone is not a stop condition:
+   route agent-owned red results through bounded recovery.
+   Red gates block forward advancement and enter caller-owned recovery. Stop on
+   hard risk, human-owned blocking/escalating/NO-GO, resource exhaustion, or the
+   exact fingerprint's proven exhaustion. Technical exhaustion records terminal
+   `Next step: none`, never a routine phase command. **Completion:** no stop is active, or its cursor and reason are durable.
+6. **Seal boundary.** Without a ship flag, stop at Seal GO with `$rite-ship`.
+   With one, perform Ship preflight, disclose the exact Git plan, and stop for
+   fresh literal `GO` plus native approval. **Completion:** performed no Git action before fresh literal `GO` plus native approval.
 
-Keep the log terse:
-```
+## Reply and resume
+
+HITL Build returns after one slice; explicit valid AFK may chain only green
+slices within every cap. One Autocomplete invocation owns all internal
+backtracking. Context pressure, compaction, or a nested completion footer does
+not create a stop; persist and resume the cursor.
+
+Use one terse line:
+
+```text
 Autocomplete: <slug>
 spec <done|stopped> · clarify <clear|stopped> · temper <done|skipped|stopped> · define <done|stopped> · vet <ready|stopped> · build <n/N|stopped> · prove <done|stopped> · polish <done|stopped> · review <done|stopped> · seal <GO|NO-GO|stopped>
 ```
 
-Final state examples: `Shipped: <feature>`, `Stopped: <reason>`, `Awaiting human:
-<qid> · <gate> · <slice/phase>`, `NO-GO: <verdict>`, or `GO: feature cleared to ship`.
-Do not write a narrative recap.
-
-## Clean baseline and checkpoint mode
-- Before autonomy, require a clean or accepted baseline; refuse unrelated dirty work and record plan artifacts.
-- Arm `.devrites/CHECKPOINT`; `$rite-ship` collapses its local-only proven-slice checkpoints.
-- Red gates block forward advancement and enter caller-owned bounded recovery.
-  Stop only when the shared stop contract classifies risk/HITL or the exact
-  fingerprint's recovery budget is exhausted.
-- One autocomplete pass spans the lifecycle. Each wright returns after one slice;
-  explicit `.devrites/AFK` lets the Build root chain green slices under cap/pause rules;
-  otherwise HITL stops.
+Final state is `Shipped`, `Stopped`, `Awaiting human`, `NO-GO`, or `GO`; do not
+write a narrative recap. Require a clean or accepted baseline, arm checkpoint
+mode, and never auto-pass a red gate.

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

@@ -4,6 +4,14 @@ Unattended ≠ careless. Every discretionary choice is made the way a senior eng
 would, then **recorded** so the seal can audit it. The difference from interactive mode
 is only *who answers* a discretionary question, not whether it's reasoned.
 
+Authority: `.agents/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 -->
+
 ## The rule
 
 For each non-trivial choice, pick the option the **relevant specialist favours**, and
@@ -28,8 +36,6 @@ not pick the option that's merely easiest to implement.
 
 ## When a choice is NOT autocomplete's to make
 
-If a discretionary choice would change **product behaviour, scope, data model, security
-posture, or acceptance criteria**, it is no longer discretionary. It is a material
-question. Route it through the Spec Drift Guard / a `blocking` question and **stop**
-(see [stop-conditions.md](stop-conditions.md)). Autocomplete answers *how*, never
-*what to build* beyond what the up-front interview settled.
+Human-owned contract, data-model, security, and product choices are not discretionary.
+Use owning elicitation/safety gates and the topology marked action. Autocomplete
+answers *how*, never *what to build* beyond the settled interview.

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

@@ -1,154 +1,116 @@
 # The autocomplete loop: arm AFK, drive every phase
 
-Autocomplete sequences existing `/rite-*` workflows and enforces stop
-conditions without pausing between routine phases.
+Autocomplete sequences existing `/rite-*` workflows without pausing between
+routine phases. Acceptance-preserving Reslice authority is
+`.agents/skills/devrites-lib/reference/standards/acceptance-preserving-reslice.md`.
 
-## Arm AFK once
+<!-- 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 the gate policy up front without mutating it later:
+## Arm AFK once
 
 ```yaml
-allow_gates: [advisory]        # only advisory auto-handles; validating+ pause
-max_slices: 10                 # explicit --max-slices N replaces this default
-max_agents: 32                 # native leaf dispatches in this host activation
-max_minutes: 120               # activation wall-clock cap
-max_review_queue: 8            # unresolved review/gate backlog cap
-expires_at: "<now + 4 hours>"  # write one absolute ISO-8601 UTC timestamp
-# max_tokens: <N>              # optional stricter native-host cap
-# max_cost_usd: <amount>        # optional stricter native-host cap
-# notify: "<cmd>"              # optional — fired after a durable stop
+allow_gates: [advisory]
+max_slices: 10
+max_agents: 32
+max_minutes: 120
+max_review_queue: 8
+expires_at: "<now + 4 hours>"
+# max_tokens: <N>
+# max_cost_usd: <amount>
+# notify: "<cmd>"
 ```
 
-Read an existing sentinel first. Preserve it byte-for-byte when valid; stop if its gate
-ceiling exceeds `advisory`, its required resource envelope is missing/malformed/expired,
-or its `max_slices` conflicts with the invocation. If absent, write it once after clarity
-with the safe defaults above, replacing `max_slices` only for an explicit
-`--max-slices N` and resolving `expires_at` to one absolute timestamp. The sentinel is
-read-only: never rewrite it after `$rite-vet` to inject a discovered plan count or to
-reset resource authority.
+Read an existing sentinel first. Preserve it byte-for-byte when valid; stop if
+its gate ceiling exceeds advisory, required envelope is malformed/expired, or
+`max_slices` conflicts with the invocation. If absent, write it once after
+clarity, replacing the safe slice default only for explicit `--max-slices N`
+and resolving one absolute UTC expiry. It is read-only: never rewrite it after
+Vet or reset it on resume.
 
 ### Derive the mutable post-vet budget
 
-After `$rite-vet`, count remaining pending slices and derive the run budget as the
-minimum of that count, an explicit `--max-slices`, and a configured sentinel cap. Before
-the first build dispatch, pre-seed `state.md` `afk_slices_remaining` when absent. If a
-valid remaining counter already exists, retain the lower of it and the derived budget;
-never increase or reinitialize it. This keeps the crash-survivable budget in its mutable owner
-without changing AFK configuration mid-run.
+After Vet, count pending slices and take the minimum of that count, explicit
+flag, and sentinel cap. Before first Build, seed absent state-owned
+`afk_slices_remaining`; retain the lower valid existing value and never increase
+or reinitialize it. AFK configuration itself stays unchanged.
 
 ### Admit each unattended cycle
 
-Before every phase, parallel review fan-out, recovery dispatch, or writer dispatch,
-apply [`afk-hitl.md`](../../devrites-lib/reference/standards/afk-hitl.md#unattended-resource-envelope):
-run the cheapest readiness/current-state check, reject overlapping work, count the
-current unresolved review queue, and check expiry plus native agent/token/cost/time
-headroom. Count every leaf, including failed/malformed/unavailable results. At the
-review cap, only reconciliation that reduces the queue may run. Any limit reached or
-unobservable declared cap ends the current activation before more work and persists
-its checkpoint/reason. A genuinely new native activation starts fresh agent/time/token/
-cost counters, but reuses durable slice/recovery state, absolute expiry, and recomputed
-review queue. It never resets those durable bounds.
-
-`allow_gates: [advisory]` prevents an open `gate: validating` from being queued until
-seal, where it would force NO-GO under `afk-hitl.md`. Autocomplete pauses on it instead. Widen
-`allow_gates` only outside autocomplete through an explicit human configuration change;
-autocomplete itself never widens the ceiling.
-
-## Drive the phases
-
-Read each phase's `SKILL.md` and execute that workflow. Workspace files such as
-`state.md`, `tasks.md`, and `evidence.md` carry state between phases; chat does not.
-
-| Step | Phase | Loop / gate |
-|---|---|---|
-| 1 | `$rite-spec` | interactive window: investigate, feed intent answers, write `spec.md` |
-| 2 | `$rite-clarify` | same interactive window: topology-first scan; write `decision-coverage.md`; proceed only on `CLEAR`, then arm AFK |
-| 3 | `$rite-temper` | significance-gated strategic review; harden spec + write `strategy.md`. Skip low-stakes specs in one line. AFK: `hold-rigor` / `reduce-to-MVP` auto-apply; **any `expand` pauses (blocking)**; irreversible-risk pauses |
-| 4 | `$rite-define` | reads `decision-coverage.md` + `strategy.md`; writes `plan.md` + `tasks.md`; records `Plan approved` |
-| 5 | `$rite-vet` | engineering/readiness review on **every** plan (light pass on simple plans, full on big/risky; never skipped); harden `plan.md` / `tasks.md` + write `eng-review.md` (`Implementation readiness: READY`) + `test-plan.md`. AFK: hardening / coverage findings auto-apply; **any scope-growing / acceptance-changing finding pauses (blocking)**; irreversible-risk pauses. Derive and pre-seed the state-owned slice budget after this (vet may split a slice); never rewrite the AFK sentinel |
-| 6 | `$rite-build` ×N | **loop** while any slice is `pending`; build one, then let the root charge exactly one budget unit with the built-state record. Zero ⇒ STOP before another dispatch. |
-| 7 | `$rite-prove` | once all slices `built`; walks `test-plan.md`; on failure → `devrites-debug-recovery` within scope |
-| 8 | `$rite-polish` | re-verify after code edits (evidence must stay fresh) |
-| 9 | `$rite-review` | apply in-scope fixes; re-prove if code changed |
-| 10 | `$rite-seal` | GO/NO-GO decision (no git here) |
-| 11 | `$rite-ship` | only if seal GO; `--ship` / `--yolo` never authorizes Git and only continues to the exact-plan literal-GO/native-approval boundary |
+Before every phase, review fan-out, recovery, or writer dispatch, apply
+`afk-hitl.md#unattended-resource-envelope`: cheapest current-state/readiness
+check first; reject overlap; count unresolved review; check expiry and native
+agent/token/cost/time headroom. Count every leaf result. At the review cap, only
+reconciliation that reduces the queue may run. Any reached or unobservable
+bound stops before more work and persists the winning reason. A new activation
+gets fresh activation-local counters but retains durable slice/recovery state,
+expiry, and recomputed queue.
+
+`allow_gates: [advisory]` means validating gates pause now rather than becoming
+Seal NO-GO. Only explicit human configuration outside Autocomplete may widen it.
+
+## 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 or reduce; expansion and irreversible risk pause |
+| 4 | `$rite-define` | approved plan/tasks/traceability |
+| 5 | `$rite-vet` | every plan; derive mutable budget after READY |
+| 6 | `$rite-build` ×N | one pending slice per wright; charge once only after green built state |
+| 7 | `$rite-prove` | all slices built; approved proof; recovery on red |
+| 8 | `$rite-polish` | re-prove after code edits |
+| 9 | `$rite-review` | in-scope correction then fresh proof |
+| 10 | `$rite-seal` | GO/NO-GO; no Git |
+| 11 | `$rite-ship` | only after GO; `--ship` never authorizes Git; stop at literal-GO/native approval |
+
+Before advancing, check resource admission and
+[stop-conditions.md](stop-conditions.md). After source edits, discard stale pass
+evidence. Re-read the active workspace before each phase.
 
 ## Backtrack without handing off
 
-When a later phase finds an agent-owned technical gap in an earlier phase, the
-Autocomplete root remains the caller:
-
-On cold resume, reconcile the terminal cursor against durable fingerprint
-accounting first. A retained distinct fingerprint with fewer than three
-no-progress corrections is unfinished recovery, not an unchanged terminal stop.
-Restore `return_phase` from the current phase and `return_next_action` only from
-the exact approved action recorded in `test-plan.md` / evidence; ambiguity returns
-to the applicable Vet contract and never licenses execution.
-
-Also reconcile a **stale writer-exhaustion cursor** against
-`workflow-artifacts.md`. When exact Vet-ready workflow-artifact paths and behavior
-exist, the old attempts only targeted the read-only drafter/reviewer or product
-wright, and there is **no controlling-root materialization attempt**, supported
-root ownership is a changed routing condition. Preserve the old fingerprint,
-record the new materialization fingerprint, and run that offline branch directly;
-do not charge or require product-slice/AFK budget, re-ask a resolved question, or
-request GO. Once a root materialization attempt exists, never apply this migration
-again—route its observed failure normally. That one-time migration
-does not make the first root attempt terminal: record it as attempt one under the new
-materializer fingerprint and continue bounded offline correction while fewer than
-three no-progress corrections exist. This reconciliation runs even when all
-product slices are already built, before selecting the next forward phase.
-
-1. Save the originating phase/action in the native return cursor unless a valid
-   one already exists.
-2. Invoke the required repair, Vet, remediation, and proof skills inline. After
-   Plan repair, run Vet in its recovery mode as a narrow Vet recheck of the prior
-   findings, changed paths/criteria, and affected evidence; do not restart a Full
-   Vet over unchanged axes. Their
-   `STOP` instructions end only those nested phases.
-3. Re-read `state.md` after each nested phase and follow its intermediate
-   `next_action`; do not hand the intermediate command to the user.
-4. Reconcile each exact causal fingerprint from `drift.md` and `evidence.md`.
-   Continue automatically when the recheck closes a prior fingerprint or admits
-   a genuinely new Critical/Important fingerprint. Charge only a no-progress
-   outcome against the same fingerprint; lower-severity novelty cannot prolong
-   the chain.
-   For a failed consumptive action, its spent authorization blocks only another
-   real execution. A retained artifact that identifies a new fingerprint is the
-   offline reproduction input: diagnose, repair, and narrow-Vet it now, then pause
-   for fresh authorization before any next consumptive execution.
-5. When the prerequisite chain is green, restore and consume the return cursor,
-   resume the originating phase, and continue the forward table.
-
-Count failed corrections by causal fingerprint under `afk-hitl.md`. Ask only
-for a human-owned decision or mandatory safety/access action. Exhausted
-agent-owned recovery stops once with its reproduction and dead ends, never with
-another routine Plan/Vet command.
+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. 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 the durable state contains an
-agent-owned `NEEDS_REPLAN`, an intermediate Plan/Vet `next_action`, or a distinct
-Critical/Important fingerprint with remaining recovery budget. Invoke the exact
-next Plan repair and Recovery Vet immediately. A narrow reviewer closing its input
-finding and exposing another Critical/Important invariant is progress: close the
-old fingerprint, open the new one, and continue without handing a command to the
-user.
-
-The number of completed repair/Vet cycles is not a stop condition and cannot be
-used as a surrogate recovery budget. Only three no-progress corrections of the
-same exact fingerprint exhaust. Context pressure, compaction, session duration,
-or a nested skill's completion footer also cannot convert an internal checkpoint
-into a stop; persist the checkpoint and resume from it inside the same controlling
-invocation. Autocomplete may emit its final reply only after reaching its requested
-rest point or one of the shared human/safety/access/exhaustion stop conditions.
-
-## Between phases
-
-- Re-read the active workspace before each phase (don't trust chat memory).
-- Re-run resource admission before each phase or native dispatch; stop before work
-  when expiry, review backlog, or agent/token/cost/time headroom is exhausted.
-- After a phase that edits code (build, polish, review), evidence may be stale: let
-  the next gate re-prove rather than carrying a stale pass (see
-  `.agents/skills/devrites-lib/reference/standards/development-workflow.md`).
-- Check [stop-conditions.md](stop-conditions.md) at every gate **before** advancing.
+No user-facing reply is permitted while durable state contains agent-owned
+`NEEDS_REPLAN`, an intermediate Plan/Vet action, or a distinct retained
+Critical/Important fingerprint below its cap. Invoke the next internal repair
+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.