devrites 7.1.1 → 7.2.0

package/pack/generated/codex/skills/devrites-debug-recovery/reference/regression-test.md

@@ -10,10 +10,13 @@ confidence.
 
 ## No correct seam? That itself is the finding
 
-Note it in `evidence.md` and append a follow-up in the active feature's
-`decisions.md` (or run `$rite-plan repair` if the spec is affected): the
-codebase architecture is preventing this class of failure from being locked
-down. Frame it as a *deepening opportunity* ("this module needs a seam at <X>
+Follow [`SKILL.md` § Caller-owned records and routing](../SKILL.md#caller-owned-records-and-routing):
+root notes it in `evidence.md` and appends a follow-up in the active feature's
+`decisions.md` (or routes `$rite-plan repair` if the spec is affected). A leaf
+returns the complete finding, evidence, and proposed route for root acceptance and
+persistence; it never writes the workspace or invokes the rite. The codebase
+architecture is preventing this class of failure from being locked down. Frame it as
+a *deepening opportunity* ("this module needs a seam at <X>
 so this failure can be regression-tested") so the next `$rite-plan` repair or
 architecture cleanup pass has a concrete target.
 

package/pack/generated/codex/skills/devrites-lib/reference/reply-contract.md

@@ -1,8 +1,7 @@
 # DevRites completion reply contract
 
-Use the host's normal response. Do not run a progress renderer, emit session
-telemetry, assign a health score, or repeat state already visible in the durable
-artifact.
+Use normal host responses. No progress renderer, session telemetry, health score,
+or repetition of durable artifact state.
 
 Keep the reply compact and evidence-backed:
 
@@ -21,16 +20,17 @@ Next: <one recommended action>
 Record: <primary durable artifact path>
 ```
 
-`Changed:` is the complete write set, not a highlight reel: every file written
-or edited this turn — workspace artifact and project source alike — appears
-there or inside one named grouped entry, so a reviewer can `git diff` exactly
-those paths. `Record:` then names the single durable artifact a later session
-reads first.
+`Changed:` lists every file written/edited this turn (workspace and source),
+individually or in one named group, so reviewers can `git diff` those paths.
+`Record:` names the single durable artifact the next session reads first.
 
-Mid-flight replies — the turns between completion states — obey the same economy:
+Active `$rite-autocomplete` consumes green checkpoints/`next_action` internally.
+Continue execution or tool progress; never end with a text-only final reply between green phases.
 
-- **Restate position.** The reader cannot hold "step 3 of 5" between turns; name it
-  (`step N of M` / `state: <where things stand>`) rather than asking them to remember.
+Standalone HITL mid-flight replies follow the same economy:
+
+- **Restate position** (`step N of M` / `state: <where things stand>`); do not rely
+  on the reader remembering it between turns.
 - **One next action, doable now.** `Next:` names one concrete action completable in
   under two minutes — a command, a file to open, a yes/no decision. "Want me to
   continue?" is a stall, not an action.

package/pack/generated/codex/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/codex/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/codex/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 .agents/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 .agents/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/codex/skills/rite-autocomplete/SKILL.md

@@ -140,30 +140,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.