devrites 7.1.1 → 7.2.0

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

@@ -4,11 +4,8 @@
 
 > Applies when: any rite/devrites skill that can pause for a human or run unattended; irreversible-risk list, budgets, recovery accounting.
 
-Defines two modes for `rite-*`/`devrites-*` skills that may pause; main
-callers are `/rite-build`, `/rite-status`, `/rite-resolve`, and
-`devrites-doubt`.
-
-The contract uses one sentinel, one queue, and one resume verb.
+Two pause modes for `rite-*`/`devrites-*`, chiefly `/rite-build`, `/rite-status`,
+`/rite-resolve`, `devrites-doubt`: one sentinel, queue, resume verb.
 
 ## Contents
 
@@ -46,15 +43,15 @@ The contract uses one sentinel, one queue, and one resume verb.
   ceiling (and every irreversible-risk item) pause and queue a `questions.md` entry for
   `/rite-resolve`.
 
-`.devrites/AFK` presence is authoritative for run mode; gate-deciding skills re-read
-it at decision time. There is no `state.md` run-mode field to drift out of sync.
+`.devrites/AFK` presence owns run mode; gate-deciding skills re-read it at decision
+time. No `state.md` run-mode field can drift out of sync.
 
 ## The sentinel: `.devrites/AFK`
 
 Presence = AFK active. The file body is optional YAML:
 
 ```yaml
-max_slices: 10                       # whole-workspace writer budget; seeds state.md remaining count
+max_slices: 10 # whole-workspace writer budget; seeds state.md remaining count
 max_agents: 32                       # native agent dispatches in one host activation
 max_minutes: 120                     # min; /rite-autocomplete: not a ceiling
 max_review_queue: 8                  # unresolved review/gate items admitted before fan-out stops
@@ -64,55 +61,52 @@ notify: 'curl -fsS -m 10 -d "$DEVRITES_QID: $DEVRITES_QUESTION" ntfy.sh/my-topic
 allow_gates: [advisory, validating]  # gate severities AFK auto-handles (auto-picks the recommended option)
 continue_sequence: true              # after Seal GO, open the next recorded continuation
 max_workspaces: 5                    # workspaces one armed sequence may open
-max_parallel: 10                     # unattended default cap; `--parallel N` on this invocation wins and may rewrite only this field
+max_parallel: 10 # unattended default cap; `--parallel N` on this invocation wins and may rewrite only this field
 ```
 
-The file is **read-only config**: never rewritten in place, except `/rite-autocomplete --parallel N` writes or replaces only `max_parallel: N`. `max_slices` is the initial
-budget; the mutable remaining count is the `state.md` cursor
-`afk_slices_remaining` (`AFK slices remaining: <n>` in the released bullet
-form), owned by the controlling root. Recognize either spelling and preserve
-the existing table or bullet presentation. Before dispatch, a configured
-`max_slices` and any existing remaining value must be decimal nonnegative
-integers; malformed or negative values fail closed. The pending → built state transition spends
+The file is **read-only config**: never rewritten in place, except `/rite-autocomplete --parallel N` writes or replaces only `max_parallel: N`.
+
+Outside active `/rite-autocomplete`, the following slice-budget rules apply:
+`max_slices` seeds root-owned `state.md` cursor `afk_slices_remaining`
+(released bullet alias: `AFK slices remaining: <n>`). Accept either spelling;
+preserve table/bullet presentation. Before dispatch, require configured
+`max_slices` and existing remaining values to be decimal nonnegative integers;
+malformed or negative values fail closed. The pending → built state transition spends
 exactly one slice: on the first green slice write `max_slices - 1`, otherwise
 write `remaining - 1`, never below zero. Re-reading an already built slice does
 not spend again. At zero, stop before the next dispatch.
 
-An orchestrator that can derive a stricter budget only after planning may pre-seed
-`afk_slices_remaining` in `state.md` before the first dispatch instead of rewriting the
-sentinel. It uses the minimum of pending work and every configured/explicit cap. An
-existing counter may be lowered but never increased or reinitialized. Once present, that state
-counter is the effective remaining budget even when the read-only sentinel omits
-`max_slices`.
+A stricter post-planning budget may pre-seed `afk_slices_remaining` before first
+dispatch, not rewrite the sentinel: use the minimum of pending work and all
+configured/explicit caps. An existing counter may be lowered but never increased or reinitialized.
+It remains effective even if the sentinel omits `max_slices`. Under active `/rite-autocomplete`, skip these slice-cap checks,
+charges, zero stops, and minimum-cap seeding; use its
+[post-Vet budget](../../../rite-autocomplete/reference/loop.md#derive-the-mutable-post-vet-budget).
 
 ### Sequence continuation (`continue_sequence`, `max_workspaces`)
 
-`continue_sequence: true` lets one armed run open the next **recorded** continuation
-after a `Seal GO` instead of stopping. Under `/rite-autocomplete`, absent means on, even
-in an existing sentinel; `false` opts out. `max_workspaces` (default 5) is the
-sequence budget (nonnegative decimal, fail closed): spend one when a new workspace is
-opened, never when resuming the current one. `max_slices` stays **per workspace** —
-each new workspace's `state.md` seeds its own `afk_slices_remaining`.
+`continue_sequence: true` opens the next **recorded** continuation after Seal GO.
+Under `/rite-autocomplete`, absent means on, even in existing sentinels; `false` opts out.
+`max_workspaces` (default 5): nonnegative decimal sequence budget, fail closed;
+charge new workspaces only, never resumes. `max_slices`/`afk_slices_remaining` stay **per workspace** outside active
+`/rite-autocomplete`, which uses its post-Vet pending count.
 
 The chain lives in root-owned `state.md` cursor fields, not in chat:
 `sequence_parent` (the immediately preceding workspace slug), `sequence_position`
 (1-based ordinal), `sequence_workspaces_remaining` (slots the chain may still
 open after this workspace), and — on the release milestone only —
-`sequence_role: release`. Seeding is exactly-once because the values are
-derived, not remembered: a continuation's fields are computed from its recorded
-parent and the parent's counter at creation, and a resumed run that finds a
-continuation workspace missing the fields re-derives the same values from its
-`brief.md` parent/position plus the parent's counter — never a second charge. A
-workspace without a recorded parent/position is not a sequence member; the
-counter only decreases, malformed values fail closed, and `0` opens nothing.
+`sequence_role: release`. Seed exactly once from the recorded parent and its counter at creation.
+On resume, re-derive missing continuation fields from its `brief.md` parent/position
+and parent counter — same values, never a second charge. No recorded parent/position means no sequence membership. Counter only decreases;
+malformed values fail closed; `0` opens nothing.
 `sequence_role: release` makes `check candidate` and `check seal` require the
 candidate manifest to cover the whole recorded chain — run
 `devrites-engine state merge-manifest <slug>` before Prove.
 
 - Only continuations recorded in the parent's `decisions.md` sequence
   ([slicing.md § Continuation workspaces](../../../rite-plan/reference/slicing.md#continuation-workspaces))
-  qualify; no recorded next entry, or the cap/review-queue bound reached, stops
-  with the winning reason.
+  qualify; no next entry or exhausted `max_workspaces` stops with that reason. The review-queue bound applies only outside active
+  `/rite-autocomplete`.
 - Milestones are **not** shipped: they stay sealed and unarchived in `.devrites/work/`
   with `Next step: /rite-ship` preserved. Local `WIP(<slug>):` checkpoints still
   land ([checkpoint.md](../../../rite-build/reference/checkpoint.md)), so the tree
@@ -120,8 +114,9 @@ candidate manifest to cover the whole recorded chain — run
 - Git stays human-gated. The release ship is one disclosed plan, one literal `GO`, and
   one native approval; it collapses the sequence's `WIP` commits into the single
   release commit and may archive the sealed predecessors.
-- Every human-owned, safety, access, exhaustion, and `NO-GO` condition still stops the
-  run exactly as without this field.
+- Human-owned, safety, access, and exhaustion stops remain. Active
+  `/rite-autocomplete` recovers agent-owned Seal `NO-GO` per
+  [stop-conditions.md](../../../rite-autocomplete/reference/stop-conditions.md), not a handoff.
 
 `max_parallel` is the unattended default batch cap only when this invocation does
 not contain `--parallel N`; `1` forces the serial cycle only in that default
@@ -145,28 +140,30 @@ Existing sentinels that declare writer admission but miss/malform these fail clo
 state-owned slice counter. A leftover `expires_at` is ignored and never rewritten.
 Read-only watchers use equivalent native caps from [`loop-operations.md`](loop-operations.md).
 
+Outside active `/rite-autocomplete`, the following dispatch/queue limits apply:
 `max_agents` counts every leaf in the native activation, including failures and
 parallel branches; do not add dispatch telemetry to `.devrites/`. `max_review_queue`
 counts open validating questions plus unresolved admitted Critical/Important findings.
-Above it stop; at it run only reconciliation that reduces the queue. Optional
-`max_tokens`/`max_cost_usd` lower enforceable native caps; if declared but unobservable, stop.
+Above it stop; at it run only reconciliation that reduces the queue.
+
+Optional `max_tokens`/`max_cost_usd` lower native caps in all unattended modes; if declared but unobservable, stop.
 `/rite-autocomplete` deliberately ignores `max_slices`, `max_agents`, `max_minutes` and
 `max_review_queue` ([stop-conditions.md](../../../rite-autocomplete/reference/stop-conditions.md));
-there they are not a ceiling.
+not ceilings there.
 
 Numeric limits are nonnegative decimals. Before costly checks, fan-out, or writing,
-run cheap readiness, reject overlap, count queue, and confirm agent/time/token/cost
-headroom; re-check after every result. Never start one call that can exceed remaining
-headroom. Agent/time/token/cost counters are per native activation and start fresh only
-for a genuinely new activation. Slices, recovery attempts, and current
-review queue remain durable/recomputed across wakes. Persist each activation stop and
-checkpoint before notification.
+run cheap readiness and reject overlap. Outside active `/rite-autocomplete`, count
+queue and confirm agent/time headroom; under Autocomplete those ignored limits
+never block admission. In both cases confirm declared token/cost and native safety
+headroom; re-check after every result. Never start a call that can exceed an
+applicable remaining limit. Agent/time/token/cost counters are per native activation and start fresh only
+for a new activation. Slice/recovery state and review queue remain durable/recomputed across wakes.
+Persist stops/checkpoints before notification.
 
-New sentinels write no `expires_at` and no notification/token/cost cap.
-Post-Vet pending count may lower slices. Existing files
-never receive missing defaults implicitly.
+New sentinels omit `expires_at` and notification/token/cost caps. Post-Vet pending
+count may lower standalone slices. Never add missing defaults to existing files.
 
-To leave AFK, delete the file. The next skill invocation reverts to HITL.
+Delete the file to restore HITL on the next invocation.
 
 ## The four gates
 
@@ -223,10 +220,9 @@ keep the **rejected options in `questions.md`**.
 
 ## Decision ownership: search before asking
 
-A gate is human only when its remaining choice is human-owned. First search live code,
-project/decision docs, and authoritative dependency sources; make and record reversible
-implementation/test choices. Ask only about product, scope, acceptance, architecture policy,
-irreversible risk, or human-only access/action.
+First search live code, project/decision docs, and authoritative dependency sources;
+make and record reversible implementation/test choices. Ask only human-owned
+product, scope, acceptance, architecture-policy, irreversible-risk, or access/action choices.
 
 Objective test/build/tool failure runs bounded `devrites-debug-recovery`; fix it, or escalate and
 park it under the [retry contract](#retry-cap-no-progress-loops-and-self-resolve). Never ask

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

@@ -10,7 +10,10 @@ Follow DevRites policy and [`depth profiles`](../orchestration-profiles.md).
 - Root owns scope, questions/decisions/results, `.devrites/**`, phase transitions — not product source/tests; vetted executable workflow artifacts follow [`workflow-artifacts.md`](workflow-artifacts.md).
 - Every named role runs; unavailable → HITL, never skip/substitute.
 <!-- /root-only -->
-- Only bounded wright writes product source/tests; others inspect an immutable candidate.
+- Among lifecycle `devrites-*` specialists, only bounded wright writes product
+  source/tests; others inspect an immutable candidate. The independent `/rite-fast`
+  lane instead uses only its existing `fast-builder` as writer under its own roster;
+  never substitute a lifecycle role. Root remains source/test nonwriter.
 - Leaves never invoke agents, ask humans, change phase, push, install/deploy, migrate live data, or act irreversibly; they return evidence/proposals for root acceptance. Sole exception: one local unpushed transfer commit by an eligible native-worktree `devrites-slice-wright` — transport, not shipping authority or a checkpoint.
 
 <!-- root-only -->
@@ -56,8 +59,15 @@ Workflow-named skills (e.g. devrites-source-driven) are invoked inline in the ro
 
 ## Source-writing boundary
 
+Among lifecycle `devrites-*` specialists only (independent Fast exception below):
 Claude grants only wright `acceptEdits`; Codex root is workspace-capable (children cannot elevate). Wright alone `:workspace`; others `:read-only`. Wright gets the smallest exact project-relative source/test list — no directories/globs, traversal, or `.devrites/**`; no scope widening; root rejects `git diff --name-only` extras. Never patch product source/tests in root, bypass/substitute wright, accept drift, or recreate a dispatch bridge.
 
+Independent Fast exception: `/rite-fast` uses its existing `fast-builder` write-capable
+profile, not a `devrites-*` substitute, under the exact Fast roster and lane contract.
+Only that bounded writer may edit its exact project-relative source/test paths; no
+workspace writes, scope widening, or second writer. Root remains source/test nonwriter.
+This exception grants no additional tools, permissions, phase, agent-launch, or Git authority.
+
 Isolated-worktree pilot only under [`wright-dispatch.md`](../../../rite-build/reference/wright-dispatch.md#isolated-writer-worktree-pilot): one writer, committed/clean baseline, non-submodule parent, exact transfer commit, candidate reconciliation — never parallel writers nor weaker exact-path admission. Root may materialize only exact Vet-ready workflow-artifact paths per [`workflow-artifacts.md`](workflow-artifacts.md) — not a writer dispatch or candidate mutation.
 
 Each job gets objective/exclusions, exact paths/immutable candidate, rubric/result shape, a **stop condition** (when to return), and the exact result shape; a dispatch missing them is malformed and re-issued. Briefs MUST NOT seed verdict/severity cap/conclusion/suppression. Results state status/scope, outcome, commands/escalation; wright adds paths, changed files, gates, stood decisions; results never widen scope.

package/pack/generated/devin/skills/devrites-lib/reference/standards/core.md

@@ -2,14 +2,12 @@
 
 > Applies when: always; every workspace rite reads it first.
 
-Each workspace rite reads core first. Its `loads:` manifest `always` set is its required
-read-set (`devrites-engine context --skills-root .devin/skills <slug> --skill <name>` where a workspace exists, else
-read the listed files); a trigger's files load when its named condition holds. Load any
-other rule file from `README.md` on demand.
+Read core first, then the `loads:` manifest `always` set (via
+`devrites-engine context --skills-root .devin/skills <slug> --skill <name>` with a workspace, else listed files).
+Load trigger files when their named condition holds; other `README.md` rules on demand.
 
-Rules are cited as `core.md #N` (CORE-N). Numbering is stable: text may be
-reworded, an ID never changes meaning. Other files name the ID instead of
-repeating the rule.
+Cite rules as `core.md #N` (CORE-N), not repeated text. IDs keep their meaning
+even when reworded.
 
 Uppercase MUST/MUST NOT/SHOULD/SHOULD NOT/MAY carry RFC 2119 meaning: MUST is a gate;
 a SHOULD deviation records its reason in `decisions.md` (the exception procedure); MAY
@@ -20,9 +18,9 @@ Repository conventions follow [Precedence](#precedence).
 
 ## Operating rules (every phase)
 
-1. **Right step, right time:** use the smallest workflow and load only relevant
-   files. Batch independent reads and cover the relevant code, not just the first
-   match. Prefer an available code index for structure; see
+1. **Right step, right time:** use the smallest workflow/relevant read-set. Batch
+   independent reads; cover relevant code beyond the first match. Prefer an
+   available structural code index; see
    [`tooling.md`](tooling.md) and [`code-index.md`](code-index.md).
 2. **No silent assumptions:** surface material assumptions; ask when the answer
    changes scope, architecture, data model, UX, security, migration risk, or
@@ -32,12 +30,14 @@ Repository conventions follow [Precedence](#precedence).
    when the answer changes the product.
 4. **Keep the spec current:** change spec / plan only through the Spec Drift Guard;
    never code against a known-wrong plan. A later phase MUST NOT rewrite a sealed
-   artifact in place so the code "matches." Append a dated delta through the
-   owning rite, or record drift. **Failing case:** Build edits `spec.md`
+   artifact so the code "matches." Record drift and route to the owning rite;
+   an authorized owner repair reconciles the current owning clause in place and
+   preserves rationale/history in `decisions.md`, not an adjacent dated delta. **Failing case:** Build edits `spec.md`
    acceptance criteria to fit the implementation.
-5. **One slice at a time:** leave one vertical slice working and proven, then
-   stop. HITL never auto-continues; AFK runs to its slice budget
-   ([`afk-hitl.md`](afk-hitl.md)).
+5. **One slice at a time:** prove each vertical slice working.
+   Standalone HITL stops after one slice; standalone AFK runs to its slice budget
+   ([`afk-hitl.md`](afk-hitl.md)). Active `/rite-autocomplete` returns green
+   checkpoints internally and continues the lifecycle to completion or a genuine stop.
 6. **Evidence over confidence:** tests, builds, runtime, screenshots beat
    assertions; record commands and output. Tag how each claim was known:
    `observed` (you ran or read the evidence), `inferred` (deduced — name the
@@ -69,51 +69,50 @@ Each gate is declared as **Name · Precondition · Satisfying observation (exact
 
 Verdict discipline — no vacuous verdicts:
 
-- The precondition asserts the artifact **exists and is non-empty**, not merely that its
-  path resolves. **Failing case:** a phase passes its prerequisite gate, then dies
-  mid-analysis reading a missing spec.
+- The precondition asserts the artifact **exists and is non-empty**, not just a
+  resolved path. **Failing case:** prerequisite passes, analysis dies on a missing spec.
 - A verdict is **PASS**, **FAIL**, or **NOT-RUN**. A NOT-RUN carries its named marker
   (`unavailable: <reason>`, `unproven`, `partial: <what ran>`) in the consuming artifact;
   it never renders as clean and never goes silent. **Failing case:** a review sub-step
   that never ran is simply omitted from the summary, which reads as a clean run.
-- A PASS is valid only when the observation states a **positive count of items actually
-  checked**; zero checked items is FAIL. **Failing case:** an unparseable checklist yields
-  an empty result set and a green verdict over zero evidence.
+- PASS needs a **positive count of items actually checked**; zero is FAIL.
+  **Failing case:** an unparseable checklist produces an empty green result.
 - Scope-bearing gates name their **baseline** and fail only on issues attributable to the
   change; "could not run" (timeout, unreachable, parse failure) is never recorded as
   "failed". **Failing case:** a dependency gate reddens on a pre-existing advisory
   unrelated to the diff.
-- Failure behavior is **abort** (stop; the blocked step is named) or **record-and-continue**
-  (the FAIL/NOT-RUN is recorded with its marker and the run proceeds). Both are legal;
-  silent is not.
+- Failure behavior is **abort** (name blocked step and stop) or **record-and-continue**
+  (record FAIL/NOT-RUN with its marker, proceed). Never silent.
 
 <!-- root-only -->
 ## Caller-owned technical backtracking
 
 When a rite invokes an earlier rite inline to repair an agent-owned technical gap, the original rite stays the controlling caller: a nested `STOP` is a phase boundary, not user-facing. The caller re-reads `state.md`, follows the return cursor/`next_action`, and resumes unless a human-owned, safety, access, budget, or parked-recovery stop is active ([Persistence before stopping](#persistence-before-stopping-handoff-discipline)). Derive `parked-recovery` from the fingerprint's recorded no-progress attempts and escalations, not from a stale `state.md` label; one consumed authorization doesn't exhaust offline recovery from retained new evidence.
 
-An intermediate `Next step` is cold-resume metadata. Do not ask the human to
-copy routine `/rite-plan repair`, `/rite-vet`, `/rite-build`, or proof-rerun
-commands during the active recovery chain. Only the controlling caller emits
-the final response; standalone phase invocations still stop normally.
+Under active `/rite-autocomplete`, green slice/phase checkpoints and their recorded
+`next_action` are internal continuation edges, not final replies. Consume them and
+technical backtracking until requested completion or a genuine stop; tool progress never yields control.
+
+Intermediate `Next step` is cold-resume metadata, not a human copy/paste request
+for routine `/rite-plan repair`, `/rite-vet`, `/rite-build`, or proof reruns during
+active recovery. Only the caller emits the final response; standalone phases stop normally.
 <!-- /root-only -->
 
 <!-- root-only -->
 ## Final response
 
-Immediately before its final response, each rite loads
-[`reply-contract.md`](../reply-contract.md) then uses the compact form: evidenced
-claims plus one next action.
+Immediately before its final response, the controlling caller or standalone rite loads
+[`reply-contract.md`](../reply-contract.md): compact evidenced claims, one next action.
 <!-- /root-only -->
 
 ## Rationalization guard
 
-On an excuse, apply its matching
-[`anti-patterns.md` rebuttal](anti-patterns.md#universal-rationalizations) before continuing.
+Before continuing on an excuse, apply its
+[`anti-patterns.md` rebuttal](anti-patterns.md#universal-rationalizations).
 
 ## Rule summary (load the full file when in scope)
 
-These universal musts link to their full rules; load depth only when needed.
+Universal musts; load linked rules when needed.
 
 - **Fail fast, no silent catches.** Validate early; catch narrow, recover or
   rethrow with context; fail closed on auth/permission/transaction. →
@@ -136,7 +135,7 @@ These universal musts link to their full rules; load depth only when needed.
 - **Measure before you optimize.** An optimisation without a measurement is a
   guess that adds complexity. → [`performance.md`](performance.md)
 - **Names reveal intent.** No `process()` / `handle()` / `data` / `temp`.
-  One concept, one word, across the codebase. → [`coding-style.md`](coding-style.md)
+  One word per concept codebase-wide. → [`coding-style.md`](coding-style.md)
 - **Comments explain *why*, not *what*.** Rename before you comment; delete
   commented-out code. → [`coding-style.md`](coding-style.md)
 - **Write like a human, not a model.** Cut filler, fake contrast/profundity,
@@ -167,19 +166,21 @@ Before any `rite-*` skill stops:
   [--unset key]`; a new ledger section via `state append <slug> <ledger> --heading "<id>"
   --body-file <path|->`. Never splice workspace Markdown with an ad-hoc script or regex.
 
-A skill that stops without doing this leaves the workspace incomplete.
+Stopping without this leaves an incomplete workspace.
 <!-- /root-only -->
 
 ## Context hygiene (end of every phase)
 
 Long contexts degrade reasoning quality. Act on context at **50-70% used, not 95%**.
 
-Read the engine `context` bundle once per phase instead of re-reading the files it
-contains; after compaction re-read the bundle, not its sources.
+Read the engine `context` bundle once per phase, not its sources; after compaction
+re-read the bundle.
 
 <!-- root-only -->
-Every rite names the single resume command on its action line; a `↻ Hygiene:` footer
-advises `/clear`, `/compact`, or `/rite-handoff` and never a competing command. Full phase-by-phase guidance:
+Only controlling-caller final replies or standalone rites name a resume command
+on the action line; nested phases persist it internally, not as a handoff.
+A `↻ Hygiene:` footer advises `/clear`, `/compact`, or `/rite-handoff`, never a
+competing command. Phase guidance:
 [`context-hygiene.md`](context-hygiene.md).
 <!-- /root-only -->
 

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

@@ -139,30 +139,28 @@ next sequence continuation through Vet in a second session, then stop.
    product scope is never auto-resolved by a recommended option; it stops for a human.
    A spent strategy escalates; parked recovery records
    `Next step: /rite-autocomplete`, never a routine phase command. **Completion:** no stop is active, or its cursor and reason are durable.
-6. **Seal boundary.** Without a ship flag, leave the sealed workspace unshipped and
-   open the next recorded continuation
+6. **Seal boundary.** With or without a ship flag, leave intermediate sealed
+   workspaces unshipped and open the next recorded continuation
    ([loop.md § Sequence continuation](reference/loop.md#sequence-continuation))
    unless `continue_sequence: false`, the sequence budget is spent, or no entry
-   remains; then stop at Seal GO with `/rite-ship`. Report the sequence position on
-   every stop.
-   With a ship flag, 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.
+   remains. At that boundary without a ship flag, stop at Seal GO with `/rite-ship`.
+   Report sequence position at every stop. Only at that boundary, with a ship flag, 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.
 
 ## Reply and resume
 
-HITL Build returns after one slice; Autocomplete ignores `--max-slices` and
-keeps chaining pending slices. One Autocomplete invocation owns all internal
-backtracking. Context pressure, compaction, or a nested completion footer does
+HITL Build returns after one slice; Autocomplete ignores `--max-slices`, chaining
+pending slices. Each Autocomplete invocation owns internal backtracking. Context pressure, compaction, or a nested completion footer does
 not create a stop; persist and resume the cursor.
 
-Reply only at a final state, never as mid-run progress: a text-only turn ends
-the run, so after a compaction or phase change keep calling tools. Use one terse line:
+Reply only at final state: text-only turns end the run. Keep
+calling tools after compaction or phase changes. Use one line:
 
 ```text
 Autocomplete: <slug>
 spec <done|stopped> · clarify <clear|stopped> · temper <done|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 is `Shipped`, `Stopped`, `Awaiting human`, `NO-GO`, or `GO`; do not
-write a narrative recap. Require a clean or accepted baseline, land a local
-unpushed checkpoint after each green check, and never auto-pass a red gate.
+Final state: `Shipped`, `Stopped`, `Awaiting human`, `NO-GO`, or `GO`; no narrative
+recap. Require clean or accepted baseline; land local unpushed checkpoints after
+each green check; never auto-pass red gates.

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

@@ -1,7 +1,6 @@
 # The autocomplete loop: arm AFK, drive every phase
 
-Autocomplete sequences existing `/rite-*` workflows without pausing between
-routine phases. Acceptance-preserving Reslice authority is
+Autocomplete chains existing `/rite-*` workflows without routine-phase pauses. Acceptance-preserving Reslice authority is
 `.devin/skills/devrites-lib/reference/standards/acceptance-preserving-reslice.md`.
 
 <!-- BEGIN RESLICE ROUTE-TO-ACTION -->
@@ -23,7 +22,7 @@ allow_gates: [advisory, validating]
 # notify: "<cmd>"
 ```
 
-Read an existing sentinel first. Preserve it byte-for-byte when valid, except
+Read existing sentinel first. Preserve valid bytes, 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` /
@@ -41,10 +40,9 @@ remaining. AFK configuration itself stays unchanged.
 
 ### Admit each unattended cycle
 
-Before every phase, review fan-out, recovery, or writer dispatch: cheapest
+Before each 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.
+`max_minutes`, or `max_review_queue`. Count every leaf result. New activations reset activation-local counters, retaining durable slice/recovery state.
 
 [Build return](../../rite-build/reference/output.md#caller-owned-continuation).
 Pass `--parallel N`; ignore leftover cap/headroom, remaining-0,
@@ -57,7 +55,7 @@ without recommendations, and Seal judgment (`slice: seal`) still pause.
 
 ## Phase arc
 
-Workspace files carry state; chat does not. Read and execute each phase skill:
+Workspace files, not chat, carry state. Read/execute each phase skill:
 
 | Step | Phase | Completion / edge |
 | --- | --- | --- |
@@ -73,9 +71,8 @@ Workspace files carry state; chat does not. Read and execute each phase skill:
 | 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
+Check [stop-conditions.md](stop-conditions.md) before advancing. Discard stale
+pass evidence after source edits. Re-read active workspace before each phase. On a cold resume or
 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
@@ -92,37 +89,35 @@ step 10 does not end the run: leave the sealed workspace unshipped with its
 (`/rite-spec <parent>-<n> "<objective>"` from the parent's `decisions.md` sequence)
 and re-enter step 1. Spend one workspace per opened continuation.
 
-When that workspace already exists because a [lookahead](lookahead.md) session
-planned it, do not specify it again. Wait while `devrites-engine claim check
---workspace <child>` exits 3 (a live lookahead holds it), then set
-`.devrites/ACTIVE` to the child and resume from its cursor at step 1. A
-predecessor replan since its Vet blocks the child's readiness with
-`DRV-GATE-READINESS-STALE`; route that to `/rite-vet` before Build.
-
-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
+For a child already planned by [lookahead](lookahead.md), do not re-specify.
+Wait while `devrites-engine claim check --workspace <child>` exits 3 (live
+lookahead), then set `.devrites/ACTIVE` to the child and resume its cursor at
+step 1. A predecessor replan since its Vet blocks child readiness with
+`DRV-GATE-READINESS-STALE`; route to `/rite-vet` before Build.
+
+Before invoking a continuation, require durable `state.md`
+`sequence_workspaces_remaining > 0`; if absent, first write
+`max_workspaces - 1` and `sequence_position: 1`. `/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,
+verify the created child's `state.md`: `sequence_parent` = 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 parked-recovery stop 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
+require the union manifest). On resume, re-seed missing child fields from its `brief.md` parent/position and
+parent counter (same values, no second charge). No recorded parent/position
+means no sequence membership: stop the chain.
+
+Stop sequence continuation when: `continue_sequence: false`; no recorded next
+entry (the final milestone); the `max_workspaces` cap is reached; or a genuine
+human-owned, safety, access, or parked-recovery stop fires. `max_review_queue`
+never stops Autocomplete; agent-owned Seal `NO-GO` enters recovery, not a handoff.
+Intermediate sealed milestones continue without `--ship` and without Git mutation. On stop, report sequence position, sealed/unshipped workspaces, and
+one 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:
+Autocomplete remains caller for agent-owned earlier-phase gaps:
 
 1. Save the originating phase/action unless a valid native return cursor exists.
 2. On cold resume, reconcile the terminal cursor against durable fingerprint
@@ -152,6 +147,8 @@ and park it after three escalations while independent work continues.
 
 ## Continuous caller obligation
 
+Green slice/phase checkpoints consume their recorded `next_action` internally;
+only the caller replies finally at completion or a genuine stop.
 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 with an escalation left, runnable
@@ -162,7 +159,6 @@ already names a ranked recommended option. Invoke the next internal repair or
 `state resolve` exits 1 on every call and the loop re-invokes it without end. 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/parked-recovery condition.
+The number of completed repair/Vet cycles, context pressure, compaction, session
+duration, and nested completion never turn checkpoints into handoffs. Persist and
+resume to the requested rest point or shared human/safety/access/parked-recovery stop.